https://rasev.ru/js/e14b8c3cf.js

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 = 129);
92/******/ })
93/************************************************************************/
94/******/ ([
95/* 0 */
96/***/ (function(module, exports) {
97
98function _interopRequireDefault(obj) {
99  return obj && obj.__esModule ? obj : {
100    "default": obj
101  };
102}
103
104module.exports = _interopRequireDefault;
105
106/***/ }),
107/* 1 */
108/***/ (function(module, exports, __webpack_require__) {
109
110/* WEBPACK VAR INJECTION */(function(global) {var check = function (it) {
111  return it && it.Math == Math && it;
112};
113
114// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
115module.exports =
116  // eslint-disable-next-line es/no-global-this -- safe
117  check(typeof globalThis == 'object' && globalThis) ||
118  check(typeof window == 'object' && window) ||
119  // eslint-disable-next-line no-restricted-globals -- safe
120  check(typeof self == 'object' && self) ||
121  check(typeof global == 'object' && global) ||
122  // eslint-disable-next-line no-new-func -- fallback
123  (function () { return this; })() || Function('return this')();
124
125/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(25)))
126
127/***/ }),
128/* 2 */

129/***/ (function(module, exports) {
130
131/**
132 * Checks if `value` is classified as an `Array` object.
133 *
134 * @static
135 * @memberOf _
136 * @since 0.1.0
137 * @category Lang
138 * @param {*} value The value to check.
139 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
140 * @example
141 *
142 * _.isArray([1, 2, 3]);
143 * // => true
144 *
145 * _.isArray(document.body.children);
146 * // => false
147 *
148 * _.isArray('abc');
149 * // => false
150 *
151 * _.isArray(_.noop);
152 * // => false
153 */
154var isArray = Array.isArray;
155
156module.exports = isArray;
157
158
159/***/ }),
160/* 3 */
161/***/ (function(module, exports, __webpack_require__) {
162
163"use strict";
164 // @wf-will-never-add-flow-to-this-file
165
166/* globals window, document, navigator, WEBFLOW_ENV_TEST */
167
168/* eslint-disable no-var */
169
170/**
171 * Webflow: Core site library
172 */
173
174var Webflow = {};
175var modules = {};
176var primary = [];
177var secondary = window.Webflow || [];
178var $ = window.jQuery;
179var $win = $(window);
180var $doc = $(document);
181var isFunction = $.isFunction;
182
183var _ = Webflow._ = __webpack_require__(133);
184
185var tram = Webflow.tram = __webpack_require__(69) && $.tram;
186var domready = false;
187var destroyed = false;
188tram.config.hideBackface = false;
189tram.config.keepInherited = true;
190/**
191 * Webflow.define - Define a named module
192 * @param  {string} name
193 * @param  {function} factory
194 * @param  {object} options
195 * @return {object}
196 */
197
198Webflow.define = function (name, factory, options) {
199  if (modules[name]) {
200    unbindModule(modules[name]);
201  }
202
203  var instance = modules[name] = factory($, _, options) || {};
204  bindModule(instance);
205  return instance;
206};
207/**
208 * Webflow.require - Require a named module
209 * @param  {string} name
210 * @return {object}
211 */
212
213
214Webflow.require = function (name) {
215  return modules[name];
216};
217
218function bindModule(module) {
219  // If running in Webflow app, subscribe to design/preview events
220  if (Webflow.env()) {
221    isFunction(module.design) && $win.on('__wf_design', module.design);
222    isFunction(module.preview) && $win.on('__wf_preview', module.preview);
223  } // Subscribe to front-end destroy event
224
225
226  isFunction(module.destroy) && $win.on('__wf_destroy', module.destroy); // Look for ready method on module
227
228  if (module.ready && isFunction(module.ready)) {
229    addReady(module);
230  }
231}
232
233function addReady(module) {
234  // If domready has already happened, run ready method
235  if (domready) {
236    module.ready();
237    return;
238  } // Otherwise add ready method to the primary queue (only once)
239
240
241  if (_.contains(primary, module.ready)) {
242    return;
243  }
244
245  primary.push(module.ready);
246}
247
248function unbindModule(module) {
249  // Unsubscribe module from window events
250  isFunction(module.design) && $win.off('__wf_design', module.design);
251  isFunction(module.preview) && $win.off('__wf_preview', module.preview);
252  isFunction(module.destroy) && $win.off('__wf_destroy', module.destroy); // Remove ready method from primary queue
253
254  if (module.ready && isFunction(module.ready)) {
255    removeReady(module);
256  }
257}
258
259function removeReady(module) {
260  primary = _.filter(primary, function (readyFn) {
261    return readyFn !== module.ready;
262  });
263}
264/**
265 * Webflow.push - Add a ready handler into secondary queue
266 * @param {function} ready  Callback to invoke on domready
267 */
268
269
270Webflow.push = function (ready) {
271  // If domready has already happened, invoke handler
272  if (domready) {
273    isFunction(ready) && ready();
274    return;
275  } // Otherwise push into secondary queue
276
277
278  secondary.push(ready);
279};
280/**
281 * Webflow.env - Get the state of the Webflow app
282 * @param {string} mode [optional]
283 * @return {boolean}
284 */
285
286
287Webflow.env = function (mode) {
288  var designFlag = window.__wf_design;
289  var inApp = typeof designFlag !== 'undefined';
290
291  if (!mode) {
292    return inApp;
293  }
294
295  if (mode === 'design') {
296    return inApp && designFlag;
297  }
298
299  if (mode === 'preview') {
300    return inApp && !designFlag;
301  }
302
303  if (mode === 'slug') {
304    return inApp && window.__wf_slug;
305  }
306
307  if (mode === 'editor') {
308    return window.WebflowEditor;
309  }
310
311  if (mode === 'test') {
312    return  false || window.__wf_test;
313  }
314
315  if (mode === 'frame') {
316    return window !== window.top;
317  }
318}; // Feature detects + browser sniffs  ಠ_ಠ
319
320
321var userAgent = navigator.userAgent.toLowerCase();
322var touch = Webflow.env.touch = 'ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch;
323var chrome = Webflow.env.chrome = /chrome/.test(userAgent) && /Google/.test(navigator.vendor) && parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
324var ios = Webflow.env.ios = /(ipod|iphone|ipad)/.test(userAgent);
325Webflow.env.safari = /safari/.test(userAgent) && !chrome && !ios; // Maintain current touch target to prevent late clicks on touch devices
326
327var touchTarget; // Listen for both events to support touch/mouse hybrid devices
328
329touch && $doc.on('touchstart mousedown', function (evt) {
330  touchTarget = evt.target;
331});
332/**
333 * Webflow.validClick - validate click target against current touch target
334 * @param  {HTMLElement} clickTarget  Element being clicked
335 * @return {Boolean}  True if click target is valid (always true on non-touch)
336 */
337
338Webflow.validClick = touch ? function (clickTarget) {
339  return clickTarget === touchTarget || $.contains(clickTarget, touchTarget);
340} : function () {
341  return true;
342};
343/**
344 * Webflow.resize, Webflow.scroll - throttled event proxies
345 */
346
347var resizeEvents = 'resize.webflow orientationchange.webflow load.webflow';

348var scrollEvents = 'scroll.webflow ' + resizeEvents;
349Webflow.resize = eventProxy($win, resizeEvents);
350Webflow.scroll = eventProxy($win, scrollEvents);
351Webflow.redraw = eventProxy(); // Create a proxy instance for throttled events
352
353function eventProxy(target, types) {
354  // Set up throttled method (using custom frame-based _.throttle)
355  var handlers = [];
356  var proxy = {};
357  proxy.up = _.throttle(function (evt) {
358    _.each(handlers, function (h) {
359      h(evt);
360    });
361  }); // Bind events to target
362
363  if (target && types) {
364    target.on(types, proxy.up);
365  }
366  /**
367   * Add an event handler
368   * @param  {function} handler
369   */
370
371
372  proxy.on = function (handler) {
373    if (typeof handler !== 'function') {
374      return;
375    }
376
377    if (_.contains(handlers, handler)) {
378      return;
379    }
380
381    handlers.push(handler);
382  };
383  /**
384   * Remove an event handler
385   * @param  {function} handler
386   */
387
388
389  proxy.off = function (handler) {
390    // If no arguments supplied, clear all handlers
391    if (!arguments.length) {
392      handlers = [];
393      return;
394    } // Otherwise, remove handler from the list
395
396
397    handlers = _.filter(handlers, function (h) {
398      return h !== handler;
399    });
400  };
401
402  return proxy;
403} // Webflow.location - Wrap window.location in api
404
405
406Webflow.location = function (url) {
407  window.location = url;
408};
409
410if (Webflow.env()) {
411  // Ignore redirects inside a Webflow design/edit environment
412  Webflow.location = function () {};
413} // Webflow.ready - Call primary and secondary handlers
414
415
416Webflow.ready = function () {
417  domready = true; // Restore modules after destroy
418
419  if (destroyed) {
420    restoreModules(); // Otherwise run primary ready methods
421  } else {
422    _.each(primary, callReady);
423  } // Run secondary ready methods
424
425
426  _.each(secondary, callReady); // Trigger resize
427
428
429  Webflow.resize.up();
430};
431
432function callReady(readyFn) {
433  isFunction(readyFn) && readyFn();
434}
435
436function restoreModules() {
437  destroyed = false;
438
439  _.each(modules, bindModule);
440}
441/**
442 * Webflow.load - Add a window load handler that will run even if load event has already happened
443 * @param  {function} handler
444 */
445
446
447var deferLoad;
448
449Webflow.load = function (handler) {
450  deferLoad.then(handler);
451};
452
453function bindLoad() {
454  // Reject any previous deferred (to support destroy)
455  if (deferLoad) {
456    deferLoad.reject();
457    $win.off('load', deferLoad.resolve);
458  } // Create deferred and bind window load event
459
460
461  deferLoad = new $.Deferred();
462  $win.on('load', deferLoad.resolve);
463} // Webflow.destroy - Trigger a destroy event for all modules
464
465
466Webflow.destroy = function (options) {
467  options = options || {};
468  destroyed = true;
469  $win.triggerHandler('__wf_destroy'); // Allow domready reset for tests
470
471  if (options.domready != null) {
472    domready = options.domready;
473  } // Unbind modules
474
475
476  _.each(modules, unbindModule); // Clear any proxy event handlers
477
478
479  Webflow.resize.off();
480  Webflow.scroll.off();
481  Webflow.redraw.off(); // Clear any queued ready methods
482
483  primary = [];
484  secondary = []; // If load event has not yet fired, replace the deferred
485
486  if (deferLoad.state() === 'pending') {
487    bindLoad();
488  }
489}; // Listen for domready
490
491
492$(Webflow.ready); // Listen for window.onload and resolve deferred
493
494bindLoad(); // Export commonjs module
495
496module.exports = window.Webflow = Webflow;
497
498/***/ }),
499/* 4 */
500/***/ (function(module, exports, __webpack_require__) {
501
502"use strict";
503
504
505var _interopRequireWildcard = __webpack_require__(18);
506
507Object.defineProperty(exports, "__esModule", {
508  value: true
509});
510var _exportNames = {
511  IX2EngineActionTypes: true,
512  IX2EngineConstants: true
513};
514exports.IX2EngineConstants = exports.IX2EngineActionTypes = void 0;
515
516var _triggerEvents = __webpack_require__(190);
517
518Object.keys(_triggerEvents).forEach(function (key) {
519  if (key === "default" || key === "__esModule") return;
520  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
521  Object.defineProperty(exports, key, {
522    enumerable: true,
523    get: function get() {
524      return _triggerEvents[key];
525    }
526  });
527});
528
529var _animationActions = __webpack_require__(94);
530

531Object.keys(_animationActions).forEach(function (key) {
532  if (key === "default" || key === "__esModule") return;
533  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
534  Object.defineProperty(exports, key, {
535    enumerable: true,
536    get: function get() {
537      return _animationActions[key];
538    }
539  });
540});
541
542var _triggerInteractions = __webpack_require__(191);
543
544Object.keys(_triggerInteractions).forEach(function (key) {
545  if (key === "default" || key === "__esModule") return;
546  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
547  Object.defineProperty(exports, key, {
548    enumerable: true,
549    get: function get() {
550      return _triggerInteractions[key];
551    }
552  });
553});
554
555var _reducedMotion = __webpack_require__(192);
556
557Object.keys(_reducedMotion).forEach(function (key) {
558  if (key === "default" || key === "__esModule") return;
559  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
560  Object.defineProperty(exports, key, {
561    enumerable: true,
562    get: function get() {
563      return _reducedMotion[key];
564    }
565  });
566});
567
568var IX2EngineActionTypes = _interopRequireWildcard(__webpack_require__(193));
569
570exports.IX2EngineActionTypes = IX2EngineActionTypes;
571
572var IX2EngineConstants = _interopRequireWildcard(__webpack_require__(194));
573
574exports.IX2EngineConstants = IX2EngineConstants;
575
576/***/ }),
577/* 5 */
578/***/ (function(module, exports) {
579
580var FunctionPrototype = Function.prototype;
581var bind = FunctionPrototype.bind;
582var call = FunctionPrototype.call;
583var callBind = bind && bind.bind(call);
584
585module.exports = bind ? function (fn) {
586  return fn && callBind(call, fn);
587} : function (fn) {
588  return fn && function () {
589    return call.apply(fn, arguments);
590  };
591};
592
593
594/***/ }),
595/* 6 */
596/***/ (function(module, exports, __webpack_require__) {
597
598var freeGlobal = __webpack_require__(99);
599
600/** Detect free variable `self`. */
601var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
602
603/** Used as a reference to the global object. */
604var root = freeGlobal || freeSelf || Function('return this')();
605
606module.exports = root;
607
608
609/***/ }),
610/* 7 */
611/***/ (function(module, exports) {
612
613// `IsCallable` abstract operation
614// https://tc39.es/ecma262/#sec-iscallable
615module.exports = function (argument) {
616  return typeof argument == 'function';
617};
618
619
620/***/ }),
621/* 8 */
622/***/ (function(module, exports) {
623
624/**
625 * Checks if `value` is the
626 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
627 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
628 *
629 * @static
630 * @memberOf _
631 * @since 0.1.0
632 * @category Lang
633 * @param {*} value The value to check.
634 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
635 * @example
636 *
637 * _.isObject({});
638 * // => true
639 *
640 * _.isObject([1, 2, 3]);
641 * // => true
642 *
643 * _.isObject(_.noop);
644 * // => true
645 *
646 * _.isObject(null);
647 * // => false
648 */
649function isObject(value) {
650  var type = typeof value;
651  return value != null && (type == 'object' || type == 'function');
652}
653
654module.exports = isObject;
655
656
657/***/ }),
658/* 9 */
659/***/ (function(module, exports, __webpack_require__) {
660
661var uncurryThis = __webpack_require__(5);
662var toObject = __webpack_require__(158);
663
664var hasOwnProperty = uncurryThis({}.hasOwnProperty);
665
666// `HasOwnProperty` abstract operation
667// https://tc39.es/ecma262/#sec-hasownproperty
668module.exports = Object.hasOwn || function hasOwn(it, key) {
669  return hasOwnProperty(toObject(it), key);
670};
671
672
673/***/ }),
674/* 10 */
675/***/ (function(module, exports, __webpack_require__) {
676
677var baseMatches = __webpack_require__(197),
678    baseMatchesProperty = __webpack_require__(251),
679    identity = __webpack_require__(63),
680    isArray = __webpack_require__(2),
681    property = __webpack_require__(260);
682
683/**
684 * The base implementation of `_.iteratee`.
685 *
686 * @private
687 * @param {*} [value=_.identity] The value to convert to an iteratee.
688 * @returns {Function} Returns the iteratee.
689 */
690function baseIteratee(value) {
691  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
692  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
693  if (typeof value == 'function') {
694    return value;
695  }
696  if (value == null) {
697    return identity;
698  }
699  if (typeof value == 'object') {
700    return isArray(value)
701      ? baseMatchesProperty(value[0], value[1])
702      : baseMatches(value);
703  }
704  return property(value);
705}
706
707module.exports = baseIteratee;
708
709
710/***/ }),
711/* 11 */
712/***/ (function(module, exports, __webpack_require__) {
713
714var baseIsNative = __webpack_require__(209),
715    getValue = __webpack_require__(214);
716
717/**
718 * Gets the native function at `key` of `object`.
719 *
720 * @private
721 * @param {Object} object The object to query.
722 * @param {string} key The key of the method to get.
723 * @returns {*} Returns the function if it's native, else `undefined`.
724 */
725function getNative(object, key) {
726  var value = getValue(object, key);
727  return baseIsNative(value) ? value : undefined;
728}
729
730module.exports = getNative;
731
732
733/***/ }),
734/* 12 */

735/***/ (function(module, exports) {
736
737/**
738 * Checks if `value` is object-like. A value is object-like if it's not `null`
739 * and has a `typeof` result of "object".
740 *
741 * @static
742 * @memberOf _
743 * @since 4.0.0
744 * @category Lang
745 * @param {*} value The value to check.
746 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
747 * @example
748 *
749 * _.isObjectLike({});
750 * // => true
751 *
752 * _.isObjectLike([1, 2, 3]);
753 * // => true
754 *
755 * _.isObjectLike(_.noop);
756 * // => false
757 *
758 * _.isObjectLike(null);
759 * // => false
760 */
761function isObjectLike(value) {
762  return value != null && typeof value == 'object';
763}
764
765module.exports = isObjectLike;
766
767
768/***/ }),
769/* 13 */
770/***/ (function(module, exports) {
771
772function _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); }
773
774function _typeof(obj) {
775  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
776    module.exports = _typeof = function _typeof(obj) {
777      return _typeof2(obj);
778    };
779  } else {
780    module.exports = _typeof = function _typeof(obj) {
781      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
782    };
783  }
784
785  return _typeof(obj);
786}
787
788module.exports = _typeof;
789
790/***/ }),
791/* 14 */
792/***/ (function(module, exports, __webpack_require__) {
793
794var fails = __webpack_require__(19);
795
796// Detect IE8's incomplete defineProperty implementation
797module.exports = !fails(function () {
798  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
799  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
800});
801
802
803/***/ }),
804/* 15 */
805/***/ (function(module, exports, __webpack_require__) {
806
807"use strict";
808
809
810var _interopRequireWildcard = __webpack_require__(18);
811
812Object.defineProperty(exports, "__esModule", {
813  value: true
814});
815exports.IX2VanillaUtils = exports.IX2VanillaPlugins = exports.IX2ElementsReducer = exports.IX2EasingUtils = exports.IX2Easings = exp

815orts.IX2BrowserSupport = void 0;
816
817var IX2BrowserSupport = _interopRequireWildcard(__webpack_require__(48));
818
819exports.IX2BrowserSupport = IX2BrowserSupport;
820
821var IX2Easings = _interopRequireWildcard(__webpack_require__(116));
822
823exports.IX2Easings = IX2Easings;
824
825var IX2EasingUtils = _interopRequireWildcard(__webpack_require__(118));
826
827exports.IX2EasingUtils = IX2EasingUtils;
828
829var IX2ElementsReducer = _interopRequireWildcard(__webpack_require__(269));
830
831exports.IX2ElementsReducer = IX2ElementsReducer;
832
833var IX2VanillaPlugins = _interopRequireWildcard(__webpack_require__(120));
834
835exports.IX2VanillaPlugins = IX2VanillaPlugins;
836
837var IX2VanillaUtils = _interopRequireWildcard(__webpack_require__(271));
838
839exports.IX2VanillaUtils = IX2VanillaUtils;
840
841/***/ }),
842/* 16 */
843/***/ (function(module, exports, __webpack_require__) {
844
845var Symbol = __webpack_require__(23),
846    getRawTag = __webpack_require__(210),
847    objectToString = __webpack_require__(211);
848
849/** `Object#toString` result references. */
850var nullTag = '[object Null]',
851    undefinedTag = '[object Undefined]';
852
853/** Built-in value references. */
854var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
855
856/**
857 * The base implementation of `getTag` without fallbacks for buggy environments.
858 *
859 * @private
860 * @param {*} value The value to query.
861 * @returns {string} Returns the `toStringTag`.
862 */
863function baseGetTag(value) {
864  if (value == null) {
865    return value === undefined ? undefinedTag : nullTag;
866  }
867  return (symToStringTag && symToStringTag in Object(value))
868    ? getRawTag(value)
869    : objectToString(value);
870}
871
872module.exports = baseGetTag;
873
874
875/***/ }),
876/* 17 */
877/***/ (function(module, exports, __webpack_require__) {
878
879var isFunction = __webpack_require__(98),
880    isLength = __webpack_require__(56);
881
882/**
883 * Checks if `value` is array-like. A value is considered array-like if it's
884 * not a function and has a `value.length` that's an integer greater than or
885 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
886 *
887 * @static
888 * @memberOf _
889 * @since 4.0.0
890 * @category Lang
891 * @param {*} value The value to check.
892 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
893 * @example
894 *
895 * _.isArrayLike([1, 2, 3]);
896 * // => true
897 *
898 * _.isArrayLike(document.body.children);
899 * // => true
900 *
901 * _.isArrayLike('abc');
902 * // => true
903 *
904 * _.isArrayLike(_.noop);
905 * // => false
906 */
907function isArrayLike(value) {
908  return value != null && isLength(value.length) && !isFunction(value);
909}
910
911module.exports = isArrayLike;
912
913
914/***/ }),
915/* 18 */
916/***/ (function(module, exports) {
917
918function _interopRequireWildcard(obj) {
919  if (obj && obj.__esModule) {
920    return obj;
921  } else {
922    var newObj = {};
923
924    if (obj != null) {
925      for (var key in obj) {
926        if (Object.prototype.hasOwnProperty.call(obj, key)) {
927          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
928
929          if (desc.get || desc.set) {
930            Object.defineProperty(newObj, key, desc);
931          } else {
932            newObj[key] = obj[key];
933          }
934        }
935      }
936    }
937
938    newObj["default"] = obj;
939    return newObj;
940  }
941}
942
943module.exports = _interopRequireWildcard;
944
945/***/ }),
946/* 19 */
947/***/ (function(module, exports) {
948
949module.exports = function (exec) {
950  try {
951    return !!exec();
952  } catch (error) {
953    return true;
954  }
955};
956
957
958/***/ }),
959/* 20 */
960/***/ (function(module, exports, __webpack_require__) {
961
962var isCallable = __webpack_require__(7);
963
964module.exports = function (it) {
965  return typeof it == 'object' ? it !== null : isCallable(it);
966};
967
968
969/***/ }),
970/* 21 */
971/***/ (function(module, exports) {
972
973function _defineProperty(obj, key, value) {
974  if (key in obj) {
975    Object.defineProperty(obj, key, {
976      value: value,
977      enumerable: true,
978      configurable: true,
979      writable: true
980    });
981  } else {
982    obj[key] = value;
983  }
984
985  return obj;
986}
987
988module.exports = _defineProperty;
989
990/***/ }),
991/* 22 */
992/***/ (function(module, exports, __webpack_require__) {
993
994"use strict";
995
996
997Object.defineProperty(exports, "__esModule", {
998  value: true
999});
1000
1001var _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; };
1002
1003exports.clone = clone;
1004exports.addLast = addLast;
1005exports.addFirst = addFirst;
1006exports.removeLast = removeLast;
1007exports.removeFirst = removeFirst;
1008exports.insert = insert;
1009exports.removeAt = removeAt;
1010exports.replaceAt = replaceAt;
1011exports.getIn = getIn;

1012exports.set = set;
1013exports.setIn = setIn;
1014exports.update = update;
1015exports.updateIn = updateIn;
1016exports.merge = merge;
1017exports.mergeDeep = mergeDeep;
1018exports.mergeIn = mergeIn;
1019exports.omit = omit;
1020exports.addDefaults = addDefaults;
1021
1022
1023/*!
1024 * Timm
1025 *
1026 * Immutability helpers with fast reads and acceptable writes.
1027 *
1028 * @copyright Guillermo Grau Panea 2016
1029 * @license MIT
1030 */
1031
1032var INVALID_ARGS = 'INVALID_ARGS';
1033
1034// ===============================================
1035// ### Helpers
1036// ===============================================
1037
1038
1039function throwStr(msg) {
1040  throw new Error(msg);
1041}
1042
1043function getKeysAndSymbols(obj) {
1044  var keys = Object.keys(obj);
1045  if (Object.getOwnPropertySymbols) {
1046    return keys.concat(Object.getOwnPropertySymbols(obj));
1047  }
1048  return keys;
1049}
1050
1051var hasOwnProperty = {}.hasOwnProperty;
1052
1053function clone(obj) {
1054  if (Array.isArray(obj)) return obj.slice();
1055  var keys = getKeysAndSymbols(obj);
1056  var out = {};
1057  for (var i = 0; i < keys.length; i++) {
1058    var key = keys[i];
1059    out[key] = obj[key];
1060  }
1061  return out;
1062}
1063
1064function doMerge(fAddDefaults, fDeep, first) {
1065  var out = first;
1066  !(out != null) && throwStr( false ? undefined : INVALID_ARGS);
1067  var fChanged = false;
1068
1069  for (var _len = arguments.length, rest = Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
1070    rest[_key - 3] = arguments[_key];
1071  }
1072
1073  for (var idx = 0; idx < rest.length; idx++) {
1074    var obj = rest[idx];
1075    if (obj == null) continue;
1076    var keys = getKeysAndSymbols(obj);
1077    if (!keys.length) continue;
1078    for (var j = 0; j <= keys.length; j++) {
1079      var key = keys[j];
1080      if (fAddDefaults && out[key] !== undefined) continue;
1081      var nextVal = obj[key];
1082      if (fDeep && isObject(out[key]) && isObject(nextVal)) {
1083        nextVal = doMerge(fAddDefaults, fDeep, out[key], nextVal);
1084      }

1085      if (nextVal === undefined || nextVal === out[key]) continue;
1086      if (!fChanged) {
1087        fChanged = true;
1088        out = clone(out);
1089      }
1090      out[key] = nextVal;
1091    }
1092  }
1093  return out;
1094}
1095
1096function isObject(o) {
1097  var type = typeof o === 'undefined' ? 'undefined' : _typeof(o);
1098  return o != null && (type === 'object' || type === 'function');
1099}
1100
1101// _deepFreeze = (obj) ->
1102//   Object.freeze obj
1103//   for key in Object.getOwnPropertyNames obj
1104//     val = obj[key]
1105//     if isObject(val) and not Object.isFrozen val
1106//       _deepFreeze val
1107//   obj
1108
1109// ===============================================
1110// -- ### Arrays
1111// ===============================================
1112
1113// -- #### addLast()
1114// -- Returns a new array with an appended item or items.
1115// --
1116// -- Usage: `addLast<T>(array: Array<T>, val: Array<T>|T): Array<T>`
1117// --
1118// -- ```js
1119// -- arr = ['a', 'b']
1120// -- arr2 = addLast(arr, 'c')
1121// -- // ['a', 'b', 'c']
1122// -- arr2 === arr
1123// -- // false
1124// -- arr3 = addLast(arr, ['c', 'd'])
1125// -- // ['a', 'b', 'c', 'd']
1126// -- ```
1127// `array.concat(val)` also handles the scalar case,
1128// but is apparently very slow
1129function addLast(array, val) {
1130  if (Array.isArray(val)) return array.concat(val);
1131  return array.concat([val]);
1132}
1133
1134// -- #### addFirst()
1135// -- Returns a new array with a prepended item or items.
1136// --
1137// -- Usage: `addFirst<T>(array: Array<T>, val: Array<T>|T): Array<T>`
1138// --
1139// -- ```js
1140// -- arr = ['a', 'b']
1141// -- arr2 = addFirst(arr, 'c')
1142// -- // ['c', 'a', 'b']
1143// -- arr2 === arr
1144// -- // false
1145// -- arr3 = addFirst(arr, ['c', 'd'])
1146// -- // ['c', 'd', 'a', 'b']
1147// -- ```
1148function addFirst(array, val) {
1149  if (Array.isArray(val)) return val.concat(array);
1150  return [val].concat(array);
1151}
1152
1153// -- #### removeLast()
1154// -- Returns a new array removing the last item.
1155// --
1156// -- Usage: `removeLast<T>(array: Array<T>): Array<T>`
1157// --
1158// -- ```js
1159// -- arr = ['a', 'b']
1160// -- arr2 = removeLast(arr)
1161// -- // ['a']
1162// -- arr2 === arr
1163// -- // false
1164// --
1165// -- // The same array is returned if there are no changes:
1166// -- arr3 = []
1167// -- removeLast(arr3) === arr3
1168// -- // true
1169// -- ```
1170function removeLast(array) {
1171  if (!array.length) return array;
1172  return array.slice(0, array.length - 1);
1173}
1174
1175// -- #### removeFirst()
1176// -- Returns a new array removing the first item.
1177// --
1178// -- Usage: `removeFirst<T>(array: Array<T>): Array<T>`
1179// --
1180// -- ```js
1181// -- arr = ['a', 'b']
1182// -- arr2 = removeFirst(arr)
1183// -- // ['b']
1184// -- arr2 === arr
1185// -- // false
1186// --
1187// -- // The same array is returned if there are no changes:
1188// -- arr3 = []
1189// -- removeFirst(arr3) === arr3
1190// -- // true
1191// -- ```
1192function removeFirst(array) {
1193  if (!array.length) return array;
1194  return array.slice(1);
1195}
1196
1197// -- #### insert()
1198// -- Returns a new array obtained by inserting an item or items
1199// -- at a specified index.
1200// --
1201// -- Usage: `insert<T>(array: Array<T>, idx: number, val: Array<T>|T): Array<T>`
1202// --
1203// -- ```js
1204// -- arr = ['a', 'b', 'c']
1205// -- arr2 = insert(arr, 1, 'd')
1206// -- // ['a', 'd', 'b', 'c']
1207// -- arr2 === arr
1208// -- // false
1209// -- insert(arr, 1, ['d', 'e'])
1210// -- // ['a', 'd', 'e', 'b', 'c']
1211// -- ```
1212function insert(array, idx, val) {
1213  return array.slice(0, idx).concat(Array.isArray(val) ? val : [val]).concat(array.slice(idx));
1214}
1215
1216// -- #### removeAt()
1217// -- Returns a new array obtained by removing an item at
1218// -- a specified index.
1219// --
1220// -- Usage: `removeAt<T>(array: Array<T>, idx: number): Array<T>`
1221// --
1222// -- ```js
1223// -- arr = ['a', 'b', 'c']
1224// -- arr2 = removeAt(arr, 1)
1225// -- // ['a', 'c']
1226// -- arr2 === arr
1227// -- // false
1228// --
1229// -- // The same array is returned if there are no changes:
1230// -- removeAt(arr, 4) === arr
1231// -- // true
1232// -- ```
1233function removeAt(array, idx) {
1234  if (idx >= array.length || idx < 0) return array;
1235  return array.slice(0, idx).concat(array.slice(idx + 1));
1236}
1237
1238// -- #### replaceAt()
1239// -- Returns a new array obtained by replacing an item at
1240// -- a specified index. If the provided item is the same as
1241// -- (*referentially equal to*) the previous item at that position,
1242// -- the original array is returned.
1243// --
1244// -- Usage: `replaceAt<T>(array: Array<T>, idx: number, newItem: T): Array<T>`
1245// --
1246// -- ```js
1247// -- arr = ['a', 'b', 'c']

1248// -- arr2 = replaceAt(arr, 1, 'd')
1249// -- // ['a', 'd', 'c']
1250// -- arr2 === arr
1251// -- // false
1252// --
1253// -- // The same object is returned if there are no changes:
1254// -- replaceAt(arr, 1, 'b') === arr
1255// -- // true
1256// -- ```
1257function replaceAt(array, idx, newItem) {
1258  if (array[idx] === newItem) return array;
1259  var len = array.length;
1260  var result = Array(len);
1261  for (var i = 0; i < len; i++) {
1262    result[i] = array[i];
1263  }
1264  result[idx] = newItem;
1265  return result;
1266}
1267
1268// ===============================================
1269// -- ### Collections (objects and arrays)
1270// ===============================================
1271// -- The following types are used throughout this section
1272// -- ```js
1273// -- type ArrayOrObject = Array<any>|Object;
1274// -- type Key = number|string;
1275// -- ```
1276
1277// -- #### getIn()
1278// -- Returns a value from an object at a given path. Works with
1279// -- nested arrays and objects. If the path does not exist, it returns
1280// -- `undefined`.
1281// --
1282// -- Usage: `getIn(obj: ?ArrayOrObject, path: Array<Key>): any`
1283// --
1284// -- ```js
1285// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: ['a', 'b', 'c'] }
1286// -- getIn(obj, ['d', 'd1'])
1287// -- // 3
1288// -- getIn(obj, ['e', 1])
1289// -- // 'b'
1290// -- ```
1291function getIn(obj, path) {
1292  !Array.isArray(path) && throwStr( false ? undefined : INVALID_ARGS);
1293  if (obj == null) return undefined;
1294  var ptr = obj;
1295  for (var i = 0; i < path.length; i++) {
1296    var key = path[i];
1297    ptr = ptr != null ? ptr[key] : undefined;
1298    if (ptr === undefined) return ptr;
1299  }
1300  return ptr;
1301}
1302
1303// -- #### set()
1304// -- Returns a new object with a modified attribute.
1305// -- If the provided value is the same as (*referentially equal to*)
1306// -- the previous value, the original object is returned.
1307// --
1308// -- Usage: `set<T>(obj: ?T, key: Key, val: any): T`
1309// --
1310// -- ```js
1311// -- obj = { a: 1, b: 2, c: 3 }
1312// -- obj2 = set(obj, 'b', 5)
1313// -- // { a: 1, b: 5, c: 3 }
1314// -- obj2 === obj
1315// -- // false
1316// --
1317// -- // The same object is returned if there are no changes:
1318// -- set(obj, 'b', 2) === obj
1319// -- // true
1320// -- ```
1321function set(obj, key, val) {
1322  var fallback = typeof key === 'number' ? [] : {};
1323  var finalObj = obj == null ? fallback : obj;
1324  if (finalObj[key] === val) return finalObj;
1325  var obj2 = clone(finalObj);
1326  obj2[key] = val;
1327  return obj2;
1328}
1329
1330// -- #### setIn()
1331// -- Returns a new object with a modified **nested** attribute.
1332// --
1333// -- Notes:
1334// --
1335// -- * If the provided value is the same as (*referentially equal to*)
1336// -- the previous value, the original object is returned.
1337// -- * If the path does not exist, it will be created before setting
1338// -- the new value.
1339// --
1340// -- Usage: `setIn<T: ArrayOrObject>(obj: T, path: Array<Key>, val: any): T`
1341// --
1342// -- ```js
1343// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1344// -- obj2 = setIn(obj, ['d', 'd1'], 4)
1345// -- // { a: 1, b: 2, d: { d1: 4, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1346// -- obj2 === obj
1347// -- // false
1348// -- obj2.d === obj.d
1349// -- // false
1350// -- obj2.e === obj.e
1351// -- // true
1352// --
1353// -- // The same object is returned if there are no changes:
1354// -- obj3 = setIn(obj, ['d', 'd1'], 3)
1355// -- // { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1356// -- obj3 === obj
1357// -- // true
1358// -- obj3.d === obj.d
1359// -- // true
1360// -- obj3.e === obj.e
1361// -- // true
1362// --
1363// -- // ... unknown paths create intermediate keys. Numeric segments are treated as array indices:
1364// -- setIn({ a: 3 }, ['unknown', 0, 'path'], 4)
1365// -- // { a: 3, unknown: [{ path: 4 }] }
1366// -- ```
1367function doSetIn(obj, path, val, idx) {
1368  var newValue = void 0;
1369  var key = path[idx];
1370  if (idx === path.length - 1) {
1371    newValue = val;
1372  } else {
1373    var nestedObj = isObject(obj) && isObject(obj[key]) ? obj[key] : typeof path[idx + 1] === 'number' ? [] : {};
1374    newValue = doSetIn(nestedObj, path, val, idx + 1);
1375  }
1376  return set(obj, key, newValue);
1377}
1378
1379function setIn(obj, path, val) {
1380  if (!path.length) return val;
1381  return doSetIn(obj, path, val, 0);
1382}
1383
1384// -- #### update()
1385// -- Returns a new object with a modified attribute,

1386// -- calculated via a user-provided callback based on the current value.
1387// -- If the calculated value is the same as (*referentially equal to*)
1388// -- the previous value, the original object is returned.
1389// --
1390// -- Usage: `update<T: ArrayOrObject>(obj: T, key: Key,
1391// -- fnUpdate: (prevValue: any) => any): T`
1392// --
1393// -- ```js
1394// -- obj = { a: 1, b: 2, c: 3 }
1395// -- obj2 = update(obj, 'b', (val) => val + 1)
1396// -- // { a: 1, b: 3, c: 3 }
1397// -- obj2 === obj
1398// -- // false
1399// --
1400// -- // The same object is returned if there are no changes:
1401// -- update(obj, 'b', (val) => val) === obj
1402// -- // true
1403// -- ```
1404function update(obj, key, fnUpdate) {
1405  var prevVal = obj == null ? undefined : obj[key];
1406  var nextVal = fnUpdate(prevVal);
1407  return set(obj, key, nextVal);
1408}
1409
1410// -- #### updateIn()
1411// -- Returns a new object with a modified **nested** attribute,
1412// -- calculated via a user-provided callback based on the current value.
1413// -- If the calculated value is the same as (*referentially equal to*)
1414// -- the previous value, the original object is returned.
1415// --
1416// -- Usage: `updateIn<T: ArrayOrObject>(obj: T, path: Array<Key>,
1417// -- fnUpdate: (prevValue: any) => any): T`
1418// --
1419// -- ```js
1420// -- obj = { a: 1, d: { d1: 3, d2: 4 } }
1421// -- obj2 = updateIn(obj, ['d', 'd1'], (val) => val + 1)
1422// -- // { a: 1, d: { d1: 4, d2: 4 } }
1423// -- obj2 === obj
1424// -- // false
1425// --
1426// -- // The same object is returned if there are no changes:
1427// -- obj3 = updateIn(obj, ['d', 'd1'], (val) => val)
1428// -- // { a: 1, d: { d1: 3, d2: 4 } }
1429// -- obj3 === obj
1430// -- // true
1431// -- ```
1432function updateIn(obj, path, fnUpdate) {
1433  var prevVal = getIn(obj, path);
1434  var nextVal = fnUpdate(prevVal);
1435  return setIn(obj, path, nextVal);
1436}
1437
1438// -- #### merge()
1439// -- Returns a new object built as follows: the overlapping keys from the
1440// -- second one overwrite the corresponding entries from the first one.
1441// -- Similar to `Object.assign()`, but immutable.
1442// --
1443// -- Usage:
1444// --
1445// -- * `merge(obj1: Object, obj2: ?Object): Object`
1446// -- * `merge(obj1: Object, ...objects: Array<?Object>): Object`
1447// --
1448// -- The unmodified `obj1` is returned if `obj2` does not *provide something
1449// -- new to* `obj1`, i.e. if either of the following
1450// -- conditions are true:
1451// --
1452// -- * `obj2` is `null` or `undefined`
1453// -- * `obj2` is an object, but it is empty
1454// -- * All attributes of `obj2` are `undefined`
1455// -- * All attributes of `obj2` are referentially equal to the
1456// --   corresponding attributes of `obj1`
1457// --
1458// -- Note that `undefined` attributes in `obj2` do not modify the
1459// -- corresponding attributes in `obj1`.
1460// --
1461// -- ```js
1462// -- obj1 = { a: 1, b: 2, c: 3 }
1463// -- obj2 = { c: 4, d: 5 }
1464// -- obj3 = merge(obj1, obj2)
1465// -- // { a: 1, b: 2, c: 4, d: 5 }
1466// -- obj3 === obj1
1467// -- // false
1468// --
1469// -- // The same object is returned if there are no changes:
1470// -- merge(obj1, { c: 3 }) === obj1
1471// -- // true
1472// -- ```
1473function merge(a, b, c, d, e, f) {
1474  for (var _len2 = arguments.length, rest = Array(_len2 > 6 ? _len2 - 6 : 0), _key2 = 6; _key2 < _len2; _key2++) {
1475    rest[_key2 - 6] = arguments[_key2];
1476  }
1477
1478  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);
1479}
1480
1481// -- #### mergeDeep()
1482// -- Returns a new object built as follows: the overlapping keys from the
1483// -- second one overwrite the corresponding entries from the first one.
1484// -- If both the first and second entries are objects they are merged recursively.
1485// -- Similar to `Object.assign()`, but immutable, and deeply merging.
1486// --
1487// -- Usage:
1488// --
1489// -- * `mergeDeep(obj1: Object, obj2: ?Object): Object`
1490// -- * `mergeDeep(obj1: Object, ...objects: Array<?Object>): Object`
1491// --
1492// -- The unmodified `obj1` is returned if `obj2` does not *provide something
1493// -- new to* `obj1`, i.e. if either of the following
1494// -- conditions are true:
1495// --
1496// -- * `obj2` is `null` or `undefined`
1497// -- * `obj2` is an object, but it is empty
1498// -- * All attributes of `obj2` are `undefined`
1499// -- * All attributes of `obj2` are referentially equal to the

