https://culturelink.com.sg/wp-content/themes/culturelink-1/js/culturelink.js?v=1624872851359

1/*!
2 * Webflow: Front-end site library
3 * @license MIT
4 * Inline scripts may access the api using an async handler:
5 *   var Webflow = Webflow || [];
6 *   Webflow.push(readyFunction);
7 */
8/******/ (function(modules) { // webpackBootstrap
9/******/ 	// The module cache
10/******/ 	var installedModules = {};
11/******/
12/******/ 	// The require function
13/******/ 	function __webpack_require__(moduleId) {
14/******/
15/******/ 		// Check if module is in cache
16/******/ 		if(installedModules[moduleId]) {
17/******/ 			return installedModules[moduleId].exports;
18/******/ 		}
19/******/ 		// Create a new module (and put it into the cache)
20/******/ 		var module = installedModules[moduleId] = {
21/******/ 			i: moduleId,
22/******/ 			l: false,
23/******/ 			exports: {}
24/******/ 		};
25/******/
26/******/ 		// Execute the module function
27/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
28/******/
29/******/ 		// Flag the module as loaded
30/******/ 		module.l = true;
31/******/
32/******/ 		// Return the exports of the module
33/******/ 		return module.exports;
34/******/ 	}
35/******/
36/******/
37/******/ 	// expose the modules object (__webpack_modules__)
38/******/ 	__webpack_require__.m = modules;
39/******/
40/******/ 	// expose the module cache
41/******/ 	__webpack_require__.c = installedModules;
42/******/
43/******/ 	// define getter function for harmony exports
44/******/ 	__webpack_require__.d = function(exports, name, getter) {
45/******/ 		if(!__webpack_require__.o(exports, name)) {
46/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
47/******/ 		}
48/******/ 	};
49/******/
50/******/ 	// define __esModule on exports
51/******/ 	__webpack_require__.r = function(exports) {
52/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
53/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
54/******/ 		}
55/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
56/******/ 	};
57/******/
58/******/ 	// create a fake namespace object
59/******/ 	// mode & 1: value is a module id, require it
60/******/ 	// mode & 2: merge all properties of value into the ns
61/******/ 	// mode & 4: return value when already ns object
62/******/ 	// mode & 8|1: behave like require
63/******/ 	__webpack_require__.t = function(value, mode) {
64/******/ 		if(mode & 1) value = __webpack_require__(value);
65/******/ 		if(mode & 8) return value;
66/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
67/******/ 		var ns = Object.create(null);
68/******/ 		__webpack_require__.r(ns);
69/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
70/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
71/******/ 		return ns;
72/******/ 	};
73/******/
74/******/ 	// getDefaultExport function for compatibility with non-harmony modules
75/******/ 	__webpack_require__.n = function(module) {
76/******/ 		var getter = module && module.__esModule ?
77/******/ 			function getDefault() { return module['default']; } :
78/******/ 			function getModuleExports() { return module; };
79/******/ 		__webpack_require__.d(getter, 'a', getter);
80/******/ 		return getter;
81/******/ 	};
82/******/
83/******/ 	// Object.prototype.hasOwnProperty.call
84/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
85/******/
86/******/ 	// __webpack_public_path__
87/******/ 	__webpack_require__.p = "";
88/******/
89/******/
90/******/ 	// Load entry module and return exports
91/******/ 	return __webpack_require__(__webpack_require__.s = 151);
92/******/ })
93/************************************************************************/
94/******/ ([
95/* 0 */
96/***/ (function(module, exports, __webpack_require__) {
97
98var global = __webpack_require__(7);
99var getOwnPropertyDescriptor = __webpack_require__(117).f;
100var hide = __webpack_require__(21);
101var redefine = __webpack_require__(118);
102var setGlobal = __webpack_require__(75);
103var copyConstructorProperties = __webpack_require__(231);
104var isForced = __webpack_require__(235);
105
106/*
107  options.target      - name of the target object
108  options.global      - target is the global object
109  options.stat        - export as static methods of target
110  options.proto       - export as prototype methods of target
111  options.real        - real prototype method for the `pure` version
112  options.forced      - export even if the native feature is available

113  options.bind        - bind methods to the target, required for the `pure` version
114  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
115  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
116  options.sham        - add a flag to not completely full polyfills
117  options.enumerable  - export as enumerable property
118  options.noTargetGet - prevent calling a getter on target
119*/
120module.exports = function (options, source) {
121  var TARGET = options.target;
122  var GLOBAL = options.global;
123  var STATIC = options.stat;
124  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
125  if (GLOBAL) {
126    target = global;
127  } else if (STATIC) {
128    target = global[TARGET] || setGlobal(TARGET, {});
129  } else {
130    target = (global[TARGET] || {}).prototype;
131  }
132  if (target) for (key in source) {
133    sourceProperty = source[key];
134    if (options.noTargetGet) {
135      descriptor = getOwnPropertyDescriptor(target, key);
136      targetProperty = descriptor && descriptor.value;
137    } else targetProperty = target[key];
138    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
139    // contained in target
140    if (!FORCED && targetProperty !== undefined) {
141      if (typeof sourceProperty === typeof targetProperty) continue;
142      copyConstructorProperties(sourceProperty, targetProperty);
143    }
144    // add a flag to not completely full polyfills
145    if (options.sham || (targetProperty && targetProperty.sham)) {
146      hide(sourceProperty, 'sham', true);
147    }
148    // extend global
149    redefine(target, key, sourceProperty, options);
150  }
151};
152
153
154/***/ }),
155/* 1 */
156/***/ (function(module, exports) {
157
158function _interopRequireDefault(obj) {
159  return obj && obj.__esModule ? obj : {
160    "default": obj
161  };
162}
163
164module.exports = _interopRequireDefault;
165
166/***/ }),
167/* 2 */
168/***/ (function(module, exports) {
169
170/**
171 * Checks if `value` is classified as an `Array` object.
172 *
173 * @static
174 * @memberOf _
175 * @since 0.1.0
176 * @category Lang
177 * @param {*} value The value to check.
178 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
179 * @example
180 *
181 * _.isArray([1, 2, 3]);
182 * // => true
183 *
184 * _.isArray(document.body.children);
185 * // => false
186 *
187 * _.isArray('abc');
188 * // => false
189 *
190 * _.isArray(_.noop);
191 * // => false
192 */
193var isArray = Array.isArray;
194
195module.exports = isArray;
196
197
198/***/ }),
199/* 3 */
200/***/ (function(module, exports, __webpack_require__) {
201
202var toInteger = __webpack_require__(26);
203
204var min = Math.min;
205
206// `ToLength` abstract operation
207// https://tc39.github.io/ecma262/#sec-tolength
208module.exports = function (argument) {
209  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
210};
211
212
213/***/ }),
214/* 4 */
215/***/ (function(module, exports, __webpack_require__) {
216
217var requireObjectCoercible = __webpack_require__(73);
218
219// `ToObject` abstract operation
220// https://tc39.github.io/ecma262/#sec-toobject
221module.exports = function (argument) {
222  return Object(requireObjectCoercible(argument));
223};
224
225
226/***/ }),
227/* 5 */
228/***/ (function(module, exports, __webpack_require__) {
229
230var global = __webpack_require__(7);
231var shared = __webpack_require__(51);
232var uid = __webpack_require__(115);
233var NATIVE_SYMBOL = __webpack_require__(238);
234
235var Symbol = global.Symbol;
236var store = shared('wks');
237
238module.exports = function (name) {
239  return store[name] || (store[name] = NATIVE_SYMBOL && Symbol[name]
240    || (NATIVE_SYMBOL ? Symbol : uid)('Symbol.' + name));
241};
242
243
244/***/ }),
245/* 6 */
246/***/ (function(module, exports, __webpack_require__) {
247
248"use strict";
249
250
251var _interopRequireWildcard = __webpack_require__(39);
252
253Object.defineProperty(exports, "__esModule", {
254  value: true
255});
256var _exportNames = {
257  IX2EngineActionTypes: true,
258  IX2EngineConstants: true
259};
260exports.IX2EngineConstants = exports.IX2EngineActionTypes = void 0;
261
262var _triggerEvents = __webpack_require__(306);
263
264Object.keys(_triggerEvents).forEach(function (key) {
265  if (key === "default" || key === "__esModule") return;
266  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
267  Object.defineProperty(exports, key, {
268    enumerable: true,
269    get: function get() {
270      return _triggerEvents[key];
271    }
272  });
273});
274
275var _animationActions = __webpack_require__(307);
276

277Object.keys(_animationActions).forEach(function (key) {
278  if (key === "default" || key === "__esModule") return;
279  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
280  Object.defineProperty(exports, key, {
281    enumerable: true,
282    get: function get() {
283      return _animationActions[key];
284    }
285  });
286});
287
288var _triggerInteractions = __webpack_require__(308);
289
290Object.keys(_triggerInteractions).forEach(function (key) {
291  if (key === "default" || key === "__esModule") return;
292  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
293  Object.defineProperty(exports, key, {
294    enumerable: true,
295    get: function get() {
296      return _triggerInteractions[key];
297    }
298  });
299});
300
301var IX2EngineActionTypes = _interopRequireWildcard(__webpack_require__(309));
302
303exports.IX2EngineActionTypes = IX2EngineActionTypes;
304
305var IX2EngineConstants = _interopRequireWildcard(__webpack_require__(310));
306
307exports.IX2EngineConstants = IX2EngineConstants;
308
309/***/ }),
310/* 7 */
311/***/ (function(module, exports, __webpack_require__) {
312
313/* WEBPACK VAR INJECTION */(function(global) {var O = 'object';
314var check = function (it) {
315  return it && it.Math == Math && it;
316};
317
318// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
319module.exports =
320  // eslint-disable-next-line no-undef
321  check(typeof globalThis == O && globalThis) ||
322  check(typeof window == O && window) ||
323  check(typeof self == O && self) ||
324  check(typeof global == O && global) ||
325  // eslint-disable-next-line no-new-func
326  Function('return this')();
327
328/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(44)))
329
330/***/ }),
331/* 8 */
332/***/ (function(module, exports) {
333
334module.exports = function (exec) {
335  try {
336    return !!exec();
337  } catch (error) {
338    return true;
339  }
340};
341
342
343/***/ }),
344/* 9 */
345/***/ (function(module, exports, __webpack_require__) {
346
347"use strict";
348 // @wf-will-never-add-flow-to-this-file
349
350/* globals window, document, navigator, WEBFLOW_ENV_TEST */
351
352/* eslint-disable no-var */
353
354/**
355 * Webflow: Core site library
356 */
357
358var Webflow = {};
359var modules = {};
360var primary = [];
361var secondary = window.Webflow || [];
362var $ = window.jQuery;
363var $win = $(window);
364var $doc = $(document);
365var isFunction = $.isFunction;
366
367var _ = Webflow._ = __webpack_require__(153);
368
369var tram = Webflow.tram = __webpack_require__(91) && $.tram;
370var domready = false;
371var destroyed = false;
372tram.config.hideBackface = false;
373tram.config.keepInherited = true;
374/**
375 * Webflow.define - Define a named module
376 * @param  {string} name
377 * @param  {function} factory
378 * @param  {object} options
379 * @return {object}
380 */
381
382Webflow.define = function (name, factory, options) {
383  if (modules[name]) {
384    unbindModule(modules[name]);
385  }
386
387  var instance = modules[name] = factory($, _, options) || {};
388  bindModule(instance);
389  return instance;
390};
391/**
392 * Webflow.require - Require a named module
393 * @param  {string} name
394 * @return {object}
395 */
396
397
398Webflow.require = function (name) {
399  return modules[name];
400};
401
402function bindModule(module) {
403  // If running in Webflow app, subscribe to design/preview events
404  if (Webflow.env()) {
405    isFunction(module.design) && $win.on('__wf_design', module.design);
406    isFunction(module.preview) && $win.on('__wf_preview', module.preview);
407  } // Subscribe to front-end destroy event
408
409
410  isFunction(module.destroy) && $win.on('__wf_destroy', module.destroy); // Look for ready method on module
411
412  if (module.ready && isFunction(module.ready)) {
413    addReady(module);
414  }
415}
416
417function addReady(module) {
418  // If domready has already happened, run ready method
419  if (domready) {
420    module.ready();
421    return;
422  } // Otherwise add ready method to the primary queue (only once)
423
424
425  if (_.contains(primary, module.ready)) {
426    return;
427  }
428
429  primary.push(module.ready);
430}
431
432function unbindModule(module) {
433  // Unsubscribe module from window events
434  isFunction(module.design) && $win.off('__wf_design', module.design);
435  isFunction(module.preview) && $win.off('__wf_preview', module.preview);
436  isFunction(module.destroy) && $win.off('__wf_destroy', module.destroy); // Remove ready method from primary queue
437
438  if (module.ready && isFunction(module.ready)) {
439    removeReady(module);
440  }
441}
442
443function removeReady(module) {
444  primary = _.filter(primary, function (readyFn) {
445    return readyFn !== module.ready;
446  });
447}
448/**
449 * Webflow.push - Add a ready handler into secondary queue
450 * @param {function} ready  Callback to invoke on domready
451 */
452
453
454Webflow.push = function (ready) {
455  // If domready has already happened, invoke handler
456  if (domready) {
457    isFunction(ready) && ready();
458    return;
459  } // Otherwise push into secondary queue
460
461
462  secondary.push(ready);
463};
464/**
465 * Webflow.env - Get the state of the Webflow app
466 * @param {string} mode [optional]
467 * @return {boolean}
468 */
469
470
471Webflow.env = function (mode) {
472  var designFlag = window.__wf_design;
473  var inApp = typeof designFlag !== 'undefined';
474
475  if (!mode) {
476    return inApp;
477  }
478
479  if (mode === 'design') {
480    return inApp && designFlag;
481  }
482
483  if (mode === 'preview') {
484    return inApp && !designFlag;
485  }
486
487  if (mode === 'slug') {
488    return inApp && window.__wf_slug;
489  }
490
491  if (mode === 'editor') {
492    return window.WebflowEditor;
493  }
494
495  if (mode === 'test') {
496    return  false || window.__wf_test;
497  }
498
499  if (mode === 'frame') {
500    return window !== window.top;
501  }
502}; // Feature detects + browser sniffs  ಠ_ಠ
503
504
505var userAgent = navigator.userAgent.toLowerCase();
506var touch = Webflow.env.touch = 'ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch;
507var chrome = Webflow.env.chrome = /chrome/.test(userAgent) && /Google/.test(navigator.vendor) && parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
508var ios = Webflow.env.ios = /(ipod|iphone|ipad)/.test(userAgent);
509Webflow.env.safari = /safari/.test(userAgent) && !chrome && !ios; // Maintain current touch target to prevent late clicks on touch devices
510
511var touchTarget; // Listen for both events to support touch/mouse hybrid devices
512
513touch && $doc.on('touchstart mousedown', function (evt) {
514  touchTarget = evt.target;
515});
516/**
517 * Webflow.validClick - validate click target against current touch target
518 * @param  {HTMLElement} clickTarget  Element being clicked
519 * @return {Boolean}  True if click target is valid (always true on non-touch)
520 */
521
522Webflow.validClick = touch ? function (clickTarget) {
523  return clickTarget === touchTarget || $.contains(clickTarget, touchTarget);
524} : function () {
525  return true;
526};
527/**
528 * Webflow.resize, Webflow.scroll - throttled event proxies
529 */
530
531var resizeEvents = 'resize.webflow orientationchange.webflow load.webflow';

532var scrollEvents = 'scroll.webflow ' + resizeEvents;
533Webflow.resize = eventProxy($win, resizeEvents);
534Webflow.scroll = eventProxy($win, scrollEvents);
535Webflow.redraw = eventProxy(); // Create a proxy instance for throttled events
536
537function eventProxy(target, types) {
538  // Set up throttled method (using custom frame-based _.throttle)
539  var handlers = [];
540  var proxy = {};
541  proxy.up = _.throttle(function (evt) {
542    _.each(handlers, function (h) {
543      h(evt);
544    });
545  }); // Bind events to target
546
547  if (target && types) {
548    target.on(types, proxy.up);
549  }
550  /**
551   * Add an event handler
552   * @param  {function} handler
553   */
554
555
556  proxy.on = function (handler) {
557    if (typeof handler !== 'function') {
558      return;
559    }
560
561    if (_.contains(handlers, handler)) {
562      return;
563    }
564
565    handlers.push(handler);
566  };
567  /**
568   * Remove an event handler
569   * @param  {function} handler
570   */
571
572
573  proxy.off = function (handler) {
574    // If no arguments supplied, clear all handlers
575    if (!arguments.length) {
576      handlers = [];
577      return;
578    } // Otherwise, remove handler from the list
579
580
581    handlers = _.filter(handlers, function (h) {
582      return h !== handler;
583    });
584  };
585
586  return proxy;
587} // Webflow.location - Wrap window.location in api
588
589
590Webflow.location = function (url) {
591  window.location = url;
592};
593
594if (Webflow.env()) {
595  // Ignore redirects inside a Webflow design/edit environment
596  Webflow.location = function () {};
597} // Webflow.ready - Call primary and secondary handlers
598
599
600Webflow.ready = function () {
601  domready = true; // Restore modules after destroy
602
603  if (destroyed) {
604    restoreModules(); // Otherwise run primary ready methods
605  } else {
606    _.each(primary, callReady);
607  } // Run secondary ready methods
608
609
610  _.each(secondary, callReady); // Trigger resize
611
612
613  Webflow.resize.up();
614};
615
616function callReady(readyFn) {
617  isFunction(readyFn) && readyFn();
618}
619
620function restoreModules() {
621  destroyed = false;
622
623  _.each(modules, bindModule);
624}
625/**
626 * Webflow.load - Add a window load handler that will run even if load event has already happened
627 * @param  {function} handler
628 */
629
630
631var deferLoad;
632
633Webflow.load = function (handler) {
634  deferLoad.then(handler);
635};
636
637function bindLoad() {
638  // Reject any previous deferred (to support destroy)
639  if (deferLoad) {
640    deferLoad.reject();
641    $win.off('load', deferLoad.resolve);
642  } // Create deferred and bind window load event
643
644
645  deferLoad = new $.Deferred();
646  $win.on('load', deferLoad.resolve);
647} // Webflow.destroy - Trigger a destroy event for all modules
648
649
650Webflow.destroy = function (options) {
651  options = options || {};
652  destroyed = true;
653  $win.triggerHandler('__wf_destroy'); // Allow domready reset for tests
654
655  if (options.domready != null) {
656    domready = options.domready;
657  } // Unbind modules
658
659
660  _.each(modules, unbindModule); // Clear any proxy event handlers
661
662
663  Webflow.resize.off();
664  Webflow.scroll.off();
665  Webflow.redraw.off(); // Clear any queued ready methods
666
667  primary = [];
668  secondary = []; // If load event has not yet fired, replace the deferred
669
670  if (deferLoad.state() === 'pending') {
671    bindLoad();
672  }
673}; // Listen for domready
674
675
676$(Webflow.ready); // Listen for window.onload and resolve deferred
677
678bindLoad(); // Export commonjs module
679
680module.exports = window.Webflow = Webflow;
681
682/***/ }),
683/* 10 */
684/***/ (function(module, exports, __webpack_require__) {
685
686var freeGlobal = __webpack_require__(96);
687
688/** Detect free variable `self`. */
689var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
690
691/** Used as a reference to the global object. */
692var root = freeGlobal || freeSelf || Function('return this')();
693
694module.exports = root;
695
696
697/***/ }),
698/* 11 */
699/***/ (function(module, exports, __webpack_require__) {
700
701var wellKnownSymbol = __webpack_require__(5);
702var create = __webpack_require__(123);
703var hide = __webpack_require__(21);
704
705var UNSCOPABLES = wellKnownSymbol('unscopables');
706var ArrayPrototype = Array.prototype;
707
708// Array.prototype[@@unscopables]
709// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
710if (ArrayPrototype[UNSCOPABLES] == undefined) {
711  hide(ArrayPrototype, UNSCOPABLES, create(null));
712}
713
714// add a key to Array.prototype[@@unscopables]
715module.exports = function (key) {
716  ArrayPrototype[UNSCOPABLES][key] = true;
717};
718
719
720/***/ }),
721/* 12 */

722/***/ (function(module, exports) {
723
724/**
725 * Checks if `value` is the
726 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
727 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
728 *
729 * @static
730 * @memberOf _
731 * @since 0.1.0
732 * @category Lang
733 * @param {*} value The value to check.
734 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
735 * @example
736 *
737 * _.isObject({});
738 * // => true
739 *
740 * _.isObject([1, 2, 3]);
741 * // => true
742 *
743 * _.isObject(_.noop);
744 * // => true
745 *
746 * _.isObject(null);
747 * // => false
748 */
749function isObject(value) {
750  var type = typeof value;
751  return value != null && (type == 'object' || type == 'function');
752}
753
754module.exports = isObject;
755
756
757/***/ }),
758/* 13 */
759/***/ (function(module, exports, __webpack_require__) {
760
761"use strict";
762
763var fails = __webpack_require__(8);
764
765module.exports = function (METHOD_NAME, argument) {
766  var method = [][METHOD_NAME];
767  return !method || !fails(function () {
768    // eslint-disable-next-line no-useless-call,no-throw-literal
769    method.call(null, argument || function () { throw 1; }, 1);
770  });
771};
772
773
774/***/ }),
775/* 14 */
776/***/ (function(module, exports, __webpack_require__) {
777
778var fails = __webpack_require__(8);
779
780// Thank's IE8 for his funny defineProperty
781module.exports = !fails(function () {
782  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
783});
784
785
786/***/ }),
787/* 15 */
788/***/ (function(module, exports, __webpack_require__) {
789
790var DESCRIPTORS = __webpack_require__(14);
791var IE8_DOM_DEFINE = __webpack_require__(113);
792var anObject = __webpack_require__(27);
793var toPrimitive = __webpack_require__(76);
794
795var nativeDefineProperty = Object.defineProperty;
796
797// `Object.defineProperty` method
798// https://tc39.github.io/ecma262/#sec-object.defineproperty
799exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
800  anObject(O);
801  P = toPrimitive(P, true);
802  anObject(Attributes);
803  if (IE8_DOM_DEFINE) try {
804    return nativeDefineProperty(O, P, Attributes);
805  } catch (error) { /* empty */ }
806  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
807  if ('value' in Attributes) O[P] = Attributes.value;
808  return O;
809};
810
811
812/***/ }),
813/* 16 */
814/***/ (function(module, exports) {
815
816module.exports = function (it) {
817  return typeof it === 'object' ? it !== null : typeof it === 'function';
818};
819
820
821/***/ }),
822/* 17 */
823/***/ (function(module, exports) {
824
825var hasOwnProperty = {}.hasOwnProperty;
826
827module.exports = function (it, key) {
828  return hasOwnProperty.call(it, key);
829};
830
831
832/***/ }),
833/* 18 */
834/***/ (function(module, exports, __webpack_require__) {
835
836var baseMatches = __webpack_require__(157),
837    baseMatchesProperty = __webpack_require__(211),
838    identity = __webpack_require__(71),
839    isArray = __webpack_require__(2),
840    property = __webpack_require__(220);
841
842/**
843 * The base implementation of `_.iteratee`.
844 *
845 * @private
846 * @param {*} [value=_.identity] The value to convert to an iteratee.
847 * @returns {Function} Returns the iteratee.
848 */
849function baseIteratee(value) {
850  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
851  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
852  if (typeof value == 'function') {
853    return value;
854  }
855  if (value == null) {
856    return identity;
857  }
858  if (typeof value == 'object') {
859    return isArray(value)
860      ? baseMatchesProperty(value[0], value[1])
861      : baseMatches(value);
862  }
863  return property(value);
864}
865
866module.exports = baseIteratee;
867
868
869/***/ }),
870/* 19 */
871/***/ (function(module, exports, __webpack_require__) {
872
873var baseIsNative = __webpack_require__(169),
874    getValue = __webpack_require__(174);
875
876/**
877 * Gets the native function at `key` of `object`.
878 *
879 * @private
880 * @param {Object} object The object to query.
881 * @param {string} key The key of the method to get.
882 * @returns {*} Returns the function if it's native, else `undefined`.
883 */
884function getNative(object, key) {
885  var value = getValue(object, key);
886  return baseIsNative(value) ? value : undefined;
887}
888
889module.exports = getNative;
890
891
892/***/ }),
893/* 20 */

894/***/ (function(module, exports) {
895
896/**
897 * Checks if `value` is object-like. A value is object-like if it's not `null`
898 * and has a `typeof` result of "object".
899 *
900 * @static
901 * @memberOf _
902 * @since 4.0.0
903 * @category Lang
904 * @param {*} value The value to check.
905 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
906 * @example
907 *
908 * _.isObjectLike({});
909 * // => true
910 *
911 * _.isObjectLike([1, 2, 3]);
912 * // => true
913 *
914 * _.isObjectLike(_.noop);
915 * // => false
916 *
917 * _.isObjectLike(null);
918 * // => false
919 */
920function isObjectLike(value) {
921  return value != null && typeof value == 'object';
922}
923
924module.exports = isObjectLike;
925
926
927/***/ }),
928/* 21 */
929/***/ (function(module, exports, __webpack_require__) {
930
931var DESCRIPTORS = __webpack_require__(14);
932var definePropertyModule = __webpack_require__(15);
933var createPropertyDescriptor = __webpack_require__(52);
934
935module.exports = DESCRIPTORS ? function (object, key, value) {
936  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
937} : function (object, key, value) {
938  object[key] = value;
939  return object;
940};
941
942
943/***/ }),
944/* 22 */
945/***/ (function(module, exports, __webpack_require__) {
946
947// toObject with fallback for non-array-like ES3 strings
948var IndexedObject = __webpack_require__(53);
949var requireObjectCoercible = __webpack_require__(73);
950
951module.exports = function (it) {
952  return IndexedObject(requireObjectCoercible(it));
953};
954
955
956/***/ }),
957/* 23 */
958/***/ (function(module, exports, __webpack_require__) {
959
960var bind = __webpack_require__(54);
961var IndexedObject = __webpack_require__(53);
962var toObject = __webpack_require__(4);
963var toLength = __webpack_require__(3);
964var arraySpeciesCreate = __webpack_require__(37);
965
966var push = [].push;
967
968// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation
969var createMethod = function (TYPE) {
970  var IS_MAP = TYPE == 1;
971  var IS_FILTER = TYPE == 2;
972  var IS_SOME = TYPE == 3;
973  var IS_EVERY = TYPE == 4;
974  var IS_FIND_INDEX = TYPE == 6;
975  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
976  return function ($this, callbackfn, that, specificCreate) {
977    var O = toObject($this);
978    var self = IndexedObject(O);
979    var boundFunction = bind(callbackfn, that, 3);
980    var length = toLength(self.length);
981    var index = 0;
982    var create = specificCreate || arraySpeciesCreate;
983    var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
984    var value, result;
985    for (;length > index; index++) if (NO_HOLES || index in self) {
986      value = self[index];
987      result = boundFunction(value, index, O);
988      if (TYPE) {
989        if (IS_MAP) target[index] = result; // map
990        else if (result) switch (TYPE) {
991          case 3: return true;              // some
992          case 5: return value;             // find
993          case 6: return index;             // findIndex
994          case 2: push.call(target, value); // filter
995        } else if (IS_EVERY) return false;  // every
996      }
997    }
998    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
999  };
1000};
1001
1002module.exports = {
1003  // `Array.prototype.forEach` method
1004  // https://tc39.github.io/ecma262/#sec-array.prototype.foreach
1005  forEach: createMethod(0),
1006  // `Array.prototype.map` method
1007  // https://tc39.github.io/ecma262/#sec-array.prototype.map
1008  map: createMethod(1),
1009  // `Array.prototype.filter` method
1010  // https://tc39.github.io/ecma262/#sec-array.prototype.filter
1011  filter: createMethod(2),
1012  // `Array.prototype.some` method
1013  // https://tc39.github.io/ecma262/#sec-array.prototype.some
1014  some: createMethod(3),
1015  // `Array.prototype.every` method
1016  // https://tc39.github.io/ecma262/#sec-array.prototype.every
1017  every: createMethod(4),
1018  // `Array.prototype.find` method
1019  // https://tc39.github.io/ecma262/#sec-array.prototype.find
1020  find: createMethod(5),
1021  // `Array.prototype.findIndex` method
1022  // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex
1023  findIndex: createMethod(6)
1024};
1025
1026
1027/***/ }),
1028/* 24 */
1029/***/ (function(module, exports, __webpack_require__) {
1030
1031var Symbol = __webpack_require__(32),
1032    getRawTag = __webpack_require__(170),
1033    objectToString = __webpack_require__(171);
1034
1035/** `Object#toString` result references. */
1036var nullTag = '[object Null]',

1037    undefinedTag = '[object Undefined]';
1038
1039/** Built-in value references. */
1040var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
1041
1042/**
1043 * The base implementation of `getTag` without fallbacks for buggy environments.
1044 *
1045 * @private
1046 * @param {*} value The value to query.
1047 * @returns {string} Returns the `toStringTag`.
1048 */
1049function baseGetTag(value) {
1050  if (value == null) {
1051    return value === undefined ? undefinedTag : nullTag;
1052  }
1053  return (symToStringTag && symToStringTag in Object(value))
1054    ? getRawTag(value)
1055    : objectToString(value);
1056}
1057
1058module.exports = baseGetTag;
1059
1060
1061/***/ }),
1062/* 25 */
1063/***/ (function(module, exports, __webpack_require__) {
1064
1065var isFunction = __webpack_require__(95),
1066    isLength = __webpack_require__(64);
1067
1068/**
1069 * Checks if `value` is array-like. A value is considered array-like if it's
1070 * not a function and has a `value.length` that's an integer greater than or
1071 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
1072 *
1073 * @static
1074 * @memberOf _
1075 * @since 4.0.0
1076 * @category Lang
1077 * @param {*} value The value to check.
1078 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
1079 * @example
1080 *
1081 * _.isArrayLike([1, 2, 3]);
1082 * // => true
1083 *
1084 * _.isArrayLike(document.body.children);
1085 * // => true
1086 *
1087 * _.isArrayLike('abc');
1088 * // => true
1089 *
1090 * _.isArrayLike(_.noop);
1091 * // => false
1092 */
1093function isArrayLike(value) {
1094  return value != null && isLength(value.length) && !isFunction(value);
1095}
1096
1097module.exports = isArrayLike;
1098
1099
1100/***/ }),
1101/* 26 */
1102/***/ (function(module, exports) {
1103
1104var ceil = Math.ceil;
1105var floor = Math.floor;
1106
1107// `ToInteger` abstract operation
1108// https://tc39.github.io/ecma262/#sec-tointeger
1109module.exports = function (argument) {
1110  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
1111};
1112
1113
1114/***/ }),
1115/* 27 */
1116/***/ (function(module, exports, __webpack_require__) {
1117
1118var isObject = __webpack_require__(16);
1119
1120module.exports = function (it) {
1121  if (!isObject(it)) {
1122    throw TypeError(String(it) + ' is not an object');
1123  } return it;
1124};
1125
1126
1127/***/ }),
1128/* 28 */
1129/***/ (function(module, exports, __webpack_require__) {
1130
1131var classof = __webpack_require__(80);
1132
1133// `IsArray` abstract operation
1134// https://tc39.github.io/ecma262/#sec-isarray
1135module.exports = Array.isArray || function isArray(arg) {
1136  return classof(arg) == 'Array';
1137};
1138
1139
1140/***/ }),
1141/* 29 */
1142/***/ (function(module, exports, __webpack_require__) {
1143
1144"use strict";
1145
1146
1147var _interopRequireWildcard = __webpack_require__(39);
1148
1149Object.defineProperty(exports, "__esModule", {
1150  value: true
1151});
1152exports.IX2VanillaUtils = exports.IX2VanillaPlugins = exports.IX2ElementsReducer = exports.IX2EasingUtils = exports.IX2Easings = exp

1152orts.IX2BrowserSupport = void 0;
1153
1154var IX2BrowserSupport = _interopRequireWildcard(__webpack_require__(86));
1155
1156exports.IX2BrowserSupport = IX2BrowserSupport;
1157
1158var IX2Easings = _interopRequireWildcard(__webpack_require__(137));
1159
1160exports.IX2Easings = IX2Easings;
1161
1162var IX2EasingUtils = _interopRequireWildcard(__webpack_require__(139));
1163
1164exports.IX2EasingUtils = IX2EasingUtils;
1165
1166var IX2ElementsReducer = _interopRequireWildcard(__webpack_require__(316));
1167
1168exports.IX2ElementsReducer = IX2ElementsReducer;
1169
1170var IX2VanillaPlugins = _interopRequireWildcard(__webpack_require__(141));
1171
1172exports.IX2VanillaPlugins = IX2VanillaPlugins;
1173
1174var IX2VanillaUtils = _interopRequireWildcard(__webpack_require__(318));
1175
1176exports.IX2VanillaUtils = IX2VanillaUtils;
1177
1178/***/ }),
1179/* 30 */
1180/***/ (function(module, exports) {
1181
1182function _extends() {
1183  module.exports = _extends = Object.assign || function (target) {
1184    for (var i = 1; i < arguments.length; i++) {
1185      var source = arguments[i];
1186
1187      for (var key in source) {
1188        if (Object.prototype.hasOwnProperty.call(source, key)) {
1189          target[key] = source[key];
1190        }
1191      }
1192    }
1193
1194    return target;
1195  };
1196
1197  return _extends.apply(this, arguments);
1198}
1199
1200module.exports = _extends;
1201
1202/***/ }),
1203/* 31 */
1204/***/ (function(module, exports) {
1205
1206function _defineProperty(obj, key, value) {
1207  if (key in obj) {
1208    Object.defineProperty(obj, key, {
1209      value: value,
1210      enumerable: true,
1211      configurable: true,
1212      writable: true
1213    });
1214  } else {
1215    obj[key] = value;
1216  }
1217
1218  return obj;
1219}
1220
1221module.exports = _defineProperty;
1222
1223/***/ }),
1224/* 32 */
1225/***/ (function(module, exports, __webpack_require__) {
1226
1227var root = __webpack_require__(10);
1228
1229/** Built-in value references. */
1230var Symbol = root.Symbol;
1231
1232module.exports = Symbol;
1233
1234
1235/***/ }),
1236/* 33 */
1237/***/ (function(module, exports, __webpack_require__) {
1238
1239var isSymbol = __webpack_require__(50);
1240
1241/** Used as references for various `Number` constants. */
1242var INFINITY = 1 / 0;
1243
1244/**
1245 * Converts `value` to a string key if it's not a string or symbol.
1246 *
1247 * @private
1248 * @param {*} value The value to inspect.
1249 * @returns {string|symbol} Returns the key.
1250 */
1251function toKey(value) {
1252  if (typeof value == 'string' || isSymbol(value)) {
1253    return value;
1254  }
1255  var result = (value + '');
1256  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
1257}
1258
1259module.exports = toKey;
1260
1261
1262/***/ }),
1263/* 34 */
1264/***/ (function(module, exports, __webpack_require__) {
1265
1266var toInteger = __webpack_require__(26);
1267
1268var max = Math.max;
1269var min = Math.min;
1270
1271// Helper for a popular repeating case of the spec:
1272// Let integer be ? ToInteger(index).
1273// If integer < 0, let result be max((length + integer), 0); else let result be min(length, length).
1274module.exports = function (index, length) {
1275  var integer = toInteger(index);
1276  return integer < 0 ? max(integer + length, 0) : min(integer, length);
1277};
1278
1279
1280/***/ }),
1281/* 35 */
1282/***/ (function(module, exports) {
1283
1284module.exports = {};
1285
1286
1287/***/ }),
1288/* 36 */
1289/***/ (function(module, exports, __webpack_require__) {
1290
1291"use strict";
1292
1293var toPrimitive = __webpack_require__(76);
1294var definePropertyModule = __webpack_require__(15);
1295var createPropertyDescriptor = __webpack_require__(52);
1296
1297module.exports = function (object, key, value) {
1298  var propertyKey = toPrimitive(key);
1299  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
1300  else object[propertyKey] = value;
1301};
1302
1303
1304/***/ }),
1305/* 37 */
1306/***/ (function(module, exports, __webpack_require__) {
1307
1308var isObject = __webpack_require__(16);
1309var isArray = __webpack_require__(28);
1310var wellKnownSymbol = __webpack_require__(5);
1311
1312var SPECIES = wellKnownSymbol('species');
1313
1314// `ArraySpeciesCreate` abstract operation
1315// https://tc39.github.io/ecma262/#sec-arrayspeciescreate
1316module.exports = function (originalArray, length) {
1317  var C;
1318  if (isArray(originalArray)) {
1319    C = originalArray.constructor;
1320    // cross-realm fallback
1321    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
1322    else if (isObject(C)) {
1323      C = C[SPECIES];
1324      if (C === null) C = undefined;
1325    }
1326  } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);
1327};
1328
1329
1330/***/ }),
1331/* 38 */
1332/***/ (function(module, exports, __webpack_require__) {
1333
1334var fails = __webpack_require__(8);
1335var wellKnownSymbol = __webpack_require__(5);
1336
1337var SPECIES = wellKnownSymbol('species');
1338
1339module.exports = function (METHOD_NAME) {
1340  return !fails(function () {
1341    var array = [];
1342    var constructor = array.constructor = {};
1343    constructor[SPECIES] = function () {
1344      return { foo: 1 };
1345    };
1346    return array[METHOD_NAME](Boolean).foo !== 1;
1347  });
1348};
1349
1350
1351/***/ }),
1352/* 39 */

