https://uat-epicdice.firebaseapp.com/js/webflow.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 = 121);
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) {
109
110/**
111 * Checks if `value` is classified as an `Array` object.
112 *
113 * @static
114 * @memberOf _
115 * @since 0.1.0
116 * @category Lang
117 * @param {*} value The value to check.
118 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
119 * @example
120 *
121 * _.isArray([1, 2, 3]);
122 * // => true
123 *
124 * _.isArray(document.body.children);
125 * // => false
126 *
127 * _.isArray('abc');
128 * // => false
129 *
130 * _.isArray(_.noop);
131 * // => false
132 */
133var isArray = Array.isArray;
134
135module.exports = isArray;
136
137
138/***/ }),
139/* 2 */
140/***/ (function(module, exports, __webpack_require__) {
141
142"use strict";
143
144
145var _interopRequireWildcard = __webpack_require__(13);
146
147Object.defineProperty(exports, "__esModule", {
148  value: true
149});
150var _exportNames = {
151  IX2EngineActionTypes: true,
152  IX2EngineConstants: true
153};

154exports.IX2EngineConstants = exports.IX2EngineActionTypes = void 0;
155
156var _triggerEvents = __webpack_require__(170);
157
158Object.keys(_triggerEvents).forEach(function (key) {
159  if (key === "default" || key === "__esModule") return;
160  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
161  Object.defineProperty(exports, key, {
162    enumerable: true,
163    get: function get() {
164      return _triggerEvents[key];
165    }
166  });
167});
168
169var _animationActions = __webpack_require__(171);
170
171Object.keys(_animationActions).forEach(function (key) {
172  if (key === "default" || key === "__esModule") return;
173  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
174  Object.defineProperty(exports, key, {
175    enumerable: true,
176    get: function get() {
177      return _animationActions[key];
178    }
179  });
180});
181
182var _triggerInteractions = __webpack_require__(172);
183
184Object.keys(_triggerInteractions).forEach(function (key) {
185  if (key === "default" || key === "__esModule") return;
186  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
187  Object.defineProperty(exports, key, {
188    enumerable: true,
189    get: function get() {
190      return _triggerInteractions[key];
191    }
192  });
193});
194
195var IX2EngineActionTypes = _interopRequireWildcard(__webpack_require__(173));
196
197exports.IX2EngineActionTypes = IX2EngineActionTypes;
198
199var IX2EngineConstants = _interopRequireWildcard(__webpack_require__(174));
200
201exports.IX2EngineConstants = IX2EngineConstants;
202
203/***/ }),
204/* 3 */
205/***/ (function(module, exports, __webpack_require__) {
206
207/* WEBPACK VAR INJECTION */(function(global) {var O = 'object';
208var check = function (it) {
209  return it && it.Math == Math && it;
210};
211
212// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
213module.exports =
214  // eslint-disable-next-line no-undef
215  check(typeof globalThis == O && globalThis) ||
216  check(typeof window == O && window) ||
217  check(typeof self == O && self) ||
218  check(typeof global == O && global) ||
219  // eslint-disable-next-line no-new-func
220  Function('return this')();
221
222/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(22)))
223
224/***/ }),
225/* 4 */
226/***/ (function(module, exports, __webpack_require__) {
227
228var freeGlobal = __webpack_require__(90);
229
230/** Detect free variable `self`. */
231var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
232
233/** Used as a reference to the global object. */
234var root = freeGlobal || freeSelf || Function('return this')();
235
236module.exports = root;
237
238
239/***/ }),
240/* 5 */
241/***/ (function(module, exports, __webpack_require__) {
242
243"use strict";
244 // @wf-will-never-add-flow-to-this-file
245
246/* globals window, document, navigator, WEBFLOW_ENV_TEST */
247
248/* eslint-disable no-var */
249
250/**
251 * Webflow: Core site library
252 */
253
254var Webflow = {};
255var modules = {};
256var primary = [];
257var secondary = window.Webflow || [];
258var $ = window.jQuery;
259var $win = $(window);
260var $doc = $(document);
261var isFunction = $.isFunction;
262
263var _ = Webflow._ = __webpack_require__(123);
264
265var tram = Webflow.tram = __webpack_require__(66) && $.tram;
266var domready = false;
267var destroyed = false;
268tram.config.hideBackface = false;
269tram.config.keepInherited = true;
270/**
271 * Webflow.define - Define a named module
272 * @param  {string} name
273 * @param  {function} factory
274 * @param  {object} options
275 * @return {object}
276 */
277
278Webflow.define = function (name, factory, options) {
279  if (modules[name]) {
280    unbindModule(modules[name]);
281  }
282
283  var instance = modules[name] = factory($, _, options) || {};
284  bindModule(instance);
285  return instance;
286};
287/**
288 * Webflow.require - Require a named module
289 * @param  {string} name
290 * @return {object}
291 */
292
293
294Webflow.require = function (name) {
295  return modules[name];
296};
297
298function bindModule(module) {
299  // If running in Webflow app, subscribe to design/preview events
300  if (Webflow.env()) {
301    isFunction(module.design) && $win.on('__wf_design', module.design);
302    isFunction(module.preview) && $win.on('__wf_preview', module.preview);
303  } // Subscribe to front-end destroy event
304
305
306  isFunction(module.destroy) && $win.on('__wf_destroy', module.destroy); // Look for ready method on module
307
308  if (module.ready && isFunction(module.ready)) {
309    addReady(module);
310  }
311}
312
313function addReady(module) {
314  // If domready has already happened, run ready method
315  if (domready) {
316    module.ready();
317    return;
318  } // Otherwise add ready method to the primary queue (only once)
319
320
321  if (_.contains(primary, module.ready)) {
322    return;
323  }
324
325  primary.push(module.ready);
326}
327
328function unbindModule(module) {
329  // Unsubscribe module from window events
330  isFunction(module.design) && $win.off('__wf_design', module.design);
331  isFunction(module.preview) && $win.off('__wf_preview', module.preview);
332  isFunction(module.destroy) && $win.off('__wf_destroy', module.destroy); // Remove ready method from primary queue
333
334  if (module.ready && isFunction(module.ready)) {
335    removeReady(module);
336  }
337}
338
339function removeReady(module) {
340  primary = _.filter(primary, function (readyFn) {
341    return readyFn !== module.ready;
342  });
343}
344/**
345 * Webflow.push - Add a ready handler into secondary queue
346 * @param {function} ready  Callback to invoke on domready
347 */
348
349
350Webflow.push = function (ready) {
351  // If domready has already happened, invoke handler
352  if (domready) {
353    isFunction(ready) && ready();
354    return;
355  } // Otherwise push into secondary queue
356
357
358  secondary.push(ready);
359};
360/**
361 * Webflow.env - Get the state of the Webflow app
362 * @param {string} mode [optional]
363 * @return {boolean}
364 */
365
366
367Webflow.env = function (mode) {
368  var designFlag = window.__wf_design;
369  var inApp = typeof designFlag !== 'undefined';
370
371  if (!mode) {
372    return inApp;
373  }
374
375  if (mode === 'design') {
376    return inApp && designFlag;
377  }
378
379  if (mode === 'preview') {
380    return inApp && !designFlag;
381  }
382
383  if (mode === 'slug') {
384    return inApp && window.__wf_slug;
385  }
386
387  if (mode === 'editor') {
388    return window.WebflowEditor;
389  }
390
391  if (mode === 'test') {
392    return  false || window.__wf_test;
393  }
394
395  if (mode === 'frame') {
396    return window !== window.top;
397  }
398}; // Feature detects + browser sniffs  ಠ_ಠ
399
400
401var userAgent = navigator.userAgent.toLowerCase();
402var touch = Webflow.env.touch = 'ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch;
403var chrome = Webflow.env.chrome = /chrome/.test(userAgent) && /Google/.test(navigator.vendor) && parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
404var ios = Webflow.env.ios = /(ipod|iphone|ipad)/.test(userAgent);
405Webflow.env.safari = /safari/.test(userAgent) && !chrome && !ios; // Maintain current touch target to prevent late clicks on touch devices
406
407var touchTarget; // Listen for both events to support touch/mouse hybrid devices
408
409touch && $doc.on('touchstart mousedown', function (evt) {
410  touchTarget = evt.target;
411});
412/**
413 * Webflow.validClick - validate click target against current touch target
414 * @param  {HTMLElement} clickTarget  Element being clicked
415 * @return {Boolean}  True if click target is valid (always true on non-touch)
416 */
417
418Webflow.validClick = touch ? function (clickTarget) {
419  return clickTarget === touchTarget || $.contains(clickTarget, touchTarget);
420} : function () {
421  return true;
422};
423/**
424 * Webflow.resize, Webflow.scroll - throttled event proxies
425 */
426
427var resizeEvents = 'resize.webflow orientationchange.webflow load.webflow';

428var scrollEvents = 'scroll.webflow ' + resizeEvents;
429Webflow.resize = eventProxy($win, resizeEvents);
430Webflow.scroll = eventProxy($win, scrollEvents);
431Webflow.redraw = eventProxy(); // Create a proxy instance for throttled events
432
433function eventProxy(target, types) {
434  // Set up throttled method (using custom frame-based _.throttle)
435  var handlers = [];
436  var proxy = {};
437  proxy.up = _.throttle(function (evt) {
438    _.each(handlers, function (h) {
439      h(evt);
440    });
441  }); // Bind events to target
442
443  if (target && types) {
444    target.on(types, proxy.up);
445  }
446  /**
447   * Add an event handler
448   * @param  {function} handler
449   */
450
451
452  proxy.on = function (handler) {
453    if (typeof handler !== 'function') {
454      return;
455    }
456
457    if (_.contains(handlers, handler)) {
458      return;
459    }
460
461    handlers.push(handler);
462  };
463  /**
464   * Remove an event handler
465   * @param  {function} handler
466   */
467
468
469  proxy.off = function (handler) {
470    // If no arguments supplied, clear all handlers
471    if (!arguments.length) {
472      handlers = [];
473      return;
474    } // Otherwise, remove handler from the list
475
476
477    handlers = _.filter(handlers, function (h) {
478      return h !== handler;
479    });
480  };
481
482  return proxy;
483} // Webflow.location - Wrap window.location in api
484
485
486Webflow.location = function (url) {
487  window.location = url;
488};
489
490if (Webflow.env()) {
491  // Ignore redirects inside a Webflow design/edit environment
492  Webflow.location = function () {};
493} // Webflow.ready - Call primary and secondary handlers
494
495
496Webflow.ready = function () {
497  domready = true; // Restore modules after destroy
498
499  if (destroyed) {
500    restoreModules(); // Otherwise run primary ready methods
501  } else {
502    _.each(primary, callReady);
503  } // Run secondary ready methods
504
505
506  _.each(secondary, callReady); // Trigger resize
507
508
509  Webflow.resize.up();
510};
511
512function callReady(readyFn) {
513  isFunction(readyFn) && readyFn();
514}
515
516function restoreModules() {
517  destroyed = false;
518
519  _.each(modules, bindModule);
520}
521/**
522 * Webflow.load - Add a window load handler that will run even if load event has already happened
523 * @param  {function} handler
524 */
525
526
527var deferLoad;
528
529Webflow.load = function (handler) {
530  deferLoad.then(handler);
531};
532
533function bindLoad() {
534  // Reject any previous deferred (to support destroy)
535  if (deferLoad) {
536    deferLoad.reject();
537    $win.off('load', deferLoad.resolve);
538  } // Create deferred and bind window load event
539
540
541  deferLoad = new $.Deferred();
542  $win.on('load', deferLoad.resolve);
543} // Webflow.destroy - Trigger a destroy event for all modules
544
545
546Webflow.destroy = function (options) {
547  options = options || {};
548  destroyed = true;
549  $win.triggerHandler('__wf_destroy'); // Allow domready reset for tests
550
551  if (options.domready != null) {
552    domready = options.domready;
553  } // Unbind modules
554
555
556  _.each(modules, unbindModule); // Clear any proxy event handlers
557
558
559  Webflow.resize.off();
560  Webflow.scroll.off();
561  Webflow.redraw.off(); // Clear any queued ready methods
562
563  primary = [];
564  secondary = []; // If load event has not yet fired, replace the deferred
565
566  if (deferLoad.state() === 'pending') {
567    bindLoad();
568  }
569}; // Listen for domready
570
571
572$(Webflow.ready); // Listen for window.onload and resolve deferred
573
574bindLoad(); // Export commonjs module
575
576module.exports = window.Webflow = Webflow;
577
578/***/ }),
579/* 6 */
580/***/ (function(module, exports) {
581
582/**
583 * Checks if `value` is the
584 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
585 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
586 *
587 * @static
588 * @memberOf _
589 * @since 0.1.0
590 * @category Lang
591 * @param {*} value The value to check.
592 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
593 * @example
594 *
595 * _.isObject({});
596 * // => true
597 *
598 * _.isObject([1, 2, 3]);
599 * // => true
600 *
601 * _.isObject(_.noop);
602 * // => true
603 *
604 * _.isObject(null);
605 * // => false
606 */
607function isObject(value) {
608  var type = typeof value;
609  return value != null && (type == 'object' || type == 'function');
610}
611
612module.exports = isObject;
613
614
615/***/ }),
616/* 7 */
617/***/ (function(module, exports, __webpack_require__) {
618
619var baseMatches = __webpack_require__(177),
620    baseMatchesProperty = __webpack_require__(231),
621    identity = __webpack_require__(60),
622    isArray = __webpack_require__(1),
623    property = __webpack_require__(240);
624
625/**
626 * The base implementation of `_.iteratee`.
627 *
628 * @private
629 * @param {*} [value=_.identity] The value to convert to an iteratee.
630 * @returns {Function} Returns the iteratee.
631 */
632function baseIteratee(value) {
633  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
634  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
635  if (typeof value == 'function') {
636    return value;
637  }
638  if (value == null) {
639    return identity;
640  }
641  if (typeof value == 'object') {
642    return isArray(value)
643      ? baseMatchesProperty(value[0], value[1])
644      : baseMatches(value);
645  }
646  return property(value);
647}
648
649module.exports = baseIteratee;
650
651
652/***/ }),
653/* 8 */
654/***/ (function(module, exports, __webpack_require__) {
655
656var baseIsNative = __webpack_require__(189),
657    getValue = __webpack_require__(194);
658
659/**
660 * Gets the native function at `key` of `object`.
661 *
662 * @private
663 * @param {Object} object The object to query.
664 * @param {string} key The key of the method to get.
665 * @returns {*} Returns the function if it's native, else `undefined`.
666 */
667function getNative(object, key) {
668  var value = getValue(object, key);
669  return baseIsNative(value) ? value : undefined;
670}
671
672module.exports = getNative;
673
674
675/***/ }),
676/* 9 */

