https://sketchrunner.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 = 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__(14);
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__(89);
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) {
242
243/**
244 * Checks if `value` is the
245 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
246 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
247 *
248 * @static
249 * @memberOf _
250 * @since 0.1.0
251 * @category Lang
252 * @param {*} value The value to check.
253 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
254 * @example
255 *
256 * _.isObject({});
257 * // => true
258 *
259 * _.isObject([1, 2, 3]);
260 * // => true
261 *
262 * _.isObject(_.noop);
263 * // => true
264 *
265 * _.isObject(null);
266 * // => false
267 */
268function isObject(value) {
269  var type = typeof value;
270  return value != null && (type == 'object' || type == 'function');
271}
272
273module.exports = isObject;
274
275
276/***/ }),
277/* 6 */
278/***/ (function(module, exports, __webpack_require__) {
279
280"use strict";
281 // @wf-will-never-add-flow-to-this-file
282
283/* globals window, document, navigator, WEBFLOW_ENV_TEST */
284
285/* eslint-disable no-var */
286
287/**
288 * Webflow: Core site library
289 */
290
291var Webflow = {};
292var modules = {};
293var primary = [];
294var secondary = window.Webflow || [];
295var $ = window.jQuery;
296var $win = $(window);
297var $doc = $(document);
298var isFunction = $.isFunction;
299
300var _ = Webflow._ = __webpack_require__(123);
301
302var tram = Webflow.tram = __webpack_require__(64) && $.tram;
303var domready = false;
304var destroyed = false;
305tram.config.hideBackface = false;
306tram.config.keepInherited = true;
307/**
308 * Webflow.define - Define a named module
309 * @param  {string} name
310 * @param  {function} factory
311 * @param  {object} options
312 * @return {object}
313 */
314
315Webflow.define = function (name, factory, options) {
316  if (modules[name]) {
317    unbindModule(modules[name]);
318  }
319
320  var instance = modules[name] = factory($, _, options) || {};
321  bindModule(instance);
322  return instance;
323};
324/**
325 * Webflow.require - Require a named module
326 * @param  {string} name
327 * @return {object}
328 */
329
330
331Webflow.require = function (name) {
332  return modules[name];
333};
334
335function bindModule(module) {

336  // If running in Webflow app, subscribe to design/preview events
337  if (Webflow.env()) {
338    isFunction(module.design) && $win.on('__wf_design', module.design);
339    isFunction(module.preview) && $win.on('__wf_preview', module.preview);
340  } // Subscribe to front-end destroy event
341
342
343  isFunction(module.destroy) && $win.on('__wf_destroy', module.destroy); // Look for ready method on module
344
345  if (module.ready && isFunction(module.ready)) {
346    addReady(module);
347  }
348}
349
350function addReady(module) {
351  // If domready has already happened, run ready method
352  if (domready) {
353    module.ready();
354    return;
355  } // Otherwise add ready method to the primary queue (only once)
356
357
358  if (_.contains(primary, module.ready)) {
359    return;
360  }
361
362  primary.push(module.ready);
363}
364
365function unbindModule(module) {
366  // Unsubscribe module from window events
367  isFunction(module.design) && $win.off('__wf_design', module.design);
368  isFunction(module.preview) && $win.off('__wf_preview', module.preview);
369  isFunction(module.destroy) && $win.off('__wf_destroy', module.destroy); // Remove ready method from primary queue
370
371  if (module.ready && isFunction(module.ready)) {
372    removeReady(module);
373  }
374}
375
376function removeReady(module) {
377  primary = _.filter(primary, function (readyFn) {
378    return readyFn !== module.ready;
379  });
380}
381/**
382 * Webflow.push - Add a ready handler into secondary queue
383 * @param {function} ready  Callback to invoke on domready
384 */
385
386
387Webflow.push = function (ready) {
388  // If domready has already happened, invoke handler
389  if (domready) {
390    isFunction(ready) && ready();
391    return;
392  } // Otherwise push into secondary queue
393
394
395  secondary.push(ready);
396};
397/**
398 * Webflow.env - Get the state of the Webflow app
399 * @param {string} mode [optional]
400 * @return {boolean}
401 */
402
403
404Webflow.env = function (mode) {
405  var designFlag = window.__wf_design;
406  var inApp = typeof designFlag !== 'undefined';
407
408  if (!mode) {
409    return inApp;
410  }
411
412  if (mode === 'design') {
413    return inApp && designFlag;
414  }
415
416  if (mode === 'preview') {
417    return inApp && !designFlag;
418  }
419
420  if (mode === 'slug') {
421    return inApp && window.__wf_slug;
422  }
423
424  if (mode === 'editor') {
425    return window.WebflowEditor;
426  }
427
428  if (mode === 'test') {
429    return  false || window.__wf_test;
430  }
431
432  if (mode === 'frame') {
433    return window !== window.top;
434  }
435}; // Feature detects + browser sniffs  ಠ_ಠ
436
437
438var userAgent = navigator.userAgent.toLowerCase();
439var touch = Webflow.env.touch = 'ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch;
440var chrome = Webflow.env.chrome = /chrome/.test(userAgent) && /Google/.test(navigator.vendor) && parseInt(userAgent.match(/chrome\/(\d+)\./)[1], 10);
441var ios = Webflow.env.ios = /(ipod|iphone|ipad)/.test(userAgent);
442Webflow.env.safari = /safari/.test(userAgent) && !chrome && !ios; // Maintain current touch target to prevent late clicks on touch devices
443
444var touchTarget; // Listen for both events to support touch/mouse hybrid devices
445
446touch && $doc.on('touchstart mousedown', function (evt) {
447  touchTarget = evt.target;
448});
449/**
450 * Webflow.validClick - validate click target against current touch target
451 * @param  {HTMLElement} clickTarget  Element being clicked
452 * @return {Boolean}  True if click target is valid (always true on non-touch)
453 */
454
455Webflow.validClick = touch ? function (clickTarget) {
456  return clickTarget === touchTarget || $.contains(clickTarget, touchTarget);
457} : function () {
458  return true;
459};
460/**
461 * Webflow.resize, Webflow.scroll - throttled event proxies
462 */
463
464var resizeEvents = 'resize.webflow orientationchange.webflow load.webflow';
465var scrollEvents = 'scroll.webflow ' + resizeEvents;
466Webflow.resize = eventProxy($win, resizeEvents);
467Webflow.scroll = eventProxy($win, scrollEvents);
468Webflow.redraw = eventProxy(); // Create a proxy instance for throttled events
469
470function eventProxy(target, types) {
471  // Set up throttled method (using custom frame-based _.throttle)
472  var handlers = [];
473  var proxy = {};
474  proxy.up = _.throttle(function (evt) {
475    _.each(handlers, function (h) {
476      h(evt);
477    });
478  }); // Bind events to target
479
480  if (target && types) {
481    target.on(types, proxy.up);
482  }
483  /**
484   * Add an event handler
485   * @param  {function} handler
486   */
487
488
489  proxy.on = function (handler) {
490    if (typeof handler !== 'function') {
491      return;
492    }
493
494    if (_.contains(handlers, handler)) {
495      return;
496    }
497
498    handlers.push(handler);
499  };
500  /**
501   * Remove an event handler
502   * @param  {function} handler
503   */
504
505
506  proxy.off = function (handler) {
507    // If no arguments supplied, clear all handlers
508    if (!arguments.length) {
509      handlers = [];
510      return;
511    } // Otherwise, remove handler from the list
512
513
514    handlers = _.filter(handlers, function (h) {
515      return h !== handler;
516    });
517  };
518
519  return proxy;
520} // Webflow.location - Wrap window.location in api
521
522
523Webflow.location = function (url) {
524  window.location = url;
525};
526
527if (Webflow.env()) {
528  // Ignore redirects inside a Webflow design/edit environment
529  Webflow.location = function () {};
530} // Webflow.ready - Call primary and secondary handlers
531
532
533Webflow.ready = function () {
534  domready = true; // Restore modules after destroy
535
536  if (destroyed) {
537    restoreModules(); // Otherwise run primary ready methods
538  } else {

539    _.each(primary, callReady);
540  } // Run secondary ready methods
541
542
543  _.each(secondary, callReady); // Trigger resize
544
545
546  Webflow.resize.up();
547};
548
549function callReady(readyFn) {
550  isFunction(readyFn) && readyFn();
551}
552
553function restoreModules() {
554  destroyed = false;
555
556  _.each(modules, bindModule);
557}
558/**
559 * Webflow.load - Add a window load handler that will run even if load event has already happened
560 * @param  {function} handler
561 */
562
563
564var deferLoad;
565
566Webflow.load = function (handler) {
567  deferLoad.then(handler);
568};
569
570function bindLoad() {
571  // Reject any previous deferred (to support destroy)
572  if (deferLoad) {
573    deferLoad.reject();
574    $win.off('load', deferLoad.resolve);
575  } // Create deferred and bind window load event
576
577
578  deferLoad = new $.Deferred();
579  $win.on('load', deferLoad.resolve);
580} // Webflow.destroy - Trigger a destroy event for all modules
581
582
583Webflow.destroy = function (options) {
584  options = options || {};
585  destroyed = true;
586  $win.triggerHandler('__wf_destroy'); // Allow domready reset for tests
587
588  if (options.domready != null) {
589    domready = options.domready;
590  } // Unbind modules
591
592
593  _.each(modules, unbindModule); // Clear any proxy event handlers
594
595
596  Webflow.resize.off();
597  Webflow.scroll.off();
598  Webflow.redraw.off(); // Clear any queued ready methods
599
600  primary = [];
601  secondary = []; // If load event has not yet fired, replace the deferred
602
603  if (deferLoad.state() === 'pending') {
604    bindLoad();
605  }
606}; // Listen for domready
607
608
609$(Webflow.ready); // Listen for window.onload and resolve deferred
610
611bindLoad(); // Export commonjs module
612
613module.exports = window.Webflow = Webflow;
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__(58),
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__(14);
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__(43));
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__(247));
737
738exports.IX2ElementsReducer = IX2ElementsReducer;
739
740var IX2VanillaPlugins = _interopRequireWildcard(__webpack_require__(110));
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__(20),
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__(88),
787    isLength = __webpack_require__(51);
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 _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); }
826
827function _typeof(obj) {
828  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
829    module.exports = _typeof = function _typeof(obj) {
830      return _typeof2(obj);
831    };
832  } else {
833    module.exports = _typeof = function _typeof(obj) {
834      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
835    };
836  }
837
838  return _typeof(obj);
839}
840
841module.exports = _typeof;
842
843/***/ }),
844/* 14 */
845/***/ (function(module, exports) {
846
847function _interopRequireWildcard(obj) {
848  if (obj && obj.__esModule) {
849    return obj;
850  } else {
851    var newObj = {};
852
853    if (obj != null) {
854      for (var key in obj) {
855        if (Object.prototype.hasOwnProperty.call(obj, key)) {
856          var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
857
858          if (desc.get || desc.set) {
859            Object.defineProperty(newObj, key, desc);
860          } else {
861            newObj[key] = obj[key];
862          }
863        }
864      }
865    }
866
867    newObj["default"] = obj;
868    return newObj;
869  }
870}
871
872module.exports = _interopRequireWildcard;
873
874/***/ }),
875/* 15 */
876/***/ (function(module, exports, __webpack_require__) {
877
878var fails = __webpack_require__(16);
879
880// Thank's IE8 for his funny defineProperty
881module.exports = !fails(function () {
882  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
883});
884
885
886/***/ }),
887/* 16 */

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

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

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

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