1353/***/ (function(module, exports) {
1354
1355function _interopRequireWildcard(obj) {
1356  if (obj && obj.__esModule) {
1357    return obj;
1358  } else {
1359    var newObj = {};
1360
1361    if (obj != null) {
1362      for (var key in obj) {
1363        if (Object.prototype.hasOwnProperty.call(obj, key)) {
1364          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
1365
1366          if (desc.get || desc.set) {
1367            Object.defineProperty(newObj, key, desc);
1368          } else {
1369            newObj[key] = obj[key];
1370          }
1371        }
1372      }
1373    }
1374
1375    newObj["default"] = obj;
1376    return newObj;
1377  }
1378}
1379
1380module.exports = _interopRequireWildcard;
1381
1382/***/ }),
1383/* 40 */
1384/***/ (function(module, exports, __webpack_require__) {
1385
1386"use strict";
1387
1388
1389Object.defineProperty(exports, "__esModule", {
1390  value: true
1391});
1392
1393var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
1394
1395exports.clone = clone;
1396exports.addLast = addLast;
1397exports.addFirst = addFirst;
1398exports.removeLast = removeLast;
1399exports.removeFirst = removeFirst;
1400exports.insert = insert;
1401exports.removeAt = removeAt;
1402exports.replaceAt = replaceAt;
1403exports.getIn = getIn;
1404exports.set = set;
1405exports.setIn = setIn;
1406exports.update = update;
1407exports.updateIn = updateIn;
1408exports.merge = merge;
1409exports.mergeDeep = mergeDeep;
1410exports.mergeIn = mergeIn;
1411exports.omit = omit;
1412exports.addDefaults = addDefaults;
1413
1414
1415/*!
1416 * Timm
1417 *
1418 * Immutability helpers with fast reads and acceptable writes.
1419 *
1420 * @copyright Guillermo Grau Panea 2016
1421 * @license MIT
1422 */
1423
1424var INVALID_ARGS = 'INVALID_ARGS';
1425
1426// ===============================================
1427// ### Helpers
1428// ===============================================
1429
1430
1431function throwStr(msg) {
1432  throw new Error(msg);
1433}
1434
1435function getKeysAndSymbols(obj) {
1436  var keys = Object.keys(obj);
1437  if (Object.getOwnPropertySymbols) {
1438    return keys.concat(Object.getOwnPropertySymbols(obj));
1439  }
1440  return keys;
1441}
1442
1443var hasOwnProperty = {}.hasOwnProperty;
1444
1445function clone(obj) {
1446  if (Array.isArray(obj)) return obj.slice();
1447  var keys = getKeysAndSymbols(obj);
1448  var out = {};
1449  for (var i = 0; i < keys.length; i++) {
1450    var key = keys[i];
1451    out[key] = obj[key];
1452  }
1453  return out;
1454}
1455
1456function doMerge(fAddDefaults, fDeep, first) {
1457  var out = first;
1458  !(out != null) && throwStr( false ? undefined : INVALID_ARGS);
1459  var fChanged = false;
1460
1461  for (var _len = arguments.length, rest = Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
1462    rest[_key - 3] = arguments[_key];
1463  }
1464
1465  for (var idx = 0; idx < rest.length; idx++) {
1466    var obj = rest[idx];
1467    if (obj == null) continue;
1468    var keys = getKeysAndSymbols(obj);
1469    if (!keys.length) continue;
1470    for (var j = 0; j <= keys.length; j++) {
1471      var key = keys[j];
1472      if (fAddDefaults && out[key] !== undefined) continue;
1473      var nextVal = obj[key];
1474      if (fDeep && isObject(out[key]) && isObject(nextVal)) {
1475        nextVal = doMerge(fAddDefaults, fDeep, out[key], nextVal);
1476      }

1477      if (nextVal === undefined || nextVal === out[key]) continue;
1478      if (!fChanged) {
1479        fChanged = true;
1480        out = clone(out);
1481      }
1482      out[key] = nextVal;
1483    }
1484  }
1485  return out;
1486}
1487
1488function isObject(o) {
1489  var type = typeof o === 'undefined' ? 'undefined' : _typeof(o);
1490  return o != null && (type === 'object' || type === 'function');
1491}
1492
1493// _deepFreeze = (obj) ->
1494//   Object.freeze obj
1495//   for key in Object.getOwnPropertyNames obj
1496//     val = obj[key]
1497//     if isObject(val) and not Object.isFrozen val
1498//       _deepFreeze val
1499//   obj
1500
1501// ===============================================
1502// -- ### Arrays
1503// ===============================================
1504
1505// -- #### addLast()
1506// -- Returns a new array with an appended item or items.
1507// --
1508// -- Usage: `addLast<T>(array: Array<T>, val: Array<T>|T): Array<T>`
1509// --
1510// -- ```js
1511// -- arr = ['a', 'b']
1512// -- arr2 = addLast(arr, 'c')
1513// -- // ['a', 'b', 'c']
1514// -- arr2 === arr
1515// -- // false
1516// -- arr3 = addLast(arr, ['c', 'd'])
1517// -- // ['a', 'b', 'c', 'd']
1518// -- ```
1519// `array.concat(val)` also handles the scalar case,
1520// but is apparently very slow
1521function addLast(array, val) {
1522  if (Array.isArray(val)) return array.concat(val);
1523  return array.concat([val]);
1524}
1525
1526// -- #### addFirst()
1527// -- Returns a new array with a prepended item or items.
1528// --
1529// -- Usage: `addFirst<T>(array: Array<T>, val: Array<T>|T): Array<T>`
1530// --
1531// -- ```js
1532// -- arr = ['a', 'b']
1533// -- arr2 = addFirst(arr, 'c')
1534// -- // ['c', 'a', 'b']
1535// -- arr2 === arr
1536// -- // false
1537// -- arr3 = addFirst(arr, ['c', 'd'])
1538// -- // ['c', 'd', 'a', 'b']
1539// -- ```
1540function addFirst(array, val) {
1541  if (Array.isArray(val)) return val.concat(array);
1542  return [val].concat(array);
1543}
1544
1545// -- #### removeLast()
1546// -- Returns a new array removing the last item.
1547// --
1548// -- Usage: `removeLast<T>(array: Array<T>): Array<T>`
1549// --
1550// -- ```js
1551// -- arr = ['a', 'b']
1552// -- arr2 = removeLast(arr)
1553// -- // ['a']
1554// -- arr2 === arr
1555// -- // false
1556// --
1557// -- // The same array is returned if there are no changes:
1558// -- arr3 = []
1559// -- removeLast(arr3) === arr3
1560// -- // true
1561// -- ```
1562function removeLast(array) {
1563  if (!array.length) return array;
1564  return array.slice(0, array.length - 1);
1565}
1566
1567// -- #### removeFirst()
1568// -- Returns a new array removing the first item.
1569// --
1570// -- Usage: `removeFirst<T>(array: Array<T>): Array<T>`
1571// --
1572// -- ```js
1573// -- arr = ['a', 'b']
1574// -- arr2 = removeFirst(arr)
1575// -- // ['b']
1576// -- arr2 === arr
1577// -- // false
1578// --
1579// -- // The same array is returned if there are no changes:
1580// -- arr3 = []
1581// -- removeFirst(arr3) === arr3
1582// -- // true
1583// -- ```
1584function removeFirst(array) {
1585  if (!array.length) return array;
1586  return array.slice(1);
1587}
1588
1589// -- #### insert()
1590// -- Returns a new array obtained by inserting an item or items
1591// -- at a specified index.
1592// --
1593// -- Usage: `insert<T>(array: Array<T>, idx: number, val: Array<T>|T): Array<T>`
1594// --
1595// -- ```js
1596// -- arr = ['a', 'b', 'c']
1597// -- arr2 = insert(arr, 1, 'd')
1598// -- // ['a', 'd', 'b', 'c']
1599// -- arr2 === arr
1600// -- // false
1601// -- insert(arr, 1, ['d', 'e'])
1602// -- // ['a', 'd', 'e', 'b', 'c']
1603// -- ```
1604function insert(array, idx, val) {
1605  return array.slice(0, idx).concat(Array.isArray(val) ? val : [val]).concat(array.slice(idx));
1606}
1607
1608// -- #### removeAt()
1609// -- Returns a new array obtained by removing an item at
1610// -- a specified index.
1611// --
1612// -- Usage: `removeAt<T>(array: Array<T>, idx: number): Array<T>`
1613// --
1614// -- ```js
1615// -- arr = ['a', 'b', 'c']
1616// -- arr2 = removeAt(arr, 1)
1617// -- // ['a', 'c']
1618// -- arr2 === arr
1619// -- // false
1620// --
1621// -- // The same array is returned if there are no changes:
1622// -- removeAt(arr, 4) === arr
1623// -- // true
1624// -- ```
1625function removeAt(array, idx) {
1626  if (idx >= array.length || idx < 0) return array;
1627  return array.slice(0, idx).concat(array.slice(idx + 1));
1628}
1629
1630// -- #### replaceAt()
1631// -- Returns a new array obtained by replacing an item at
1632// -- a specified index. If the provided item is the same as
1633// -- (*referentially equal to*) the previous item at that position,
1634// -- the original array is returned.
1635// --
1636// -- Usage: `replaceAt<T>(array: Array<T>, idx: number, newItem: T): Array<T>`
1637// --
1638// -- ```js
1639// -- arr = ['a', 'b', 'c']

1640// -- arr2 = replaceAt(arr, 1, 'd')
1641// -- // ['a', 'd', 'c']
1642// -- arr2 === arr
1643// -- // false
1644// --
1645// -- // The same object is returned if there are no changes:
1646// -- replaceAt(arr, 1, 'b') === arr
1647// -- // true
1648// -- ```
1649function replaceAt(array, idx, newItem) {
1650  if (array[idx] === newItem) return array;
1651  var len = array.length;
1652  var result = Array(len);
1653  for (var i = 0; i < len; i++) {
1654    result[i] = array[i];
1655  }
1656  result[idx] = newItem;
1657  return result;
1658}
1659
1660// ===============================================
1661// -- ### Collections (objects and arrays)
1662// ===============================================
1663// -- The following types are used throughout this section
1664// -- ```js
1665// -- type ArrayOrObject = Array<any>|Object;
1666// -- type Key = number|string;
1667// -- ```
1668
1669// -- #### getIn()
1670// -- Returns a value from an object at a given path. Works with
1671// -- nested arrays and objects. If the path does not exist, it returns
1672// -- `undefined`.
1673// --
1674// -- Usage: `getIn(obj: ?ArrayOrObject, path: Array<Key>): any`
1675// --
1676// -- ```js
1677// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: ['a', 'b', 'c'] }
1678// -- getIn(obj, ['d', 'd1'])
1679// -- // 3
1680// -- getIn(obj, ['e', 1])
1681// -- // 'b'
1682// -- ```
1683function getIn(obj, path) {
1684  !Array.isArray(path) && throwStr( false ? undefined : INVALID_ARGS);
1685  if (obj == null) return undefined;
1686  var ptr = obj;
1687  for (var i = 0; i < path.length; i++) {
1688    var key = path[i];
1689    ptr = ptr != null ? ptr[key] : undefined;
1690    if (ptr === undefined) return ptr;
1691  }
1692  return ptr;
1693}
1694
1695// -- #### set()
1696// -- Returns a new object with a modified attribute.
1697// -- If the provided value is the same as (*referentially equal to*)
1698// -- the previous value, the original object is returned.
1699// --
1700// -- Usage: `set<T>(obj: ?T, key: Key, val: any): T`
1701// --
1702// -- ```js
1703// -- obj = { a: 1, b: 2, c: 3 }
1704// -- obj2 = set(obj, 'b', 5)
1705// -- // { a: 1, b: 5, c: 3 }
1706// -- obj2 === obj
1707// -- // false
1708// --
1709// -- // The same object is returned if there are no changes:
1710// -- set(obj, 'b', 2) === obj
1711// -- // true
1712// -- ```
1713function set(obj, key, val) {
1714  var fallback = typeof key === 'number' ? [] : {};
1715  var finalObj = obj == null ? fallback : obj;
1716  if (finalObj[key] === val) return finalObj;
1717  var obj2 = clone(finalObj);
1718  obj2[key] = val;
1719  return obj2;
1720}
1721
1722// -- #### setIn()
1723// -- Returns a new object with a modified **nested** attribute.
1724// --
1725// -- Notes:
1726// --
1727// -- * If the provided value is the same as (*referentially equal to*)
1728// -- the previous value, the original object is returned.
1729// -- * If the path does not exist, it will be created before setting
1730// -- the new value.
1731// --
1732// -- Usage: `setIn<T: ArrayOrObject>(obj: T, path: Array<Key>, val: any): T`
1733// --
1734// -- ```js
1735// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1736// -- obj2 = setIn(obj, ['d', 'd1'], 4)
1737// -- // { a: 1, b: 2, d: { d1: 4, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1738// -- obj2 === obj
1739// -- // false
1740// -- obj2.d === obj.d
1741// -- // false
1742// -- obj2.e === obj.e
1743// -- // true
1744// --
1745// -- // The same object is returned if there are no changes:
1746// -- obj3 = setIn(obj, ['d', 'd1'], 3)
1747// -- // { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1748// -- obj3 === obj
1749// -- // true
1750// -- obj3.d === obj.d
1751// -- // true
1752// -- obj3.e === obj.e
1753// -- // true
1754// --
1755// -- // ... unknown paths create intermediate keys. Numeric segments are treated as array indices:
1756// -- setIn({ a: 3 }, ['unknown', 0, 'path'], 4)
1757// -- // { a: 3, unknown: [{ path: 4 }] }
1758// -- ```
1759function doSetIn(obj, path, val, idx) {
1760  var newValue = void 0;
1761  var key = path[idx];
1762  if (idx === path.length - 1) {
1763    newValue = val;
1764  } else {
1765    var nestedObj = isObject(obj) && isObject(obj[key]) ? obj[key] : typeof path[idx + 1] === 'number' ? [] : {};
1766    newValue = doSetIn(nestedObj, path, val, idx + 1);
1767  }
1768  return set(obj, key, newValue);
1769}
1770
1771function setIn(obj, path, val) {
1772  if (!path.length) return val;
1773  return doSetIn(obj, path, val, 0);
1774}
1775
1776// -- #### update()
1777// -- Returns a new object with a modified attribute,

1778// -- calculated via a user-provided callback based on the current value.
1779// -- If the calculated value is the same as (*referentially equal to*)
1780// -- the previous value, the original object is returned.
1781// --
1782// -- Usage: `update<T: ArrayOrObject>(obj: T, key: Key,
1783// -- fnUpdate: (prevValue: any) => any): T`
1784// --
1785// -- ```js
1786// -- obj = { a: 1, b: 2, c: 3 }
1787// -- obj2 = update(obj, 'b', (val) => val + 1)
1788// -- // { a: 1, b: 3, c: 3 }
1789// -- obj2 === obj
1790// -- // false
1791// --
1792// -- // The same object is returned if there are no changes:
1793// -- update(obj, 'b', (val) => val) === obj
1794// -- // true
1795// -- ```
1796function update(obj, key, fnUpdate) {
1797  var prevVal = obj == null ? undefined : obj[key];
1798  var nextVal = fnUpdate(prevVal);
1799  return set(obj, key, nextVal);
1800}
1801
1802// -- #### updateIn()
1803// -- Returns a new object with a modified **nested** attribute,
1804// -- calculated via a user-provided callback based on the current value.
1805// -- If the calculated value is the same as (*referentially equal to*)
1806// -- the previous value, the original object is returned.
1807// --
1808// -- Usage: `updateIn<T: ArrayOrObject>(obj: T, path: Array<Key>,
1809// -- fnUpdate: (prevValue: any) => any): T`
1810// --
1811// -- ```js
1812// -- obj = { a: 1, d: { d1: 3, d2: 4 } }
1813// -- obj2 = updateIn(obj, ['d', 'd1'], (val) => val + 1)
1814// -- // { a: 1, d: { d1: 4, d2: 4 } }
1815// -- obj2 === obj
1816// -- // false
1817// --
1818// -- // The same object is returned if there are no changes:
1819// -- obj3 = updateIn(obj, ['d', 'd1'], (val) => val)
1820// -- // { a: 1, d: { d1: 3, d2: 4 } }
1821// -- obj3 === obj
1822// -- // true
1823// -- ```
1824function updateIn(obj, path, fnUpdate) {
1825  var prevVal = getIn(obj, path);
1826  var nextVal = fnUpdate(prevVal);
1827  return setIn(obj, path, nextVal);
1828}
1829
1830// -- #### merge()
1831// -- Returns a new object built as follows: the overlapping keys from the
1832// -- second one overwrite the corresponding entries from the first one.
1833// -- Similar to `Object.assign()`, but immutable.
1834// --
1835// -- Usage:
1836// --
1837// -- * `merge(obj1: Object, obj2: ?Object): Object`
1838// -- * `merge(obj1: Object, ...objects: Array<?Object>): Object`
1839// --
1840// -- The unmodified `obj1` is returned if `obj2` does not *provide something
1841// -- new to* `obj1`, i.e. if either of the following
1842// -- conditions are true:
1843// --
1844// -- * `obj2` is `null` or `undefined`
1845// -- * `obj2` is an object, but it is empty
1846// -- * All attributes of `obj2` are `undefined`
1847// -- * All attributes of `obj2` are referentially equal to the
1848// --   corresponding attributes of `obj1`
1849// --
1850// -- Note that `undefined` attributes in `obj2` do not modify the
1851// -- corresponding attributes in `obj1`.
1852// --
1853// -- ```js
1854// -- obj1 = { a: 1, b: 2, c: 3 }
1855// -- obj2 = { c: 4, d: 5 }
1856// -- obj3 = merge(obj1, obj2)
1857// -- // { a: 1, b: 2, c: 4, d: 5 }
1858// -- obj3 === obj1
1859// -- // false
1860// --
1861// -- // The same object is returned if there are no changes:
1862// -- merge(obj1, { c: 3 }) === obj1
1863// -- // true
1864// -- ```
1865function merge(a, b, c, d, e, f) {
1866  for (var _len2 = arguments.length, rest = Array(_len2 > 6 ? _len2 - 6 : 0), _key2 = 6; _key2 < _len2; _key2++) {
1867    rest[_key2 - 6] = arguments[_key2];
1868  }
1869
1870  return rest.length ? doMerge.call.apply(doMerge, [null, false, false, a, b, c, d, e, f].concat(rest)) : doMerge(false, false, a, b, c, d, e, f);
1871}
1872
1873// -- #### mergeDeep()
1874// -- Returns a new object built as follows: the overlapping keys from the
1875// -- second one overwrite the corresponding entries from the first one.
1876// -- If both the first and second entries are objects they are merged recursively.
1877// -- Similar to `Object.assign()`, but immutable, and deeply merging.
1878// --
1879// -- Usage:
1880// --
1881// -- * `mergeDeep(obj1: Object, obj2: ?Object): Object`
1882// -- * `mergeDeep(obj1: Object, ...objects: Array<?Object>): Object`
1883// --
1884// -- The unmodified `obj1` is returned if `obj2` does not *provide something
1885// -- new to* `obj1`, i.e. if either of the following
1886// -- conditions are true:
1887// --
1888// -- * `obj2` is `null` or `undefined`
1889// -- * `obj2` is an object, but it is empty
1890// -- * All attributes of `obj2` are `undefined`
1891// -- * All attributes of `obj2` are referentially equal to the

1892// --   corresponding attributes of `obj1`
1893// --
1894// -- Note that `undefined` attributes in `obj2` do not modify the
1895// -- corresponding attributes in `obj1`.
1896// --
1897// -- ```js
1898// -- obj1 = { a: 1, b: 2, c: { a: 1 } }
1899// -- obj2 = { b: 3, c: { b: 2 } }
1900// -- obj3 = mergeDeep(obj1, obj2)
1901// -- // { a: 1, b: 3, c: { a: 1, b: 2 }  }
1902// -- obj3 === obj1
1903// -- // false
1904// --
1905// -- // The same object is returned if there are no changes:
1906// -- mergeDeep(obj1, { c: { a: 1 } }) === obj1
1907// -- // true
1908// -- ```
1909function mergeDeep(a, b, c, d, e, f) {
1910  for (var _len3 = arguments.length, rest = Array(_len3 > 6 ? _len3 - 6 : 0), _key3 = 6; _key3 < _len3; _key3++) {
1911    rest[_key3 - 6] = arguments[_key3];
1912  }
1913
1914  return rest.length ? doMerge.call.apply(doMerge, [null, false, true, a, b, c, d, e, f].concat(rest)) : doMerge(false, true, a, b, c, d, e, f);
1915}
1916
1917// -- #### mergeIn()
1918// -- Similar to `merge()`, but merging the value at a given nested path.
1919// -- Note that the returned type is the same as that of the first argument.
1920// --
1921// -- Usage:
1922// --
1923// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>, obj2: ?Object): T`
1924// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>,
1925// -- ...objects: Array<?Object>): T`
1926// --
1927// -- ```js
1928// -- obj1 = { a: 1, d: { b: { d1: 3, d2: 4 } } }
1929// -- obj2 = { d3: 5 }
1930// -- obj3 = mergeIn(obj1, ['d', 'b'], obj2)
1931// -- // { a: 1, d: { b: { d1: 3, d2: 4, d3: 5 } } }
1932// -- obj3 === obj1
1933// -- // false
1934// --
1935// -- // The same object is returned if there are no changes:
1936// -- mergeIn(obj1, ['d', 'b'], { d2: 4 }) === obj1
1937// -- // true
1938// -- ```
1939function mergeIn(a, path, b, c, d, e, f) {
1940  var prevVal = getIn(a, path);
1941  if (prevVal == null) prevVal = {};
1942  var nextVal = void 0;
1943
1944  for (var _len4 = arguments.length, rest = Array(_len4 > 7 ? _len4 - 7 : 0), _key4 = 7; _key4 < _len4; _key4++) {
1945    rest[_key4 - 7] = arguments[_key4];
1946  }
1947
1948  if (rest.length) {
1949    nextVal = doMerge.call.apply(doMerge, [null, false, false, prevVal, b, c, d, e, f].concat(rest));
1950  } else {
1951    nextVal = doMerge(false, false, prevVal, b, c, d, e, f);
1952  }
1953  return setIn(a, path, nextVal);
1954}
1955
1956// -- #### omit()
1957// -- Returns an object excluding one or several attributes.
1958// --
1959// -- Usage: `omit(obj: Object, attrs: Array<string>|string): Object`
1960//
1961// -- ```js
1962// -- obj = { a: 1, b: 2, c: 3, d: 4 }
1963// -- omit(obj, 'a')
1964// -- // { b: 2, c: 3, d: 4 }
1965// -- omit(obj, ['b', 'c'])
1966// -- // { a: 1, d: 4 }
1967// --
1968// -- // The same object is returned if there are no changes:
1969// -- omit(obj, 'z') === obj1
1970// -- // true
1971// -- ```
1972function omit(obj, attrs) {
1973  var omitList = Array.isArray(attrs) ? attrs : [attrs];
1974  var fDoSomething = false;
1975  for (var i = 0; i < omitList.length; i++) {
1976    if (hasOwnProperty.call(obj, omitList[i])) {
1977      fDoSomething = true;
1978      break;
1979    }
1980  }
1981  if (!fDoSomething) return obj;
1982  var out = {};
1983  var keys = getKeysAndSymbols(obj);
1984  for (var _i = 0; _i < keys.length; _i++) {
1985    var key = keys[_i];
1986    if (omitList.indexOf(key) >= 0) continue;
1987    out[key] = obj[key];
1988  }
1989  return out;
1990}
1991
1992// -- #### addDefaults()
1993// -- Returns a new object built as follows: `undefined` keys in the first one
1994// -- are filled in with the corresponding values from the second one
1995// -- (even if they are `null`).
1996// --
1997// -- Usage:
1998// --
1999// -- * `addDefaults(obj: Object, defaults: Object): Object`
2000// -- * `addDefaults(obj: Object, ...defaultObjects: Array<?Object>): Object`
2001// --
2002// -- ```js
2003// -- obj1 = { a: 1, b: 2, c: 3 }
2004// -- obj2 = { c: 4, d: 5, e: null }
2005// -- obj3 = addDefaults(obj1, obj2)
2006// -- // { a: 1, b: 2, c: 3, d: 5, e: null }
2007// -- obj3 === obj1
2008// -- // false
2009// --
2010// -- // The same object is returned if there are no changes:
2011// -- addDefaults(obj1, { c: 4 }) === obj1
2012// -- // true
2013// -- ```
2014function addDefaults(a, b, c, d, e, f) {
2015  for (var _len5 = arguments.length, rest = Array(_len5 > 6 ? _len5 - 6 : 0), _key5 = 6; _key5 < _len5; _key5++) {
2016    rest[_key5 - 6] = arguments[_key5];
2017  }
2018
2019  return rest.length ? doMerge.call.apply(doMerge, [null, true, false, a, b, c, d, e, f].concat(rest)) : doMerge(true, false, a, b, c, d, e, f);
2020}
2021
2022// ===============================================
2023// ### Public API
2024// ===============================================
2025var timm = {
2026  clone: clone,
2027  addLast: addLast,
2028  addFirst: addFirst,
2029  removeLast: removeLast,
2030  removeFirst: removeFirst,
2031  insert: insert,
2032  removeAt: removeAt,
2033  replaceAt: replaceAt,
2034
2035  getIn: getIn,
2036  // eslint-disable-next-line object-shorthand
2037  set: set, // so that flow doesn't complain
2038  setIn: setIn,
2039  update: update,
2040  updateIn: updateIn,
2041  merge: merge,
2042  mergeDeep: mergeDeep,
2043  mergeIn: mergeIn,
2044  omit: omit,
2045  addDefaults: addDefaults
2046};
2047
2048exports.default = timm;
2049
2050
2051/***/ }),
2052/* 41 */