677/***/ (function(module, exports) {
678
679/**
680 * Checks if `value` is object-like. A value is object-like if it's not `null`
681 * and has a `typeof` result of "object".
682 *
683 * @static
684 * @memberOf _
685 * @since 4.0.0
686 * @category Lang
687 * @param {*} value The value to check.
688 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
689 * @example
690 *
691 * _.isObjectLike({});
692 * // => true
693 *
694 * _.isObjectLike([1, 2, 3]);
695 * // => true
696 *
697 * _.isObjectLike(_.noop);
698 * // => false
699 *
700 * _.isObjectLike(null);
701 * // => false
702 */
703function isObjectLike(value) {
704  return value != null && typeof value == 'object';
705}
706
707module.exports = isObjectLike;
708
709
710/***/ }),
711/* 10 */
712/***/ (function(module, exports, __webpack_require__) {
713
714"use strict";
715
716
717var _interopRequireWildcard = __webpack_require__(13);
718
719Object.defineProperty(exports, "__esModule", {
720  value: true
721});
722exports.IX2VanillaUtils = exports.IX2VanillaPlugins = exports.IX2ElementsReducer = exports.IX2EasingUtils = exports.IX2Easings = exports.IX2BrowserSupport = void 0;
723
724var IX2BrowserSupport = _interopRequireWildcard(__webpack_require__(46));
725
726exports.IX2BrowserSupport = IX2BrowserSupport;
727
728var IX2Easings = _interopRequireWildcard(__webpack_require__(107));
729
730exports.IX2Easings = IX2Easings;
731
732var IX2EasingUtils = _interopRequireWildcard(__webpack_require__(109));
733
734exports.IX2EasingUtils = IX2EasingUtils;
735
736var IX2ElementsReducer = _interopRequireWildcard(__webpack_require__(247));
737
738exports.IX2ElementsReducer = IX2ElementsReducer;
739
740var IX2VanillaPlugins = _interopRequireWildcard(__webpack_require__(111));
741
742exports.IX2VanillaPlugins = IX2VanillaPlugins;
743
744var IX2VanillaUtils = _interopRequireWildcard(__webpack_require__(249));
745
746exports.IX2VanillaUtils = IX2VanillaUtils;
747
748/***/ }),
749/* 11 */
750/***/ (function(module, exports, __webpack_require__) {
751
752var Symbol = __webpack_require__(19),
753    getRawTag = __webpack_require__(190),
754    objectToString = __webpack_require__(191);
755
756/** `Object#toString` result references. */
757var nullTag = '[object Null]',
758    undefinedTag = '[object Undefined]';
759
760/** Built-in value references. */
761var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
762
763/**
764 * The base implementation of `getTag` without fallbacks for buggy environments.
765 *
766 * @private
767 * @param {*} value The value to query.
768 * @returns {string} Returns the `toStringTag`.
769 */
770function baseGetTag(value) {
771  if (value == null) {
772    return value === undefined ? undefinedTag : nullTag;
773  }
774  return (symToStringTag && symToStringTag in Object(value))
775    ? getRawTag(value)
776    : objectToString(value);
777}
778
779module.exports = baseGetTag;
780
781
782/***/ }),
783/* 12 */
784/***/ (function(module, exports, __webpack_require__) {
785
786var isFunction = __webpack_require__(89),
787    isLength = __webpack_require__(54);
788
789/**
790 * Checks if `value` is array-like. A value is considered array-like if it's
791 * not a function and has a `value.length` that's an integer greater than or
792 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
793 *
794 * @static
795 * @memberOf _
796 * @since 4.0.0
797 * @category Lang
798 * @param {*} value The value to check.
799 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
800 * @example
801 *
802 * _.isArrayLike([1, 2, 3]);
803 * // => true
804 *
805 * _.isArrayLike(document.body.children);
806 * // => true
807 *
808 * _.isArrayLike('abc');
809 * // => true
810 *
811 * _.isArrayLike(_.noop);
812 * // => false
813 */
814function isArrayLike(value) {
815  return value != null && isLength(value.length) && !isFunction(value);
816}
817
818module.exports = isArrayLike;
819
820
821/***/ }),
822/* 13 */
823/***/ (function(module, exports) {
824
825function _interopRequireWildcard(obj) {
826  if (obj && obj.__esModule) {
827    return obj;
828  } else {
829    var newObj = {};
830
831    if (obj != null) {
832      for (var key in obj) {
833        if (Object.prototype.hasOwnProperty.call(obj, key)) {
834          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
835
836          if (desc.get || desc.set) {
837            Object.defineProperty(newObj, key, desc);
838          } else {
839            newObj[key] = obj[key];
840          }
841        }
842      }
843    }
844
845    newObj["default"] = obj;
846    return newObj;
847  }
848}
849
850module.exports = _interopRequireWildcard;
851
852/***/ }),
853/* 14 */
854/***/ (function(module, exports, __webpack_require__) {
855
856var fails = __webpack_require__(15);
857
858// Thank's IE8 for his funny defineProperty
859module.exports = !fails(function () {
860  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
861});
862
863
864/***/ }),
865/* 15 */