1436// --   corresponding attributes of `obj1`
1437// --
1438// -- Note that `undefined` attributes in `obj2` do not modify the
1439// -- corresponding attributes in `obj1`.
1440// --
1441// -- ```js
1442// -- obj1 = { a: 1, b: 2, c: { a: 1 } }
1443// -- obj2 = { b: 3, c: { b: 2 } }
1444// -- obj3 = mergeDeep(obj1, obj2)
1445// -- // { a: 1, b: 3, c: { a: 1, b: 2 }  }
1446// -- obj3 === obj1
1447// -- // false
1448// --
1449// -- // The same object is returned if there are no changes:
1450// -- mergeDeep(obj1, { c: { a: 1 } }) === obj1
1451// -- // true
1452// -- ```
1453function mergeDeep(a, b, c, d, e, f) {
1454  for (var _len3 = arguments.length, rest = Array(_len3 > 6 ? _len3 - 6 : 0), _key3 = 6; _key3 < _len3; _key3++) {
1455    rest[_key3 - 6] = arguments[_key3];
1456  }
1457
1458  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);
1459}
1460
1461// -- #### mergeIn()
1462// -- Similar to `merge()`, but merging the value at a given nested path.
1463// -- Note that the returned type is the same as that of the first argument.
1464// --
1465// -- Usage:
1466// --
1467// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>, obj2: ?Object): T`
1468// -- * `mergeIn<T: ArrayOrObject>(obj1: T, path: Array<Key>,
1469// -- ...objects: Array<?Object>): T`
1470// --
1471// -- ```js
1472// -- obj1 = { a: 1, d: { b: { d1: 3, d2: 4 } } }
1473// -- obj2 = { d3: 5 }
1474// -- obj3 = mergeIn(obj1, ['d', 'b'], obj2)
1475// -- // { a: 1, d: { b: { d1: 3, d2: 4, d3: 5 } } }
1476// -- obj3 === obj1
1477// -- // false
1478// --
1479// -- // The same object is returned if there are no changes:
1480// -- mergeIn(obj1, ['d', 'b'], { d2: 4 }) === obj1
1481// -- // true
1482// -- ```
1483function mergeIn(a, path, b, c, d, e, f) {
1484  var prevVal = getIn(a, path);
1485  if (prevVal == null) prevVal = {};
1486  var nextVal = void 0;
1487
1488  for (var _len4 = arguments.length, rest = Array(_len4 > 7 ? _len4 - 7 : 0), _key4 = 7; _key4 < _len4; _key4++) {
1489    rest[_key4 - 7] = arguments[_key4];
1490  }
1491
1492  if (rest.length) {
1493    nextVal = doMerge.call.apply(doMerge, [null, false, false, prevVal, b, c, d, e, f].concat(rest));
1494  } else {
1495    nextVal = doMerge(false, false, prevVal, b, c, d, e, f);
1496  }
1497  return setIn(a, path, nextVal);
1498}
1499
1500// -- #### omit()
1501// -- Returns an object excluding one or several attributes.
1502// --
1503// -- Usage: `omit(obj: Object, attrs: Array<string>|string): Object`
1504//
1505// -- ```js
1506// -- obj = { a: 1, b: 2, c: 3, d: 4 }
1507// -- omit(obj, 'a')
1508// -- // { b: 2, c: 3, d: 4 }
1509// -- omit(obj, ['b', 'c'])
1510// -- // { a: 1, d: 4 }
1511// --
1512// -- // The same object is returned if there are no changes:
1513// -- omit(obj, 'z') === obj1
1514// -- // true
1515// -- ```
1516function omit(obj, attrs) {
1517  var omitList = Array.isArray(attrs) ? attrs : [attrs];
1518  var fDoSomething = false;
1519  for (var i = 0; i < omitList.length; i++) {
1520    if (hasOwnProperty.call(obj, omitList[i])) {
1521      fDoSomething = true;
1522      break;
1523    }
1524  }
1525  if (!fDoSomething) return obj;
1526  var out = {};
1527  var keys = getKeysAndSymbols(obj);
1528  for (var _i = 0; _i < keys.length; _i++) {
1529    var key = keys[_i];
1530    if (omitList.indexOf(key) >= 0) continue;
1531    out[key] = obj[key];
1532  }
1533  return out;
1534}
1535
1536// -- #### addDefaults()
1537// -- Returns a new object built as follows: `undefined` keys in the first one
1538// -- are filled in with the corresponding values from the second one
1539// -- (even if they are `null`).
1540// --
1541// -- Usage:
1542// --
1543// -- * `addDefaults(obj: Object, defaults: Object): Object`
1544// -- * `addDefaults(obj: Object, ...defaultObjects: Array<?Object>): Object`
1545// --
1546// -- ```js
1547// -- obj1 = { a: 1, b: 2, c: 3 }
1548// -- obj2 = { c: 4, d: 5, e: null }
1549// -- obj3 = addDefaults(obj1, obj2)
1550// -- // { a: 1, b: 2, c: 3, d: 5, e: null }
1551// -- obj3 === obj1
1552// -- // false
1553// --
1554// -- // The same object is returned if there are no changes:
1555// -- addDefaults(obj1, { c: 4 }) === obj1
1556// -- // true
1557// -- ```
1558function addDefaults(a, b, c, d, e, f) {
1559  for (var _len5 = arguments.length, rest = Array(_len5 > 6 ? _len5 - 6 : 0), _key5 = 6; _key5 < _len5; _key5++) {
1560    rest[_key5 - 6] = arguments[_key5];
1561  }
1562
1563  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);
1564}
1565
1566// ===============================================
1567// ### Public API
1568// ===============================================
1569var timm = {
1570  clone: clone,
1571  addLast: addLast,
1572  addFirst: addFirst,
1573  removeLast: removeLast,
1574  removeFirst: removeFirst,
1575  insert: insert,
1576  removeAt: removeAt,
1577  replaceAt: replaceAt,
1578
1579  getIn: getIn,
1580  // eslint-disable-next-line object-shorthand
1581  set: set, // so that flow doesn't complain
1582  setIn: setIn,
1583  update: update,
1584  updateIn: updateIn,
1585  merge: merge,
1586  mergeDeep: mergeDeep,
1587  mergeIn: mergeIn,
1588  omit: omit,
1589  addDefaults: addDefaults
1590};
1591
1592exports.default = timm;
1593
1594
1595/***/ }),
1596/* 20 */
1597/***/ (function(module, exports, __webpack_require__) {
1598
1599var root = __webpack_require__(4);
1600
1601/** Built-in value references. */
1602var Symbol = root.Symbol;
1603
1604module.exports = Symbol;
1605
1606
1607/***/ }),
1608/* 21 */
1609/***/ (function(module, exports, __webpack_require__) {
1610
1611var isSymbol = __webpack_require__(35);
1612
1613/** Used as references for various `Number` constants. */
1614var INFINITY = 1 / 0;
1615
1616/**
1617 * Converts `value` to a string key if it's not a string or symbol.
1618 *
1619 * @private
1620 * @param {*} value The value to inspect.
1621 * @returns {string|symbol} Returns the key.
1622 */
1623function toKey(value) {
1624  if (typeof value == 'string' || isSymbol(value)) {
1625    return value;
1626  }
1627  var result = (value + '');
1628  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
1629}
1630
1631module.exports = toKey;
1632
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__(38);
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__(44);
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 {*} 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__(96),
1853    baseKeys = __webpack_require__(52),
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 isArray = __webpack_require__(1),
1938    isKey = __webpack_require__(57),
1939    stringToPath = __webpack_require__(232),
1940    toString = __webpack_require__(235);
1941
1942/**
1943 * Casts `value` to a path array if it's not one.
1944 *
1945 * @private
1946 * @param {*} value The value to inspect.
1947 * @param {Object} [object] The object to query keys on.
1948 * @returns {Array} Returns the cast property path array.
1949 */
1950function castPath(value, object) {
1951  if (isArray(value)) {
1952    return value;
1953  }
1954  return isKey(value, object) ? [value] : stringToPath(toString(value));
1955}
1956
1957module.exports = castPath;
1958
1959
1960/***/ }),
1961/* 35 */
1962/***/ (function(module, exports, __webpack_require__) {
1963
1964var baseGetTag = __webpack_require__(11),
1965    isObjectLike = __webpack_require__(9);
1966
1967/** `Object#toString` result references. */
1968var symbolTag = '[object Symbol]';
1969
1970/**
1971 * Checks if `value` is classified as a `Symbol` primitive or object.
1972 *
1973 * @static
1974 * @memberOf _
1975 * @since 4.0.0
1976 * @category Lang
1977 * @param {*} value The value to check.
1978 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
1979 * @example
1980 *
1981 * _.isSymbol(Symbol.iterator);
1982 * // => true
1983 *
1984 * _.isSymbol('abc');
1985 * // => false
1986 */
1987function isSymbol(value) {
1988  return typeof value == 'symbol' ||
1989    (isObjectLike(value) && baseGetTag(value) == symbolTag);
1990}
1991
1992module.exports = isSymbol;
1993
1994
1995/***/ }),
1996/* 36 */
1997/***/ (function(module, exports, __webpack_require__) {
1998
1999// toObject with fallback for non-array-like ES3 strings
2000var IndexedObject = __webpack_require__(132);
2001var requireObjectCoercible = __webpack_require__(134);
2002
2003module.exports = function (it) {
2004  return IndexedObject(requireObjectCoercible(it));
2005};
2006
2007
2008/***/ }),
2009/* 37 */
2010/***/ (function(module, exports, __webpack_require__) {
2011
2012var DESCRIPTORS = __webpack_require__(15);
2013var IE8_DOM_DEFINE = __webpack_require__(69);
2014var anObject = __webpack_require__(24);
2015var toPrimitive = __webpack_require__(68);
2016
2017var nativeDefineProperty = Object.defineProperty;
2018
2019// `Object.defineProperty` method
2020// https://tc39.github.io/ecma262/#sec-object.defineproperty
2021exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
2022  anObject(O);
2023  P = toPrimitive(P, true);
2024  anObject(Attributes);
2025  if (IE8_DOM_DEFINE) try {
2026    return nativeDefineProperty(O, P, Attributes);
2027  } catch (error) { /* empty */ }
2028  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
2029  if ('value' in Attributes) O[P] = Attributes.value;
2030  return O;
2031};
2032
2033
2034/***/ }),
2035/* 38 */
2036/***/ (function(module, exports, __webpack_require__) {
2037
2038var global = __webpack_require__(3);
2039var hide = __webpack_require__(18);
2040
2041module.exports = function (key, value) {
2042  try {
2043    hide(global, key, value);
2044  } catch (error) {
2045    global[key] = value;
2046  } return value;
2047};
2048
2049
2050/***/ }),
2051/* 39 */

