https://certification.byblack.us/landing-page/js/byblack.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 = 120);
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__(169);
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__(170);
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__(171);
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__(172));
196
197exports.IX2EngineActionTypes = IX2EngineActionTypes;
198
199var IX2EngineConstants = _interopRequireWildcard(__webpack_require__(173));
200
201exports.IX2EngineConstants = IX2EngineConstants;
202
203/***/ }),
204/* 3 */
205/***/ (function(module, exports, __webpack_require__) {
206
207"use strict";
208 // @wf-will-never-add-flow-to-this-file
209
210/* globals window, document, navigator, WEBFLOW_ENV_TEST */
211
212/* eslint-disable no-var */
213
214/**
215 * Webflow: Core site library
216 */
217
218var Webflow = {};
219var modules = {};
220var primary = [];
221var secondary = window.Webflow || [];
222var $ = window.jQuery;
223var $win = $(window);
224var $doc = $(document);
225var isFunction = $.isFunction;
226
227var _ = Webflow._ = __webpack_require__(122);
228
229var tram = Webflow.tram = __webpack_require__(65) && $.tram;
230var domready = false;
231var destroyed = false;
232tram.config.hideBackface = false;
233tram.config.keepInherited = true;
234/**
235 * Webflow.define - Define a named module
236 * @param  {string} name
237 * @param  {function} factory
238 * @param  {object} options
239 * @return {object}
240 */
241
242Webflow.define = function (name, factory, options) {
243  if (modules[name]) {
244    unbindModule(modules[name]);
245  }
246
247  var instance = modules[name] = factory($, _, options) || {};
248  bindModule(instance);
249  return instance;
250};
251/**
252 * Webflow.require - Require a named module
253 * @param  {string} name
254 * @return {object}
255 */
256
257
258Webflow.require = function (name) {
259  return modules[name];
260};
261
262function bindModule(module) {
263  // If running in Webflow app, subscribe to design/preview events
264  if (Webflow.env()) {
265    isFunction(module.design) && $win.on('__wf_design', module.design);
266    isFunction(module.preview) && $win.on('__wf_preview', module.preview);
267  } // Subscribe to front-end destroy event
268
269
270  isFunction(module.destroy) && $win.on('__wf_destroy', module.destroy); // Look for ready method on module
271
272  if (module.ready && isFunction(module.ready)) {
273    addReady(module);
274  }
275}
276
277function addReady(module) {
278  // If domready has already happened, run ready method
279  if (domready) {
280    module.ready();
281    return;
282  } // Otherwise add ready method to the primary queue (only once)
283
284
285  if (_.contains(primary, module.ready)) {
286    return;
287  }
288
289  primary.push(module.ready);
290}
291
292function unbindModule(module) {
293  // Unsubscribe module from window events
294  isFunction(module.design) && $win.off('__wf_design', module.design);
295  isFunction(module.preview) && $win.off('__wf_preview', module.preview);
296  isFunction(module.destroy) && $win.off('__wf_destroy', module.destroy); // Remove ready method from primary queue
297
298  if (module.ready && isFunction(module.ready)) {
299    removeReady(module);
300  }
301}
302
303function removeReady(module) {
304  primary = _.filter(primary, function (readyFn) {
305    return readyFn !== module.ready;
306  });
307}
308/**
309 * Webflow.push - Add a ready handler into secondary queue
310 * @param {function} ready  Callback to invoke on domready
311 */
312
313
314Webflow.push = function (ready) {
315  // If domready has already happened, invoke handler
316  if (domready) {
317    isFunction(ready) && ready();
318    return;
319  } // Otherwise push into secondary queue
320
321
322  secondary.push(ready);
323};
324/**
325 * Webflow.env - Get the state of the Webflow app
326 * @param {string} mode [optional]
327 * @return {boolean}
328 */
329
330
331Webflow.env = function (mode) {
332  var designFlag = window.__wf_design;
333  var inApp = typeof designFlag !== 'undefined';
334
335  if (!mode) {
336    return inApp;
337  }
338
339  if (mode === 'design') {
340    return inApp && designFlag;
341  }
342
343  if (mode === 'preview') {
344    return inApp && !designFlag;
345  }
346
347  if (mode === 'slug') {
348    return inApp && window.__wf_slug;
349  }
350
351  if (mode === 'editor') {
352    return window.WebflowEditor;
353  }
354
355  if (mode === 'test') {
356    return  false || window.__wf_test;
357  }
358
359  if (mode === 'frame') {
360    return window !== window.top;
361  }
362}; // Feature detects + browser sniffs  ಠ_ಠ
363
364
365var userAgent = navigator.userAgent.toLowerCase();
366var touch = Webflow.env.touch = 'ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch;
367var chrome = Webflow.env.chrome = /chrome/.test(userAgent) && /Google/.test(navigator.vendor) && parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
368var ios = Webflow.env.ios = /(ipod|iphone|ipad)/.test(userAgent);
369Webflow.env.safari = /safari/.test(userAgent) && !chrome && !ios; // Maintain current touch target to prevent late clicks on touch devices
370
371var touchTarget; // Listen for both events to support touch/mouse hybrid devices
372
373touch && $doc.on('touchstart mousedown', function (evt) {
374  touchTarget = evt.target;
375});
376/**
377 * Webflow.validClick - validate click target against current touch target
378 * @param  {HTMLElement} clickTarget  Element being clicked
379 * @return {Boolean}  True if click target is valid (always true on non-touch)
380 */
381
382Webflow.validClick = touch ? function (clickTarget) {
383  return clickTarget === touchTarget || $.contains(clickTarget, touchTarget);
384} : function () {
385  return true;
386};
387/**
388 * Webflow.resize, Webflow.scroll - throttled event proxies
389 */
390
391var resizeEvents = 'resize.webflow orientationchange.webflow load.webflow';

392var scrollEvents = 'scroll.webflow ' + resizeEvents;
393Webflow.resize = eventProxy($win, resizeEvents);
394Webflow.scroll = eventProxy($win, scrollEvents);
395Webflow.redraw = eventProxy(); // Create a proxy instance for throttled events
396
397function eventProxy(target, types) {
398  // Set up throttled method (using custom frame-based _.throttle)
399  var handlers = [];
400  var proxy = {};
401  proxy.up = _.throttle(function (evt) {
402    _.each(handlers, function (h) {
403      h(evt);
404    });
405  }); // Bind events to target
406
407  if (target && types) {
408    target.on(types, proxy.up);
409  }
410  /**
411   * Add an event handler
412   * @param  {function} handler
413   */
414
415
416  proxy.on = function (handler) {
417    if (typeof handler !== 'function') {
418      return;
419    }
420
421    if (_.contains(handlers, handler)) {
422      return;
423    }
424
425    handlers.push(handler);
426  };
427  /**
428   * Remove an event handler
429   * @param  {function} handler
430   */
431
432
433  proxy.off = function (handler) {
434    // If no arguments supplied, clear all handlers
435    if (!arguments.length) {
436      handlers = [];
437      return;
438    } // Otherwise, remove handler from the list
439
440
441    handlers = _.filter(handlers, function (h) {
442      return h !== handler;
443    });
444  };
445
446  return proxy;
447} // Webflow.location - Wrap window.location in api
448
449
450Webflow.location = function (url) {
451  window.location = url;
452};
453
454if (Webflow.env()) {
455  // Ignore redirects inside a Webflow design/edit environment
456  Webflow.location = function () {};
457} // Webflow.ready - Call primary and secondary handlers
458
459
460Webflow.ready = function () {
461  domready = true; // Restore modules after destroy
462
463  if (destroyed) {
464    restoreModules(); // Otherwise run primary ready methods
465  } else {
466    _.each(primary, callReady);
467  } // Run secondary ready methods
468
469
470  _.each(secondary, callReady); // Trigger resize
471
472
473  Webflow.resize.up();
474};
475
476function callReady(readyFn) {
477  isFunction(readyFn) && readyFn();
478}
479
480function restoreModules() {
481  destroyed = false;
482
483  _.each(modules, bindModule);
484}
485/**
486 * Webflow.load - Add a window load handler that will run even if load event has already happened
487 * @param  {function} handler
488 */
489
490
491var deferLoad;
492
493Webflow.load = function (handler) {
494  deferLoad.then(handler);
495};
496
497function bindLoad() {
498  // Reject any previous deferred (to support destroy)
499  if (deferLoad) {
500    deferLoad.reject();
501    $win.off('load', deferLoad.resolve);
502  } // Create deferred and bind window load event
503
504
505  deferLoad = new $.Deferred();
506  $win.on('load', deferLoad.resolve);
507} // Webflow.destroy - Trigger a destroy event for all modules
508
509
510Webflow.destroy = function (options) {
511  options = options || {};
512  destroyed = true;
513  $win.triggerHandler('__wf_destroy'); // Allow domready reset for tests
514
515  if (options.domready != null) {
516    domready = options.domready;
517  } // Unbind modules
518
519
520  _.each(modules, unbindModule); // Clear any proxy event handlers
521
522
523  Webflow.resize.off();
524  Webflow.scroll.off();
525  Webflow.redraw.off(); // Clear any queued ready methods
526
527  primary = [];
528  secondary = []; // If load event has not yet fired, replace the deferred
529
530  if (deferLoad.state() === 'pending') {
531    bindLoad();
532  }
533}; // Listen for domready
534
535
536$(Webflow.ready); // Listen for window.onload and resolve deferred
537
538bindLoad(); // Export commonjs module
539
540module.exports = window.Webflow = Webflow;
541
542/***/ }),
543/* 4 */
544/***/ (function(module, exports, __webpack_require__) {
545
546/* WEBPACK VAR INJECTION */(function(global) {var O = 'object';
547var check = function (it) {
548  return it && it.Math == Math && it;
549};
550
551// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
552module.exports =
553  // eslint-disable-next-line no-undef
554  check(typeof globalThis == O && globalThis) ||
555  check(typeof window == O && window) ||
556  check(typeof self == O && self) ||
557  check(typeof global == O && global) ||
558  // eslint-disable-next-line no-new-func
559  Function('return this')();
560
561/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(23)))
562
563/***/ }),
564/* 5 */
565/***/ (function(module, exports, __webpack_require__) {
566
567var freeGlobal = __webpack_require__(89);
568
569/** Detect free variable `self`. */
570var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
571
572/** Used as a reference to the global object. */
573var root = freeGlobal || freeSelf || Function('return this')();
574
575module.exports = root;
576
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__(176),
620    baseMatchesProperty = __webpack_require__(230),
621    identity = __webpack_require__(59),
622    isArray = __webpack_require__(1),
623    property = __webpack_require__(239);
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__(188),
657    getValue = __webpack_require__(193);
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 = exp

722orts.IX2BrowserSupport = void 0;
723
724var IX2BrowserSupport = _interopRequireWildcard(__webpack_require__(45));
725
726exports.IX2BrowserSupport = IX2BrowserSupport;
727
728var IX2Easings = _interopRequireWildcard(__webpack_require__(106));
729
730exports.IX2Easings = IX2Easings;
731
732var IX2EasingUtils = _interopRequireWildcard(__webpack_require__(108));
733
734exports.IX2EasingUtils = IX2EasingUtils;
735
736var IX2ElementsReducer = _interopRequireWildcard(__webpack_require__(246));
737
738exports.IX2ElementsReducer = IX2ElementsReducer;
739
740var IX2VanillaPlugins = _interopRequireWildcard(__webpack_require__(110));
741
742exports.IX2VanillaPlugins = IX2VanillaPlugins;
743
744var IX2VanillaUtils = _interopRequireWildcard(__webpack_require__(248));
745
746exports.IX2VanillaUtils = IX2VanillaUtils;
747
748/***/ }),
749/* 11 */
750/***/ (function(module, exports, __webpack_require__) {
751
752var Symbol = __webpack_require__(19),
753    getRawTag = __webpack_require__(189),
754    objectToString = __webpack_require__(190);
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__(88),
787    isLength = __webpack_require__(53);
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__(39);
894var createPropertyDescriptor = __webpack_require__(67);
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__(5);
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__(37);
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, __webpack_require__) {
1637
1638"use strict";
1639// @wf-will-never-add-flow-to-this-file
1640
1641/* globals window, document */
1642
1643/* eslint-disable no-var */
1644// eslint-disable-next-line strict
1645
1646
1647var IXEvents = __webpack_require__(123);
1648
1649function dispatchCustomEvent(element, eventName) {
1650  var event = document.createEvent('CustomEvent');
1651  event.initCustomEvent(eventName, true, true, null);
1652  element.dispatchEvent(event);
1653}
1654/**
1655 * Webflow: IX Event triggers for other modules
1656 */
1657
1658
1659var $ = window.jQuery;
1660var api = {};
1661var namespace = '.w-ix';
1662var eventTriggers = {
1663  reset: function reset(i, el) {
1664    IXEvents.triggers.reset(i, el);
1665  },
1666  intro: function intro(i, el) {
1667    IXEvents.triggers.intro(i, el);
1668    dispatchCustomEvent(el, 'COMPONENT_ACTIVE');
1669  },
1670  outro: function outro(i, el) {
1671    IXEvents.triggers.outro(i, el);
1672    dispatchCustomEvent(el, 'COMPONENT_INACTIVE');
1673  }
1674};
1675api.triggers = {};
1676api.types = {
1677  INTRO: 'w-ix-intro' + namespace,
1678  OUTRO: 'w-ix-outro' + namespace
1679};
1680$.extend(api.triggers, eventTriggers);
1681module.exports = api;
1682
1683/***/ }),
1684/* 23 */
1685/***/ (function(module, exports) {
1686
1687var g;
1688
1689// This works in non-strict mode
1690g = (function() {
1691	return this;
1692})();
1693
1694try {
1695	// This works if eval is allowed (see CSP)
1696	g = g || new Function("return this")();
1697} catch (e) {
1698	// This works if the window reference is available
1699	if (typeof window === "object") g = window;
1700}
1701
1702// g can still be undefined, but nothing to do about it...
1703// We return undefined, instead of nothing here, so it's
1704// easier to handle this case. if(!global) { ...}
1705
1706module.exports = g;
1707
1708
1709/***/ }),
1710/* 24 */
1711/***/ (function(module, exports) {
1712
1713module.exports = function (it) {
1714  return typeof it === 'object' ? it !== null : typeof it === 'function';
1715};
1716
1717
1718/***/ }),
1719/* 25 */
1720/***/ (function(module, exports, __webpack_require__) {
1721
1722var isObject = __webpack_require__(24);
1723
1724module.exports = function (it) {
1725  if (!isObject(it)) {
1726    throw TypeError(String(it) + ' is not an object');
1727  } return it;
1728};
1729
1730
1731/***/ }),
1732/* 26 */
1733/***/ (function(module, exports, __webpack_require__) {
1734
1735var global = __webpack_require__(4);
1736var setGlobal = __webpack_require__(40);
1737var IS_PURE = __webpack_require__(135);
1738
1739var SHARED = '__core-js_shared__';
1740var store = global[SHARED] || setGlobal(SHARED, {});
1741
1742(module.exports = function (key, value) {
1743  return store[key] || (store[key] = value !== undefined ? value : {});
1744})('versions', []).push({
1745  version: '3.1.3',
1746  mode: IS_PURE ? 'pure' : 'global',
1747  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
1748});
1749
1750
1751/***/ }),
1752/* 27 */
1753/***/ (function(module, exports) {
1754
1755function _defineProperty(obj, key, value) {
1756  if (key in obj) {
1757    Object.defineProperty(obj, key, {
1758      value: value,
1759      enumerable: true,
1760      configurable: true,
1761      writable: true
1762    });
1763  } else {
1764    obj[key] = value;
1765  }
1766
1767  return obj;
1768}
1769
1770module.exports = _defineProperty;
1771
1772/***/ }),
1773/* 28 */
1774/***/ (function(module, exports) {
1775
1776function _extends() {
1777  module.exports = _extends = Object.assign || function (target) {
1778    for (var i = 1; i < arguments.length; i++) {
1779      var source = arguments[i];
1780
1781      for (var key in source) {
1782        if (Object.prototype.hasOwnProperty.call(source, key)) {
1783          target[key] = source[key];
1784        }
1785      }
1786    }
1787
1788    return target;
1789  };
1790
1791  return _extends.apply(this, arguments);
1792}
1793
1794module.exports = _extends;
1795
1796/***/ }),
1797/* 29 */
1798/***/ (function(module, exports, __webpack_require__) {
1799
1800var listCacheClear = __webpack_require__(178),
1801    listCacheDelete = __webpack_require__(179),
1802    listCacheGet = __webpack_require__(180),
1803    listCacheHas = __webpack_require__(181),
1804    listCacheSet = __webpack_require__(182);
1805
1806/**
1807 * Creates an list cache object.
1808 *
1809 * @private
1810 * @constructor
1811 * @param {Array} [entries] The key-value pairs to cache.
1812 */
1813function ListCache(entries) {
1814  var index = -1,
1815      length = entries == null ? 0 : entries.length;
1816
1817  this.clear();
1818  while (++index < length) {
1819    var entry = entries[index];
1820    this.set(entry[0], entry[1]);
1821  }
1822}
1823
1824// Add methods to `ListCache`.
1825ListCache.prototype.clear = listCacheClear;
1826ListCache.prototype['delete'] = listCacheDelete;
1827ListCache.prototype.get = listCacheGet;
1828ListCache.prototype.has = listCacheHas;
1829ListCache.prototype.set = listCacheSet;
1830

1831module.exports = ListCache;
1832
1833
1834/***/ }),
1835/* 30 */
1836/***/ (function(module, exports, __webpack_require__) {
1837
1838var eq = __webpack_require__(46);
1839
1840/**
1841 * Gets the index at which the `key` is found in `array` of key-value pairs.
1842 *
1843 * @private
1844 * @param {Array} array The array to inspect.
1845 * @param {*} key The key to search for.
1846 * @returns {number} Returns the index of the matched value, else `-1`.
1847 */
1848function assocIndexOf(array, key) {
1849  var length = array.length;
1850  while (length--) {
1851    if (eq(array[length][0], key)) {
1852      return length;
1853    }
1854  }
1855  return -1;
1856}
1857
1858module.exports = assocIndexOf;
1859
1860
1861/***/ }),
1862/* 31 */
1863/***/ (function(module, exports, __webpack_require__) {
1864
1865var getNative = __webpack_require__(8);
1866
1867/* Built-in method references that are verified to be native. */
1868var nativeCreate = getNative(Object, 'create');
1869
1870module.exports = nativeCreate;
1871
1872
1873/***/ }),
1874/* 32 */
1875/***/ (function(module, exports, __webpack_require__) {
1876
1877var isKeyable = __webpack_require__(202);
1878
1879/**
1880 * Gets the data for `map`.
1881 *
1882 * @private
1883 * @param {Object} map The map to query.
1884 * @param {string} key The reference key.
1885 * @returns {*} Returns the map data.
1886 */
1887function getMapData(map, key) {
1888  var data = map.__data__;
1889  return isKeyable(key)
1890    ? data[typeof key == 'string' ? 'string' : 'hash']
1891    : data.map;
1892}
1893
1894module.exports = getMapData;
1895
1896
1897/***/ }),
1898/* 33 */
1899/***/ (function(module, exports, __webpack_require__) {
1900
1901var arrayLikeKeys = __webpack_require__(96),
1902    baseKeys = __webpack_require__(54),
1903    isArrayLike = __webpack_require__(12);
1904
1905/**
1906 * Creates an array of the own enumerable property names of `object`.
1907 *
1908 * **Note:** Non-object values are coerced to objects. See the
1909 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
1910 * for more details.
1911 *
1912 * @static
1913 * @since 0.1.0
1914 * @memberOf _
1915 * @category Object
1916 * @param {Object} object The object to query.
1917 * @returns {Array} Returns the array of property names.
1918 * @example
1919 *
1920 * function Foo() {
1921 *   this.a = 1;
1922 *   this.b = 2;
1923 * }
1924 *
1925 * Foo.prototype.c = 3;
1926 *
1927 * _.keys(new Foo);
1928 * // => ['a', 'b'] (iteration order is not guaranteed)
1929 *
1930 * _.keys('hi');
1931 * // => ['0', '1']
1932 */
1933function keys(object) {
1934  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
1935}
1936
1937module.exports = keys;
1938
1939
1940/***/ }),
1941/* 34 */
1942/***/ (function(module, exports, __webpack_require__) {
1943
1944var baseIsArguments = __webpack_require__(220),
1945    isObjectLike = __webpack_require__(9);
1946
1947/** Used for built-in method references. */
1948var objectProto = Object.prototype;
1949
1950/** Used to check objects for own properties. */
1951var hasOwnProperty = objectProto.hasOwnProperty;
1952
1953/** Built-in value references. */
1954var propertyIsEnumerable = objectProto.propertyIsEnumerable;
1955
1956/**
1957 * Checks if `value` is likely an `arguments` object.
1958 *
1959 * @static
1960 * @memberOf _
1961 * @since 0.1.0
1962 * @category Lang
1963 * @param {*} value The value to check.
1964 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
1965 *  else `false`.
1966 * @example
1967 *
1968 * _.isArguments(function() { return arguments; }());
1969 * // => true
1970 *
1971 * _.isArguments([1, 2, 3]);
1972 * // => false
1973 */
1974var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
1975  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
1976    !propertyIsEnumerable.call(value, 'callee');
1977};
1978
1979module.exports = isArguments;
1980
1981
1982/***/ }),
1983/* 35 */
1984/***/ (function(module, exports, __webpack_require__) {
1985
1986var baseGet = __webpack_require__(57);
1987
1988/**
1989 * Gets the value at `path` of `object`. If the resolved value is
1990 * `undefined`, the `defaultValue` is returned in its place.
1991 *
1992 * @static
1993 * @memberOf _
1994 * @since 3.7.0
1995 * @category Object
1996 * @param {Object} object The object to query.
1997 * @param {Array|string} path The path of the property to get.
1998 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
1999 * @returns {*} Returns the resolved value.
2000 * @example
2001 *
2002 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
2003 *
2004 * _.get(object, 'a[0].b.c');
2005 * // => 3
2006 *
2007 * _.get(object, ['a', '0', 'b', 'c']);
2008 * // => 3
2009 *
2010 * _.get(object, 'a.b.c', 'default');
2011 * // => 'default'
2012 */
2013function get(object, path, defaultValue) {
2014  var result = object == null ? undefined : baseGet(object, path);
2015  return result === undefined ? defaultValue : result;
2016}
2017
2018module.exports = get;
2019
2020
2021/***/ }),
2022/* 36 */
2023/***/ (function(module, exports, __webpack_require__) {
2024
2025var isArray = __webpack_require__(1),
2026    isKey = __webpack_require__(58),
2027    stringToPath = __webpack_require__(231),
2028    toString = __webpack_require__(234);
2029
2030/**
2031 * Casts `value` to a path array if it's not one.
2032 *
2033 * @private
2034 * @param {*} value The value to inspect.
2035 * @param {Object} [object] The object to query keys on.
2036 * @returns {Array} Returns the cast property path array.

2037 */
2038function castPath(value, object) {
2039  if (isArray(value)) {
2040    return value;
2041  }
2042  return isKey(value, object) ? [value] : stringToPath(toString(value));
2043}
2044
2045module.exports = castPath;
2046
2047
2048/***/ }),
2049/* 37 */
2050/***/ (function(module, exports, __webpack_require__) {
2051
2052var baseGetTag = __webpack_require__(11),
2053    isObjectLike = __webpack_require__(9);
2054
2055/** `Object#toString` result references. */
2056var symbolTag = '[object Symbol]';
2057
2058/**
2059 * Checks if `value` is classified as a `Symbol` primitive or object.
2060 *
2061 * @static
2062 * @memberOf _
2063 * @since 4.0.0
2064 * @category Lang
2065 * @param {*} value The value to check.
2066 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
2067 * @example
2068 *
2069 * _.isSymbol(Symbol.iterator);
2070 * // => true
2071 *
2072 * _.isSymbol('abc');
2073 * // => false
2074 */
2075function isSymbol(value) {
2076  return typeof value == 'symbol' ||
2077    (isObjectLike(value) && baseGetTag(value) == symbolTag);
2078}
2079
2080module.exports = isSymbol;
2081
2082
2083/***/ }),
2084/* 38 */
2085/***/ (function(module, exports, __webpack_require__) {
2086
2087// toObject with fallback for non-array-like ES3 strings
2088var IndexedObject = __webpack_require__(131);
2089var requireObjectCoercible = __webpack_require__(133);
2090
2091module.exports = function (it) {
2092  return IndexedObject(requireObjectCoercible(it));
2093};
2094
2095
2096/***/ }),
2097/* 39 */
2098/***/ (function(module, exports, __webpack_require__) {
2099
2100var DESCRIPTORS = __webpack_require__(14);
2101var IE8_DOM_DEFINE = __webpack_require__(69);
2102var anObject = __webpack_require__(25);
2103var toPrimitive = __webpack_require__(68);
2104
2105var nativeDefineProperty = Object.defineProperty;
2106
2107// `Object.defineProperty` method
2108// https://tc39.github.io/ecma262/#sec-object.defineproperty
2109exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
2110  anObject(O);
2111  P = toPrimitive(P, true);
2112  anObject(Attributes);
2113  if (IE8_DOM_DEFINE) try {
2114    return nativeDefineProperty(O, P, Attributes);
2115  } catch (error) { /* empty */ }
2116  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
2117  if ('value' in Attributes) O[P] = Attributes.value;
2118  return O;
2119};
2120
2121
2122/***/ }),
2123/* 40 */
2124/***/ (function(module, exports, __webpack_require__) {
2125
2126var global = __webpack_require__(4);
2127var hide = __webpack_require__(17);
2128
2129module.exports = function (key, value) {
2130  try {
2131    hide(global, key, value);
2132  } catch (error) {
2133    global[key] = value;
2134  } return value;
2135};
2136
2137
2138/***/ }),
2139/* 41 */
2140/***/ (function(module, exports) {
2141
2142module.exports = {};
2143
2144
2145/***/ }),
2146/* 42 */
2147/***/ (function(module, exports) {
2148
2149// IE8- don't enum bug keys
2150module.exports = [
2151  'constructor',
2152  'hasOwnProperty',
2153  'isPrototypeOf',
2154  'propertyIsEnumerable',
2155  'toLocaleString',
2156  'toString',
2157  'valueOf'
2158];
2159
2160
2161/***/ }),
2162/* 43 */
2163/***/ (function(module, __webpack_exports__, __webpack_require__) {
2164
2165"use strict";
2166__webpack_require__.r(__webpack_exports__);
2167/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ActionTypes", function() { return ActionTypes; });
2168/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return createStore; });
2169/* harmony import */ var lodash_es_isPlainObject__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(79);
2170/* harmony import */ var symbol_observable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(164);
2171
2172
2173
2174/**
2175 * These are private action types reserved by Redux.
2176 * For any unknown actions, you must return the current state.
2177 * If the current state is undefined, you must return the initial state.
2178 * Do not reference these action types directly in your code.
2179 */
2180var ActionTypes = {
2181  INIT: '@@redux/INIT'
2182};
2183
2184/**
2185 * Creates a Redux store that holds the state tree.
2186 * The only way to change the data in the store is to call `dispatch()` on it.
2187 *

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

2339    }
2340
2341    var listeners = currentListeners = nextListeners;
2342    for (var i = 0; i < listeners.length; i++) {
2343      listeners[i]();
2344    }
2345
2346    return action;
2347  }
2348
2349  /**
2350   * Replaces the reducer currently used by the store to calculate the state.
2351   *
2352   * You might need this if your app implements code splitting and you want to
2353   * load some of the reducers dynamically. You might also need this if you
2354   * implement a hot reloading mechanism for Redux.
2355   *
2356   * @param {Function} nextReducer The reducer for the store to use instead.
2357   * @returns {void}
2358   */
2359  function replaceReducer(nextReducer) {
2360    if (typeof nextReducer !== 'function') {
2361      throw new Error('Expected the nextReducer to be a function.');
2362    }
2363
2364    currentReducer = nextReducer;
2365    dispatch({ type: ActionTypes.INIT });
2366  }
2367
2368  /**
2369   * Interoperability point for observable/reactive libraries.
2370   * @returns {observable} A minimal observable of state changes.
2371   * For more information, see the observable proposal:
2372   * https://github.com/zenparsing/es-observable
2373   */
2374  function observable() {
2375    var _ref;
2376
2377    var outerSubscribe = subscribe;
2378    return _ref = {
2379      /**
2380       * The minimal observable subscription method.
2381       * @param {Object} observer Any object that can be used as an observer.
2382       * The observer object should have a `next` method.
2383       * @returns {subscription} An object with an `unsubscribe` method that can
2384       * be used to unsubscribe the observable from the store, and prevent further
2385       * emission of values from the observable.
2386       */
2387      subscribe: function subscribe(observer) {
2388        if (typeof observer !== 'object') {
2389          throw new TypeError('Expected the observer to be an object.');
2390        }
2391
2392        function observeState() {
2393          if (observer.next) {
2394            observer.next(getState());
2395          }
2396        }
2397
2398        observeState();
2399        var unsubscribe = outerSubscribe(observeState);
2400        return { unsubscribe: unsubscribe };
2401      }
2402    }, _ref[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = function () {
2403      return this;
2404    }, _ref;
2405  }
2406
2407  // When a store is created, an "INIT" action is dispatched so that every
2408  // reducer returns their initial state. This effectively populates
2409  // the initial state tree.
2410  dispatch({ type: ActionTypes.INIT });
2411
2412  return _ref2 = {
2413    dispatch: dispatch,
2414    subscribe: subscribe,
2415    getState: getState,
2416    replaceReducer: replaceReducer
2417  }, _ref2[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = observable, _ref2;
2418}
2419
2420/***/ }),
2421/* 44 */
2422/***/ (function(module, __webpack_exports__, __webpack_require__) {
2423
2424"use strict";
2425__webpack_require__.r(__webpack_exports__);
2426/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return compose; });
2427/**
2428 * Composes single-argument functions from right to left. The rightmost
2429 * function can take multiple arguments as it provides the signature for
2430 * the resulting composite function.
2431 *
2432 * @param {...Function} funcs The functions to compose.
2433 * @returns {Function} A function obtained by composing the argument functions
2434 * from right to left. For example, compose(f, g, h) is identical to doing
2435 * (...args) => f(g(h(...args))).
2436 */
2437
2438function compose() {
2439  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
2440    funcs[_key] = arguments[_key];
2441  }
2442
2443  if (funcs.length === 0) {
2444    return function (arg) {
2445      return arg;
2446    };
2447  }
2448
2449  if (funcs.length === 1) {
2450    return funcs[0];
2451  }
2452
2453  var last = funcs[funcs.length - 1];
2454  var rest = funcs.slice(0, -1);
2455  return function () {
2456    return rest.reduceRight(function (composed, f) {
2457      return f(composed);
2458    }, last.apply(undefined, arguments));
2459  };
2460}
2461
2462/***/ }),
2463/* 45 */
2464/***/ (function(module, exports, __webpack_require__) {
2465
2466"use strict";
2467
2468
2469var _interopRequireDefault = __webpack_require__(0);
2470
2471Object.defineProperty(exports, "__esModule", {
2472  value: true
2473});
2474exports.TRANSFORM_STYLE_PREFIXED = exports.TRANSFORM_PREFIXED = exports.FLEX_PREFIXED = exports.ELEMENT_MATCHES = exports.withBrowser = exports.IS_BROW

2474SER_ENV = void 0;
2475
2476var _find = _interopRequireDefault(__webpack_require__(85));
2477/* eslint-env browser */
2478
2479
2480var IS_BROWSER_ENV = typeof window !== 'undefined'; // $FlowFixMe
2481
2482exports.IS_BROWSER_ENV = IS_BROWSER_ENV;
2483
2484var withBrowser = function withBrowser(fn, fallback) {
2485  if (IS_BROWSER_ENV) {
2486    return fn();
2487  }
2488
2489  return fallback;
2490};
2491
2492exports.withBrowser = withBrowser;
2493var ELEMENT_MATCHES = withBrowser(function () {
2494  return (0, _find["default"])(['matches', 'matchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector', 'webkitMatchesSelector'], function (key) {
2495    return key in Element.prototype;
2496  });
2497});
2498exports.ELEMENT_MATCHES = ELEMENT_MATCHES;
2499var FLEX_PREFIXED = withBrowser(function () {
2500  var el = document.createElement('i');
2501  var values = ['flex', '-webkit-flex', '-ms-flexbox', '-moz-box', '-webkit-box'];
2502  var none = '';
2503
2504  try {
2505    var length = values.length;
2506
2507    for (var i = 0; i < length; i++) {
2508      var value = values[i];
2509      el.style.display = value;
2510
2511      if (el.style.display === value) {
2512        return value;
2513      }
2514    }
2515
2516    return none;
2517  } catch (err) {
2518    return none;
2519  }
2520}, 'flex');
2521exports.FLEX_PREFIXED = FLEX_PREFIXED;
2522var TRANSFORM_PREFIXED = withBrowser(function () {
2523  var el = document.createElement('i');
2524
2525  if (el.style.transform == null) {
2526    var prefixes = ['Webkit', 'Moz', 'ms'];
2527    var suffix = 'Transform';
2528    var length = prefixes.length;
2529
2530    for (var i = 0; i < length; i++) {
2531      var prop = prefixes[i] + suffix; // $FlowFixMe
2532
2533      if (el.style[prop] !== undefined) {
2534        return prop;
2535      }
2536    }
2537  }
2538
2539  return 'transform';
2540}, 'transform'); // $FlowFixMe
2541
2542exports.TRANSFORM_PREFIXED = TRANSFORM_PREFIXED;
2543var TRANSFORM_PREFIX = TRANSFORM_PREFIXED.split('transform')[0];
2544var TRANSFORM_STYLE_PREFIXED = TRANSFORM_PREFIX ? TRANSFORM_PREFIX + 'TransformStyle' : 'transformStyle';
2545exports.TRANSFORM_STYLE_PREFIXED = TRANSFORM_STYLE_PREFIXED;
2546
2547/***/ }),
2548/* 46 */
2549/***/ (function(module, exports) {
2550
2551/**
2552 * Performs a
2553 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2554 * comparison between two values to determine if they are equivalent.
2555 *
2556 * @static
2557 * @memberOf _
2558 * @since 4.0.0
2559 * @category Lang
2560 * @param {*} value The value to compare.
2561 * @param {*} other The other value to compare.
2562 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
2563 * @example
2564 *
2565 * var object = { 'a': 1 };
2566 * var other = { 'a': 1 };
2567 *
2568 * _.eq(object, object);
2569 * // => true
2570 *
2571 * _.eq(object, other);
2572 * // => false
2573 *
2574 * _.eq('a', 'a');
2575 * // => true
2576 *
2577 * _.eq('a', Object('a'));
2578 * // => false
2579 *
2580 * _.eq(NaN, NaN);
2581 * // => true
2582 */
2583function eq(value, other) {
2584  return value === other || (value !== value && other !== other);
2585}
2586
2587module.exports = eq;
2588
2589
2590/***/ }),
2591/* 47 */
2592/***/ (function(module, exports, __webpack_require__) {
2593
2594var getNative = __webpack_require__(8),
2595    root = __webpack_require__(5);
2596
2597/* Built-in method references that are verified to be native. */
2598var Map = getNative(root, 'Map');
2599
2600module.exports = Map;
2601
2602
2603/***/ }),
2604/* 48 */
2605/***/ (function(module, exports, __webpack_require__) {
2606
2607var mapCacheClear = __webpack_require__(194),
2608    mapCacheDelete = __webpack_require__(201),
2609    mapCacheGet = __webpack_require__(203),
2610    mapCacheHas = __webpack_require__(204),
2611    mapCacheSet = __webpack_require__(205);
2612
2613/**
2614 * Creates a map cache object to store key-value pairs.
2615 *
2616 * @private
2617 * @constructor
2618 * @param {Array} [entries] The key-value pairs to cache.
2619 */
2620function MapCache(entries) {
2621  var index = -1,
2622      length = entries == null ? 0 : entries.length;
2623
2624  this.clear();
2625  while (++index < length) {
2626    var entry = entries[index];
2627    this.set(entry[0], entry[1]);
2628  }
2629}
2630
2631// Add methods to `MapCache`.
2632MapCache.prototype.clear = mapCacheClear;
2633MapCache.prototype['delete'] = mapCacheDelete;
2634MapCache.prototype.get = mapCacheGet;
2635MapCache.prototype.has = mapCacheHas;
2636MapCache.prototype.set = mapCacheSet;
2637
2638module.exports = MapCache;
2639
2640
2641/***/ }),
2642/* 49 */
2643/***/ (function(module, exports) {
2644
2645/**
2646 * Appends the elements of `values` to `array`.
2647 *
2648 * @private
2649 * @param {Array} array The array to modify.
2650 * @param {Array} values The values to append.
2651 * @returns {Array} Returns `array`.
2652 */
2653function arrayPush(array, values) {
2654  var index = -1,
2655      length = values.length,
2656      offset = array.length;
2657
2658  while (++index < length) {
2659    array[offset + index] = values[index];
2660  }
2661  return array;
2662}
2663
2664module.exports = arrayPush;
2665
2666
2667/***/ }),
2668/* 50 */
2669/***/ (function(module, exports, __webpack_require__) {
2670
2671/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(5),
2672    stubFalse = __webpack_require__(221);
2673
2674/** Detect free variable `exports`. */
2675var freeExports =  true && exports && !exports.nodeType && exports;
2676
2677/** Detect free variable `module`. */
2678var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
2679
2680/** Detect the popular CommonJS extension `module.exports`. */
2681var moduleExports = freeModule && freeModule.exports === freeExports;
2682
2683/** Built-in value references. */
2684var Buffer = moduleExports ? root.Buffer : undefined;
2685
2686/* Built-in method references for those with the same name as other `lodash` methods. */
2687var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
2688
2689/**
2690 * Checks if `value` is a buffer.
2691 *
2692 * @static
2693 * @memberOf _
2694 * @since 4.3.0
2695 * @category Lang
2696 * @param {*} value The value to check.
2697 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
2698 * @example
2699 *
2700 * _.isBuffer(new Buffer(2));
2701 * // => true
2702 *
2703 * _.isBuffer(new Uint8Array(2));
2704 * // => false
2705 */
2706var isBuffer = nativeIsBuffer || stubFalse;
2707
2708module.exports = isBuffer;
2709
2710/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(97)(module)))
2711
2712/***/ }),
2713/* 51 */