866/***/ (function(module, exports) {
867
868module.exports = function (exec) {
869  try {
870    return !!exec();
871  } catch (error) {
872    return true;
873  }
874};
875
876
877/***/ }),
878/* 16 */
879/***/ (function(module, exports) {
880
881var hasOwnProperty = {}.hasOwnProperty;
882
883module.exports = function (it, key) {
884  return hasOwnProperty.call(it, key);
885};
886
887
888/***/ }),
889/* 17 */
890/***/ (function(module, exports, __webpack_require__) {
891
892var DESCRIPTORS = __webpack_require__(14);
893var definePropertyModule = __webpack_require__(40);
894var createPropertyDescriptor = __webpack_require__(68);
895
896module.exports = DESCRIPTORS ? function (object, key, value) {
897  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
898} : function (object, key, value) {
899  object[key] = value;
900  return object;
901};
902
903
904/***/ }),
905/* 18 */
906/***/ (function(module, exports, __webpack_require__) {
907
908"use strict";
909
910
911Object.defineProperty(exports, "__esModule", {
912  value: true
913});
914
915var _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; };
916
917exports.clone = clone;
918exports.addLast = addLast;
919exports.addFirst = addFirst;
920exports.removeLast = removeLast;
921exports.removeFirst = removeFirst;
922exports.insert = insert;
923exports.removeAt = removeAt;
924exports.replaceAt = replaceAt;
925exports.getIn = getIn;
926exports.set = set;
927exports.setIn = setIn;
928exports.update = update;
929exports.updateIn = updateIn;
930exports.merge = merge;
931exports.mergeDeep = mergeDeep;
932exports.mergeIn = mergeIn;
933exports.omit = omit;
934exports.addDefaults = addDefaults;
935
936
937/*!
938 * Timm
939 *
940 * Immutability helpers with fast reads and acceptable writes.
941 *
942 * @copyright Guillermo Grau Panea 2016
943 * @license MIT
944 */
945
946var INVALID_ARGS = 'INVALID_ARGS';
947
948// ===============================================
949// ### Helpers
950// ===============================================
951
952
953function throwStr(msg) {
954  throw new Error(msg);
955}
956
957function getKeysAndSymbols(obj) {
958  var keys = Object.keys(obj);
959  if (Object.getOwnPropertySymbols) {
960    return keys.concat(Object.getOwnPropertySymbols(obj));
961  }
962  return keys;
963}
964
965var hasOwnProperty = {}.hasOwnProperty;
966
967function clone(obj) {
968  if (Array.isArray(obj)) return obj.slice();
969  var keys = getKeysAndSymbols(obj);
970  var out = {};
971  for (var i = 0; i < keys.length; i++) {
972    var key = keys[i];
973    out[key] = obj[key];
974  }
975  return out;
976}
977
978function doMerge(fAddDefaults, fDeep, first) {
979  var out = first;
980  !(out != null) && throwStr( false ? undefined : INVALID_ARGS);
981  var fChanged = false;
982
983  for (var _len = arguments.length, rest = Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
984    rest[_key - 3] = arguments[_key];
985  }
986
987  for (var idx = 0; idx < rest.length; idx++) {
988    var obj = rest[idx];
989    if (obj == null) continue;
990    var keys = getKeysAndSymbols(obj);
991    if (!keys.length) continue;
992    for (var j = 0; j <= keys.length; j++) {
993      var key = keys[j];
994      if (fAddDefaults && out[key] !== undefined) continue;
995      var nextVal = obj[key];
996      if (fDeep && isObject(out[key]) && isObject(nextVal)) {
997        nextVal = doMerge(fAddDefaults, fDeep, out[key], nextVal);
998      }

999      if (nextVal === undefined || nextVal === out[key]) continue;
1000      if (!fChanged) {
1001        fChanged = true;
1002        out = clone(out);
1003      }
1004      out[key] = nextVal;
1005    }
1006  }
1007  return out;
1008}
1009
1010function isObject(o) {
1011  var type = typeof o === 'undefined' ? 'undefined' : _typeof(o);
1012  return o != null && (type === 'object' || type === 'function');
1013}
1014
1015// _deepFreeze = (obj) ->
1016//   Object.freeze obj
1017//   for key in Object.getOwnPropertyNames obj
1018//     val = obj[key]
1019//     if isObject(val) and not Object.isFrozen val
1020//       _deepFreeze val
1021//   obj
1022
1023// ===============================================
1024// -- ### Arrays
1025// ===============================================
1026
1027// -- #### addLast()
1028// -- Returns a new array with an appended item or items.
1029// --
1030// -- Usage: `addLast<T>(array: Array<T>, val: Array<T>|T): Array<T>`
1031// --
1032// -- ```js
1033// -- arr = ['a', 'b']
1034// -- arr2 = addLast(arr, 'c')
1035// -- // ['a', 'b', 'c']
1036// -- arr2 === arr
1037// -- // false
1038// -- arr3 = addLast(arr, ['c', 'd'])
1039// -- // ['a', 'b', 'c', 'd']
1040// -- ```
1041// `array.concat(val)` also handles the scalar case,
1042// but is apparently very slow
1043function addLast(array, val) {
1044  if (Array.isArray(val)) return array.concat(val);
1045  return array.concat([val]);
1046}
1047
1048// -- #### addFirst()
1049// -- Returns a new array with a prepended item or items.
1050// --
1051// -- Usage: `addFirst<T>(array: Array<T>, val: Array<T>|T): Array<T>`
1052// --
1053// -- ```js
1054// -- arr = ['a', 'b']
1055// -- arr2 = addFirst(arr, 'c')
1056// -- // ['c', 'a', 'b']
1057// -- arr2 === arr
1058// -- // false
1059// -- arr3 = addFirst(arr, ['c', 'd'])
1060// -- // ['c', 'd', 'a', 'b']
1061// -- ```
1062function addFirst(array, val) {
1063  if (Array.isArray(val)) return val.concat(array);
1064  return [val].concat(array);
1065}
1066
1067// -- #### removeLast()
1068// -- Returns a new array removing the last item.
1069// --
1070// -- Usage: `removeLast<T>(array: Array<T>): Array<T>`
1071// --
1072// -- ```js
1073// -- arr = ['a', 'b']
1074// -- arr2 = removeLast(arr)
1075// -- // ['a']
1076// -- arr2 === arr
1077// -- // false
1078// --
1079// -- // The same array is returned if there are no changes:
1080// -- arr3 = []
1081// -- removeLast(arr3) === arr3
1082// -- // true
1083// -- ```
1084function removeLast(array) {
1085  if (!array.length) return array;
1086  return array.slice(0, array.length - 1);
1087}
1088
1089// -- #### removeFirst()
1090// -- Returns a new array removing the first item.
1091// --
1092// -- Usage: `removeFirst<T>(array: Array<T>): Array<T>`
1093// --
1094// -- ```js
1095// -- arr = ['a', 'b']
1096// -- arr2 = removeFirst(arr)
1097// -- // ['b']
1098// -- arr2 === arr
1099// -- // false
1100// --
1101// -- // The same array is returned if there are no changes:
1102// -- arr3 = []
1103// -- removeFirst(arr3) === arr3
1104// -- // true
1105// -- ```
1106function removeFirst(array) {
1107  if (!array.length) return array;
1108  return array.slice(1);
1109}
1110
1111// -- #### insert()
1112// -- Returns a new array obtained by inserting an item or items
1113// -- at a specified index.
1114// --
1115// -- Usage: `insert<T>(array: Array<T>, idx: number, val: Array<T>|T): Array<T>`
1116// --
1117// -- ```js
1118// -- arr = ['a', 'b', 'c']
1119// -- arr2 = insert(arr, 1, 'd')
1120// -- // ['a', 'd', 'b', 'c']
1121// -- arr2 === arr
1122// -- // false
1123// -- insert(arr, 1, ['d', 'e'])
1124// -- // ['a', 'd', 'e', 'b', 'c']
1125// -- ```
1126function insert(array, idx, val) {
1127  return array.slice(0, idx).concat(Array.isArray(val) ? val : [val]).concat(array.slice(idx));
1128}
1129
1130// -- #### removeAt()
1131// -- Returns a new array obtained by removing an item at
1132// -- a specified index.
1133// --
1134// -- Usage: `removeAt<T>(array: Array<T>, idx: number): Array<T>`
1135// --
1136// -- ```js
1137// -- arr = ['a', 'b', 'c']
1138// -- arr2 = removeAt(arr, 1)
1139// -- // ['a', 'c']
1140// -- arr2 === arr
1141// -- // false
1142// --
1143// -- // The same array is returned if there are no changes:
1144// -- removeAt(arr, 4) === arr
1145// -- // true
1146// -- ```
1147function removeAt(array, idx) {
1148  if (idx >= array.length || idx < 0) return array;
1149  return array.slice(0, idx).concat(array.slice(idx + 1));
1150}
1151
1152// -- #### replaceAt()
1153// -- Returns a new array obtained by replacing an item at
1154// -- a specified index. If the provided item is the same as
1155// -- (*referentially equal to*) the previous item at that position,
1156// -- the original array is returned.
1157// --
1158// -- Usage: `replaceAt<T>(array: Array<T>, idx: number, newItem: T): Array<T>`
1159// --
1160// -- ```js
1161// -- arr = ['a', 'b', 'c']

1162// -- arr2 = replaceAt(arr, 1, 'd')
1163// -- // ['a', 'd', 'c']
1164// -- arr2 === arr
1165// -- // false
1166// --
1167// -- // The same object is returned if there are no changes:
1168// -- replaceAt(arr, 1, 'b') === arr
1169// -- // true
1170// -- ```
1171function replaceAt(array, idx, newItem) {
1172  if (array[idx] === newItem) return array;
1173  var len = array.length;
1174  var result = Array(len);
1175  for (var i = 0; i < len; i++) {
1176    result[i] = array[i];
1177  }
1178  result[idx] = newItem;
1179  return result;
1180}
1181
1182// ===============================================
1183// -- ### Collections (objects and arrays)
1184// ===============================================
1185// -- The following types are used throughout this section
1186// -- ```js
1187// -- type ArrayOrObject = Array<any>|Object;
1188// -- type Key = number|string;
1189// -- ```
1190
1191// -- #### getIn()
1192// -- Returns a value from an object at a given path. Works with
1193// -- nested arrays and objects. If the path does not exist, it returns
1194// -- `undefined`.
1195// --
1196// -- Usage: `getIn(obj: ?ArrayOrObject, path: Array<Key>): any`
1197// --
1198// -- ```js
1199// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: ['a', 'b', 'c'] }
1200// -- getIn(obj, ['d', 'd1'])
1201// -- // 3
1202// -- getIn(obj, ['e', 1])
1203// -- // 'b'
1204// -- ```
1205function getIn(obj, path) {
1206  !Array.isArray(path) && throwStr( false ? undefined : INVALID_ARGS);
1207  if (obj == null) return undefined;
1208  var ptr = obj;
1209  for (var i = 0; i < path.length; i++) {
1210    var key = path[i];
1211    ptr = ptr != null ? ptr[key] : undefined;
1212    if (ptr === undefined) return ptr;
1213  }
1214  return ptr;
1215}
1216
1217// -- #### set()
1218// -- Returns a new object with a modified attribute.
1219// -- If the provided value is the same as (*referentially equal to*)
1220// -- the previous value, the original object is returned.
1221// --
1222// -- Usage: `set<T>(obj: ?T, key: Key, val: any): T`
1223// --
1224// -- ```js
1225// -- obj = { a: 1, b: 2, c: 3 }
1226// -- obj2 = set(obj, 'b', 5)
1227// -- // { a: 1, b: 5, c: 3 }
1228// -- obj2 === obj
1229// -- // false
1230// --
1231// -- // The same object is returned if there are no changes:
1232// -- set(obj, 'b', 2) === obj
1233// -- // true
1234// -- ```
1235function set(obj, key, val) {
1236  var fallback = typeof key === 'number' ? [] : {};
1237  var finalObj = obj == null ? fallback : obj;
1238  if (finalObj[key] === val) return finalObj;
1239  var obj2 = clone(finalObj);
1240  obj2[key] = val;
1241  return obj2;
1242}
1243
1244// -- #### setIn()
1245// -- Returns a new object with a modified **nested** attribute.
1246// --
1247// -- Notes:
1248// --
1249// -- * If the provided value is the same as (*referentially equal to*)
1250// -- the previous value, the original object is returned.
1251// -- * If the path does not exist, it will be created before setting
1252// -- the new value.
1253// --
1254// -- Usage: `setIn<T: ArrayOrObject>(obj: T, path: Array<Key>, val: any): T`
1255// --
1256// -- ```js
1257// -- obj = { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1258// -- obj2 = setIn(obj, ['d', 'd1'], 4)
1259// -- // { a: 1, b: 2, d: { d1: 4, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1260// -- obj2 === obj
1261// -- // false
1262// -- obj2.d === obj.d
1263// -- // false
1264// -- obj2.e === obj.e
1265// -- // true
1266// --
1267// -- // The same object is returned if there are no changes:
1268// -- obj3 = setIn(obj, ['d', 'd1'], 3)
1269// -- // { a: 1, b: 2, d: { d1: 3, d2: 4 }, e: { e1: 'foo', e2: 'bar' } }
1270// -- obj3 === obj
1271// -- // true
1272// -- obj3.d === obj.d
1273// -- // true
1274// -- obj3.e === obj.e
1275// -- // true
1276// --
1277// -- // ... unknown paths create intermediate keys. Numeric segments are treated as array indices:
1278// -- setIn({ a: 3 }, ['unknown', 0, 'path'], 4)
1279// -- // { a: 3, unknown: [{ path: 4 }] }
1280// -- ```
1281function doSetIn(obj, path, val, idx) {
1282  var newValue = void 0;
1283  var key = path[idx];
1284  if (idx === path.length - 1) {
1285    newValue = val;
1286  } else {
1287    var nestedObj = isObject(obj) && isObject(obj[key]) ? obj[key] : typeof path[idx + 1] === 'number' ? [] : {};
1288    newValue = doSetIn(nestedObj, path, val, idx + 1);
1289  }
1290  return set(obj, key, newValue);
1291}
1292
1293function setIn(obj, path, val) {
1294  if (!path.length) return val;
1295  return doSetIn(obj, path, val, 0);
1296}
1297
1298// -- #### update()
1299// -- Returns a new object with a modified attribute,

1300// -- calculated via a user-provided callback based on the current value.
1301// -- If the calculated value is the same as (*referentially equal to*)
1302// -- the previous value, the original object is returned.
1303// --
1304// -- Usage: `update<T: ArrayOrObject>(obj: T, key: Key,
1305// -- fnUpdate: (prevValue: any) => any): T`
1306// --
1307// -- ```js
1308// -- obj = { a: 1, b: 2, c: 3 }
1309// -- obj2 = update(obj, 'b', (val) => val + 1)
1310// -- // { a: 1, b: 3, c: 3 }
1311// -- obj2 === obj
1312// -- // false
1313// --
1314// -- // The same object is returned if there are no changes:
1315// -- update(obj, 'b', (val) => val) === obj
1316// -- // true
1317// -- ```
1318function update(obj, key, fnUpdate) {
1319  var prevVal = obj == null ? undefined : obj[key];
1320  var nextVal = fnUpdate(prevVal);
1321  return set(obj, key, nextVal);
1322}
1323
1324// -- #### updateIn()
1325// -- Returns a new object with a modified **nested** attribute,
1326// -- calculated via a user-provided callback based on the current value.
1327// -- If the calculated value is the same as (*referentially equal to*)
1328// -- the previous value, the original object is returned.
1329// --
1330// -- Usage: `updateIn<T: ArrayOrObject>(obj: T, path: Array<Key>,
1331// -- fnUpdate: (prevValue: any) => any): T`
1332// --
1333// -- ```js
1334// -- obj = { a: 1, d: { d1: 3, d2: 4 } }
1335// -- obj2 = updateIn(obj, ['d', 'd1'], (val) => val + 1)
1336// -- // { a: 1, d: { d1: 4, d2: 4 } }
1337// -- obj2 === obj
1338// -- // false
1339// --
1340// -- // The same object is returned if there are no changes:
1341// -- obj3 = updateIn(obj, ['d', 'd1'], (val) => val)
1342// -- // { a: 1, d: { d1: 3, d2: 4 } }
1343// -- obj3 === obj
1344// -- // true
1345// -- ```
1346function updateIn(obj, path, fnUpdate) {
1347  var prevVal = getIn(obj, path);
1348  var nextVal = fnUpdate(prevVal);
1349  return setIn(obj, path, nextVal);
1350}
1351
1352// -- #### merge()
1353// -- Returns a new object built as follows: the overlapping keys from the
1354// -- second one overwrite the corresponding entries from the first one.
1355// -- Similar to `Object.assign()`, but immutable.
1356// --
1357// -- Usage:
1358// --
1359// -- * `merge(obj1: Object, obj2: ?Object): Object`
1360// -- * `merge(obj1: Object, ...objects: Array<?Object>): Object`
1361// --
1362// -- The unmodified `obj1` is returned if `obj2` does not *provide something
1363// -- new to* `obj1`, i.e. if either of the following
1364// -- conditions are true:
1365// --
1366// -- * `obj2` is `null` or `undefined`
1367// -- * `obj2` is an object, but it is empty
1368// -- * All attributes of `obj2` are `undefined`
1369// -- * All attributes of `obj2` are referentially equal to the
1370// --   corresponding attributes of `obj1`
1371// --
1372// -- Note that `undefined` attributes in `obj2` do not modify the
1373// -- corresponding attributes in `obj1`.
1374// --
1375// -- ```js
1376// -- obj1 = { a: 1, b: 2, c: 3 }
1377// -- obj2 = { c: 4, d: 5 }
1378// -- obj3 = merge(obj1, obj2)
1379// -- // { a: 1, b: 2, c: 4, d: 5 }
1380// -- obj3 === obj1
1381// -- // false
1382// --
1383// -- // The same object is returned if there are no changes:
1384// -- merge(obj1, { c: 3 }) === obj1
1385// -- // true
1386// -- ```
1387function merge(a, b, c, d, e, f) {
1388  for (var _len2 = arguments.length, rest = Array(_len2 > 6 ? _len2 - 6 : 0), _key2 = 6; _key2 < _len2; _key2++) {
1389    rest[_key2 - 6] = arguments[_key2];
1390  }
1391
1392  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);
1393}
1394
1395// -- #### mergeDeep()
1396// -- Returns a new object built as follows: the overlapping keys from the
1397// -- second one overwrite the corresponding entries from the first one.
1398// -- If both the first and second entries are objects they are merged recursively.
1399// -- Similar to `Object.assign()`, but immutable, and deeply merging.
1400// --
1401// -- Usage:
1402// --
1403// -- * `mergeDeep(obj1: Object, obj2: ?Object): Object`
1404// -- * `mergeDeep(obj1: Object, ...objects: Array<?Object>): Object`
1405// --
1406// -- The unmodified `obj1` is returned if `obj2` does not *provide something
1407// -- new to* `obj1`, i.e. if either of the following
1408// -- conditions are true:
1409// --
1410// -- * `obj2` is `null` or `undefined`
1411// -- * `obj2` is an object, but it is empty
1412// -- * All attributes of `obj2` are `undefined`
1413// -- * All attributes of `obj2` are referentially equal to the

