1(function webpackUniversalModuleDefinition(root, factory) {
2	if(typeof exports === 'object' && typeof module === 'object')
3		module.exports = factory();
4	else if(typeof define === 'function' && define.amd)
5		define([], factory);
6	else if(typeof exports === 'object')
7		exports["mapping"] = factory();
8	else
9		root["mapping"] = factory();
10})(this, function() {
11return /******/ (function(modules) { // webpackBootstrap
12/******/ 	// The module cache
13/******/ 	var installedModules = {};
14
15/******/ 	// The require function
16/******/ 	function __webpack_require__(moduleId) {
17
18/******/ 		// Check if module is in cache
19/******/ 		if(installedModules[moduleId])
20/******/ 			return installedModules[moduleId].exports;
21
22/******/ 		// Create a new module (and put it into the cache)
23/******/ 		var module = installedModules[moduleId] = {
24/******/ 			exports: {},
25/******/ 			id: moduleId,
26/******/ 			loaded: false
27/******/ 		};
28
29/******/ 		// Execute the module function
30/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
31
32/******/ 		// Flag the module as loaded
33/******/ 		module.loaded = true;
34
35/******/ 		// Return the exports of the module
36/******/ 		return module.exports;
37/******/ 	}
38
39
40/******/ 	// expose the modules object (__webpack_modules__)
41/******/ 	__webpack_require__.m = modules;
42
43/******/ 	// expose the module cache
44/******/ 	__webpack_require__.c = installedModules;
45
46/******/ 	// __webpack_public_path__
47/******/ 	__webpack_require__.p = "";
48
49/******/ 	// Load entry module and return exports
50/******/ 	return __webpack_require__(0);
51/******/ })
52/************************************************************************/
53/******/ ([
54/* 0 */
55/***/ (function(module, exports) {
56
57	/** Used to map aliases to their real names. */
58	exports.aliasToReal = {
59
60	  // Lodash aliases.
61	  'each': 'forEach',
62	  'eachRight': 'forEachRight',
63	  'entries': 'toPairs',
64	  'entriesIn': 'toPairsIn',
65	  'extend': 'assignIn',
66	  'extendAll': 'assignInAll',
67	  'extendAllWith': 'assignInAllWith',
68	  'extendWith': 'assignInWith',
69	  'first': 'head',
70
71	  // Methods that are curried variants of others.
72	  'conforms': 'conformsTo',
73	  'matches': 'isMatch',
74	  'property': 'get',
75
76	  // Ramda aliases.
77	  '__': 'placeholder',
78	  'F': 'stubFalse',
79	  'T': 'stubTrue',
80	  'all': 'every',
81	  'allPass': 'overEvery',
82	  'always': 'constant',
83	  'any': 'some',
84	  'anyPass': 'overSome',
85	  'apply': 'spread',
86	  'assoc': 'set',
87	  'assocPath': 'set',
88	  'complement': 'negate',
89	  'compose': 'flowRight',
90	  'contains': 'includes',
91	  'dissoc': 'unset',
92	  'dissocPath': 'unset',
93	  'dropLast': 'dropRight',
94	  'dropLastWhile': 'dropRightWhile',
95	  'equals': 'isEqual',
96	  'identical': 'eq',
97	  'indexBy': 'keyBy',
98	  'init': 'initial',
99	  'invertObj': 'invert',
100	  'juxt': 'over',
101	  'omitAll': 'omit',
102	  'nAry': 'ary',
103	  'path': 'get',
104	  'pathEq': 'matchesProperty',
105	  'pathOr': 'getOr',
106	  'paths': 'at',
107	  'pickAll': 'pick',
108	  'pipe': 'flow',
109	  'pluck': 'map',
110	  'prop': 'get',
111	  'propEq': 'matchesProperty',
112	  'propOr': 'getOr',
113	  'props': 'at',
114	  'symmetricDifference': 'xor',
115	  'symmetricDifferenceBy': 'xorBy',
116	  'symmetricDifferenceWith': 'xorWith',
117	  'takeLast': 'takeRight',
118	  'takeLastWhile': 'takeRightWhile',
119	  'unapply': 'rest',
120	  'unnest': 'flatten',
121	  'useWith': 'overArgs',
122	  'where': 'conformsTo',
123	  'whereEq': 'isMatch',
124	  'zipObj': 'zipObject'
125	};
126
127	/** Used to map ary to method names. */
128	exports.aryMethod = {
129	  '1': [
130	    'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',
131	    'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow',
132	    'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'mergeAll',
133	    'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest', 'reverse',
134	    'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
135	    'uniqueId', 'words', 'zipAll'
136	  ],
137	  '2': [
138	    'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith',
139	    'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith',
140	    'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN',
141	    'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference',
142	    'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq',
143	    'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
144	    'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',
145	    'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get',
146	    'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection',
147	    'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy',
148	    'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty',
149	    'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit',
150	    'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial',
151	    'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll',
152	    'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
153	    'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
154	    'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
155	    'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
156	    'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
157	    'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
158	    'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
159	    'zipObjectDeep'
160	  ],
161	  '3': [
162	    'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
163	    'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',
164	    'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',
165	    'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',
166	    'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
167	    'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepRight',
168	    'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',
169	    'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', 'xorBy',
170	    'xorWith', 'zipWith'
171	  ],
172	  '4': [
173	    'fill', 'setWith', 'updateWith'
174	  ]
175	};
176
177	/** Used to map ary to rearg configs. */
178	exports.aryRearg = {
179	  '2': [1, 0],
180	  '3': [2, 0, 1],
181	  '4': [3, 2, 0, 1]
182	};
183
184	/** Used to map method names to their iteratee ary. */
185	exports.iterateeAry = {
186	  'dropRightWhile': 1,
187	  'dropWhile': 1,
188	  'every': 1,
189	  'filter': 1,
190	  'find': 1,
191	  'findFrom': 1,
192	  'findIndex': 1,
193	  'findIndexFrom': 1,
194	  'findKey': 1,
195	  'findLast': 1,
196	  'findLastFrom': 1,
197	  'findLastIndex': 1,
198	  'findLastIndexFrom': 1,
199	  'findLastKey': 1,
200	  'flatMap': 1,
201	  'flatMapDeep': 1,
202	  'flatMapDepth': 1,
203	  'forEach': 1,
204	  'forEachRight': 1,
205	  'forIn': 1,
206	  'forInRight': 1,
207	  'forOwn': 1,
208	  'forOwnRight': 1,
209	  'map': 1,
210	  'mapKeys': 1,
211	  'mapValues': 1,
212	  'partition': 1,
213	  'reduce': 2,
214	  'reduceRight': 2,
215	  'reject': 1,
216	  'remove': 1,
217	  'some': 1,
218	  'takeRightWhile': 1,
219	  'takeWhile': 1,
220	  'times': 1,
221	  'transform': 2
222	};
223
224	/** Used to map method names to iteratee rearg configs. */
225	exports.iterateeRearg = {
226	  'mapKeys': [1],
227	  'reduceRight': [1, 0]
228	};
229
230	/** Used to map method names to rearg configs. */
231	exports.methodRearg = {
232	  'assignInAllWith': [1, 0],
233	  'assignInWith': [1, 2, 0],
234	  'assignAllWith': [1, 0],
235	  'assignWith': [1, 2, 0],
236	  'differenceBy': [1, 2, 0],
237	  'differenceWith': [1, 2, 0],
238	  'getOr': [2, 1, 0],
239	  'intersectionBy': [1, 2, 0],
240	  'intersectionWith': [1, 2, 0],
241	  'isEqualWith': [1, 2, 0],
242	  'isMatchWith': [2, 1, 0],
243	  'mergeAllWith': [1, 0],
244	  'mergeWith': [1, 2, 0],
245	  'padChars': [2, 1, 0],
246	  'padCharsEnd': [2, 1, 0],
247	  'padCharsStart': [2, 1, 0],
248	  'pullAllBy': [2, 1, 0],
249	  'pullAllWith': [2, 1, 0],
250	  'rangeStep': [1, 2, 0],
251	  'rangeStepRight': [1, 2, 0],
252	  'setWith': [3, 1, 2, 0],
253	  'sortedIndexBy': [2, 1, 0],
254	  'sortedLastIndexBy': [2, 1, 0],
255	  'unionBy': [1, 2, 0],
256	  'unionWith': [1, 2, 0],
257	  'updateWith': [3, 1, 2, 0],
258	  'xorBy': [1, 2, 0],
259	  'xorWith': [1, 2, 0],
260	  'zipWith': [1, 2, 0]
261	};
262
263	/** Used to map method names to spread configs. */
264	exports.methodSpread = {
265	  'assignAll': { 'start': 0 },
266	  'assignAllWith': { 'start': 0 },
267	  'assignInAll': { 'start': 0 },
268	  'assignInAllWith': { 'start': 0 },
269	  'defaultsAll': { 'start': 0 },
270	  'defaultsDeepAll': { 'start': 0 },
271	  'invokeArgs': { 'start': 2 },
272	  'invokeArgsMap': { 'start': 2 },
273	  'mergeAll': { 'start': 0 },
274	  'mergeAllWith': { 'start': 0 },
275	  'partial': { 'start': 1 },
276	  'partialRight': { 'start': 1 },
277	  'without': { 'start': 1 },
278	  'zipAll': { 'start': 0 }
279	};
280
281	/** Used to identify methods which mutate arrays or objects. */
282	exports.mutate = {
283	  'array': {
284	    'fill': true,
285	    'pull': true,
286	    'pullAll': true,
287	    'pullAllBy': true,
288	    'pullAllWith': true,
289	    'pullAt': true,
290	    'remove': true,
291	    'reverse': true
292	  },
293	  'object': {
294	    'assign': true,
295	    'assignAll': true,
296	    'assignAllWith': true,
297	    'assignIn': true,
298	    'assignInAll': true,
299	    'assignInAllWith': true,
300	    'assignInWith': true,
301	    'assignWith': true,
302	    'defaults': true,
303	    'defaultsAll': true,
304	    'defaultsDeep': true,
305	    'defaultsDeepAll': true,
306	    'merge': true,
307	    'mergeAll': true,
308	    'mergeAllWith': true,
309	    'mergeWith': true,
310	  },
311	  'set': {
312	    'set': true,
313	    'setWith': true,
314	    'unset': true,
315	    'update': true,
316	    'updateWith': true
317	  }
318	};
319
320	/** Used to map real names to their aliases. */
321	exports.realToAlias = (function() {
322	  var hasOwnProperty = Object.prototype.hasOwnProperty,
323	      object = exports.aliasToReal,
324	      result = {};
325
326	  for (var key in object) {
327	    var value = object[key];
328	    if (hasOwnProperty.call(result, value)) {
329	      result[value].push(key);
330	    } else {
331	      result[value] = [key];
332	    }
333	  }
334	  return result;
335	}());
336
337	/** Used to map method names to other names. */
338	exports.remap = {
339	  'assignAll': 'assign',
340	  'assignAllWith': 'assignWith',
341	  'assignInAll': 'assignIn',
342	  'assignInAllWith': 'assignInWith',
343	  'curryN': 'curry',
344	  'curryRightN': 'curryRight',
345	  'defaultsAll': 'defaults',
346	  'defaultsDeepAll': 'defaultsDeep',
347	  'findFrom': 'find',
348	  'findIndexFrom': 'findIndex',
349	  'findLastFrom': 'findLast',
350	  'findLastIndexFrom': 'findLastIndex',
351	  'getOr': 'get',
352	  'includesFrom': 'includes',
353	  'indexOfFrom': 'indexOf',
354	  'invokeArgs': 'invoke',
355	  'invokeArgsMap': 'invokeMap',
356	  'lastIndexOfFrom': 'lastIndexOf',
357	  'mergeAll': 'merge',
358	  'mergeAllWith': 'mergeWith',
359	  'padChars': 'pad',
360	  'padCharsEnd': 'padEnd',
361	  'padCharsStart': 'padStart',
362	  'propertyOf': 'get',
363	  'rangeStep': 'range',
364	  'rangeStepRight': 'rangeRight',
365	  'restFrom': 'rest',
366	  'spreadFrom': 'spread',
367	  'trimChars': 'trim',
368	  'trimCharsEnd': 'trimEnd',
369	  'trimCharsStart': 'trimStart',
370	  'zipAll': 'zip'
371	};
372
373	/** Used to track methods that skip fixing their arity. */
374	exports.skipFixed = {
375	  'castArray': true,
376	  'flow': true,
377	  'flowRight': true,
378	  'iteratee': true,
379	  'mixin': true,
380	  'rearg': true,
381	  'runInContext': true
382	};
383
384	/** Used to track methods that skip rearranging arguments. */
385	exports.skipRearg = {
386	  'add': true,
387	  'assign': true,
388	  'assignIn': true,
389	  'bind': true,
390	  'bindKey': true,
391	  'concat': true,
392	  'difference': true,
393	  'divide': true,
394	  'eq': true,
395	  'gt': true,
396	  'gte': true,
397	  'isEqual': true,
398	  'lt': true,
399	  'lte': true,
400	  'matchesProperty': true,
401	  'merge': true,
402	  'multiply': true,
403	  'overArgs': true,
404	  'partial': true,
405	  'partialRight': true,
406	  'propertyOf': true,
407	  'random': true,
408	  'range': true,
409	  'rangeRight': true,
410	  'subtract': true,
411	  'zip': true,
412	  'zipObject': true,
413	  'zipObjectDeep': true
414	};
415
416
417/***/ })
418/******/ ])
419});
420;