2053/***/ (function(module, exports) {
2054
2055function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
2056
2057function _typeof(obj) {
2058  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
2059    module.exports = _typeof = function _typeof(obj) {
2060      return _typeof2(obj);
2061    };
2062  } else {
2063    module.exports = _typeof = function _typeof(obj) {
2064      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
2065    };
2066  }
2067
2068  return _typeof(obj);
2069}
2070
2071module.exports = _typeof;
2072
2073/***/ }),
2074/* 42 */
2075/***/ (function(module, exports, __webpack_require__) {
2076
2077var listCacheClear = __webpack_require__(159),
2078    listCacheDelete = __webpack_require__(160),
2079    listCacheGet = __webpack_require__(161),
2080    listCacheHas = __webpack_require__(162),
2081    listCacheSet = __webpack_require__(163);
2082
2083/**
2084 * Creates an list cache object.
2085 *
2086 * @private
2087 * @constructor
2088 * @param {Array} [entries] The key-value pairs to cache.
2089 */
2090function ListCache(entries) {
2091  var index = -1,
2092      length = entries == null ? 0 : entries.length;
2093
2094  this.clear();
2095  while (++index < length) {
2096    var entry = entries[index];
2097    this.set(entry[0], entry[1]);
2098  }
2099}
2100
2101// Add methods to `ListCache`.
2102ListCache.prototype.clear = listCacheClear;
2103ListCache.prototype['delete'] = listCacheDelete;
2104ListCache.prototype.get = listCacheGet;
2105ListCache.prototype.has = listCacheHas;
2106ListCache.prototype.set = listCacheSet;
2107
2108module.exports = ListCache;
2109
2110
2111/***/ }),
2112/* 43 */
2113/***/ (function(module, exports, __webpack_require__) {
2114
2115var eq = __webpack_require__(57);
2116
2117/**
2118 * Gets the index at which the `key` is found in `array` of key-value pairs.
2119 *
2120 * @private
2121 * @param {Array} array The array to inspect.
2122 * @param {*} key The key to search for.
2123 * @returns {number} Returns the index of the matched value, else `-1`.
2124 */
2125function assocIndexOf(array, key) {
2126  var length = array.length;
2127  while (length--) {
2128    if (eq(array[length][0], key)) {
2129      return length;
2130    }
2131  }
2132  return -1;
2133}
2134
2135module.exports = assocIndexOf;
2136
2137
2138/***/ }),
2139/* 44 */
2140/***/ (function(module, exports) {
2141
2142var g;
2143
2144// This works in non-strict mode
2145g = (function() {
2146	return this;
2147})();
2148
2149try {
2150	// This works if eval is allowed (see CSP)
2151	g = g || new Function("return this")();
2152} catch (e) {
2153	// This works if the window reference is available
2154	if (typeof window === "object") g = window;
2155}
2156
2157// g can still be undefined, but nothing to do about it...
2158// We return undefined, instead of nothing here, so it's
2159// easier to handle this case. if(!global) { ...}
2160
2161module.exports = g;
2162
2163
2164/***/ }),
2165/* 45 */
2166/***/ (function(module, exports, __webpack_require__) {
2167
2168var getNative = __webpack_require__(19);
2169
2170/* Built-in method references that are verified to be native. */
2171var nativeCreate = getNative(Object, 'create');
2172
2173module.exports = nativeCreate;
2174
2175
2176/***/ }),
2177/* 46 */
2178/***/ (function(module, exports, __webpack_require__) {
2179
2180var isKeyable = __webpack_require__(183);
2181
2182/**
2183 * Gets the data for `map`.
2184 *
2185 * @private
2186 * @param {Object} map The map to query.
2187 * @param {string} key The reference key.
2188 * @returns {*} Returns the map data.
2189 */
2190function getMapData(map, key) {
2191  var data = map.__data__;
2192  return isKeyable(key)
2193    ? data[typeof key == 'string' ? 'string' : 'hash']
2194    : data.map;
2195}
2196
2197module.exports = getMapData;
2198
2199
2200/***/ }),
2201/* 47 */
2202/***/ (function(module, exports, __webpack_require__) {
2203
2204var arrayLikeKeys = __webpack_require__(103),
2205    baseKeys = __webpack_require__(65),
2206    isArrayLike = __webpack_require__(25);
2207
2208/**
2209 * Creates an array of the own enumerable property names of `object`.
2210 *
2211 * **Note:** Non-object values are coerced to objects. See the
2212 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
2213 * for more details.
2214 *
2215 * @static
2216 * @since 0.1.0
2217 * @memberOf _
2218 * @category Object
2219 * @param {Object} object The object to query.
2220 * @returns {Array} Returns the array of property names.
2221 * @example
2222 *
2223 * function Foo() {
2224 *   this.a = 1;
2225 *   this.b = 2;
2226 * }
2227 *
2228 * Foo.prototype.c = 3;
2229 *
2230 * _.keys(new Foo);
2231 * // => ['a', 'b'] (iteration order is not guaranteed)
2232 *
2233 * _.keys('hi');
2234 * // => ['0', '1']
2235 */
2236function keys(object) {
2237  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
2238}
2239
2240module.exports = keys;
2241
2242
2243/***/ }),
2244/* 48 */
2245/***/ (function(module, exports, __webpack_require__) {
2246
2247var baseIsArguments = __webpack_require__(201),
2248    isObjectLike = __webpack_require__(20);
2249
2250/** Used for built-in method references. */
2251var objectProto = Object.prototype;
2252
2253/** Used to check objects for own properties. */
2254var hasOwnProperty = objectProto.hasOwnProperty;
2255
2256/** Built-in value references. */
2257var propertyIsEnumerable = objectProto.propertyIsEnumerable;
2258
2259/**
2260 * Checks if `value` is likely an `arguments` object.
2261 *
2262 * @static
2263 * @memberOf _
2264 * @since 0.1.0
2265 * @category Lang
2266 * @param {*} value The value to check.
2267 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
2268 *  else `false`.
2269 * @example
2270 *
2271 * _.isArguments(function() { return arguments; }());
2272 * // => true
2273 *
2274 * _.isArguments([1, 2, 3]);
2275 * // => false
2276 */
2277var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
2278  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
2279    !propertyIsEnumerable.call(value, 'callee');
2280};
2281
2282module.exports = isArguments;
2283
2284
2285/***/ }),
2286/* 49 */
2287/***/ (function(module, exports, __webpack_require__) {
2288
2289var isArray = __webpack_require__(2),
2290    isKey = __webpack_require__(70),
2291    stringToPath = __webpack_require__(212),
2292    toString = __webpack_require__(215);
2293
2294/**
2295 * Casts `value` to a path array if it's not one.
2296 *
2297 * @private
2298 * @param {*} value The value to inspect.
2299 * @param {Object} [object] The object to query keys on.
2300 * @returns {Array} Returns the cast property path array.

2301 */
2302function castPath(value, object) {
2303  if (isArray(value)) {
2304    return value;
2305  }
2306  return isKey(value, object) ? [value] : stringToPath(toString(value));
2307}
2308
2309module.exports = castPath;
2310
2311
2312/***/ }),
2313/* 50 */
2314/***/ (function(module, exports, __webpack_require__) {
2315
2316var baseGetTag = __webpack_require__(24),
2317    isObjectLike = __webpack_require__(20);
2318
2319/** `Object#toString` result references. */
2320var symbolTag = '[object Symbol]';
2321
2322/**
2323 * Checks if `value` is classified as a `Symbol` primitive or object.
2324 *
2325 * @static
2326 * @memberOf _
2327 * @since 4.0.0
2328 * @category Lang
2329 * @param {*} value The value to check.
2330 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
2331 * @example
2332 *
2333 * _.isSymbol(Symbol.iterator);
2334 * // => true
2335 *
2336 * _.isSymbol('abc');
2337 * // => false
2338 */
2339function isSymbol(value) {
2340  return typeof value == 'symbol' ||
2341    (isObjectLike(value) && baseGetTag(value) == symbolTag);
2342}
2343
2344module.exports = isSymbol;
2345
2346
2347/***/ }),
2348/* 51 */
2349/***/ (function(module, exports, __webpack_require__) {
2350
2351var global = __webpack_require__(7);
2352var setGlobal = __webpack_require__(75);
2353var IS_PURE = __webpack_require__(77);
2354
2355var SHARED = '__core-js_shared__';
2356var store = global[SHARED] || setGlobal(SHARED, {});
2357
2358(module.exports = function (key, value) {
2359  return store[key] || (store[key] = value !== undefined ? value : {});
2360})('versions', []).push({
2361  version: '3.1.3',
2362  mode: IS_PURE ? 'pure' : 'global',
2363  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
2364});
2365
2366
2367/***/ }),
2368/* 52 */
2369/***/ (function(module, exports) {
2370
2371module.exports = function (bitmap, value) {
2372  return {
2373    enumerable: !(bitmap & 1),
2374    configurable: !(bitmap & 2),
2375    writable: !(bitmap & 4),
2376    value: value
2377  };
2378};
2379
2380
2381/***/ }),
2382/* 53 */
2383/***/ (function(module, exports, __webpack_require__) {
2384
2385var fails = __webpack_require__(8);
2386var classof = __webpack_require__(80);
2387
2388var split = ''.split;
2389
2390// fallback for non-array-like ES3 and non-enumerable old V8 strings
2391module.exports = fails(function () {
2392  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
2393  // eslint-disable-next-line no-prototype-builtins
2394  return !Object('z').propertyIsEnumerable(0);
2395}) ? function (it) {
2396  return classof(it) == 'String' ? split.call(it, '') : Object(it);
2397} : Object;
2398
2399
2400/***/ }),
2401/* 54 */
2402/***/ (function(module, exports, __webpack_require__) {
2403
2404var aFunction = __webpack_require__(55);
2405
2406// optional / simple context binding
2407module.exports = function (fn, that, length) {
2408  aFunction(fn);
2409  if (that === undefined) return fn;
2410  switch (length) {
2411    case 0: return function () {
2412      return fn.call(that);
2413    };
2414    case 1: return function (a) {
2415      return fn.call(that, a);
2416    };
2417    case 2: return function (a, b) {
2418      return fn.call(that, a, b);
2419    };
2420    case 3: return function (a, b, c) {
2421      return fn.call(that, a, b, c);
2422    };
2423  }
2424  return function (/* ...args */) {
2425    return fn.apply(that, arguments);
2426  };
2427};
2428
2429
2430/***/ }),
2431/* 55 */
2432/***/ (function(module, exports) {
2433
2434module.exports = function (it) {
2435  if (typeof it != 'function') {
2436    throw TypeError(String(it) + ' is not a function');
2437  } return it;
2438};
2439
2440
2441/***/ }),
2442/* 56 */
2443/***/ (function(module, exports, __webpack_require__) {
2444
2445"use strict";

2446// @wf-will-never-add-flow-to-this-file
2447
2448/* globals window, document */
2449
2450/* eslint-disable no-var */
2451// eslint-disable-next-line strict
2452
2453
2454var IXEvents = __webpack_require__(287);
2455
2456function dispatchCustomEvent(element, eventName) {
2457  var event = document.createEvent('CustomEvent');
2458  event.initCustomEvent(eventName, true, true, null);
2459  element.dispatchEvent(event);
2460}
2461/**
2462 * Webflow: IX Event triggers for other modules
2463 */
2464
2465
2466var $ = window.jQuery;
2467var api = {};
2468var namespace = '.w-ix';
2469var eventTriggers = {
2470  reset: function reset(i, el) {
2471    IXEvents.triggers.reset(i, el);
2472  },
2473  intro: function intro(i, el) {
2474    IXEvents.triggers.intro(i, el);
2475    dispatchCustomEvent(el, 'COMPONENT_ACTIVE');
2476  },
2477  outro: function outro(i, el) {
2478    IXEvents.triggers.outro(i, el);
2479    dispatchCustomEvent(el, 'COMPONENT_INACTIVE');
2480  }
2481};
2482api.triggers = {};
2483api.types = {
2484  INTRO: 'w-ix-intro' + namespace,
2485  OUTRO: 'w-ix-outro' + namespace
2486};
2487$.extend(api.triggers, eventTriggers);
2488module.exports = api;
2489
2490/***/ }),
2491/* 57 */
2492/***/ (function(module, exports) {
2493
2494/**
2495 * Performs a
2496 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2497 * comparison between two values to determine if they are equivalent.
2498 *
2499 * @static
2500 * @memberOf _
2501 * @since 4.0.0
2502 * @category Lang
2503 * @param {*} value The value to compare.
2504 * @param {*} other The other value to compare.
2505 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
2506 * @example
2507 *
2508 * var object = { 'a': 1 };
2509 * var other = { 'a': 1 };
2510 *
2511 * _.eq(object, object);
2512 * // => true
2513 *
2514 * _.eq(object, other);
2515 * // => false
2516 *
2517 * _.eq('a', 'a');
2518 * // => true
2519 *
2520 * _.eq('a', Object('a'));
2521 * // => false
2522 *
2523 * _.eq(NaN, NaN);
2524 * // => true
2525 */
2526function eq(value, other) {
2527  return value === other || (value !== value && other !== other);
2528}
2529
2530module.exports = eq;
2531
2532
2533/***/ }),
2534/* 58 */
2535/***/ (function(module, exports, __webpack_require__) {
2536
2537var getNative = __webpack_require__(19),
2538    root = __webpack_require__(10);
2539
2540/* Built-in method references that are verified to be native. */
2541var Map = getNative(root, 'Map');
2542
2543module.exports = Map;
2544
2545
2546/***/ }),
2547/* 59 */
2548/***/ (function(module, exports, __webpack_require__) {
2549
2550var mapCacheClear = __webpack_require__(175),
2551    mapCacheDelete = __webpack_require__(182),
2552    mapCacheGet = __webpack_require__(184),
2553    mapCacheHas = __webpack_require__(185),
2554    mapCacheSet = __webpack_require__(186);
2555
2556/**
2557 * Creates a map cache object to store key-value pairs.
2558 *
2559 * @private
2560 * @constructor
2561 * @param {Array} [entries] The key-value pairs to cache.
2562 */
2563function MapCache(entries) {
2564  var index = -1,
2565      length = entries == null ? 0 : entries.length;
2566
2567  this.clear();
2568  while (++index < length) {
2569    var entry = entries[index];
2570    this.set(entry[0], entry[1]);
2571  }
2572}
2573
2574// Add methods to `MapCache`.
2575MapCache.prototype.clear = mapCacheClear;
2576MapCache.prototype['delete'] = mapCacheDelete;
2577MapCache.prototype.get = mapCacheGet;
2578MapCache.prototype.has = mapCacheHas;
2579MapCache.prototype.set = mapCacheSet;
2580
2581module.exports = MapCache;
2582
2583
2584/***/ }),
2585/* 60 */
2586/***/ (function(module, exports) {
2587
2588/**
2589 * Appends the elements of `values` to `array`.
2590 *
2591 * @private
2592 * @param {Array} array The array to modify.
2593 * @param {Array} values The values to append.
2594 * @returns {Array} Returns `array`.
2595 */
2596function arrayPush(array, values) {
2597  var index = -1,
2598      length = values.length,
2599      offset = array.length;
2600
2601  while (++index < length) {
2602    array[offset + index] = values[index];
2603  }
2604  return array;
2605}
2606
2607module.exports = arrayPush;
2608
2609
2610/***/ }),
2611/* 61 */
2612/***/ (function(module, exports, __webpack_require__) {
2613
2614/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(10),
2615    stubFalse = __webpack_require__(202);
2616
2617/** Detect free variable `exports`. */
2618var freeExports =  true && exports && !exports.nodeType && exports;
2619
2620/** Detect free variable `module`. */
2621var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
2622
2623/** Detect the popular CommonJS extension `module.exports`. */
2624var moduleExports = freeModule && freeModule.exports === freeExports;
2625
2626/** Built-in value references. */
2627var Buffer = moduleExports ? root.Buffer : undefined;
2628
2629/* Built-in method references for those with the same name as other `lodash` methods. */
2630var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
2631
2632/**
2633 * Checks if `value` is a buffer.
2634 *
2635 * @static
2636 * @memberOf _
2637 * @since 4.3.0
2638 * @category Lang
2639 * @param {*} value The value to check.
2640 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
2641 * @example
2642 *
2643 * _.isBuffer(new Buffer(2));
2644 * // => true
2645 *
2646 * _.isBuffer(new Uint8Array(2));
2647 * // => false
2648 */
2649var isBuffer = nativeIsBuffer || stubFalse;
2650
2651module.exports = isBuffer;
2652
2653/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(104)(module)))
2654
2655/***/ }),
2656/* 62 */
2657/***/ (function(module, exports) {
2658
2659/** Used as references for various `Number` constants. */
2660var MAX_SAFE_INTEGER = 9007199254740991;
2661
2662/** Used to detect unsigned integer values. */
2663var reIsUint = /^(?:0|[1-9]\d*)$/;
2664
2665/**
2666 * Checks if `value` is a valid array-like index.
2667 *
2668 * @private
2669 * @param {*} value The value to check.
2670 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
2671 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
2672 */
2673function isIndex(value, length) {
2674  var type = typeof value;
2675  length = length == null ? MAX_SAFE_INTEGER : length;
2676
2677  return !!length &&
2678    (type == 'number' ||
2679      (type != 'symbol' && reIsUint.test(value))) &&
2680        (value > -1 && value % 1 == 0 && value < length);
2681}
2682
2683module.exports = isIndex;
2684
2685
2686/***/ }),
2687/* 63 */
2688/***/ (function(module, exports, __webpack_require__) {
2689
2690var baseIsTypedArray = __webpack_require__(203),
2691    baseUnary = __webpack_require__(204),
2692    nodeUtil = __webpack_require__(205);
2693
2694/* Node.js helper references. */
2695var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
2696
2697/**
2698 * Checks if `value` is classified as a typed array.
2699 *
2700 * @static
2701 * @memberOf _
2702 * @since 3.0.0
2703 * @category Lang
2704 * @param {*} value The value to check.
2705 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
2706 * @example
2707 *
2708 * _.isTypedArray(new Uint8Array);
2709 * // => true
2710 *
2711 * _.isTypedArray([]);
2712 * // => false
2713 */
2714var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
2715
2716module.exports = isTypedArray;
2717
2718
2719/***/ }),
2720/* 64 */
2721/***/ (function(module, exports) {
2722
2723/** Used as references for various `Number` constants. */
2724var MAX_SAFE_INTEGER = 9007199254740991;
2725
2726/**
2727 * Checks if `value` is a valid array-like length.
2728 *
2729 * **Note:** This method is loosely based on
2730 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
2731 *
2732 * @static
2733 * @memberOf _
2734 * @since 4.0.0
2735 * @category Lang
2736 * @param {*} value The value to check.
2737 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
2738 * @example
2739 *
2740 * _.isLength(3);
2741 * // => true
2742 *
2743 * _.isLength(Number.MIN_VALUE);
2744 * // => false
2745 *
2746 * _.isLength(Infinity);
2747 * // => false
2748 *
2749 * _.isLength('3');
2750 * // => false
2751 */
2752function isLength(value) {
2753  return typeof value == 'number' &&
2754    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
2755}
2756
2757module.exports = isLength;
2758
2759
2760/***/ }),
2761/* 65 */
2762/***/ (function(module, exports, __webpack_require__) {
2763
2764var isPrototype = __webpack_require__(66),
2765    nativeKeys = __webpack_require__(206);
2766
2767/** Used for built-in method references. */
2768var objectProto = Object.prototype;
2769
2770/** Used to check objects for own properties. */
2771var hasOwnProperty = objectProto.hasOwnProperty;
2772
2773/**
2774 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
2775 *
2776 * @private
2777 * @param {Object} object The object to query.
2778 * @returns {Array} Returns the array of property names.
2779 */
2780function baseKeys(object) {
2781  if (!isPrototype(object)) {
2782    return nativeKeys(object);
2783  }
2784  var result = [];
2785  for (var key in Object(object)) {
2786    if (hasOwnProperty.call(object, key) && key != 'constructor') {
2787      result.push(key);
2788    }
2789  }
2790  return result;
2791}
2792
2793module.exports = baseKeys;
2794
2795
2796/***/ }),
2797/* 66 */
2798/***/ (function(module, exports) {
2799
2800/** Used for built-in method references. */
2801var objectProto = Object.prototype;
2802
2803/**
2804 * Checks if `value` is likely a prototype object.
2805 *
2806 * @private
2807 * @param {*} value The value to check.
2808 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
2809 */
2810function isPrototype(value) {
2811  var Ctor = value && value.constructor,
2812      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
2813
2814  return value === proto;
2815}
2816
2817module.exports = isPrototype;
2818
2819
2820/***/ }),
2821/* 67 */
2822/***/ (function(module, exports, __webpack_require__) {
2823
2824var DataView = __webpack_require__(207),
2825    Map = __webpack_require__(58),
2826    Promise = __webpack_require__(208),
2827    Set = __webpack_require__(209),
2828    WeakMap = __webpack_require__(106),
2829    baseGetTag = __webpack_require__(24),
2830    toSource = __webpack_require__(97);
2831
2832/** `Object#toString` result references. */
2833var mapTag = '[object Map]',
2834    objectTag = '[object Object]',
2835    promiseTag = '[object Promise]',
2836    setTag = '[object Set]',
2837    weakMapTag = '[object WeakMap]';
2838
2839var dataViewTag = '[object DataView]';
2840
2841/** Used to detect maps, sets, and weakmaps. */
2842var dataViewCtorString = toSource(DataView),
2843    mapCtorString = toSource(Map),
2844    promiseCtorString = toSource(Promise),
2845    setCtorString = toSource(Set),
2846    weakMapCtorString = toSource(WeakMap);
2847
2848/**
2849 * Gets the `toStringTag` of `value`.
2850 *
2851 * @private
2852 * @param {*} value The value to query.
2853 * @returns {string} Returns the `toStringTag`.
2854 */
2855var getTag = baseGetTag;
2856
2857// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
2858if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
2859    (Map && getTag(new Map) != mapTag) ||
2860    (Promise && getTag(Promise.resolve()) != promiseTag) ||
2861    (Set && getTag(new Set) != setTag) ||
2862    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
2863  getTag = function(value) {
2864    var result = baseGetTag(value),
2865        Ctor = result == objectTag ? value.constructor : undefined,