1414// --   corresponding attributes of `obj1`
1415// --
1416// -- Note that `undefined` attributes in `obj2` do not modify the
1417// -- corresponding attributes in `obj1`.
1418// --
1419// -- ```js
1420// -- obj1 = { a: 1, b: 2, c: { a: 1 } }
1421// -- obj2 = { b: 3, c: { b: 2 } }
1422// -- obj3 = mergeDeep(obj1, obj2)
1423// -- // { a: 1, b: 3, c: { a: 1, b: 2 }  }
1424// -- obj3 === obj1
1425// -- // false
1426// --
1427// -- // The same object is returned if there are no changes:
1428// -- mergeDeep(obj1, { c: { a: 1 } }) === obj1
1429// -- // true
1430// -- ```
1431function mergeDeep(a, b, c, d, e, f) {
1432  for (var _len3 = arguments.length, rest = Array(_len3 > 6 ? _len3 - 6 : 0), _key3 = 6; _key3 < _len3; _key3++) {
1433    rest[_key3 - 6] = arguments[_key3];
1434  }
1435
1436  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);
1437}
1438
1439// -- #### mergeIn()
1440// -- Similar to `merge()`, but merging the value at a given nested path.
1441// -- Note that the returned type is the same as that of the first argument.
1442// --
1443// -- Usage:
1444// --
1445// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>, obj2: ?Object): T`
1446// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>,
1447// -- ...objects: Array<?Object>): T`
1448// --
1449// -- ```js
1450// -- obj1 = { a: 1, d: { b: { d1: 3, d2: 4 } } }
1451// -- obj2 = { d3: 5 }
1452// -- obj3 = mergeIn(obj1, ['d', 'b'], obj2)
1453// -- // { a: 1, d: { b: { d1: 3, d2: 4, d3: 5 } } }
1454// -- obj3 === obj1
1455// -- // false
1456// --
1457// -- // The same object is returned if there are no changes:
1458// -- mergeIn(obj1, ['d', 'b'], { d2: 4 }) === obj1
1459// -- // true
1460// -- ```
1461function mergeIn(a, path, b, c, d, e, f) {
1462  var prevVal = getIn(a, path);
1463  if (prevVal == null) prevVal = {};
1464  var nextVal = void 0;
1465
1466  for (var _len4 = arguments.length, rest = Array(_len4 > 7 ? _len4 - 7 : 0), _key4 = 7; _key4 < _len4; _key4++) {
1467    rest[_key4 - 7] = arguments[_key4];
1468  }
1469
1470  if (rest.length) {
1471    nextVal = doMerge.call.apply(doMerge, [null, false, false, prevVal, b, c, d, e, f].concat(rest));
1472  } else {
1473    nextVal = doMerge(false, false, prevVal, b, c, d, e, f);
1474  }
1475  return setIn(a, path, nextVal);
1476}
1477
1478// -- #### omit()
1479// -- Returns an object excluding one or several attributes.
1480// --
1481// -- Usage: `omit(obj: Object, attrs: Array<string>|string): Object`
1482//
1483// -- ```js
1484// -- obj = { a: 1, b: 2, c: 3, d: 4 }
1485// -- omit(obj, 'a')
1486// -- // { b: 2, c: 3, d: 4 }
1487// -- omit(obj, ['b', 'c'])
1488// -- // { a: 1, d: 4 }
1489// --
1490// -- // The same object is returned if there are no changes:
1491// -- omit(obj, 'z') === obj1
1492// -- // true
1493// -- ```
1494function omit(obj, attrs) {
1495  var omitList = Array.isArray(attrs) ? attrs : [attrs];
1496  var fDoSomething = false;
1497  for (var i = 0; i < omitList.length; i++) {
1498    if (hasOwnProperty.call(obj, omitList[i])) {
1499      fDoSomething = true;
1500      break;
1501    }
1502  }
1503  if (!fDoSomething) return obj;
1504  var out = {};
1505  var keys = getKeysAndSymbols(obj);
1506  for (var _i = 0; _i < keys.length; _i++) {
1507    var key = keys[_i];
1508    if (omitList.indexOf(key) >= 0) continue;
1509    out[key] = obj[key];
1510  }
1511  return out;
1512}
1513
1514// -- #### addDefaults()
1515// -- Returns a new object built as follows: `undefined` keys in the first one
1516// -- are filled in with the corresponding values from the second one
1517// -- (even if they are `null`).
1518// --
1519// -- Usage:
1520// --
1521// -- * `addDefaults(obj: Object, defaults: Object): Object`
1522// -- * `addDefaults(obj: Object, ...defaultObjects: Array<?Object>): Object`
1523// --
1524// -- ```js
1525// -- obj1 = { a: 1, b: 2, c: 3 }
1526// -- obj2 = { c: 4, d: 5, e: null }
1527// -- obj3 = addDefaults(obj1, obj2)
1528// -- // { a: 1, b: 2, c: 3, d: 5, e: null }
1529// -- obj3 === obj1
1530// -- // false
1531// --
1532// -- // The same object is returned if there are no changes:
1533// -- addDefaults(obj1, { c: 4 }) === obj1
1534// -- // true
1535// -- ```
1536function addDefaults(a, b, c, d, e, f) {
1537  for (var _len5 = arguments.length, rest = Array(_len5 > 6 ? _len5 - 6 : 0), _key5 = 6; _key5 < _len5; _key5++) {
1538    rest[_key5 - 6] = arguments[_key5];
1539  }
1540
1541  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);
1542}
1543
1544// ===============================================
1545// ### Public API
1546// ===============================================
1547var timm = {
1548  clone: clone,
1549  addLast: addLast,
1550  addFirst: addFirst,
1551  removeLast: removeLast,
1552  removeFirst: removeFirst,
1553  insert: insert,
1554  removeAt: removeAt,
1555  replaceAt: replaceAt,
1556
1557  getIn: getIn,
1558  // eslint-disable-next-line object-shorthand
1559  set: set, // so that flow doesn't complain
1560  setIn: setIn,
1561  update: update,
1562  updateIn: updateIn,
1563  merge: merge,
1564  mergeDeep: mergeDeep,
1565  mergeIn: mergeIn,
1566  omit: omit,
1567  addDefaults: addDefaults
1568};
1569
1570exports.default = timm;
1571
1572
1573/***/ }),
1574/* 19 */
1575/***/ (function(module, exports, __webpack_require__) {
1576
1577var root = __webpack_require__(4);
1578
1579/** Built-in value references. */
1580var Symbol = root.Symbol;
1581
1582module.exports = Symbol;
1583
1584
1585/***/ }),
1586/* 20 */
1587/***/ (function(module, exports, __webpack_require__) {
1588
1589var isSymbol = __webpack_require__(36);
1590
1591/** Used as references for various `Number` constants. */
1592var INFINITY = 1 / 0;
1593
1594/**
1595 * Converts `value` to a string key if it's not a string or symbol.
1596 *
1597 * @private
1598 * @param {*} value The value to inspect.
1599 * @returns {string|symbol} Returns the key.
1600 */
1601function toKey(value) {
1602  if (typeof value == 'string' || isSymbol(value)) {
1603    return value;
1604  }
1605  var result = (value + '');
1606  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
1607}
1608
1609module.exports = toKey;
1610
1611
1612/***/ }),
1613/* 21 */