2052/***/ (function(module, exports) {
2053
2054module.exports = {};
2055
2056
2057/***/ }),
2058/* 40 */
2059/***/ (function(module, exports) {
2060
2061// IE8- don't enum bug keys
2062module.exports = [
2063  'constructor',
2064  'hasOwnProperty',
2065  'isPrototypeOf',
2066  'propertyIsEnumerable',
2067  'toLocaleString',
2068  'toString',
2069  'valueOf'
2070];
2071
2072
2073/***/ }),
2074/* 41 */
2075/***/ (function(module, __webpack_exports__, __webpack_require__) {
2076
2077"use strict";
2078__webpack_require__.r(__webpack_exports__);
2079/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ActionTypes", function() { return ActionTypes; });
2080/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return createStore; });
2081/* harmony import */ var lodash_es_isPlainObject__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(79);
2082/* harmony import */ var symbol_observable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(165);
2083
2084
2085
2086/**
2087 * These are private action types reserved by Redux.
2088 * For any unknown actions, you must return the current state.
2089 * If the current state is undefined, you must return the initial state.
2090 * Do not reference these action types directly in your code.
2091 */
2092var ActionTypes = {
2093  INIT: '@@redux/INIT'
2094};
2095
2096/**
2097 * Creates a Redux store that holds the state tree.
2098 * The only way to change the data in the store is to call `dispatch()` on it.
2099 *

2100 * There should only be a single store in your app. To specify how different
2101 * parts of the state tree respond to actions, you may combine several reducers
2102 * into a single reducer function by using `combineReducers`.
2103 *
2104 * @param {Function} reducer A function that returns the next state tree, given
2105 * the current state tree and the action to handle.
2106 *
2107 * @param {any} [preloadedState] The initial state. You may optionally specify it
2108 * to hydrate the state from the server in universal apps, or to restore a
2109 * previously serialized user session.
2110 * If you use `combineReducers` to produce the root reducer function, this must be
2111 * an object with the same shape as `combineReducers` keys.
2112 *
2113 * @param {Function} enhancer The store enhancer. You may optionally specify it
2114 * to enhance the store with third-party capabilities such as middleware,
2115 * time travel, persistence, etc. The only store enhancer that ships with Redux
2116 * is `applyMiddleware()`.
2117 *
2118 * @returns {Store} A Redux store that lets you read the state, dispatch actions
2119 * and subscribe to changes.
2120 */
2121function createStore(reducer, preloadedState, enhancer) {
2122  var _ref2;
2123
2124  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
2125    enhancer = preloadedState;
2126    preloadedState = undefined;
2127  }
2128
2129  if (typeof enhancer !== 'undefined') {
2130    if (typeof enhancer !== 'function') {
2131      throw new Error('Expected the enhancer to be a function.');
2132    }
2133
2134    return enhancer(createStore)(reducer, preloadedState);
2135  }
2136
2137  if (typeof reducer !== 'function') {
2138    throw new Error('Expected the reducer to be a function.');
2139  }
2140
2141  var currentReducer = reducer;
2142  var currentState = preloadedState;
2143  var currentListeners = [];
2144  var nextListeners = currentListeners;
2145  var isDispatching = false;
2146
2147  function ensureCanMutateNextListeners() {
2148    if (nextListeners === currentListeners) {
2149      nextListeners = currentListeners.slice();
2150    }
2151  }
2152
2153  /**
2154   * Reads the state tree managed by the store.
2155   *
2156   * @returns {any} The current state tree of your application.
2157   */
2158  function getState() {
2159    return currentState;
2160  }
2161
2162  /**
2163   * Adds a change listener. It will be called any time an action is dispatched,
2164   * and some part of the state tree may potentially have changed. You may then
2165   * call `getState()` to read the current state tree inside the callback.
2166   *
2167   * You may call `dispatch()` from a change listener, with the following
2168   * caveats:
2169   *
2170   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
2171   * If you subscribe or unsubscribe while the listeners are being invoked, this
2172   * will not have any effect on the `dispatch()` that is currently in progress.
2173   * However, the next `dispatch()` call, whether nested or not, will use a more
2174   * recent snapshot of the subscription list.
2175   *
2176   * 2. The listener should not expect to see all state changes, as the state
2177   * might have been updated multiple times during a nested `dispatch()` before
2178   * the listener is called. It is, however, guaranteed that all subscribers
2179   * registered before the `dispatch()` started will be called with the latest
2180   * state by the time it exits.
2181   *
2182   * @param {Function} listener A callback to be invoked on every dispatch.
2183   * @returns {Function} A function to remove this change listener.
2184   */
2185  function subscribe(listener) {
2186    if (typeof listener !== 'function') {
2187      throw new Error('Expected listener to be a function.');
2188    }
2189
2190    var isSubscribed = true;
2191
2192    ensureCanMutateNextListeners();
2193    nextListeners.push(listener);
2194
2195    return function unsubscribe() {
2196      if (!isSubscribed) {
2197        return;
2198      }
2199
2200      isSubscribed = false;
2201
2202      ensureCanMutateNextListeners();
2203      var index = nextListeners.indexOf(listener);
2204      nextListeners.splice(index, 1);
2205    };
2206  }
2207
2208  /**
2209   * Dispatches an action. It is the only way to trigger a state change.
2210   *
2211   * The `reducer` function, used to create the store, will be called with the
2212   * current state tree and the given `action`. Its return value will
2213   * be considered the **next** state of the tree, and the change listeners
2214   * will be notified.
2215   *
2216   * The base implementation only supports plain object actions. If you want to
2217   * dispatch a Promise, an Observable, a thunk, or something else, you need to
2218   * wrap your store creating function into the corresponding middleware. For
2219   * example, see the documentation for the `redux-thunk` package. Even the
2220   * middleware will eventually dispatch plain object actions using this method.
2221   *
2222   * @param {Object} action A plain object representing “what changed”. It is
2223   * a good idea to keep actions serializable so you can record and replay user
2224   * sessions, or use the time travelling `redux-devtools`. An action must have
2225   * a `type` property which may not be `undefined`. It is a good idea to use
2226   * string constants for action types.
2227   *
2228   * @returns {Object} For convenience, the same action object you dispatched.
2229   *
2230   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
2231   * return something else (for example, a Promise you can await).
2232   */
2233  function dispatch(action) {
2234    if (!Object(lodash_es_isPlainObject__WEBPACK_IMPORTED_MODULE_0__["default"])(action)) {
2235      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
2236    }
2237
2238    if (typeof action.type === 'undefined') {
2239      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
2240    }
2241
2242    if (isDispatching) {
2243      throw new Error('Reducers may not dispatch actions.');
2244    }
2245
2246    try {
2247      isDispatching = true;
2248      currentState = currentReducer(currentState, action);
2249    } finally {
2250      isDispatching = false;

2251    }
2252
2253    var listeners = currentListeners = nextListeners;
2254    for (var i = 0; i < listeners.length; i++) {
2255      listeners[i]();
2256    }
2257
2258    return action;
2259  }
2260
2261  /**
2262   * Replaces the reducer currently used by the store to calculate the state.
2263   *
2264   * You might need this if your app implements code splitting and you want to
2265   * load some of the reducers dynamically. You might also need this if you
2266   * implement a hot reloading mechanism for Redux.
2267   *
2268   * @param {Function} nextReducer The reducer for the store to use instead.
2269   * @returns {void}
2270   */
2271  function replaceReducer(nextReducer) {
2272    if (typeof nextReducer !== 'function') {
2273      throw new Error('Expected the nextReducer to be a function.');
2274    }
2275
2276    currentReducer = nextReducer;
2277    dispatch({ type: ActionTypes.INIT });
2278  }
2279
2280  /**
2281   * Interoperability point for observable/reactive libraries.
2282   * @returns {observable} A minimal observable of state changes.
2283   * For more information, see the observable proposal:
2284   * https://github.com/zenparsing/es-observable
2285   */
2286  function observable() {
2287    var _ref;
2288
2289    var outerSubscribe = subscribe;
2290    return _ref = {
2291      /**
2292       * The minimal observable subscription method.
2293       * @param {Object} observer Any object that can be used as an observer.
2294       * The observer object should have a `next` method.
2295       * @returns {subscription} An object with an `unsubscribe` method that can
2296       * be used to unsubscribe the observable from the store, and prevent further
2297       * emission of values from the observable.
2298       */
2299      subscribe: function subscribe(observer) {
2300        if (typeof observer !== 'object') {
2301          throw new TypeError('Expected the observer to be an object.');
2302        }
2303
2304        function observeState() {
2305          if (observer.next) {
2306            observer.next(getState());
2307          }
2308        }
2309
2310        observeState();
2311        var unsubscribe = outerSubscribe(observeState);
2312        return { unsubscribe: unsubscribe };
2313      }
2314    }, _ref[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = function () {
2315      return this;
2316    }, _ref;
2317  }
2318
2319  // When a store is created, an "INIT" action is dispatched so that every
2320  // reducer returns their initial state. This effectively populates
2321  // the initial state tree.
2322  dispatch({ type: ActionTypes.INIT });
2323
2324  return _ref2 = {
2325    dispatch: dispatch,
2326    subscribe: subscribe,
2327    getState: getState,
2328    replaceReducer: replaceReducer
2329  }, _ref2[symbol_observable__WEBPACK_IMPORTED_MODULE_1__["default"]] = observable, _ref2;
2330}
2331
2332/***/ }),
2333/* 42 */
2334/***/ (function(module, __webpack_exports__, __webpack_require__) {
2335
2336"use strict";
2337__webpack_require__.r(__webpack_exports__);
2338/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return compose; });
2339/**
2340 * Composes single-argument functions from right to left. The rightmost
2341 * function can take multiple arguments as it provides the signature for
2342 * the resulting composite function.
2343 *
2344 * @param {...Function} funcs The functions to compose.
2345 * @returns {Function} A function obtained by composing the argument functions
2346 * from right to left. For example, compose(f, g, h) is identical to doing
2347 * (...args) => f(g(h(...args))).
2348 */
2349
2350function compose() {
2351  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
2352    funcs[_key] = arguments[_key];
2353  }
2354
2355  if (funcs.length === 0) {
2356    return function (arg) {
2357      return arg;
2358    };
2359  }
2360
2361  if (funcs.length === 1) {
2362    return funcs[0];
2363  }
2364
2365  var last = funcs[funcs.length - 1];
2366  var rest = funcs.slice(0, -1);
2367  return function () {
2368    return rest.reduceRight(function (composed, f) {
2369      return f(composed);
2370    }, last.apply(undefined, arguments));
2371  };
2372}
2373
2374/***/ }),
2375/* 43 */
2376/***/ (function(module, exports, __webpack_require__) {
2377
2378"use strict";
2379
2380
2381var _interopRequireDefault = __webpack_require__(0);
2382
2383Object.defineProperty(exports, "__esModule", {
2384  value: true
2385});
2386exports.TRANSFORM_STYLE_PREFIXED = exports.TRANSFORM_PREFIXED = exports.FLEX_PREFIXED = exports.ELEMENT_MATCHES = exports.withBrowser = exports.IS_BROW

2386SER_ENV = void 0;
2387
2388var _find = _interopRequireDefault(__webpack_require__(85));
2389/* eslint-env browser */
2390
2391
2392var IS_BROWSER_ENV = typeof window !== 'undefined'; // $FlowFixMe
2393
2394exports.IS_BROWSER_ENV = IS_BROWSER_ENV;
2395
2396var withBrowser = function withBrowser(fn, fallback) {
2397  if (IS_BROWSER_ENV) {
2398    return fn();
2399  }
2400
2401  return fallback;
2402};
2403
2404exports.withBrowser = withBrowser;
2405var ELEMENT_MATCHES = withBrowser(function () {
2406  return (0, _find["default"])(['matches', 'matchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector', 'webkitMatchesSelector'], function (key) {
2407    return key in Element.prototype;
2408  });
2409});
2410exports.ELEMENT_MATCHES = ELEMENT_MATCHES;
2411var FLEX_PREFIXED = withBrowser(function () {
2412  var el = document.createElement('i');
2413  var values = ['flex', '-webkit-flex', '-ms-flexbox', '-moz-box', '-webkit-box'];
2414  var none = '';
2415
2416  try {
2417    var length = values.length;
2418
2419    for (var i = 0; i < length; i++) {
2420      var value = values[i];
2421      el.style.display = value;
2422
2423      if (el.style.display === value) {
2424        return value;
2425      }
2426    }
2427
2428    return none;
2429  } catch (err) {
2430    return none;
2431  }
2432}, 'flex');
2433exports.FLEX_PREFIXED = FLEX_PREFIXED;
2434var TRANSFORM_PREFIXED = withBrowser(function () {
2435  var el = document.createElement('i');
2436
2437  if (el.style.transform == null) {
2438    var prefixes = ['Webkit', 'Moz', 'ms'];
2439    var suffix = 'Transform';
2440    var length = prefixes.length;
2441
2442    for (var i = 0; i < length; i++) {
2443      var prop = prefixes[i] + suffix; // $FlowFixMe
2444
2445      if (el.style[prop] !== undefined) {
2446        return prop;
2447      }
2448    }
2449  }
2450
2451  return 'transform';
2452}, 'transform'); // $FlowFixMe
2453
2454exports.TRANSFORM_PREFIXED = TRANSFORM_PREFIXED;
2455var TRANSFORM_PREFIX = TRANSFORM_PREFIXED.split('transform')[0];
2456var TRANSFORM_STYLE_PREFIXED = TRANSFORM_PREFIX ? TRANSFORM_PREFIX + 'TransformStyle' : 'transformStyle';
2457exports.TRANSFORM_STYLE_PREFIXED = TRANSFORM_STYLE_PREFIXED;
2458
2459/***/ }),
2460/* 44 */
2461/***/ (function(module, exports) {
2462
2463/**
2464 * Performs a
2465 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2466 * comparison between two values to determine if they are equivalent.
2467 *
2468 * @static
2469 * @memberOf _
2470 * @since 4.0.0
2471 * @category Lang
2472 * @param {*} value The value to compare.
2473 * @param {*} other The other value to compare.
2474 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
2475 * @example
2476 *
2477 * var object = { 'a': 1 };
2478 * var other = { 'a': 1 };
2479 *
2480 * _.eq(object, object);
2481 * // => true
2482 *
2483 * _.eq(object, other);
2484 * // => false
2485 *
2486 * _.eq('a', 'a');
2487 * // => true
2488 *
2489 * _.eq('a', Object('a'));
2490 * // => false
2491 *
2492 * _.eq(NaN, NaN);
2493 * // => true
2494 */
2495function eq(value, other) {
2496  return value === other || (value !== value && other !== other);
2497}
2498
2499module.exports = eq;
2500
2501
2502/***/ }),
2503/* 45 */
2504/***/ (function(module, exports, __webpack_require__) {
2505
2506var getNative = __webpack_require__(8),
2507    root = __webpack_require__(4);
2508
2509/* Built-in method references that are verified to be native. */
2510var Map = getNative(root, 'Map');
2511
2512module.exports = Map;
2513
2514
2515/***/ }),
2516/* 46 */
2517/***/ (function(module, exports, __webpack_require__) {
2518
2519var mapCacheClear = __webpack_require__(195),
2520    mapCacheDelete = __webpack_require__(202),
2521    mapCacheGet = __webpack_require__(204),
2522    mapCacheHas = __webpack_require__(205),
2523    mapCacheSet = __webpack_require__(206);
2524
2525/**
2526 * Creates a map cache object to store key-value pairs.
2527 *
2528 * @private
2529 * @constructor
2530 * @param {Array} [entries] The key-value pairs to cache.
2531 */
2532function MapCache(entries) {
2533  var index = -1,
2534      length = entries == null ? 0 : entries.length;
2535
2536  this.clear();
2537  while (++index < length) {
2538    var entry = entries[index];
2539    this.set(entry[0], entry[1]);
2540  }
2541}
2542
2543// Add methods to `MapCache`.
2544MapCache.prototype.clear = mapCacheClear;
2545MapCache.prototype['delete'] = mapCacheDelete;
2546MapCache.prototype.get = mapCacheGet;
2547MapCache.prototype.has = mapCacheHas;
2548MapCache.prototype.set = mapCacheSet;
2549
2550module.exports = MapCache;
2551
2552
2553/***/ }),
2554/* 47 */
2555/***/ (function(module, exports) {
2556
2557/**
2558 * Appends the elements of `values` to `array`.
2559 *
2560 * @private
2561 * @param {Array} array The array to modify.
2562 * @param {Array} values The values to append.
2563 * @returns {Array} Returns `array`.
2564 */
2565function arrayPush(array, values) {
2566  var index = -1,
2567      length = values.length,
2568      offset = array.length;
2569
2570  while (++index < length) {
2571    array[offset + index] = values[index];
2572  }
2573  return array;
2574}
2575
2576module.exports = arrayPush;
2577
2578
2579/***/ }),
2580/* 48 */
2581/***/ (function(module, exports, __webpack_require__) {
2582
2583/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(4),
2584    stubFalse = __webpack_require__(222);
2585
2586/** Detect free variable `exports`. */
2587var freeExports =  true && exports && !exports.nodeType && exports;
2588
2589/** Detect free variable `module`. */
2590var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
2591
2592/** Detect the popular CommonJS extension `module.exports`. */
2593var moduleExports = freeModule && freeModule.exports === freeExports;
2594
2595/** Built-in value references. */
2596var Buffer = moduleExports ? root.Buffer : undefined;
2597
2598/* Built-in method references for those with the same name as other `lodash` methods. */
2599var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
2600
2601/**
2602 * Checks if `value` is a buffer.
2603 *
2604 * @static
2605 * @memberOf _
2606 * @since 4.3.0
2607 * @category Lang
2608 * @param {*} value The value to check.
2609 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
2610 * @example
2611 *
2612 * _.isBuffer(new Buffer(2));
2613 * // => true
2614 *
2615 * _.isBuffer(new Uint8Array(2));
2616 * // => false
2617 */
2618var isBuffer = nativeIsBuffer || stubFalse;
2619
2620module.exports = isBuffer;
2621
2622/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(97)(module)))
2623
2624/***/ }),
2625/* 49 */