1500// --   corresponding attributes of `obj1`
1501// --
1502// -- Note that `undefined` attributes in `obj2` do not modify the
1503// -- corresponding attributes in `obj1`.
1504// --
1505// -- ```js
1506// -- obj1 = { a: 1, b: 2, c: { a: 1 } }
1507// -- obj2 = { b: 3, c: { b: 2 } }
1508// -- obj3 = mergeDeep(obj1, obj2)
1509// -- // { a: 1, b: 3, c: { a: 1, b: 2 }  }
1510// -- obj3 === obj1
1511// -- // false
1512// --
1513// -- // The same object is returned if there are no changes:
1514// -- mergeDeep(obj1, { c: { a: 1 } }) === obj1
1515// -- // true
1516// -- ```
1517function mergeDeep(a, b, c, d, e, f) {
1518  for (var _len3 = arguments.length, rest = Array(_len3 > 6 ? _len3 - 6 : 0), _key3 = 6; _key3 < _len3; _key3++) {
1519    rest[_key3 - 6] = arguments[_key3];
1520  }
1521
1522  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);
1523}
1524
1525// -- #### mergeIn()
1526// -- Similar to `merge()`, but merging the value at a given nested path.
1527// -- Note that the returned type is the same as that of the first argument.
1528// --
1529// -- Usage:
1530// --
1531// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>, obj2: ?Object): T`
1532// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>,
1533// -- ...objects: Array<?Object>): T`
1534// --
1535// -- ```js
1536// -- obj1 = { a: 1, d: { b: { d1: 3, d2: 4 } } }
1537// -- obj2 = { d3: 5 }
1538// -- obj3 = mergeIn(obj1, ['d', 'b'], obj2)
1539// -- // { a: 1, d: { b: { d1: 3, d2: 4, d3: 5 } } }
1540// -- obj3 === obj1
1541// -- // false
1542// --
1543// -- // The same object is returned if there are no changes:
1544// -- mergeIn(obj1, ['d', 'b'], { d2: 4 }) === obj1
1545// -- // true
1546// -- ```
1547function mergeIn(a, path, b, c, d, e, f) {
1548  var prevVal = getIn(a, path);
1549  if (prevVal == null) prevVal = {};
1550  var nextVal = void 0;
1551
1552  for (var _len4 = arguments.length, rest = Array(_len4 > 7 ? _len4 - 7 : 0), _key4 = 7; _key4 < _len4; _key4++) {
1553    rest[_key4 - 7] = arguments[_key4];
1554  }
1555
1556  if (rest.length) {
1557    nextVal = doMerge.call.apply(doMerge, [null, false, false, prevVal, b, c, d, e, f].concat(rest));
1558  } else {
1559    nextVal = doMerge(false, false, prevVal, b, c, d, e, f);
1560  }
1561  return setIn(a, path, nextVal);
1562}
1563
1564// -- #### omit()
1565// -- Returns an object excluding one or several attributes.
1566// --
1567// -- Usage: `omit(obj: Object, attrs: Array<string>|string): Object`
1568//
1569// -- ```js
1570// -- obj = { a: 1, b: 2, c: 3, d: 4 }
1571// -- omit(obj, 'a')
1572// -- // { b: 2, c: 3, d: 4 }
1573// -- omit(obj, ['b', 'c'])
1574// -- // { a: 1, d: 4 }
1575// --
1576// -- // The same object is returned if there are no changes:
1577// -- omit(obj, 'z') === obj1
1578// -- // true
1579// -- ```
1580function omit(obj, attrs) {
1581  var omitList = Array.isArray(attrs) ? attrs : [attrs];
1582  var fDoSomething = false;
1583  for (var i = 0; i < omitList.length; i++) {
1584    if (hasOwnProperty.call(obj, omitList[i])) {
1585      fDoSomething = true;
1586      break;
1587    }
1588  }
1589  if (!fDoSomething) return obj;
1590  var out = {};
1591  var keys = getKeysAndSymbols(obj);
1592  for (var _i = 0; _i < keys.length; _i++) {
1593    var key = keys[_i];
1594    if (omitList.indexOf(key) >= 0) continue;
1595    out[key] = obj[key];
1596  }
1597  return out;
1598}
1599
1600// -- #### addDefaults()
1601// -- Returns a new object built as follows: `undefined` keys in the first one
1602// -- are filled in with the corresponding values from the second one
1603// -- (even if they are `null`).
1604// --
1605// -- Usage:
1606// --
1607// -- * `addDefaults(obj: Object, defaults: Object): Object`
1608// -- * `addDefaults(obj: Object, ...defaultObjects: Array<?Object>): Object`
1609// --
1610// -- ```js
1611// -- obj1 = { a: 1, b: 2, c: 3 }
1612// -- obj2 = { c: 4, d: 5, e: null }
1613// -- obj3 = addDefaults(obj1, obj2)
1614// -- // { a: 1, b: 2, c: 3, d: 5, e: null }
1615// -- obj3 === obj1
1616// -- // false
1617// --
1618// -- // The same object is returned if there are no changes:
1619// -- addDefaults(obj1, { c: 4 }) === obj1
1620// -- // true
1621// -- ```
1622function addDefaults(a, b, c, d, e, f) {
1623  for (var _len5 = arguments.length, rest = Array(_len5 > 6 ? _len5 - 6 : 0), _key5 = 6; _key5 < _len5; _key5++) {
1624    rest[_key5 - 6] = arguments[_key5];
1625  }
1626
1627  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);
1628}
1629
1630// ===============================================
1631// ### Public API
1632// ===============================================
1633var timm = {
1634  clone: clone,
1635  addLast: addLast,
1636  addFirst: addFirst,
1637  removeLast: removeLast,
1638  removeFirst: removeFirst,
1639  insert: insert,
1640  removeAt: removeAt,
1641  replaceAt: replaceAt,
1642
1643  getIn: getIn,
1644  // eslint-disable-next-line object-shorthand
1645  set: set, // so that flow doesn't complain
1646  setIn: setIn,
1647  update: update,
1648  updateIn: updateIn,
1649  merge: merge,
1650  mergeDeep: mergeDeep,
1651  mergeIn: mergeIn,
1652  omit: omit,
1653  addDefaults: addDefaults
1654};
1655
1656exports.default = timm;
1657
1658
1659/***/ }),
1660/* 23 */
1661/***/ (function(module, exports, __webpack_require__) {
1662
1663var root = __webpack_require__(6);
1664
1665/** Built-in value references. */
1666var Symbol = root.Symbol;
1667
1668module.exports = Symbol;
1669
1670
1671/***/ }),
1672/* 24 */
1673/***/ (function(module, exports, __webpack_require__) {
1674
1675var isSymbol = __webpack_require__(38);
1676
1677/** Used as references for various `Number` constants. */
1678var INFINITY = 1 / 0;
1679
1680/**
1681 * Converts `value` to a string key if it's not a string or symbol.
1682 *
1683 * @private
1684 * @param {*} value The value to inspect.
1685 * @returns {string|symbol} Returns the key.
1686 */
1687function toKey(value) {
1688  if (typeof value == 'string' || isSymbol(value)) {
1689    return value;
1690  }
1691  var result = (value + '');
1692  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
1693}
1694
1695module.exports = toKey;
1696
1697
1698/***/ }),
1699/* 25 */