1614/***/ (function(module, exports) {
1615
1616function _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); }
1617
1618function _typeof(obj) {
1619  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
1620    module.exports = _typeof = function _typeof(obj) {
1621      return _typeof2(obj);
1622    };
1623  } else {
1624    module.exports = _typeof = function _typeof(obj) {
1625      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
1626    };
1627  }
1628
1629  return _typeof(obj);
1630}
1631
1632module.exports = _typeof;
1633
1634/***/ }),
1635/* 22 */
1636/***/ (function(module, exports) {
1637
1638var g;
1639
1640// This works in non-strict mode
1641g = (function() {
1642	return this;
1643})();
1644
1645try {
1646	// This works if eval is allowed (see CSP)
1647	g = g || new Function("return this")();
1648} catch (e) {
1649	// This works if the window reference is available
1650	if (typeof window === "object") g = window;
1651}
1652
1653// g can still be undefined, but nothing to do about it...
1654// We return undefined, instead of nothing here, so it's
1655// easier to handle this case. if(!global) { ...}
1656
1657module.exports = g;
1658
1659
1660/***/ }),
1661/* 23 */
1662/***/ (function(module, exports) {
1663
1664module.exports = function (it) {
1665  return typeof it === 'object' ? it !== null : typeof it === 'function';
1666};
1667
1668
1669/***/ }),
1670/* 24 */
1671/***/ (function(module, exports, __webpack_require__) {
1672
1673var isObject = __webpack_require__(23);
1674
1675module.exports = function (it) {
1676  if (!isObject(it)) {
1677    throw TypeError(String(it) + ' is not an object');
1678  } return it;
1679};
1680
1681
1682/***/ }),
1683/* 25 */
1684/***/ (function(module, exports, __webpack_require__) {
1685
1686var global = __webpack_require__(3);
1687var setGlobal = __webpack_require__(41);
1688var IS_PURE = __webpack_require__(136);
1689
1690var SHARED = '__core-js_shared__';
1691var store = global[SHARED] || setGlobal(SHARED, {});
1692
1693(module.exports = function (key, value) {
1694  return store[key] || (store[key] = value !== undefined ? value : {});
1695})('versions', []).push({
1696  version: '3.1.3',
1697  mode: IS_PURE ? 'pure' : 'global',
1698  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
1699});
1700
1701
1702/***/ }),
1703/* 26 */
1704/***/ (function(module, exports) {
1705
1706function _defineProperty(obj, key, value) {
1707  if (key in obj) {
1708    Object.defineProperty(obj, key, {
1709      value: value,
1710      enumerable: true,
1711      configurable: true,
1712      writable: true
1713    });
1714  } else {
1715    obj[key] = value;
1716  }
1717
1718  return obj;
1719}
1720
1721module.exports = _defineProperty;
1722
1723/***/ }),
1724/* 27 */
1725/***/ (function(module, exports) {
1726
1727function _extends() {
1728  module.exports = _extends = Object.assign || function (target) {
1729    for (var i = 1; i < arguments.length; i++) {
1730      var source = arguments[i];
1731
1732      for (var key in source) {
1733        if (Object.prototype.hasOwnProperty.call(source, key)) {
1734          target[key] = source[key];
1735        }
1736      }
1737    }
1738
1739    return target;
1740  };
1741
1742  return _extends.apply(this, arguments);
1743}
1744
1745module.exports = _extends;
1746
1747/***/ }),
1748/* 28 */
1749/***/ (function(module, exports, __webpack_require__) {
1750
1751var listCacheClear = __webpack_require__(179),
1752    listCacheDelete = __webpack_require__(180),
1753    listCacheGet = __webpack_require__(181),
1754    listCacheHas = __webpack_require__(182),
1755    listCacheSet = __webpack_require__(183);
1756
1757/**
1758 * Creates an list cache object.
1759 *
1760 * @private
1761 * @constructor
1762 * @param {Array} [entries] The key-value pairs to cache.
1763 */
1764function ListCache(entries) {
1765  var index = -1,
1766      length = entries == null ? 0 : entries.length;
1767
1768  this.clear();
1769  while (++index < length) {
1770    var entry = entries[index];
1771    this.set(entry[0], entry[1]);
1772  }
1773}
1774
1775// Add methods to `ListCache`.
1776ListCache.prototype.clear = listCacheClear;
1777ListCache.prototype['delete'] = listCacheDelete;
1778ListCache.prototype.get = listCacheGet;
1779ListCache.prototype.has = listCacheHas;
1780ListCache.prototype.set = listCacheSet;
1781
1782module.exports = ListCache;
1783
1784
1785/***/ }),
1786/* 29 */
1787/***/ (function(module, exports, __webpack_require__) {
1788
1789var eq = __webpack_require__(47);
1790
1791/**
1792 * Gets the index at which the `key` is found in `array` of key-value pairs.
1793 *
1794 * @private
1795 * @param {Array} array The array to inspect.
1796 * @param {*}

1796 key The key to search for.
1797 * @returns {number} Returns the index of the matched value, else `-1`.
1798 */
1799function assocIndexOf(array, key) {
1800  var length = array.length;
1801  while (length--) {
1802    if (eq(array[length][0], key)) {
1803      return length;
1804    }
1805  }
1806  return -1;
1807}
1808
1809module.exports = assocIndexOf;
1810
1811
1812/***/ }),
1813/* 30 */
1814/***/ (function(module, exports, __webpack_require__) {
1815
1816var getNative = __webpack_require__(8);
1817
1818/* Built-in method references that are verified to be native. */
1819var nativeCreate = getNative(Object, 'create');
1820
1821module.exports = nativeCreate;
1822
1823
1824/***/ }),
1825/* 31 */
1826/***/ (function(module, exports, __webpack_require__) {
1827
1828var isKeyable = __webpack_require__(203);
1829
1830/**
1831 * Gets the data for `map`.
1832 *
1833 * @private
1834 * @param {Object} map The map to query.
1835 * @param {string} key The reference key.
1836 * @returns {*} Returns the map data.
1837 */
1838function getMapData(map, key) {
1839  var data = map.__data__;
1840  return isKeyable(key)
1841    ? data[typeof key == 'string' ? 'string' : 'hash']
1842    : data.map;
1843}
1844
1845module.exports = getMapData;
1846
1847
1848/***/ }),
1849/* 32 */
1850/***/ (function(module, exports, __webpack_require__) {
1851
1852var arrayLikeKeys = __webpack_require__(97),
1853    baseKeys = __webpack_require__(55),
1854    isArrayLike = __webpack_require__(12);
1855
1856/**
1857 * Creates an array of the own enumerable property names of `object`.
1858 *
1859 * **Note:** Non-object values are coerced to objects. See the
1860 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
1861 * for more details.
1862 *
1863 * @static
1864 * @since 0.1.0
1865 * @memberOf _
1866 * @category Object
1867 * @param {Object} object The object to query.
1868 * @returns {Array} Returns the array of property names.
1869 * @example
1870 *
1871 * function Foo() {
1872 *   this.a = 1;
1873 *   this.b = 2;
1874 * }
1875 *
1876 * Foo.prototype.c = 3;
1877 *
1878 * _.keys(new Foo);
1879 * // => ['a', 'b'] (iteration order is not guaranteed)
1880 *
1881 * _.keys('hi');
1882 * // => ['0', '1']
1883 */
1884function keys(object) {
1885  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
1886}
1887
1888module.exports = keys;
1889
1890
1891/***/ }),
1892/* 33 */
1893/***/ (function(module, exports, __webpack_require__) {
1894
1895var baseIsArguments = __webpack_require__(221),
1896    isObjectLike = __webpack_require__(9);
1897
1898/** Used for built-in method references. */
1899var objectProto = Object.prototype;
1900
1901/** Used to check objects for own properties. */
1902var hasOwnProperty = objectProto.hasOwnProperty;
1903
1904/** Built-in value references. */
1905var propertyIsEnumerable = objectProto.propertyIsEnumerable;
1906
1907/**
1908 * Checks if `value` is likely an `arguments` object.
1909 *
1910 * @static
1911 * @memberOf _
1912 * @since 0.1.0
1913 * @category Lang
1914 * @param {*} value The value to check.
1915 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
1916 *  else `false`.
1917 * @example
1918 *
1919 * _.isArguments(function() { return arguments; }());
1920 * // => true
1921 *
1922 * _.isArguments([1, 2, 3]);
1923 * // => false
1924 */
1925var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
1926  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
1927    !propertyIsEnumerable.call(value, 'callee');
1928};
1929
1930module.exports = isArguments;
1931
1932
1933/***/ }),
1934/* 34 */
1935/***/ (function(module, exports, __webpack_require__) {
1936
1937var baseGet = __webpack_require__(58);
1938
1939/**
1940 * Gets the value at `path` of `object`. If the resolved value is
1941 * `undefined`, the `defaultValue` is returned in its place.
1942 *
1943 * @static
1944 * @memberOf _
1945 * @since 3.7.0
1946 * @category Object
1947 * @param {Object} object The object to query.
1948 * @param {Array|string} path The path of the property to get.
1949 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
1950 * @returns {*} Returns the resolved value.
1951 * @example
1952 *
1953 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
1954 *
1955 * _.get(object, 'a[0].b.c');
1956 * // => 3
1957 *
1958 * _.get(object, ['a', '0', 'b', 'c']);
1959 * // => 3
1960 *
1961 * _.get(object, 'a.b.c', 'default');
1962 * // => 'default'
1963 */
1964function get(object, path, defaultValue) {
1965  var result = object == null ? undefined : baseGet(object, path);
1966  return result === undefined ? defaultValue : result;
1967}
1968
1969module.exports = get;
1970
1971
1972/***/ }),
1973/* 35 */
1974/***/ (function(module, exports, __webpack_require__) {
1975
1976var isArray = __webpack_require__(1),
1977    isKey = __webpack_require__(59),
1978    stringToPath = __webpack_require__(232),
1979    toString = __webpack_require__(235);
1980
1981/**
1982 * Casts `value` to a path array if it's not one.
1983 *
1984 * @private
1985 * @param {*} value The value to inspect.
1986 * @param {Object} [object] The object to query keys on.
1987 * @returns {Array} Returns the cast property path array.

1988 */
1989function castPath(value, object) {
1990  if (isArray(value)) {
1991    return value;
1992  }
1993  return isKey(value, object) ? [value] : stringToPath(toString(value));
1994}
1995
1996module.exports = castPath;
1997
1998
1999/***/ }),
2000/* 36 */
2001/***/ (function(module, exports, __webpack_require__) {
2002
2003var baseGetTag = __webpack_require__(11),
2004    isObjectLike = __webpack_require__(9);
2005
2006/** `Object#toString` result references. */
2007var symbolTag = '[object Symbol]';
2008
2009/**
2010 * Checks if `value` is classified as a `Symbol` primitive or object.
2011 *
2012 * @static
2013 * @memberOf _
2014 * @since 4.0.0
2015 * @category Lang
2016 * @param {*} value The value to check.
2017 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
2018 * @example
2019 *
2020 * _.isSymbol(Symbol.iterator);
2021 * // => true
2022 *
2023 * _.isSymbol('abc');
2024 * // => false
2025 */
2026function isSymbol(value) {
2027  return typeof value == 'symbol' ||
2028    (isObjectLike(value) && baseGetTag(value) == symbolTag);
2029}
2030
2031module.exports = isSymbol;
2032
2033
2034/***/ }),
2035/* 37 */
2036/***/ (function(module, exports, __webpack_require__) {
2037
2038"use strict";

2039// @wf-will-never-add-flow-to-this-file
2040
2041/* globals window */
2042
2043/* eslint-disable no-var */
2044
2045/**
2046 * Webflow: IX Event triggers for other modules
2047 */
2048// eslint-disable-next-line strict
2049
2050
2051var $ = window.jQuery;
2052var api = {};
2053var eventQueue = [];
2054var namespace = '.w-ix';
2055var eventTriggers = {
2056  reset: function reset(i, el) {
2057    el.__wf_intro = null;
2058  },
2059  intro: function intro(i, el) {
2060    if (el.__wf_intro) {
2061      return;
2062    }
2063
2064    el.__wf_intro = true;
2065    $(el).triggerHandler(api.types.INTRO);
2066  },
2067  outro: function outro(i, el) {
2068    if (!el.__wf_intro) {
2069      return;
2070    }
2071
2072    el.__wf_intro = null;
2073    $(el).triggerHandler(api.types.OUTRO);
2074  }
2075};
2076api.triggers = {};
2077api.types = {
2078  INTRO: 'w-ix-intro' + namespace,
2079  OUTRO: 'w-ix-outro' + namespace
2080}; // Trigger any events in queue + restore trigger methods
2081
2082api.init = function () {
2083  var count = eventQueue.length;
2084
2085  for (var i = 0; i < count; i++) {
2086    var memo = eventQueue[i];
2087    memo[0](0, memo[1]);
2088  }
2089
2090  eventQueue = [];
2091  $.extend(api.triggers, eventTriggers);
2092}; // Replace all triggers with async wrapper to queue events until init
2093
2094
2095api.async = function () {
2096  for (var key in eventTriggers) {
2097    var func = eventTriggers[key];
2098
2099    if (!eventTriggers.hasOwnProperty(key)) {
2100      continue;
2101    } // Replace trigger method with async wrapper
2102
2103
2104    api.triggers[key] = function (i, el) {
2105      eventQueue.push([func, el]);
2106    };
2107  }
2108}; // Default triggers to async queue
2109
2110
2111api.async();
2112module.exports = api;
2113
2114/***/ }),
2115/* 38 */
2116/***/ (function(module, exports, __webpack_require__) {
2117
2118"use strict";

2119// @wf-will-never-add-flow-to-this-file
2120
2121/* globals window, document */
2122
2123/* eslint-disable no-var */
2124// eslint-disable-next-line strict
2125
2126
2127var IXEvents = __webpack_require__(37);
2128
2129function dispatchCustomEvent(element, eventName) {
2130  var event = document.createEvent('CustomEvent');
2131  event.initCustomEvent(eventName, true, true, null);
2132  element.dispatchEvent(event);
2133}
2134/**
2135 * Webflow: IX Event triggers for other modules
2136 */
2137
2138
2139var $ = window.jQuery;
2140var api = {};
2141var namespace = '.w-ix';
2142var eventTriggers = {
2143  reset: function reset(i, el) {
2144    IXEvents.triggers.reset(i, el);
2145  },
2146  intro: function intro(i, el) {
2147    IXEvents.triggers.intro(i, el);
2148    dispatchCustomEvent(el, 'COMPONENT_ACTIVE');
2149  },
2150  outro: function outro(i, el) {
2151    IXEvents.triggers.outro(i, el);
2152    dispatchCustomEvent(el, 'COMPONENT_INACTIVE');
2153  }
2154};
2155api.triggers = {};
2156api.types = {
2157  INTRO: 'w-ix-intro' + namespace,
2158  OUTRO: 'w-ix-outro' + namespace
2159};
2160$.extend(api.triggers, eventTriggers);
2161module.exports = api;
2162
2163/***/ }),
2164/* 39 */
2165/***/ (function(module, exports, __webpack_require__) {
2166
2167// toObject with fallback for non-array-like ES3 strings
2168var IndexedObject = __webpack_require__(132);
2169var requireObjectCoercible = __webpack_require__(134);
2170
2171module.exports = function (it) {
2172  return IndexedObject(requireObjectCoercible(it));
2173};
2174
2175
2176/***/ }),
2177/* 40 */
2178/***/ (function(module, exports, __webpack_require__) {
2179
2180var DESCRIPTORS = __webpack_require__(14);
2181var IE8_DOM_DEFINE = __webpack_require__(70);
2182var anObject = __webpack_require__(24);
2183var toPrimitive = __webpack_require__(69);
2184
2185var nativeDefineProperty = Object.defineProperty;
2186
2187// `Object.defineProperty` method
2188// https://tc39.github.io/ecma262/#sec-object.defineproperty
2189exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
2190  anObject(O);
2191  P = toPrimitive(P, true);
2192  anObject(Attributes);
2193  if (IE8_DOM_DEFINE) try {
2194    return nativeDefineProperty(O, P, Attributes);
2195  } catch (error) { /* empty */ }
2196  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
2197  if ('value' in Attributes) O[P] = Attributes.value;
2198  return O;
2199};
2200
2201
2202/***/ }),
2203/* 41 */
2204/***/ (function(module, exports, __webpack_require__) {
2205
2206var global = __webpack_require__(3);
2207var hide = __webpack_require__(17);
2208
2209module.exports = function (key, value) {
2210  try {
2211    hide(global, key, value);
2212  } catch (error) {
2213    global[key] = value;
2214  } return value;
2215};
2216
2217
2218/***/ }),
2219/* 42 */
2220/***/ (function(module, exports) {
2221
2222module.exports = {};
2223
2224
2225/***/ }),
2226/* 43 */
2227/***/ (function(module, exports) {
2228
2229// IE8- don't enum bug keys
2230module.exports = [
2231  'constructor',
2232  'hasOwnProperty',
2233  'isPrototypeOf',
2234  'propertyIsEnumerable',
2235  'toLocaleString',
2236  'toString',
2237  'valueOf'
2238];
2239
2240
2241/***/ }),
2242/* 44 */
2243/***/ (function(module, __webpack_exports__, __webpack_require__) {
2244
2245"use strict";
2246__webpack_require__.r(__webpack_exports__);
2247/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ActionTypes", function() { return ActionTypes; });
2248/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return createStore; });
2249/* harmony import */ var lodash_es_isPlainObject__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(80);
2250/* harmony import */ var symbol_observable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(165);
2251
2252
2253
2254/**
2255 * These are private action types reserved by Redux.
2256 * For any unknown actions, you must return the current state.
2257 * If the current state is undefined, you must return the initial state.
2258 * Do not reference these action types directly in your code.
2259 */
2260var ActionTypes = {
2261  INIT: '@@redux/INIT'
2262};
2263
2264/**
2265 * Creates a Redux store that holds the state tree.
2266 * The only way to change the data in the store is to call `dispatch()` on it.
2267 *

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

2419    }
2420
2421    var listeners = currentListeners = nextListeners;
2422    for (var i = 0; i < listeners.length; i++) {
2423      listeners[i]();
2424    }
2425
2426    return action;
2427  }
2428
2429  /**
2430   * Replaces the reducer currently used by the store to calculate the state.
2431   *
2432   * You might need this if your app implements code splitting and you want to
2433   * load some of the reducers dynamically. You might also need this if you
2434   * implement a hot reloading mechanism for Redux.
2435   *
2436   * @param {Function} nextReducer The reducer for the store to use instead.
2437   * @returns {void}
2438   */
2439  function replaceReducer(nextReducer) {
2440    if (typeof nextReducer !== 'function') {
2441      throw new Error('Expected the nextReducer to be a function.');
2442    }
2443
2444    currentReducer = nextReducer;
2445    dispatch({ type: ActionTypes.INIT });
2446  }
2447
2448  /**
2449   * Interoperability point for observable/reactive libraries.
2450   * @returns {observable} A minimal observable of state changes.
2451   * For more information, see the observable proposal:
2452   * https://github.com/zenparsing/es-observable
2453   */
2454  function observable() {
2455    var _ref;
2456
2457    var outerSubscribe = subscribe;
2458    return _ref = {
2459      /**
2460       * The minimal observable subscription method.
2461       * @param {Object} observer Any object that can be used as an observer.
2462       * The observer object should have a `next` method.
2463       * @returns {subscription} An object with an `unsubscribe` method that can
2464       * be used to unsubscribe the observable from the store, and prevent further
2465       * emission of values from the observable.
2466       */
2467      subscribe: function subscribe(observer) {
2468        if (typeof observer !== 'object') {
2469          throw new TypeError('Expected the observer to be an object.');
2470        }
2471
2472        function observeState() {
2473          if (observer.next) {
2474            observer.next(getState());
2475          }
2476        }
2477
2478        observeState();
2479        var unsubscribe = outerSubscribe(observeState);
2480        return { unsubscribe: unsubscribe };
2481      }
2482    }, _ref[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = function () {
2483      return this;
2484    }, _ref;
2485  }
2486
2487  // When a store is created, an "INIT" action is dispatched so that every
2488  // reducer returns their initial state. This effectively populates
2489  // the initial state tree.
2490  dispatch({ type: ActionTypes.INIT });
2491
2492  return _ref2 = {
2493    dispatch: dispatch,
2494    subscribe: subscribe,
2495    getState: getState,
2496    replaceReducer: replaceReducer
2497  }, _ref2[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = observable, _ref2;
2498}
2499
2500/***/ }),
2501/* 45 */
2502/***/ (function(module, __webpack_exports__, __webpack_require__) {
2503
2504"use strict";
2505__webpack_require__.r(__webpack_exports__);
2506/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return compose; });
2507/**
2508 * Composes single-argument functions from right to left. The rightmost
2509 * function can take multiple arguments as it provides the signature for
2510 * the resulting composite function.
2511 *
2512 * @param {...Function} funcs The functions to compose.
2513 * @returns {Function} A function obtained by composing the argument functions
2514 * from right to left. For example, compose(f, g, h) is identical to doing
2515 * (...args) => f(g(h(...args))).
2516 */
2517
2518function compose() {
2519  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
2520    funcs[_key] = arguments[_key];
2521  }
2522
2523  if (funcs.length === 0) {
2524    return function (arg) {
2525      return arg;
2526    };
2527  }
2528
2529  if (funcs.length === 1) {
2530    return funcs[0];
2531  }
2532
2533  var last = funcs[funcs.length - 1];
2534  var rest = funcs.slice(0, -1);
2535  return function () {
2536    return rest.reduceRight(function (composed, f) {
2537      return f(composed);
2538    }, last.apply(undefined, arguments));
2539  };
2540}
2541
2542/***/ }),
2543/* 46 */
2544/***/ (function(module, exports, __webpack_require__) {
2545
2546"use strict";
2547
2548
2549var _interopRequireDefault = __webpack_require__(0);
2550
2551Object.defineProperty(exports, "__esModule", {
2552  value: true
2553});
2554exports.TRANSFORM_STYLE_PREFIXED = exports.TRANSFORM_PREFIXED = exports.FLEX_PREFIXED = exports.ELEMENT_MATCHES = exports.withBrowser = exports.IS_BROW

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