2626/***/ (function(module, exports) {
2627
2628/** Used as references for various `Number` constants. */
2629var MAX_SAFE_INTEGER = 9007199254740991;
2630
2631/** Used to detect unsigned integer values. */
2632var reIsUint = /^(?:0|[1-9]\d*)$/;
2633
2634/**
2635 * Checks if `value` is a valid array-like index.
2636 *
2637 * @private
2638 * @param {*} value The value to check.
2639 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
2640 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
2641 */
2642function isIndex(value, length) {
2643  var type = typeof value;
2644  length = length == null ? MAX_SAFE_INTEGER : length;
2645
2646  return !!length &&
2647    (type == 'number' ||
2648      (type != 'symbol' && reIsUint.test(value))) &&
2649        (value > -1 && value % 1 == 0 && value < length);
2650}
2651
2652module.exports = isIndex;
2653
2654
2655/***/ }),
2656/* 50 */
2657/***/ (function(module, exports, __webpack_require__) {
2658
2659var baseIsTypedArray = __webpack_require__(223),
2660    baseUnary = __webpack_require__(224),
2661    nodeUtil = __webpack_require__(225);
2662
2663/* Node.js helper references. */
2664var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
2665
2666/**
2667 * Checks if `value` is classified as a typed array.
2668 *
2669 * @static
2670 * @memberOf _
2671 * @since 3.0.0
2672 * @category Lang
2673 * @param {*} value The value to check.
2674 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
2675 * @example
2676 *
2677 * _.isTypedArray(new Uint8Array);
2678 * // => true
2679 *
2680 * _.isTypedArray([]);
2681 * // => false
2682 */
2683var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
2684
2685module.exports = isTypedArray;
2686
2687
2688/***/ }),
2689/* 51 */
2690/***/ (function(module, exports) {
2691
2692/** Used as references for various `Number` constants. */
2693var MAX_SAFE_INTEGER = 9007199254740991;
2694
2695/**
2696 * Checks if `value` is a valid array-like length.
2697 *
2698 * **Note:** This method is loosely based on
2699 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
2700 *
2701 * @static
2702 * @memberOf _
2703 * @since 4.0.0
2704 * @category Lang
2705 * @param {*} value The value to check.
2706 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
2707 * @example
2708 *
2709 * _.isLength(3);
2710 * // => true
2711 *
2712 * _.isLength(Number.MIN_VALUE);
2713 * // => false
2714 *
2715 * _.isLength(Infinity);
2716 * // => false
2717 *
2718 * _.isLength('3');
2719 * // => false
2720 */
2721function isLength(value) {
2722  return typeof value == 'number' &&
2723    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
2724}
2725
2726module.exports = isLength;
2727
2728
2729/***/ }),
2730/* 52 */
2731/***/ (function(module, exports, __webpack_require__) {
2732
2733var isPrototype = __webpack_require__(53),
2734    nativeKeys = __webpack_require__(226);
2735
2736/** Used for built-in method references. */
2737var objectProto = Object.prototype;
2738
2739/** Used to check objects for own properties. */
2740var hasOwnProperty = objectProto.hasOwnProperty;
2741
2742/**
2743 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
2744 *
2745 * @private
2746 * @param {Object} object The object to query.
2747 * @returns {Array} Returns the array of property names.
2748 */
2749function baseKeys(object) {
2750  if (!isPrototype(object)) {
2751    return nativeKeys(object);
2752  }
2753  var result = [];
2754  for (var key in Object(object)) {
2755    if (hasOwnProperty.call(object, key) && key != 'constructor') {
2756      result.push(key);
2757    }
2758  }
2759  return result;
2760}
2761
2762module.exports = baseKeys;
2763
2764
2765/***/ }),
2766/* 53 */
2767/***/ (function(module, exports) {
2768
2769/** Used for built-in method references. */
2770var objectProto = Object.prototype;
2771
2772/**
2773 * Checks if `value` is likely a prototype object.
2774 *
2775 * @private
2776 * @param {*} value The value to check.
2777 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
2778 */
2779function isPrototype(value) {
2780  var Ctor = value && value.constructor,
2781      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
2782
2783  return value === proto;
2784}
2785
2786module.exports = isPrototype;
2787
2788
2789/***/ }),
2790/* 54 */
2791/***/ (function(module, exports, __webpack_require__) {
2792
2793var DataView = __webpack_require__(227),
2794    Map = __webpack_require__(45),
2795    Promise = __webpack_require__(228),
2796    Set = __webpack_require__(229),
2797    WeakMap = __webpack_require__(99),
2798    baseGetTag = __webpack_require__(11),
2799    toSource = __webpack_require__(90);
2800
2801/** `Object#toString` result references. */
2802var mapTag = '[object Map]',
2803    objectTag = '[object Object]',
2804    promiseTag = '[object Promise]',
2805    setTag = '[object Set]',
2806    weakMapTag = '[object WeakMap]';
2807
2808var dataViewTag = '[object DataView]';
2809
2810/** Used to detect maps, sets, and weakmaps. */
2811var dataViewCtorString = toSource(DataView),
2812    mapCtorString = toSource(Map),
2813    promiseCtorString = toSource(Promise),
2814    setCtorString = toSource(Set),
2815    weakMapCtorString = toSource(WeakMap);
2816
2817/**
2818 * Gets the `toStringTag` of `value`.
2819 *
2820 * @private
2821 * @param {*} value The value to query.
2822 * @returns {string} Returns the `toStringTag`.
2823 */
2824var getTag = baseGetTag;
2825
2826// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
2827if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
2828    (Map && getTag(new Map) != mapTag) ||
2829    (Promise && getTag(Promise.resolve()) != promiseTag) ||
2830    (Set && getTag(new Set) != setTag) ||
2831    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
2832  getTag = function(value) {
2833    var result = baseGetTag(value),
2834        Ctor = result == objectTag ? value.constructor : undefined,