1700/***/ (function(module, exports) {
1701
1702var g;
1703
1704// This works in non-strict mode
1705g = (function() {
1706	return this;
1707})();
1708
1709try {
1710	// This works if eval is allowed (see CSP)
1711	g = g || new Function("return this")();
1712} catch (e) {
1713	// This works if the window reference is available
1714	if (typeof window === "object") g = window;
1715}
1716
1717// g can still be undefined, but nothing to do about it...
1718// We return undefined, instead of nothing here, so it's
1719// easier to handle this case. if(!global) { ...}
1720
1721module.exports = g;
1722
1723
1724/***/ }),
1725/* 26 */
1726/***/ (function(module, exports, __webpack_require__) {
1727
1728// toObject with fallback for non-array-like ES3 strings
1729var IndexedObject = __webpack_require__(147);
1730var requireObjectCoercible = __webpack_require__(72);
1731
1732module.exports = function (it) {
1733  return IndexedObject(requireObjectCoercible(it));
1734};
1735
1736
1737/***/ }),
1738/* 27 */
1739/***/ (function(module, exports, __webpack_require__) {
1740
1741var global = __webpack_require__(1);
1742var isCallable = __webpack_require__(7);
1743
1744var aFunction = function (argument) {
1745  return isCallable(argument) ? argument : undefined;
1746};
1747
1748module.exports = function (namespace, method) {
1749  return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
1750};
1751
1752
1753/***/ }),
1754/* 28 */
1755/***/ (function(module, exports, __webpack_require__) {
1756
1757var global = __webpack_require__(1);
1758var DESCRIPTORS = __webpack_require__(14);
1759var IE8_DOM_DEFINE = __webpack_require__(80);
1760var anObject = __webpack_require__(29);
1761var toPropertyKey = __webpack_require__(73);
1762
1763var TypeError = global.TypeError;
1764// eslint-disable-next-line es/no-object-defineproperty -- safe
1765var $defineProperty = Object.defineProperty;
1766
1767// `Object.defineProperty` method
1768// https://tc39.es/ecma262/#sec-object.defineproperty
1769exports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {
1770  anObject(O);
1771  P = toPropertyKey(P);
1772  anObject(Attributes);
1773  if (IE8_DOM_DEFINE) try {
1774    return $defineProperty(O, P, Attributes);
1775  } catch (error) { /* empty */ }
1776  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
1777  if ('value' in Attributes) O[P] = Attributes.value;
1778  return O;
1779};
1780
1781
1782/***/ }),
1783/* 29 */
1784/***/ (function(module, exports, __webpack_require__) {
1785
1786var global = __webpack_require__(1);
1787var isObject = __webpack_require__(20);
1788
1789var String = global.String;
1790var TypeError = global.TypeError;
1791
1792// `Assert: Type(argument) is Object`
1793module.exports = function (argument) {
1794  if (isObject(argument)) return argument;
1795  throw TypeError(String(argument) + ' is not an object');
1796};
1797
1798
1799/***/ }),
1800/* 30 */
1801/***/ (function(module, exports) {
1802
1803function _extends() {
1804  module.exports = _extends = Object.assign || function (target) {
1805    for (var i = 1; i < arguments.length; i++) {
1806      var source = arguments[i];
1807
1808      for (var key in source) {
1809        if (Object.prototype.hasOwnProperty.call(source, key)) {
1810          target[key] = source[key];
1811        }
1812      }
1813    }
1814
1815    return target;
1816  };
1817
1818  return _extends.apply(this, arguments);
1819}
1820
1821module.exports = _extends;
1822
1823/***/ }),
1824/* 31 */
1825/***/ (function(module, exports, __webpack_require__) {
1826
1827var listCacheClear = __webpack_require__(199),
1828    listCacheDelete = __webpack_require__(200),
1829    listCacheGet = __webpack_require__(201),
1830    listCacheHas = __webpack_require__(202),
1831    listCacheSet = __webpack_require__(203);
1832
1833/**
1834 * Creates an list cache object.
1835 *
1836 * @private
1837 * @constructor
1838 * @param {Array} [entries] The key-value pairs to cache.
1839 */
1840function ListCache(entries) {
1841  var index = -1,
1842      length = entries == null ? 0 : entries.length;
1843
1844  this.clear();
1845  while (++index < length) {
1846    var entry = entries[index];
1847    this.set(entry[0], entry[1]);
1848  }
1849}
1850
1851// Add methods to `ListCache`.
1852ListCache.prototype.clear = listCacheClear;
1853ListCache.prototype['delete'] = listCacheDelete;
1854ListCache.prototype.get = listCacheGet;
1855ListCache.prototype.has = listCacheHas;
1856ListCache.prototype.set = listCacheSet;
1857
1858module.exports = ListCache;
1859
1860
1861/***/ }),
1862/* 32 */
1863/***/ (function(module, exports, __webpack_require__) {
1864
1865var eq = __webpack_require__(49);
1866
1867/**
1868 * Gets the index at which the `key` is found in `array` of key-value pairs.
1869 *
1870 * @private
1871 * @param {Array} array The array to inspect.
1872 * @param {*}

1872 key The key to search for.
1873 * @returns {number} Returns the index of the matched value, else `-1`.
1874 */
1875function assocIndexOf(array, key) {
1876  var length = array.length;
1877  while (length--) {
1878    if (eq(array[length][0], key)) {
1879      return length;
1880    }
1881  }
1882  return -1;
1883}
1884
1885module.exports = assocIndexOf;
1886
1887
1888/***/ }),
1889/* 33 */
1890/***/ (function(module, exports, __webpack_require__) {
1891
1892var getNative = __webpack_require__(11);
1893
1894/* Built-in method references that are verified to be native. */
1895var nativeCreate = getNative(Object, 'create');
1896
1897module.exports = nativeCreate;
1898
1899
1900/***/ }),
1901/* 34 */
1902/***/ (function(module, exports, __webpack_require__) {
1903
1904var isKeyable = __webpack_require__(223);
1905
1906/**
1907 * Gets the data for `map`.
1908 *
1909 * @private
1910 * @param {Object} map The map to query.
1911 * @param {string} key The reference key.
1912 * @returns {*} Returns the map data.
1913 */
1914function getMapData(map, key) {
1915  var data = map.__data__;
1916  return isKeyable(key)
1917    ? data[typeof key == 'string' ? 'string' : 'hash']
1918    : data.map;
1919}
1920
1921module.exports = getMapData;
1922
1923
1924/***/ }),
1925/* 35 */
1926/***/ (function(module, exports, __webpack_require__) {
1927
1928var arrayLikeKeys = __webpack_require__(106),
1929    baseKeys = __webpack_require__(57),
1930    isArrayLike = __webpack_require__(17);
1931
1932/**
1933 * Creates an array of the own enumerable property names of `object`.
1934 *
1935 * **Note:** Non-object values are coerced to objects. See the
1936 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
1937 * for more details.
1938 *
1939 * @static
1940 * @since 0.1.0
1941 * @memberOf _
1942 * @category Object
1943 * @param {Object} object The object to query.
1944 * @returns {Array} Returns the array of property names.
1945 * @example
1946 *
1947 * function Foo() {
1948 *   this.a = 1;
1949 *   this.b = 2;
1950 * }
1951 *
1952 * Foo.prototype.c = 3;
1953 *
1954 * _.keys(new Foo);
1955 * // => ['a', 'b'] (iteration order is not guaranteed)
1956 *
1957 * _.keys('hi');
1958 * // => ['0', '1']
1959 */
1960function keys(object) {
1961  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
1962}
1963
1964module.exports = keys;
1965
1966
1967/***/ }),
1968/* 36 */
1969/***/ (function(module, exports, __webpack_require__) {
1970
1971var baseIsArguments = __webpack_require__(241),
1972    isObjectLike = __webpack_require__(12);
1973
1974/** Used for built-in method references. */
1975var objectProto = Object.prototype;
1976
1977/** Used to check objects for own properties. */
1978var hasOwnProperty = objectProto.hasOwnProperty;
1979
1980/** Built-in value references. */
1981var propertyIsEnumerable = objectProto.propertyIsEnumerable;
1982
1983/**
1984 * Checks if `value` is likely an `arguments` object.
1985 *
1986 * @static
1987 * @memberOf _
1988 * @since 0.1.0
1989 * @category Lang
1990 * @param {*} value The value to check.
1991 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
1992 *  else `false`.
1993 * @example
1994 *
1995 * _.isArguments(function() { return arguments; }());
1996 * // => true
1997 *
1998 * _.isArguments([1, 2, 3]);
1999 * // => false
2000 */
2001var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
2002  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
2003    !propertyIsEnumerable.call(value, 'callee');
2004};
2005
2006module.exports = isArguments;
2007
2008
2009/***/ }),
2010/* 37 */
2011/***/ (function(module, exports, __webpack_require__) {
2012
2013var isArray = __webpack_require__(2),
2014    isKey = __webpack_require__(62),
2015    stringToPath = __webpack_require__(252),
2016    toString = __webpack_require__(255);
2017
2018/**
2019 * Casts `value` to a path array if it's not one.
2020 *
2021 * @private
2022 * @param {*} value The value to inspect.
2023 * @param {Object} [object] The object to query keys on.
2024 * @returns {Array} Returns the cast property path array.
2025 */
2026function castPath(value, object) {
2027  if (isArray(value)) {
2028    return value;
2029  }
2030  return isKey(value, object) ? [value] : stringToPath(toString(value));
2031}
2032
2033module.exports = castPath;
2034
2035
2036/***/ }),
2037/* 38 */
2038/***/ (function(module, exports, __webpack_require__) {
2039
2040var baseGetTag = __webpack_require__(16),
2041    isObjectLike = __webpack_require__(12);
2042
2043/** `Object#toString` result references. */
2044var symbolTag = '[object Symbol]';
2045
2046/**
2047 * Checks if `value` is classified as a `Symbol` primitive or object.
2048 *
2049 * @static
2050 * @memberOf _
2051 * @since 4.0.0
2052 * @category Lang
2053 * @param {*} value The value to check.
2054 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
2055 * @example
2056 *
2057 * _.isSymbol(Symbol.iterator);
2058 * // => true
2059 *
2060 * _.isSymbol('abc');
2061 * // => false
2062 */
2063function isSymbol(value) {
2064  return typeof value == 'symbol' ||
2065    (isObjectLike(value) && baseGetTag(value) == symbolTag);
2066}
2067
2068module.exports = isSymbol;
2069
2070
2071/***/ }),
2072/* 39 */
2073/***/ (function(module, exports, __webpack_require__) {
2074
2075"use strict";

2076// @wf-will-never-add-flow-to-this-file
2077
2078/* globals window, document */
2079
2080/* eslint-disable no-var */
2081// eslint-disable-next-line strict
2082
2083
2084var IXEvents = __webpack_require__(138);
2085
2086function dispatchCustomEvent(element, eventName) {
2087  var event = document.createEvent('CustomEvent');
2088  event.initCustomEvent(eventName, true, true, null);
2089  element.dispatchEvent(event);
2090}
2091/**
2092 * Webflow: IX Event triggers for other modules
2093 */
2094
2095
2096var $ = window.jQuery;
2097var api = {};
2098var namespace = '.w-ix';
2099var eventTriggers = {
2100  reset: function reset(i, el) {
2101    IXEvents.triggers.reset(i, el);
2102  },
2103  intro: function intro(i, el) {
2104    IXEvents.triggers.intro(i, el);
2105    dispatchCustomEvent(el, 'COMPONENT_ACTIVE');
2106  },
2107  outro: function outro(i, el) {
2108    IXEvents.triggers.outro(i, el);
2109    dispatchCustomEvent(el, 'COMPONENT_INACTIVE');
2110  }
2111};
2112api.triggers = {};
2113api.types = {
2114  INTRO: 'w-ix-intro' + namespace,
2115  OUTRO: 'w-ix-outro' + namespace
2116};
2117$.extend(api.triggers, eventTriggers);
2118module.exports = api;
2119
2120/***/ }),
2121/* 40 */
2122/***/ (function(module, exports) {
2123
2124var call = Function.prototype.call;
2125
2126module.exports = call.bind ? call.bind(call) : function () {
2127  return call.apply(call, arguments);
2128};
2129
2130
2131/***/ }),
2132/* 41 */
2133/***/ (function(module, exports, __webpack_require__) {
2134
2135var global = __webpack_require__(1);
2136var setGlobal = __webpack_require__(42);
2137
2138var SHARED = '__core-js_shared__';
2139var store = global[SHARED] || setGlobal(SHARED, {});
2140
2141module.exports = store;
2142
2143
2144/***/ }),
2145/* 42 */
2146/***/ (function(module, exports, __webpack_require__) {
2147
2148var global = __webpack_require__(1);
2149
2150// eslint-disable-next-line es/no-object-defineproperty -- safe
2151var defineProperty = Object.defineProperty;
2152
2153module.exports = function (key, value) {
2154  try {
2155    defineProperty(global, key, { value: value, configurable: true, writable: true });
2156  } catch (error) {
2157    global[key] = value;
2158  } return value;
2159};
2160
2161
2162/***/ }),
2163/* 43 */
2164/***/ (function(module, exports, __webpack_require__) {
2165
2166var DESCRIPTORS = __webpack_require__(14);
2167var definePropertyModule = __webpack_require__(28);
2168var createPropertyDescriptor = __webpack_require__(71);
2169
2170module.exports = DESCRIPTORS ? function (object, key, value) {
2171  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
2172} : function (object, key, value) {
2173  object[key] = value;
2174  return object;
2175};
2176
2177
2178/***/ }),
2179/* 44 */
2180/***/ (function(module, exports) {
2181
2182module.exports = {};
2183
2184
2185/***/ }),
2186/* 45 */
2187/***/ (function(module, exports) {
2188
2189// IE8- don't enum bug keys
2190module.exports = [
2191  'constructor',
2192  'hasOwnProperty',
2193  'isPrototypeOf',
2194  'propertyIsEnumerable',
2195  'toLocaleString',
2196  'toString',
2197  'valueOf'
2198];
2199
2200
2201/***/ }),
2202/* 46 */
2203/***/ (function(module, __webpack_exports__, __webpack_require__) {
2204
2205"use strict";
2206__webpack_require__.r(__webpack_exports__);
2207/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ActionTypes", function() { return ActionTypes; });
2208/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return createStore; });
2209/* harmony import */ var lodash_es_isPlainObject__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(88);
2210/* harmony import */ var symbol_observable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(185);
2211
2212
2213
2214/**
2215 * These are private action types reserved by Redux.
2216 * For any unknown actions, you must return the current state.
2217 * If the current state is undefined, you must return the initial state.
2218 * Do not reference these action types directly in your code.
2219 */
2220var ActionTypes = {
2221  INIT: '@@redux/INIT'
2222};
2223
2224/**
2225 * Creates a Redux store that holds the state tree.
2226 * The only way to change the data in the store is to call `dispatch()` on it.
2227 *

2228 * There should only be a single store in your app. To specify how different
2229 * parts of the state tree respond to actions, you may combine several reducers
2230 * into a single reducer function by using `combineReducers`.
2231 *
2232 * @param {Function} reducer A function that returns the next state tree, given
2233 * the current state tree and the action to handle.
2234 *
2235 * @param {any} [preloadedState] The initial state. You may optionally specify it
2236 * to hydrate the state from the server in universal apps, or to restore a
2237 * previously serialized user session.
2238 * If you use `combineReducers` to produce the root reducer function, this must be
2239 * an object with the same shape as `combineReducers` keys.
2240 *
2241 * @param {Function} enhancer The store enhancer. You may optionally specify it
2242 * to enhance the store with third-party capabilities such as middleware,
2243 * time travel, persistence, etc. The only store enhancer that ships with Redux
2244 * is `applyMiddleware()`.
2245 *
2246 * @returns {Store} A Redux store that lets you read the state, dispatch actions
2247 * and subscribe to changes.
2248 */
2249function createStore(reducer, preloadedState, enhancer) {
2250  var _ref2;
2251
2252  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
2253    enhancer = preloadedState;
2254    preloadedState = undefined;
2255  }
2256
2257  if (typeof enhancer !== 'undefined') {
2258    if (typeof enhancer !== 'function') {
2259      throw new Error('Expected the enhancer to be a function.');
2260    }
2261
2262    return enhancer(createStore)(reducer, preloadedState);
2263  }
2264
2265  if (typeof reducer !== 'function') {
2266    throw new Error('Expected the reducer to be a function.');
2267  }
2268
2269  var currentReducer = reducer;
2270  var currentState = preloadedState;
2271  var currentListeners = [];
2272  var nextListeners = currentListeners;
2273  var isDispatching = false;
2274
2275  function ensureCanMutateNextListeners() {
2276    if (nextListeners === currentListeners) {
2277      nextListeners = currentListeners.slice();
2278    }
2279  }
2280
2281  /**
2282   * Reads the state tree managed by the store.
2283   *
2284   * @returns {any} The current state tree of your application.
2285   */
2286  function getState() {
2287    return currentState;
2288  }
2289
2290  /**
2291   * Adds a change listener. It will be called any time an action is dispatched,
2292   * and some part of the state tree may potentially have changed. You may then
2293   * call `getState()` to read the current state tree inside the callback.
2294   *
2295   * You may call `dispatch()` from a change listener, with the following
2296   * caveats:
2297   *
2298   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
2299   * If you subscribe or unsubscribe while the listeners are being invoked, this
2300   * will not have any effect on the `dispatch()` that is currently in progress.
2301   * However, the next `dispatch()` call, whether nested or not, will use a more
2302   * recent snapshot of the subscription list.
2303   *
2304   * 2. The listener should not expect to see all state changes, as the state
2305   * might have been updated multiple times during a nested `dispatch()` before
2306   * the listener is called. It is, however, guaranteed that all subscribers
2307   * registered before the `dispatch()` started will be called with the latest
2308   * state by the time it exits.
2309   *
2310   * @param {Function} listener A callback to be invoked on every dispatch.
2311   * @returns {Function} A function to remove this change listener.
2312   */
2313  function subscribe(listener) {
2314    if (typeof listener !== 'function') {
2315      throw new Error('Expected listener to be a function.');
2316    }
2317
2318    var isSubscribed = true;
2319
2320    ensureCanMutateNextListeners();
2321    nextListeners.push(listener);
2322
2323    return function unsubscribe() {
2324      if (!isSubscribed) {
2325        return;
2326      }
2327
2328      isSubscribed = false;
2329
2330      ensureCanMutateNextListeners();
2331      var index = nextListeners.indexOf(listener);
2332      nextListeners.splice(index, 1);
2333    };
2334  }
2335
2336  /**
2337   * Dispatches an action. It is the only way to trigger a state change.
2338   *
2339   * The `reducer` function, used to create the store, will be called with the
2340   * current state tree and the given `action`. Its return value will
2341   * be considered the **next** state of the tree, and the change listeners
2342   * will be notified.
2343   *
2344   * The base implementation only supports plain object actions. If you want to
2345   * dispatch a Promise, an Observable, a thunk, or something else, you need to
2346   * wrap your store creating function into the corresponding middleware. For
2347   * example, see the documentation for the `redux-thunk` package. Even the
2348   * middleware will eventually dispatch plain object actions using this method.
2349   *
2350   * @param {Object} action A plain object representing “what changed”. It is
2351   * a good idea to keep actions serializable so you can record and replay user
2352   * sessions, or use the time travelling `redux-devtools`. An action must have
2353   * a `type` property which may not be `undefined`. It is a good idea to use
2354   * string constants for action types.
2355   *
2356   * @returns {Object} For convenience, the same action object you dispatched.
2357   *
2358   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
2359   * return something else (for example, a Promise you can await).
2360   */
2361  function dispatch(action) {
2362    if (!Object(lodash_es_isPlainObject__WEBPACK_IMPORTED_MODULE_0__["default"])(action)) {
2363      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
2364    }
2365
2366    if (typeof action.type === 'undefined') {
2367      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
2368    }
2369
2370    if (isDispatching) {
2371      throw new Error('Reducers may not dispatch actions.');
2372    }
2373
2374    try {
2375      isDispatching = true;
2376      currentState = currentReducer(currentState, action);
2377    } finally {
2378      isDispatching = false;

2379    }
2380
2381    var listeners = currentListeners = nextListeners;
2382    for (var i = 0; i < listeners.length; i++) {
2383      listeners[i]();
2384    }
2385
2386    return action;
2387  }
2388
2389  /**
2390   * Replaces the reducer currently used by the store to calculate the state.
2391   *
2392   * You might need this if your app implements code splitting and you want to
2393   * load some of the reducers dynamically. You might also need this if you
2394   * implement a hot reloading mechanism for Redux.
2395   *
2396   * @param {Function} nextReducer The reducer for the store to use instead.
2397   * @returns {void}
2398   */
2399  function replaceReducer(nextReducer) {
2400    if (typeof nextReducer !== 'function') {
2401      throw new Error('Expected the nextReducer to be a function.');
2402    }
2403
2404    currentReducer = nextReducer;
2405    dispatch({ type: ActionTypes.INIT });
2406  }
2407
2408  /**
2409   * Interoperability point for observable/reactive libraries.
2410   * @returns {observable} A minimal observable of state changes.
2411   * For more information, see the observable proposal:
2412   * https://github.com/zenparsing/es-observable
2413   */
2414  function observable() {
2415    var _ref;
2416
2417    var outerSubscribe = subscribe;
2418    return _ref = {
2419      /**
2420       * The minimal observable subscription method.
2421       * @param {Object} observer Any object that can be used as an observer.
2422       * The observer object should have a `next` method.
2423       * @returns {subscription} An object with an `unsubscribe` method that can
2424       * be used to unsubscribe the observable from the store, and prevent further
2425       * emission of values from the observable.
2426       */
2427      subscribe: function subscribe(observer) {
2428        if (typeof observer !== 'object') {
2429          throw new TypeError('Expected the observer to be an object.');
2430        }
2431
2432        function observeState() {
2433          if (observer.next) {
2434            observer.next(getState());
2435          }
2436        }
2437
2438        observeState();
2439        var unsubscribe = outerSubscribe(observeState);
2440        return { unsubscribe: unsubscribe };
2441      }
2442    }, _ref[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = function () {
2443      return this;
2444    }, _ref;
2445  }
2446
2447  // When a store is created, an "INIT" action is dispatched so that every
2448  // reducer returns their initial state. This effectively populates
2449  // the initial state tree.
2450  dispatch({ type: ActionTypes.INIT });
2451
2452  return _ref2 = {
2453    dispatch: dispatch,
2454    subscribe: subscribe,
2455    getState: getState,
2456    replaceReducer: replaceReducer
2457  }, _ref2[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = observable, _ref2;
2458}
2459
2460/***/ }),
2461/* 47 */
2462/***/ (function(module, __webpack_exports__, __webpack_require__) {
2463
2464"use strict";
2465__webpack_require__.r(__webpack_exports__);
2466/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return compose; });
2467/**
2468 * Composes single-argument functions from right to left. The rightmost
2469 * function can take multiple arguments as it provides the signature for
2470 * the resulting composite function.
2471 *
2472 * @param {...Function} funcs The functions to compose.
2473 * @returns {Function} A function obtained by composing the argument functions
2474 * from right to left. For example, compose(f, g, h) is identical to doing
2475 * (...args) => f(g(h(...args))).
2476 */
2477
2478function compose() {
2479  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
2480    funcs[_key] = arguments[_key];
2481  }
2482
2483  if (funcs.length === 0) {
2484    return function (arg) {
2485      return arg;
2486    };
2487  }
2488
2489  if (funcs.length === 1) {
2490    return funcs[0];
2491  }
2492
2493  var last = funcs[funcs.length - 1];
2494  var rest = funcs.slice(0, -1);
2495  return function () {
2496    return rest.reduceRight(function (composed, f) {
2497      return f(composed);
2498    }, last.apply(undefined, arguments));
2499  };
2500}
2501
2502/***/ }),
2503/* 48 */
2504/***/ (function(module, exports, __webpack_require__) {
2505
2506"use strict";
2507
2508
2509var _interopRequireDefault = __webpack_require__(0);
2510
2511Object.defineProperty(exports, "__esModule", {
2512  value: true
2513});
2514exports.TRANSFORM_STYLE_PREFIXED = exports.TRANSFORM_PREFIXED = exports.FLEX_PREFIXED = exports.ELEMENT_MATCHES = exports.withBrowser = exports.IS_BROW

2514SER_ENV = void 0;
2515
2516var _find = _interopRequireDefault(__webpack_require__(95));
2517/* eslint-env browser */
2518
2519
2520var IS_BROWSER_ENV = typeof window !== 'undefined'; // $FlowFixMe
2521
2522exports.IS_BROWSER_ENV = IS_BROWSER_ENV;
2523
2524var withBrowser = function withBrowser(fn, fallback) {
2525  if (IS_BROWSER_ENV) {
2526    return fn();
2527  }
2528
2529  return fallback;
2530};
2531
2532exports.withBrowser = withBrowser;
2533var ELEMENT_MATCHES = withBrowser(function () {
2534  return (0, _find["default"])(['matches', 'matchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector', 'webkitMatchesSelector'], function (key) {
2535    return key in Element.prototype;
2536  });
2537});
2538exports.ELEMENT_MATCHES = ELEMENT_MATCHES;
2539var FLEX_PREFIXED = withBrowser(function () {
2540  var el = document.createElement('i');
2541  var values = ['flex', '-webkit-flex', '-ms-flexbox', '-moz-box', '-webkit-box'];
2542  var none = '';
2543
2544  try {
2545    var length = values.length;
2546
2547    for (var i = 0; i < length; i++) {
2548      var value = values[i];
2549      el.style.display = value;
2550
2551      if (el.style.display === value) {
2552        return value;
2553      }
2554    }
2555
2556    return none;
2557  } catch (err) {
2558    return none;
2559  }
2560}, 'flex');
2561exports.FLEX_PREFIXED = FLEX_PREFIXED;
2562var TRANSFORM_PREFIXED = withBrowser(function () {
2563  var el = document.createElement('i');
2564
2565  if (el.style.transform == null) {
2566    var prefixes = ['Webkit', 'Moz', 'ms'];
2567    var suffix = 'Transform';
2568    var length = prefixes.length;
2569
2570    for (var i = 0; i < length; i++) {
2571      var prop = prefixes[i] + suffix; // $FlowFixMe
2572
2573      if (el.style[prop] !== undefined) {
2574        return prop;
2575      }
2576    }
2577  }
2578
2579  return 'transform';
2580}, 'transform'); // $FlowFixMe
2581
2582exports.TRANSFORM_PREFIXED = TRANSFORM_PREFIXED;
2583var TRANSFORM_PREFIX = TRANSFORM_PREFIXED.split('transform')[0];
2584var TRANSFORM_STYLE_PREFIXED = TRANSFORM_PREFIX ? TRANSFORM_PREFIX + 'TransformStyle' : 'transformStyle';
2585exports.TRANSFORM_STYLE_PREFIXED = TRANSFORM_STYLE_PREFIXED;
2586
2587/***/ }),
2588/* 49 */
2589/***/ (function(module, exports) {
2590
2591/**
2592 * Performs a
2593 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2594 * comparison between two values to determine if they are equivalent.
2595 *
2596 * @static
2597 * @memberOf _
2598 * @since 4.0.0
2599 * @category Lang
2600 * @param {*} value The value to compare.
2601 * @param {*} other The other value to compare.
2602 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
2603 * @example
2604 *
2605 * var object = { 'a': 1 };
2606 * var other = { 'a': 1 };
2607 *
2608 * _.eq(object, object);
2609 * // => true
2610 *
2611 * _.eq(object, other);
2612 * // => false
2613 *
2614 * _.eq('a', 'a');
2615 * // => true
2616 *
2617 * _.eq('a', Object('a'));
2618 * // => false
2619 *
2620 * _.eq(NaN, NaN);
2621 * // => true
2622 */
2623function eq(value, other) {
2624  return value === other || (value !== value && other !== other);
2625}
2626
2627module.exports = eq;
2628
2629
2630/***/ }),
2631/* 50 */
2632/***/ (function(module, exports, __webpack_require__) {
2633
2634var getNative = __webpack_require__(11),
2635    root = __webpack_require__(6);
2636
2637/* Built-in method references that are verified to be native. */
2638var Map = getNative(root, 'Map');
2639
2640module.exports = Map;
2641
2642
2643/***/ }),
2644/* 51 */
2645/***/ (function(module, exports, __webpack_require__) {
2646
2647var mapCacheClear = __webpack_require__(215),
2648    mapCacheDelete = __webpack_require__(222),
2649    mapCacheGet = __webpack_require__(224),
2650    mapCacheHas = __webpack_require__(225),
2651    mapCacheSet = __webpack_require__(226);
2652
2653/**
2654 * Creates a map cache object to store key-value pairs.
2655 *
2656 * @private
2657 * @constructor
2658 * @param {Array} [entries] The key-value pairs to cache.
2659 */
2660function MapCache(entries) {
2661  var index = -1,
2662      length = entries == null ? 0 : entries.length;
2663
2664  this.clear();
2665  while (++index < length) {
2666    var entry = entries[index];
2667    this.set(entry[0], entry[1]);
2668  }
2669}
2670
2671// Add methods to `MapCache`.
2672MapCache.prototype.clear = mapCacheClear;
2673MapCache.prototype['delete'] = mapCacheDelete;
2674MapCache.prototype.get = mapCacheGet;
2675MapCache.prototype.has = mapCacheHas;
2676MapCache.prototype.set = mapCacheSet;
2677
2678module.exports = MapCache;
2679
2680
2681/***/ }),
2682/* 52 */
2683/***/ (function(module, exports) {
2684
2685/**
2686 * Appends the elements of `values` to `array`.
2687 *
2688 * @private
2689 * @param {Array} array The array to modify.
2690 * @param {Array} values The values to append.
2691 * @returns {Array} Returns `array`.
2692 */
2693function arrayPush(array, values) {
2694  var index = -1,
2695      length = values.length,
2696      offset = array.length;
2697
2698  while (++index < length) {
2699    array[offset + index] = values[index];
2700  }
2701  return array;
2702}
2703
2704module.exports = arrayPush;
2705
2706
2707/***/ }),
2708/* 53 */
2709/***/ (function(module, exports, __webpack_require__) {
2710
2711/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(6),
2712    stubFalse = __webpack_require__(242);
2713
2714/** Detect free variable `exports`. */
2715var freeExports =  true && exports && !exports.nodeType && exports;
2716
2717/** Detect free variable `module`. */
2718var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
2719
2720/** Detect the popular CommonJS extension `module.exports`. */
2721var moduleExports = freeModule && freeModule.exports === freeExports;
2722
2723/** Built-in value references. */
2724var Buffer = moduleExports ? root.Buffer : undefined;
2725
2726/* Built-in method references for those with the same name as other `lodash` methods. */
2727var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
2728
2729/**
2730 * Checks if `value` is a buffer.
2731 *
2732 * @static
2733 * @memberOf _
2734 * @since 4.3.0
2735 * @category Lang
2736 * @param {*} value The value to check.
2737 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
2738 * @example
2739 *
2740 * _.isBuffer(new Buffer(2));
2741 * // => true
2742 *
2743 * _.isBuffer(new Uint8Array(2));
2744 * // => false
2745 */
2746var isBuffer = nativeIsBuffer || stubFalse;
2747
2748module.exports = isBuffer;
2749
2750/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(107)(module)))
2751
2752/***/ }),
2753/* 54 */