https://hunterhug.github.io/goa.c/picture/static/gitalk/dist/gitalk.js

1(function webpackUniversalModuleDefinition(root, factory) {
2    if (typeof exports === 'object' && typeof module === 'object')
3        module.exports = factory();
4    else if (typeof define === 'function' && define.amd)
5        define([], factory);
6    else if (typeof exports === 'object')
7        exports["Gitalk"] = factory();
8    else
9        root["Gitalk"] = factory();
10})(this, function () {
11    return /******/ (function (modules) { // webpackBootstrap
12        /******/ 	// The module cache
13        /******/
14        var installedModules = {};
15        /******/
16        /******/ 	// The require function
17        /******/
18        function __webpack_require__(moduleId) {
19            /******/
20            /******/ 		// Check if module is in cache
21            /******/
22            if (installedModules[moduleId]) {
23                /******/
24                return installedModules[moduleId].exports;
25                /******/
26            }
27            /******/ 		// Create a new module (and put it into the cache)
28            /******/
29            var module = installedModules[moduleId] = {
30                /******/            i: moduleId,
31                /******/            l: false,
32                /******/            exports: {}
33                /******/
34            };
35            /******/
36            /******/ 		// Execute the module function
37            /******/
38            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
39            /******/
40            /******/ 		// Flag the module as loaded
41            /******/
42            module.l = true;
43            /******/
44            /******/ 		// Return the exports of the module
45            /******/
46            return module.exports;
47            /******/
48        }
49
50        /******/
51        /******/
52        /******/ 	// expose the modules object (__webpack_modules__)
53        /******/
54        __webpack_require__.m = modules;
55        /******/
56        /******/ 	// expose the module cache
57        /******/
58        __webpack_require__.c = installedModules;
59        /******/
60        /******/ 	// define getter function for harmony exports
61        /******/
62        __webpack_require__.d = function (exports, name, getter) {
63            /******/
64            if (!__webpack_require__.o(exports, name)) {
65                /******/
66                Object.defineProperty(exports, name, {
67                    /******/                configurable: false,
68                    /******/                enumerable: true,
69                    /******/                get: getter
70                    /******/
71                });
72                /******/
73            }
74            /******/
75        };
76        /******/
77        /******/ 	// getDefaultExport function for compatibility with non-harmony modules
78        /******/
79        __webpack_require__.n = function (module) {
80            /******/
81            var getter = module && module.__esModule ?
82                /******/            function getDefault() {
83                    return module['default'];
84                } :
85                /******/            function getModuleExports() {
86                    return module;
87                };
88            /******/
89            __webpack_require__.d(getter, 'a', getter);
90            /******/
91            return getter;
92            /******/
93        };
94        /******/
95        /******/ 	// Object.prototype.hasOwnProperty.call
96        /******/
97        __webpack_require__.o = function (object, property) {
98            return Object.prototype.hasOwnProperty.call(object, property);
99        };
100        /******/
101        /******/ 	// __webpack_public_path__
102        /******/
103        __webpack_require__.p = "/dist";
104        /******/
105        /******/ 	// Load entry module and return exports
106        /******/
107        return __webpack_require__(__webpack_require__.s = 191);
108        /******/
109    })
110        /************************************************************************/
111        /******/ ([
112            /* 0 */
113            /***/ (function (module, __webpack_exports__, __webpack_require__) {
114
115                "use strict";
116                /* harmony export (immutable) */
117                __webpack_exports__["a"] = requiredArgs;
118
119                function requiredArgs(required, args) {
120                    if (args.length < required) {
121                        throw new TypeError(required + ' argument' + (required > 1 ? 's' : '') + ' required, but only ' + args.length + ' present');
122                    }
123                }
124
125                /***/
126            }),
127            /* 1 */
128            /***/ (function (module, __webpack_exports__, __webpack_require__) {
129
130                "use strict";
131                /* harmony export (immutable) */
132                __webpack_exports__["a"] = toDate;
133                /* harmony import */
134                var __WEBPACK_IMPORTED_MODULE_0__lib_requiredArgs_index_js__ = __webpack_require__(0);
135
136                /**
137                 * @name toDate
138                 * @category Common Helpers
139                 * @summary Convert the given argument to an instance of Date.
140                 *

249                        var string = String(dirtyString);
250                        var options = dirtyOptions || {};
251                        var matchResult = string.match(args.matchPattern);
252
253                        if (!matchResult) {
254                            return null;
255                        }
256
257                        var matchedString = matchResult[0];
258                        var parseResult = string.match(args.parsePattern);
259
260                        if (!parseResult) {
261                            return null;
262                        }
263
264                        var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
265                        value = options.valueCallback ? options.valueCallback(value) : value;
266                        return {
267                            value: value,
268                            rest: string.slice(matchedString.length)
269                        };
270                    };
271                }
272
273                /***/
274            }),
275            /* 5 */
276            /***/ (function (module, __webpack_exports__, __webpack_require__) {
277
278                "use strict";
279                /* harmony export (immutable) */
280                __webpack_exports__["a"] = buildMatchFn;
281
282                function buildMatchFn(args) {
283                    return function (dirtyString, dirtyOptions) {
284                        var string = String(dirtyString);
285                        var options = dirtyOptions || {};
286                        var width = options.width;
287                        var matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
288                        var matchResult = string.match(matchPattern);
289
290                        if (!matchResult) {
291                            return null;
292                        }
293
294                        var matchedString = matchResult[0];
295                        var parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
296                        var value;
297
298                        if (Object.prototype.toString.call(parsePatterns) === '[object Array]') {
299                            value = findIndex(parsePatterns, function (pattern) {
300                                return pattern.test(matchedString);
301                            });
302                        } else {
303                            value = findKey(parsePatterns, function (pattern) {
304                                return pattern.test(matchedString);
305                            });
306                        }
307
308                        value = args.valueCallback ? args.valueCallback(value) : value;
309                        value = options.valueCallback ? options.valueCallback(value) : value;
310                        return {
311                            value: value,
312                            rest: string.slice(matchedString.length)
313                        };
314                    };
315                }
316
317                function findKey(object, predicate) {
318                    for (var key in object) {
319                        if (object.hasOwnProperty(key) && predicate(object[key])) {
320                            return key;
321                        }
322                    }
323                }
324
325                function findIndex(array, predicate) {
326                    for (var key = 0; key < array.length; key++) {
327                        if (predicate(array[key])) {
328                            return key;
329                        }
330                    }
331                }
332
333                /***/
334            }),
335            /* 6 */
336            /***/ (function (module, __webpack_exports__, __webpack_require__) {
337
338                "use strict";
339                /* harmony export (immutable) */
340                __webpack_exports__["a"] = toInteger;
341
342                function toInteger(dirtyNumber) {
343                    if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
344                        return NaN;
345                    }
346
347                    var number = Number(dirtyNumber);
348
349                    if (isNaN(number)) {
350                        return number;
351                    }
352
353                    return number < 0 ? Math.ceil(number) : Math.floor(number);
354                }
355
356                /***/
357            }),
358            /* 7 */
359            /***/ (function (module, exports) {
360
361                var core = module.exports = {version: '2.6.11'};
362                if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
363
364
365                /***/
366            }),
367            /* 8 */
368            /***/ (function (module, exports) {
369
370// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
371                var global = module.exports = typeof window != 'undefined' && window.Math == Math
372                    ? window : typeof self != 'undefined' && self.Math == Math ? self
373                        // eslint-disable-next-line no-new-func
374                        : Function('return this')();
375                if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
376
377
378                /***/
379            }),
380            /* 9 */
381            /***/ (function (module, exports, __webpack_require__) {
382
383                var store = __webpack_require__(74)('wks');
384                var uid = __webpack_require__(52);
385                var Symbol = __webpack_require__(8).Symbol;
386                var USE_SYMBOL = typeof Symbol == 'function';
387
388                var $exports = module.exports = function (name) {
389                    return store[name] || (store[name] =
390                        USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
391                };
392
393                $exports.store = store;
394
395
396                /***/
397            }),
398            /* 10 */
399            /***/ (function (module, exports, __webpack_require__) {
400
401                "use strict";
402
403
404                var bind = __webpack_require__(122);
405
406                /*global toString:true*/
407
408// utils is a library of generic helper functions non-specific to axios
409
410                var toString = Object.prototype.toString;
411
412                /**
413                 * Determine if a value is an Array
414                 *
415                 * @param {Object} val The value to test
416                 * @returns {boolean} True if value is an Array, otherwise false
417                 */
418                function isArray(val) {
419                    return toString.call(val) === '[object Array]';
420                }
421
422                /**
423                 * Determine if a value is undefined
424                 *
425                 * @param {Object} val The value to test
426                 * @returns {boolean} True if the value is undefined, otherwise false
427                 */
428                function isUndefined(val) {
429                    return typeof val === 'undefined';
430                }
431
432                /**
433                 * Determine if a value is a Buffer
434                 *
435                 * @param {Object} val The value to test
436                 * @returns {boolean} True if value is a Buffer, otherwise false
437                 */
438                function isBuffer(val) {
439                    return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
440                        && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
441                }
442
443                /**
444                 * Determine if a value is an ArrayBuffer
445                 *
446                 * @param {Object} val The value to test
447                 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
448                 */
449                function isArrayBuffer(val) {
450                    return toString.call(val) === '[object ArrayBuffer]';
451                }
452
453                /**
454                 * Determine if a value is a FormData
455                 *
456                 * @param {Object} val The value to test
457                 * @returns {boolean} True if value is an FormData, otherwise false
458                 */
459                function isFormData(val) {
460                    return (typeof FormData !== 'undefined') && (val instanceof FormData);
461                }
462
463                /**
464                 * Determine if a value is a view on an ArrayBuffer
465                 *
466                 * @param {Object} val The value to test
467                 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
468                 */
469                function isArrayBufferView(val) {
470                    var result;
471                    if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
472                        result = ArrayBuffer.isView(val);
473                    } else {
474                        result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
475                    }
476                    return result;
477                }
478
479                /**
480                 * Determine if a value is a String
481                 *
482                 * @param {Object} val The value to test
483                 * @returns {boolean} True if value is a String, otherwise false
484                 */
485                function isString(val) {
486                    return typeof val === 'string';
487                }
488
489                /**
490                 * Determine if a value is a Number
491                 *
492                 * @param {Object} val The value to test
493                 * @returns {boolean} True if value is a Number, otherwise false
494                 */
495                function isNumber(val) {
496                    return typeof val === 'number';
497                }
498
499                /**
500                 * Determine if a value is an Object
501                 *
502                 * @param {Object} val The value to test
503                 * @returns {boolean} True if value is an Object, otherwise false
504                 */
505                function isObject(val) {
506                    return val !== null && typeof val === 'object';
507                }
508
509                /**
510                 * Determine if a value is a Date
511                 *
512                 * @param {Object} val The value to test
513                 * @returns {boolean} True if value is a Date, otherwise false
514                 */
515                function isDate(val) {
516                    return toString.call(val) === '[object Date]';
517                }
518
519                /**
520                 * Determine if a value is a File
521                 *
522                 * @param {Object} val The value to test
523                 * @returns {boolean} True if value is a File, otherwise false
524                 */
525                function isFile(val) {
526                    return toString.call(val) === '[object File]';
527                }
528
529                /**
530                 * Determine if a value is a Blob
531                 *
532                 * @param {Object} val The value to test
533                 * @returns {boolean} True if value is a Blob, otherwise false
534                 */
535                function isBlob(val) {
536                    return toString.call(val) === '[object Blob]';
537                }
538
539                /**
540                 * Determine if a value is a Function
541                 *
542                 * @param {Object} val The value to test
543                 * @returns {boolean} True if value is a Function, otherwise false
544                 */
545                function isFunction(val) {
546                    return toString.call(val) === '[object Function]';
547                }
548
549                /**
550                 * Determine if a value is a Stream
551                 *
552                 * @param {Object} val The value to test
553                 * @returns {boolean} True if value is a Stream, otherwise false
554                 */
555                function isStream(val) {
556                    return isObject(val) && isFunction(val.pipe);
557                }
558
559                /**
560                 * Determine if a value is a URLSearchParams object
561                 *
562                 * @param {Object} val The value to test
563                 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
564                 */
565                function isURLSearchParams(val) {
566                    return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
567                }
568
569                /**
570                 * Trim excess whitespace off the beginning and end of a string
571                 *
572                 * @param {String} str The String to trim
573                 * @returns {String} The String freed of excess whitespace
574                 */
575                function trim(str) {
576                    return str.replace(/^\s*/, '').replace(/\s*$/, '');
577                }
578
579                /**
580                 * Determine if we're running in a standard browser environment
581                 *
582                 * This allows axios to run in a web worker, and react-native.
583                 * Both environments support XMLHttpRequest, but not fully standard globals.
584                 *
585                 * web workers:
586                 *  typeof window -> undefined
587                 *  typeof document -> undefined
588                 *
589                 * react-native:
590                 *  navigator.product -> 'ReactNative'
591                 * nativescript
592                 *  navigator.product -> 'NativeScript' or 'NS'
593                 */
594                function isStandardBrowserEnv() {
595                    if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
596                        navigator.product === 'NativeScript' ||
597                        navigator.product === 'NS')) {
598                        return false;
599                    }
600                    return (
601                        typeof window !== 'undefined' &&
602                        typeof document !== 'undefined'
603                    );
604                }
605
606                /**
607                 * Iterate over an Array or an Object invoking a function for each item.
608                 *
609                 * If `obj` is an Array callback will be called passing
610                 * the value, index, and complete array for each item.
611                 *
612                 * If 'obj' is an Object callback will be called passing
613                 * the value, key, and complete object for each property.
614                 *
615                 * @param {Object|Array} obj The object to iterate
616                 * @param {Function} fn The callback to invoke for each item
617                 */
618                function forEach(obj, fn) {
619                    // Don't bother if no value provided
620                    if (obj === null || typeof obj === 'undefined') {
621                        return;
622                    }
623
624                    // Force an array if not already something iterable
625                    if (typeof obj !== 'object') {
626                        /*eslint no-param-reassign:0*/
627                        obj = [obj];
628                    }
629
630                    if (isArray(obj)) {
631                        // Iterate over array values
632                        for (var i = 0, l = obj.length; i < l; i++) {
633                            fn.call(null, obj[i], i, obj);
634                        }
635                    } else {
636                        // Iterate over object keys
637                        for (var key in obj) {
638                            if (Object.prototype.hasOwnProperty.call(obj, key)) {
639                                fn.call(null, obj[key], key, obj);
640                            }
641                        }
642                    }
643                }
644
645                /**
646                 * Accepts varargs expecting each argument to be an object, then
647                 * immutably merges the properties of each object and returns result.
648                 *
649                 * When multiple objects contain the same key the later object in
650                 * the arguments list will take precedence.
651                 *
652                 * Example:
653                 *
654                 * ```js
655                 * var result = merge({foo: 123}, {foo: 456});
656                 * console.log(result.foo); // outputs 456
657                 * ```
658                 *
659                 * @param {Object} obj1 Object to merge
660                 * @returns {Object} Result of all merge properties
661                 */
662                function merge(/* obj1, obj2, obj3, ... */) {
663                    var result = {};
664
665                    function assignValue(val, key) {
666                        if (typeof result[key] === 'object' && typeof val === 'object') {
667                            result[key] = merge(result[key], val);
668                        } else {
669                            result[key] = val;
670                        }
671                    }
672
673                    for (var i = 0, l = arguments.length; i < l; i++) {
674                        forEach(arguments[i], assignValue);
675                    }
676                    return result;
677                }
678
679                /**
680                 * Function equal to merge with the difference being that no reference
681                 * to original objects is kept.
682                 *
683                 * @see merge
684                 * @param {Object} obj1 Object to merge
685                 * @returns {Object} Result of all merge properties
686                 */
687                function deepMerge(/* obj1, obj2, obj3, ... */) {
688                    var result = {};
689
690                    function assignValue(val, key) {
691                        if (typeof result[key] === 'object' && typeof val === 'object') {
692                            result[key] = deepMerge(result[key], val);
693                        } else if (typeof val === 'object') {
694                            result[key] = deepMerge({}, val);
695                        } else {
696                            result[key] = val;
697                        }
698                    }
699
700                    for (var i = 0, l = arguments.length; i < l; i++) {
701                        forEach(arguments[i], assignValue);
702                    }
703                    return result;
704                }
705
706                /**
707                 * Extends object a by mutably adding to it the properties of object b.
708                 *
709                 * @param {Object} a The object to be extended
710                 * @param {Object} b The object to copy properties from
711                 * @param {Object} thisArg The object to bind function to
712                 * @return {Object} The resulting value of object a
713                 */
714                function extend(a, b, thisArg) {
715                    forEach(b, function assignValue(val, key) {
716                        if (thisArg && typeof val === 'function') {
717                            a[key] = bind(val, thisArg);
718                        } else {
719                            a[key] = val;
720                        }
721                    });
722                    return a;
723                }
724
725                module.exports = {
726                    isArray: isArray,
727                    isArrayBuffer: isArrayBuffer,
728                    isBuffer: isBuffer,
729                    isFormData: isFormData,
730                    isArrayBufferView: isArrayBufferView,
731                    isString: isString,
732                    isNumber: isNumber,
733                    isObject: isObject,
734                    isUndefined: isUndefined,
735                    isDate: isDate,
736                    isFile: isFile,
737                    isBlob: isBlob,
738                    isFunction: isFunction,
739                    isStream: isStream,
740                    isURLSearchParams: isURLSearchParams,
741                    isStandardBrowserEnv: isStandardBrowserEnv,
742                    forEach: forEach,
743                    merge: merge,
744                    deepMerge: deepMerge,
745                    extend: extend,
746                    trim: trim
747                };
748
749
750                /***/
751            }),
752            /* 11 */
753            /***/ (function (module, exports, __webpack_require__) {
754
755                var global = __webpack_require__(8);
756                var core = __webpack_require__(7);
757                var ctx = __webpack_require__(29);
758                var hide = __webpack_require__(23);
759                var has = __webpack_require__(24);
760                var PROTOTYPE = 'prototype';
761
762                var $export = function (type, name, source) {
763                    var IS_FORCED = type & $export.F;
764                    var IS_GLOBAL = type & $export.G;
765                    var IS_STATIC = type & $export.S;
766                    var IS_PROTO = type & $export.P;
767                    var IS_BIND = type & $export.B;
768                    var IS_WRAP = type & $export.W;
769                    var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
770                    var expProto = exports[PROTOTYPE];
771                    var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];
772                    var key, own, out;
773                    if (IS_GLOBAL) source = name;
774                    for (key in source) {
775                        // contains in native
776                        own = !IS_FORCED && target && target[key] !== undefined;
777                        if (own && has(exports, key)) continue;
778                        // export native or passed
779                        out = own ? target[key] : source[key];
780                        // prevent global pollution for namespaces
781                        exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
782                            // bind timers to global for call from export context
783                            : IS_BIND && own ? ctx(out, global)
784                                // wrap global constructors for prevent change them in library
785                                : IS_WRAP && target[key] == out ? (function (C) {
786                                    var F = function (a, b, c) {
787                                        if (this instanceof C) {
788                                            switch (arguments.length) {
789                                                case 0:
790                                                    return new C();
791                                                case 1:
792                                                    return new C(a);
793                                                case 2:
794                                                    return new C(a, b);
795                                            }
796                                            return new C(a, b, c);
797                                        }
798                                        return C.apply(this, arguments);
799                                    };
800                                    F[PROTOTYPE] = C[PROTOTYPE];
801                                    return F;
802                                    // make static versions for prototype methods
803                                }

803)(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
804                        // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
805                        if (IS_PROTO) {
806                            (exports.virtual || (exports.virtual = {}))[key] = out;
807                            // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
808                            if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);
809                        }
810                    }
811                };
812// type bitmap
813                $export.F = 1;   // forced
814                $export.G = 2;   // global
815                $export.S = 4;   // static
816                $export.P = 8;   // proto
817                $export.B = 16;  // bind
818                $export.W = 32;  // wrap
819                $export.U = 64;  // safe
820                $export.R = 128; // real proto method for `library`
821                module.exports = $export;
822
823
824                /***/
825            }),
826            /* 12 */
827            /***/ (function (module, __webpack_exports__, __webpack_require__) {
828
829                "use strict";
830                Object.defineProperty(__webpack_exports__, "__esModule", {value: true});
831                /* WEBPACK VAR INJECTION */
832                (function (process) {/* harmony export (binding) */
833                    __webpack_require__.d(__webpack_exports__, "version", function () {
834                        return version;
835                    });
836                    /* harmony export (binding) */
837                    __webpack_require__.d(__webpack_exports__, "DOM", function () {
838                        return DOM;
839                    });
840                    /* harmony export (binding) */
841                    __webpack_require__.d(__webpack_exports__, "Children", function () {
842                        return Children;
843                    });
844                    /* harmony export (binding) */
845                    __webpack_require__.d(__webpack_exports__, "render", function () {
846                        return render$1;
847                    });
848                    /* harmony export (binding) */
849                    __webpack_require__.d(__webpack_exports__, "createClass", function () {
850                        return createClass;
851                    });
852                    /* harmony export (binding) */
853                    __webpack_require__.d(__webpack_exports__, "createFactory", function () {
854                        return createFactory;
855                    });
856                    /* harmony export (binding) */
857                    __webpack_require__.d(__webpack_exports__, "createElement", function () {
858                        return createElement;
859                    });
860                    /* harmony export (binding) */
861                    __webpack_require__.d(__webpack_exports__, "cloneElement", function () {
862                        return cloneElement$1;
863                    });
864                    /* harmony export (binding) */
865                    __webpack_require__.d(__webpack_exports__, "isValidElement", function () {
866                        return isValidElement;
867                    });
868                    /* harmony export (binding) */
869                    __webpack_require__.d(__webpack_exports__, "findDOMNode", function () {
870                        return findDOMNode;
871                    });
872                    /* harmony export (binding) */
873                    __webpack_require__.d(__webpack_exports__, "unmountComponentAtNode", function () {
874                        return unmountComponentAtNode;
875                    });
876                    /* harmony export (binding) */
877                    __webpack_require__.d(__webpack_exports__, "Component", function () {
878                        return Component$1;
879                    });
880                    /* harmony export (binding) */
881                    __webpack_require__.d(__webpack_exports__, "PureComponent", function () {
882                        return PureComponent;
883                    });
884                    /* harmony export (binding) */
885                    __webpack_require__.d(__webpack_exports__, "unstable_renderSubtreeIntoContainer", function () {
886                        return renderSubtreeIntoContainer;
887                    });
888                    /* harmony import */
889                    var __WEBPACK_IMPORTED_MODULE_0_prop_types__ = __webpack_require__(195);
890                    /* harmony import */
891                    var __WEBPACK_IMPORTED_MODULE_0_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_prop_types__);
892                    /* harmony import */
893                    var __WEBPACK_IMPORTED_MODULE_1_preact__ = __webpack_require__(202);
894                    /* harmony import */
895                    var __WEBPACK_IMPORTED_MODULE_1_preact___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_preact__);
896                    /* harmony reexport (default from non-hamory) */
897                    __webpack_require__.d(__webpack_exports__, "PropTypes", function () {
898                        return __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a;
899                    });
900
901
902                    var version = '15.1.0'; // trick libraries to think we are react
903
904                    var ELEMENTS = 'a abbr address area article aside audio b base bdi bdo big blockquote body br button canvas caption cite code col colgroup data datalist dd del details dfn dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img input ins kbd keygen label legend li link main map mark menu menuitem meta meter nav noscript object ol optgroup option output p param picture pre progress q rp rt ruby s samp script section select small source span strong style sub summary sup table tbody td textarea tfoot th thead time title tr track u ul var video wbr circle clipPath defs ellipse g image line linearGradient mask path pattern polygon polyline radialGradient rect stop svg text tspan'.split(' ');
905
906                    var REACT_ELEMENT_TYPE = (typeof Symbol !== 'undefined' && Symbol.for && Symbol.for('react.element')) || 0xeac7;
907
908                    var COMPONENT_WRAPPER_KEY = typeof Symbol !== 'undefined' ? Symbol.for('__preactCompatWrapper') : '__preactCompatWrapper';
909
910// don't autobind these methods since they already have guaranteed context.
911                    var AUTOBIND_BLACKLIST = {
912                        constructor: 1,
913                        render: 1,
914                        shouldComponentUpdate: 1,
915                        componentWillReceiveProps: 1,
916                        componentWillUpdate: 1,
917                        componentDidUpdate: 1,
918                        componentWillMount: 1,
919                        componentDidMount: 1,
920                        componentWillUnmount: 1,
921                        componentDidUnmount: 1
922                    };
923
924
925                    var CAMEL_PROPS = /^(?:accent|alignment|arabic|baseline|cap|clip|color|fill|flood|font|glyph|horiz|marker|overline|paint|stop|strikethrough|stroke|text|underline|unicode|units|v|vert|word|writing|x)[A-Z]/;
926
927
928                    var BYPASS_HOOK = {};
929
930                    /*global process*/
931                    var DEV = typeof process === 'undefined' || !process.env || process.env.NODE_ENV !== 'production';
932
933// a component that renders nothing. Used to replace components for unmountComponentAtNode.
934                    function EmptyComponent() {
935                        return null;
936                    }
937
938
939// make react think we're react.
940                    var VNode = __WEBPACK_IMPORTED_MODULE_1_preact__["h"]('a', null).constructor;
941                    VNode.prototype.$$typeof = REACT_ELEMENT_TYPE;
942                    VNode.prototype.preactCompatUpgraded = false;
943                    VNode.prototype.preactCompatNormalized = false;
944
945                    Object.defineProperty(VNode.prototype, 'type', {
946                        get: function () {
947                            return this.nodeName;
948                        },
949                        set: function (v) {
950                            this.nodeName = v;
951                        },
952                        configurable: true
953                    });
954
955                    Object.defineProperty(VNode.prototype, 'props', {
956                        get: function () {
957                            return this.attributes;
958                        },
959                        set: function (v) {
960                            this.attributes = v;
961                        },
962                        configurable: true
963                    });
964
965
966                    var oldEventHook = __WEBPACK_IMPORTED_MODULE_1_preact__["options"].event;
967                    __WEBPACK_IMPORTED_MODULE_1_preact__["options"].event = function (e) {
968                        if (oldEventHook) {
969                            e = oldEventHook(e);
970                        }
971                        e.persist = Object;
972                        e.nativeEvent = e;
973                        return e;
974                    };
975
976
977                    var oldVnodeHook = __WEBPACK_IMPORTED_MODULE_1_preact__["options"].vnode;
978                    __WEBPACK_IMPORTED_MODULE_1_preact__["options"].vnode = function (vnode) {
979                        if (!vnode.preactCompatUpgraded) {
980                            vnode.preactCompatUpgraded = true;
981
982                            var tag = vnode.nodeName,
983                                attrs = vnode.attributes = extend({}, vnode.attributes);
984
985                            if (typeof tag === 'function') {
986                                if (tag[COMPONENT_WRAPPER_KEY] === true || (tag.prototype && 'isReactComponent' in tag.prototype)) {
987                                    if (vnode.children && String(vnode.children) === '') {
988                                        vnode.children = undefined;
989                                    }
990                                    if (vnode.children) {
991                                        attrs.children = vnode.children;
992                                    }
993
994                                    if (!vnode.preactCompatNormalized) {
995                                        normalizeVNode(vnode);
996                                    }
997                                    handleComponentVNode(vnode);
998                                }
999                            } else {
1000                                if (vnode.children && String(vnode.children) === '') {
1001                                    vnode.children = undefined;
1002                                }
1003                                if (vnode.children) {
1004                                    attrs.children = vnode.children;
1005                                }
1006
1007                                if (attrs.defaultValue) {
1008                                    if (!attrs.value && attrs.value !== 0) {
1009                                        attrs.value = attrs.defaultValue;
1010                                    }
1011                                    delete attrs.defaultValue;
1012                                }
1013
1014                                handleElementVNode(vnode, attrs);
1015                            }
1016                        }
1017
1018                        if (oldVnodeHook) {
1019                            oldVnodeHook(vnode);
1020                        }
1021                    };
1022
1023                    function handleComponentVNode(vnode) {
1024                        var tag = vnode.nodeName,
1025                            a = vnode.attributes;
1026
1027                        vnode.attributes = {};
1028                        if (tag.defaultProps) {
1029                            extend(vnode.attributes, tag.defaultProps);
1030                        }
1031                        if (a) {
1032                            extend(vnode.attributes, a);
1033                        }
1034                    }
1035
1036                    function handleElementVNode(vnode, a) {
1037                        var shouldSanitize, attrs, i;
1038                        if (a) {
1039                            for (i in a) {
1040                                if ((shouldSanitize = CAMEL_PROPS.test(i))) {
1041                                    break;
1042                                }
1043                            }
1044                            if (shouldSanitize) {
1045                                attrs = vnode.attributes = {};
1046                                for (i in a) {
1047                                    if (a.hasOwnProperty(i)) {
1048                                        attrs[CAMEL_PROPS.test(i) ? i.replace(/([A-Z0-9])/, '-$1').toLowerCase() : i] = a[i];
1049                                    }
1050                                }
1051                            }
1052                        }
1053                    }
1054
1055
1056// proxy render() since React returns a Component reference.
1057                    function render$1(vnode, parent, callback) {
1058                        var prev = parent && parent._preactCompatRendered && parent._preactCompatRendered.base;
1059
1060                        // ignore impossible previous renders
1061                        if (prev && prev.parentNode !== parent) {
1062                            prev = null;
1063                        }
1064
1065                        // default to first Element child
1066                        if (!prev) {
1067                            prev = parent.children[0];
1068                        }
1069
1070                        // remove unaffected siblings
1071                        for (var i = parent.childNodes.length; i--;) {
1072                            if (parent.childNodes[i] !== prev) {
1073                                parent.removeChild(parent.childNodes[i]);
1074                            }
1075                        }
1076
1077                        var out = __WEBPACK_IMPORTED_MODULE_1_preact__["render"](vnode, parent, prev);
1078                        if (parent) {
1079                            parent._preactCompatRendered = out && (out._component || {base: out});
1080                        }
1081                        if (typeof callback === 'function') {
1082                            callback();
1083                        }
1084                        return out && out._component || out;
1085                    }
1086
1087
1088                    var ContextProvider = function () {
1089                    };
1090
1091                    ContextProvider.prototype.getChildContext = function () {
1092                        return this.props.context;
1093                    };
1094                    ContextProvider.prototype.render = function (props) {
1095                        return props.children[0];
1096                    };
1097
1098                    function renderSubtreeIntoContainer(parentComponent, vnode, container, callback) {
1099                        var wrap = __WEBPACK_IMPORTED_MODULE_1_preact__["h"](ContextProvider, {context: parentComponent.context}, vnode);
1100                        var c = render$1(wrap, container);
1101                        if (callback) {
1102                            callback(c);
1103                        }
1104                        return c._component || c.base;
1105                    }
1106
1107
1108                    function unmountComponentAtNode(container) {
1109                        var existing = container._preactCompatRendered && container._preactCompatRendered.base;
1110                        if (existing && existing.parentNode === container) {
1111                            __WEBPACK_IMPORTED_MODULE_1_preact__["render"](__WEBPACK_IMPORTED_MODULE_1_preact__["h"](EmptyComponent), container, existing);
1112                            return true;
1113                        }
1114                        return false;
1115                    }
1116
1117
1118                    var ARR = [];
1119
1120// This API is completely unnecessary for Preact, so it's basically passthrough.
1121                    var Children = {
1122                        map: function (children, fn, ctx) {
1123                            if (children == null) {
1124                                return null;
1125                            }
1126                            children = Children.toArray(children);
1127                            if (ctx && ctx !== children) {
1128                                fn = fn.bind(ctx);
1129                            }
1130                            return children.map(fn);
1131                        },
1132                        forEach: function (children, fn, ctx) {
1133                            if (children == null) {
1134                                return null;
1135                            }
1136                            children = Children.toArray(children);
1137                            if (ctx && ctx !== children) {
1138                                fn = fn.bind(ctx);
1139                            }
1140                            children.forEach(fn);
1141                        },
1142                        count: function (children) {
1143                            return children && children.length || 0;
1144                        },
1145                        only: function (children) {
1146                            children = Children.toArray(children);
1147                            if (children.length !== 1) {
1148                                throw new Error('Children.only() expects only one child.');
1149                            }
1150                            return children[0];
1151                        },
1152                        toArray: function (children) {
1153                            if (children == null) {
1154                                return [];
1155                            }
1156                            return Array.isArray && Array.isArray(children) ? children : ARR.concat(children);
1157                        }
1158                    };
1159
1160
1161                    /** Track current render() component for ref assignment */
1162                    var currentComponent;
1163
1164
1165                    function createFactory(type) {
1166                        return createElement.bind(null, type);
1167                    }
1168
1169
1170                    var DOM = {};
1171                    for (var i = ELEMENTS.length; i--;) {
1172                        DOM[ELEMENTS[i]] = createFactory(ELEMENTS[i]);
1173                    }
1174
1175                    function upgradeToVNodes(arr, offset) {
1176                        for (var i = offset || 0; i < arr.length; i++) {
1177                            var obj = arr[i];
1178                            if (Array.isArray(obj)) {
1179                                upgradeToVNodes(obj);
1180                            } else if (obj && typeof obj === 'object' && !isValidElement(obj) && ((obj.props && obj.type) || (obj.attributes && obj.nodeName) || obj.children)) {
1181                                arr[i] = createElement(obj.type || obj.nodeName, obj.props || obj.attributes, obj.children);
1182                            }
1183                        }
1184                    }
1185
1186                    function isStatelessComponent(c) {
1187                        return typeof c === 'function' && !(c.prototype && c.prototype.render);
1188                    }
1189
1190
1191// wraps stateless functional components in a PropTypes validator
1192                    function wrapStatelessComponent(WrappedComponent) {
1193                        return createClass({
1194                            displayName: WrappedComponent.displayName || WrappedComponent.name,
1195                            render: function () {
1196                                return WrappedComponent(this.props, this.context);
1197                            }
1198                        });
1199                    }
1200
1201
1202                    function statelessComponentHook(Ctor) {
1203                        var Wrapped = Ctor[COMPONENT_WRAPPER_KEY];
1204                        if (Wrapped) {
1205                            return Wrapped === true ? Ctor : Wrapped;
1206                        }
1207
1208                        Wrapped = wrapStatelessComponent(Ctor);
1209
1210                        Object.defineProperty(Wrapped, COMPONENT_WRAPPER_KEY, {configurable: true, value: true});
1211                        Wrapped.displayName = Ctor.displayName;
1212                        Wrapped.propTypes = Ctor.propTypes;
1213                        Wrapped.defaultProps = Ctor.defaultProps;
1214
1215                        Object.defineProperty(Ctor, COMPONENT_WRAPPER_KEY, {configurable: true, value: Wrapped});
1216
1217                        return Wrapped;
1218                    }
1219
1220
1221                    function createElement() {
1222                        var args = [], len = arguments.length;
1223                        while (len--) args[len] = arguments[len];
1224
1225                        upgradeToVNodes(args, 2);
1226                        return normalizeVNode(__WEBPACK_IMPORTED_MODULE_1_preact__["h"].apply(void 0, args));
1227                    }
1228
1229
1230                    function normalizeVNode(vnode) {
1231                        vnode.preactCompatNormalized = true;
1232
1233                        applyClassName(vnode);
1234
1235                        if (isStatelessComponent(vnode.nodeName)) {
1236                            vnode.nodeName = statelessComponentHook(vnode.nodeName);
1237                        }
1238
1239                        var ref = vnode.attributes.ref,
1240                            type = ref && typeof ref;
1241                        if (currentComponent && (type === 'string' || type === 'number')) {
1242                            vnode.attributes.ref = createStringRefProxy(ref, currentComponent);
1243                        }
1244
1245                        applyEventNormalization(vnode);
1246
1247                        return vnode;
1248                    }
1249
1250
1251                    function cloneElement$1(element, props) {
1252                        var children = [], len = arguments.length - 2;
1253                        while (len-- > 0) children[len] = arguments[len + 2];
1254
1255                        if (!isValidElement(element)) {
1256                            return element;
1257                        }
1258                        var elementProps = element.attributes || element.props;
1259                        var node = __WEBPACK_IMPORTED_MODULE_1_preact__["h"](
1260                            element.nodeName || element.type,
1261                            elementProps,
1262                            element.children || elementProps && elementProps.children
1263                        );
1264                        // Only provide the 3rd argument if needed.
1265                        // Arguments 3+ overwrite element.children in preactCloneElement
1266                        var cloneArgs = [node, props];
1267                        if (children && children.length) {
1268                            cloneArgs.push(children);
1269                        } else if (props && props.children) {
1270                            cloneArgs.push(props.children);
1271                        }
1272                        return normalizeVNode(__WEBPACK_IMPORTED_MODULE_1_preact__["cloneElement"].apply(void 0, cloneArgs));
1273                    }
1274
1275
1276                    function isValidElement(element) {
1277                        return element && ((element instanceof VNode) || element.$$typeof === REACT_ELEMENT_TYPE);
1278                    }
1279
1280
1281                    function createStringRefProxy(name, component) {
1282                        return component._refProxies[name] || (component._refProxies[name] = function (resolved) {
1283                            if (component && component.refs) {
1284                                component.refs[name] = resolved;
1285                                if (resolved === null) {
1286                                    delete component._refProxies[name];
1287                                    component = null;
1288                                }
1289                            }
1290                        });
1291                    }
1292
1293
1294                    function applyEventNormalization(ref) {
1295                        var nodeName = ref.nodeName;
1296                        var attributes = ref.attributes;
1297
1298                        if (!attributes || typeof nodeName !== 'string') {
1299                            return;
1300                        }
1301                        var props = {};
1302                        for (var i in attributes) {
1303                            props[i.toLowerCase()] = i;
1304                        }
1305                        if (props.ondoubleclick) {
1306                            attributes.ondblclick = attributes[props.ondoubleclick];
1307                            delete attributes[props.ondoubleclick];
1308                        }
1309                        // for *textual inputs* (incl textarea), normalize `onChange` -> `onInput`:
1310                        if (props.onchange && (nodeName === 'textarea' || (nodeName.toLowerCase() === 'input' && !/^fil|che|rad/i.test(attributes.type)))) {
1311                            var normalized = props.oninput || 'oninput';
1312                            if (!attributes[normalized]) {
1313                                attributes[normalized] = multihook([attributes[normalized], attributes[props.onchange]]);
1314                                delete attributes[props.onchange];
1315                            }
1316                        }
1317                    }
1318
1319
1320                    function applyClassName(ref) {
1321                        var attributes = ref.attributes;
1322
1323                        if (!attributes) {
1324                            return;
1325                        }
1326                        var cl = attributes.className || attributes.class;
1327                        if (cl) {
1328                            attributes.className = cl;
1329                        }
1330                    }
1331
1332
1333                    function extend(base, props) {
1334                        for (var key in props) {
1335                            if (props.hasOwnProperty(key)) {
1336                                base[key] = props[key];
1337                            }
1338                        }
1339                        return base;
1340                    }
1341
1342
1343                    function shallowDiffers(a, b) {
1344                        for (var i in a) {
1345                            if (!(i in b)) {
1346                                return true;
1347                            }
1348                        }
1349                        for (var i$1 in b) {
1350                            if (a[i$1] !== b[i$1]) {
1351                                return true;
1352                            }
1353                        }
1354                        return false;
1355                    }
1356
1357
1358                    function findDOMNode(component) {
1359                        return component && component.base || component;
1360                    }
1361
1362
1363                    function F() {
1364                    }
1365
1366                    function createClass(obj) {
1367                        function cl(props, context) {
1368                            bindAll(this);
1369                            Component$1.call(this, props, context, BYPASS_HOOK);
1370                            newComponentHook.call(this, props, context);
1371                        }
1372
1373                        obj = extend({constructor: cl}, obj);
1374
1375                        // We need to apply mixins here so that getDefaultProps is correctly mixed
1376                        if (obj.mixins) {
1377                            applyMixins(obj, collateMixins(obj.mixins));
1378                        }
1379                        if (obj.statics) {
1380                            extend(cl, obj.statics);
1381                        }
1382                        if (obj.propTypes) {
1383                            cl.propTypes = obj.propTypes;
1384                        }
1385                        if (obj.defaultProps) {
1386                            cl.defaultProps = obj.defaultProps;
1387                        }
1388                        if (obj.getDefaultProps) {
1389                            cl.defaultProps = obj.getDefaultProps();
1390                        }
1391
1392                        F.prototype = Component$1.prototype;
1393                        cl.prototype = extend(new F(), obj);
1394
1395                        cl.displayName = obj.displayName || 'Component';
1396
1397                        return cl;
1398                    }
1399
1400
1401// Flatten an Array of mixins to a map of method name to mixin implementations
1402                    function collateMixins(mixins) {
1403                        var keyed = {};
1404                        for (var i = 0; i < mixins.length; i++) {
1405                            var mixin = mixins[i];
1406                            for (var key in mixin) {
1407                                if (mixin.hasOwnProperty(key) && typeof mixin[key] === 'function') {
1408                                    (keyed[key] || (keyed[key] = [])).push(mixin[key]);
1409                                }
1410                            }
1411                        }
1412                        return keyed;
1413                    }
1414
1415
1416// apply a mapping of Arrays of mixin methods to a component prototype
1417                    function applyMixins(proto, mixins) {
1418                        for (var key in mixins) {
1419                            if (mixins.hasOwnProperty(key)) {
1420                                proto[key] = multihook(
1421                                    mixins[key].concat(proto[key] || ARR),
1422                                    key === 'getDefaultProps' || key === 'getInitialState' || key === 'getChildContext'
1423                                );
1424                            }
1425                        }
1426                    }
1427
1428
1429                    function bindAll(ctx) {
1430                        for (var i in ctx) {
1431                            var v = ctx[i];
1432                            if (typeof v === 'function' && !v.__bound && !AUTOBIND_BLACKLIST.hasOwnProperty(i)) {
1433                                (ctx[i] = v.bind(ctx)).__bound = true;
1434                            }
1435                        }
1436                    }
1437
1438
1439                    function callMethod(ctx, m, args) {
1440                        if (typeof m === 'string') {
1441                            m = ctx.constructor.prototype[m];
1442                        }
1443                        if (typeof m === 'function') {
1444                            return m.apply(ctx, args);
1445                        }
1446                    }
1447
1448                    function multihook(hooks, skipDuplicates) {
1449                        return function () {
1450                            var arguments$1 = arguments;
1451                            var this$1 = this;
1452
1453                            var ret;
1454                            for (var i = 0; i < hooks.length; i++) {
1455                                var r = callMethod(this$1, hooks[i], arguments$1);
1456
1457                                if (skipDuplicates && r != null) {
1458                                    if (!ret) {
1459                                        ret = {};
1460                                    }
1461                                    for (var key in r) {
1462                                        if (r.hasOwnProperty(key)) {
1463                                            ret[key] = r[key];
1464                                        }
1465                                    }
1466                                } else if (typeof r !== 'undefined') {
1467                                    ret = r;
1468                                }
1469                            }
1470                            return ret;
1471                        };
1472                    }
1473
1474
1475                    function newComponentHook(props, context) {
1476                        propsHook.call(this, props, context);
1477                        this.componentWillReceiveProps = multihook([propsHook, this.componentWillReceiveProps || 'componentWillReceiveProps']);
1478                        this.render = multihook([propsHook, beforeRender, this.render || 'render', afterRender]);
1479                    }
1480
1481
1482                    function propsHook(props, context) {
1483                        if (!props) {
1484                            return;
1485                        }
1486
1487                        // React annoyingly special-cases single children, and some react components are ridiculously strict about this.
1488                        var c = props.children;
1489                        if (c && Array.isArray(c) && c.length === 1) {
1490                            props.children = c[0];
1491
1492                            // but its totally still going to be an Array.
1493                            if (props.children && typeof props.children === 'object') {
1494                                props.children.length = 1;
1495                                props.children[0] = props.children;
1496                            }
1497                        }
1498
1499                        // add proptype checking
1500                        if (DEV) {
1501                            var ctor = typeof this === 'function' ? this : this.constructor,
1502                                propTypes = this.propTypes || ctor.propTypes;
1503                            var displayName = this.displayName || ctor.name;
1504
1505                            if (propTypes) {
1506                                __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.checkPropTypes(propTypes, props, 'prop', displayName);
1507                            }
1508                        }
1509                    }
1510
1511
1512                    function beforeRender(props) {
1513                        currentComponent = this;
1514                    }
1515
1516                    function afterRender() {
1517                        if (currentComponent === this) {
1518                            currentComponent = null;
1519                        }
1520                    }
1521
1522
1523                    function Component$1(props, context, opts) {
1524                        __WEBPACK_IMPORTED_MODULE_1_preact__["Component"].call(this, props, context);
1525                        this.state = this.getInitialState ? this.getInitialState() : {};
1526                        this.refs = {};
1527                        this._refProxies = {};
1528                        if (opts !== BYPASS_HOOK) {
1529                            newComponentHook.call(this, props, context);
1530                        }
1531                    }
1532
1533                    extend(Component$1.prototype = new __WEBPACK_IMPORTED_MODULE_1_preact__["Component"](), {
1534                        constructor: Component$1,
1535
1536                        isReactComponent: {},
1537
1538                        replaceState: function (state, callback) {
1539                            var this$1 = this;
1540
1541                            this.setState(state, callback);
1542                            for (var i in this$1.state) {
1543                                if (!(i in state)) {
1544                                    delete this$1.state[i];
1545                                }
1546                            }
1547                        },
1548
1549                        getDOMNode: function () {
1550                            return this.base;
1551                        },
1552
1553                        isMounted: function () {
1554                            return !!this.base;
1555                        }
1556                    });
1557
1558
1559                    function PureComponent(props, context) {
1560                        Component$1.call(this, props, context);
1561                    }
1562
1563                    F.prototype = Component$1.prototype;
1564                    PureComponent.prototype = new F();
1565                    PureComponent.prototype.isPureReactComponent = true;
1566                    PureComponent.prototype.shouldComponentUpdate = function (props, state) {
1567                        return shallowDiffers(this.props, props) || shallowDiffers(this.state, state);
1568                    };
1569
1570
1571                    var index = {
1572                        version: version,
1573                        DOM: DOM,
1574                        PropTypes: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a,
1575                        Children: Children,
1576                        render: render$1,
1577                        createClass: createClass,
1578                        createFactory: createFactory,
1579                        createElement: createElement,
1580                        cloneElement: cloneElement$1,
1581                        isValidElement: isValidElement,
1582                        findDOMNode: findDOMNode,
1583                        unmountComponentAtNode: unmountComponentAtNode,
1584                        Component: Component$1,
1585                        PureComponent: PureComponent,
1586                        unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer
1587                    };
1588
1589                    /* harmony default export */
1590                    __webpack_exports__["default"] = (index);
1591//# sourceMappingURL=preact-compat.es.js.map
1592
1593                    /* WEBPACK VAR INJECTION */
1594                }.call(__webpack_exports__, __webpack_require__(18)))
1595
1596                /***/
1597            }),
1598            /* 13 */
1599            /***/ (function (module, __webpack_exports__, __webpack_require__) {
1600
1601                "use strict";
1602                /* harmony export (immutable) */
1603                __webpack_exports__["a"] = isSameUTCWeek;
1604                /* harmony import */
1605                var __WEBPACK_IMPORTED_MODULE_0__startOfUTCWeek_index_js__ = __webpack_require__(50);
1606                /* harmony import */
1607                var __WEBPACK_IMPORTED_MODULE_1__requiredArgs_index_js__ = __webpack_require__(0);
1608
1609                // This function will be a part of public API when UTC function will be implemented.
1610// See issue: https://github.com/date-fns/date-fns/issues/376
1611
1612                function isSameUTCWeek(dirtyDateLeft, dirtyDateRight, options) {
1613                    __WEBPACK_IMPORTED_MODULE_1__requiredArgs_index_js__["a" /* default */](2, arguments);
1614                    var dateLeftStartOfWeek = __WEBPACK_IMPORTED_MODULE_0__startOfUTCWeek_index_js__["a" /* default */](dirtyDateLeft, options);
1615                    var dateRightStartOfWeek = __WEBPACK_IMPORTED_MODULE_0__startOfUTCWeek_index_js__["a" /* default */](dirtyDateRight, options);
1616                    return dateLeftStartOfWeek.getTime() === dateRightStartOfWeek.getTime();
1617                }
1618
1619                /***/
1620            }),
1621            /* 14 */
1622            /***/ (function (module, exports, __webpack_require__) {
1623
1624                var isObject = __webpack_require__(20);
1625                module.exports = function (it) {
1626                    if (!isObject(it)) throw TypeError(it + ' is not an object!');
1627                    return it;
1628                };
1629
1630
1631                /***/
1632            }),
1633            /* 15 */
1634            /***/ (function (module, __webpack_exports__, __webpack_require__) {
1635
1636                "use strict";
1637                /* harmony export (immutable) */
1638                __webpack_exports__["a"] = isValid;
1639                /* harmony import */
1640                var __WEBPACK_IMPORTED_MODULE_0__toDate_index_js__ = __webpack_require__(1);
1641                /* harmony import */
1642                var __WEBPACK_IMPORTED_MODULE_1__lib_requiredArgs_index_js__ = __webpack_require__(0);
1643
1644
1645                /**
1646                 * @name isValid
1647                 * @category Common Helpers
1648                 * @summary Is the given date valid?
1649                 *

1751            /***/ (function (module, exports) {
1752
1753// shim for using process in browser
1754                var process = module.exports = {};
1755
1756// cached from whatever global is present so that test runners that stub it
1757// don't break things.  But we need to wrap it in a try catch in case it is
1758// wrapped in strict mode code which doesn't define any globals.  It's inside a
1759// function because try/catches deoptimize in certain engines.
1760
1761                var cachedSetTimeout;
1762                var cachedClearTimeout;
1763
1764                function defaultSetTimout() {
1765                    throw new Error('setTimeout has not been defined');
1766                }
1767
1768                function defaultClearTimeout() {
1769                    throw new Error('clearTimeout has not been defined');
1770                }
1771
1772                (function () {
1773                    try {
1774                        if (typeof setTimeout === 'function') {
1775                            cachedSetTimeout = setTimeout;
1776                        } else {
1777                            cachedSetTimeout = defaultSetTimout;
1778                        }
1779                    } catch (e) {
1780                        cachedSetTimeout = defaultSetTimout;
1781                    }
1782                    try {
1783                        if (typeof clearTimeout === 'function') {
1784                            cachedClearTimeout = clearTimeout;
1785                        } else {
1786                            cachedClearTimeout = defaultClearTimeout;
1787                        }
1788                    } catch (e) {
1789                        cachedClearTimeout = defaultClearTimeout;
1790                    }
1791                }())
1792
1793                function runTimeout(fun) {
1794                    if (cachedSetTimeout === setTimeout) {
1795                        //normal enviroments in sane situations
1796                        return setTimeout(fun, 0);
1797                    }
1798                    // if setTimeout wasn't available but was latter defined
1799                    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
1800                        cachedSetTimeout = setTimeout;
1801                        return setTimeout(fun, 0);
1802                    }
1803                    try {
1804                        // when when somebody has screwed with setTimeout but no I.E. maddness
1805                        return cachedSetTimeout(fun, 0);
1806                    } catch (e) {
1807                        try {
1808                            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
1809                            return cachedSetTimeout.call(null, fun, 0);
1810                        } catch (e) {
1811                            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
1812                            return cachedSetTimeout.call(this, fun, 0);
1813                        }
1814                    }
1815
1816
1817                }
1818
1819                function runClearTimeout(marker) {
1820                    if (cachedClearTimeout === clearTimeout) {
1821                        //normal enviroments in sane situations
1822                        return clearTimeout(marker);
1823                    }
1824                    // if clearTimeout wasn't available but was latter defined
1825                    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
1826                        cachedClearTimeout = clearTimeout;
1827                        return clearTimeout(marker);
1828                    }
1829                    try {
1830                        // when when somebody has screwed with setTimeout but no I.E. maddness
1831                        return cachedClearTimeout(marker);
1832                    } catch (e) {
1833                        try {
1834                            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
1835                            return cachedClearTimeout.call(null, marker);
1836                        } catch (e) {
1837                            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
1838                            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
1839                            return cachedClearTimeout.call(this, marker);
1840                        }
1841                    }
1842
1843
1844                }
1845
1846                var queue = [];
1847                var draining = false;

1848                var currentQueue;
1849                var queueIndex = -1;
1850
1851                function cleanUpNextTick() {
1852                    if (!draining || !currentQueue) {
1853                        return;
1854                    }
1855                    draining = false;
1856                    if (currentQueue.length) {
1857                        queue = currentQueue.concat(queue);
1858                    } else {
1859                        queueIndex = -1;
1860                    }
1861                    if (queue.length) {
1862                        drainQueue();
1863                    }
1864                }
1865
1866                function drainQueue() {
1867                    if (draining) {
1868                        return;
1869                    }
1870                    var timeout = runTimeout(cleanUpNextTick);
1871                    draining = true;
1872
1873                    var len = queue.length;
1874                    while (len) {
1875                        currentQueue = queue;
1876                        queue = [];
1877                        while (++queueIndex < len) {
1878                            if (currentQueue) {
1879                                currentQueue[queueIndex].run();
1880                            }
1881                        }
1882                        queueIndex = -1;
1883                        len = queue.length;
1884                    }
1885                    currentQueue = null;
1886                    draining = false;
1887                    runClearTimeout(timeout);
1888                }
1889
1890                process.nextTick = function (fun) {
1891                    var args = new Array(arguments.length - 1);
1892                    if (arguments.length > 1) {
1893                        for (var i = 1; i < arguments.length; i++) {
1894                            args[i - 1] = arguments[i];
1895                        }
1896                    }
1897                    queue.push(new Item(fun, args));
1898                    if (queue.length === 1 && !draining) {
1899                        runTimeout(drainQueue);
1900                    }
1901                };
1902
1903// v8 likes predictible objects
1904                function Item(fun, array) {
1905                    this.fun = fun;
1906                    this.array = array;
1907                }
1908
1909                Item.prototype.run = function () {
1910                    this.fun.apply(null, this.array);
1911                };
1912                process.title = 'browser';
1913                process.browser = true;
1914                process.env = {};
1915                process.argv = [];
1916                process.version = ''; // empty string to avoid regexp issues
1917                process.versions = {};
1918
1919                function noop() {
1920                }
1921
1922                process.on = noop;
1923                process.addListener = noop;
1924                process.once = noop;
1925                process.off = noop;
1926                process.removeListener = noop;
1927                process.removeAllListeners = noop;
1928                process.emit = noop;
1929                process.prependListener = noop;
1930                process.prependOnceListener = noop;
1931
1932                process.listeners = function (name) {
1933                    return []
1934                }
1935
1936                process.binding = function (name) {
1937                    throw new Error('process.binding is not supported');
1938                };
1939
1940                process.cwd = function () {
1941                    return '/'
1942                };
1943                process.chdir = function (dir) {
1944                    throw new Error('process.chdir is not supported');
1945                };
1946                process.umask = function () {
1947                    return 0;
1948                };
1949
1950
1951                /***/
1952            }),
1953            /* 19 */
1954            /***/ (function (module, __webpack_exports__, __webpack_require__) {
1955
1956                "use strict";
1957                /* harmony export (immutable) */
1958                __webpack_exports__["a"] = getTimezoneOffsetInMilliseconds;
1959                var MILLISECONDS_IN_MINUTE = 60000;
1960
1961                function getDateMillisecondsPart(date) {
1962                    return date.getTime() % MILLISECONDS_IN_MINUTE;
1963                }
1964
1965                /**
1966                 * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
1967                 * They usually appear for dates that denote time before the timezones were introduced
1968                 * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
1969                 * and GMT+01:00:00 after that date)
1970                 *
1971                 * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
1972                 * which would lead to incorrect calculations.
1973                 *
1974                 * This function returns the timezone offset in milliseconds that takes seconds in account.
1975                 */
1976
1977
1978                function getTimezoneOffsetInMilliseconds(dirtyDate) {
1979                    var date = new Date(dirtyDate.getTime());
1980                    var baseTimezoneOffset = Math.ceil(date.getTimezoneOffset());
1981                    date.setSeconds(0, 0);
1982                    var hasNegativeUTCOffset = baseTimezoneOffset > 0;
1983                    var millisecondsPartOfTimezoneOffset = hasNegativeUTCOffset ? (MILLISECONDS_IN_MINUTE + getDateMillisecondsPart(date)) % MILLISECONDS_IN_MINUTE : getDateMillisecondsPart(date);
1984                    return baseTimezoneOffset * MILLISECONDS_IN_MINUTE + millisecondsPartOfTimezoneOffset;
1985                }
1986
1987                /***/
1988            }),
1989            /* 20 */
1990            /***/ (function (module, exports) {
1991
1992                module.exports = function (it) {
1993                    return typeof it === 'object' ? it !== null : typeof it === 'function';
1994                };
1995
1996
1997                /***/
1998            }),
1999            /* 21 */
2000            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2001
2002                "use strict";
2003                /* harmony export (immutable) */
2004                __webpack_exports__["a"] = addDays;
2005                /* harmony import */
2006                var __WEBPACK_IMPORTED_MODULE_0__lib_toInteger_index_js__ = __webpack_require__(6);
2007                /* harmony import */
2008                var __WEBPACK_IMPORTED_MODULE_1__toDate_index_js__ = __webpack_require__(1);
2009                /* harmony import */
2010                var __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__ = __webpack_require__(0);
2011
2012
2013                /**
2014                 * @name addDays
2015                 * @category Day Helpers
2016                 * @summary Add the specified number of days to the given date.
2017                 *
2018                 * @description
2019                 * Add the specified number of days to the given date.
2020                 *
2021                 * ### v2.0.0 breaking changes:
2022                 *
2023                 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
2024                 *
2025                 * @param {Date|Number} date - the date to be changed
2026                 * @param {Number} amount - the amount of days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
2027                 * @returns {Date} the new date with the days added
2028                 * @throws {TypeError} 2 arguments required
2029                 *
2030                 * @example
2031                 * // Add 10 days to 1 September 2014:
2032                 * var result = addDays(new Date(2014, 8, 1), 10)
2033                 * //=> Thu Sep 11 2014 00:00:00
2034                 */
2035
2036                function addDays(dirtyDate, dirtyAmount) {
2037                    __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__["a" /* default */](2, arguments);
2038                    var date = __WEBPACK_IMPORTED_MODULE_1__toDate_index_js__["a" /* default */](dirtyDate);
2039                    var amount = __WEBPACK_IMPORTED_MODULE_0__lib_toInteger_index_js__["a" /* default */](dirtyAmount);
2040
2041                    if (isNaN(amount)) {
2042                        return new Date(NaN);
2043                    }
2044
2045                    if (!amount) {
2046                        // If 0 days, no-op to avoid changing times in the hour before end of DST
2047                        return date;
2048                    }
2049
2050                    date.setDate(date.getDate() + amount);
2051                    return date;
2052                }
2053
2054                /***/
2055            }),
2056            /* 22 */
2057            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2058
2059                "use strict";
2060                /* harmony export (immutable) */
2061                __webpack_exports__["a"] = startOfWeek;
2062                /* harmony import */
2063                var __WEBPACK_IMPORTED_MODULE_0__toDate_index_js__ = __webpack_require__(1);
2064                /* harmony import */
2065                var __WEBPACK_IMPORTED_MODULE_1__lib_toInteger_index_js__ = __webpack_require__(6);
2066                /* harmony import */
2067                var __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__ = __webpack_require__(0);
2068
2069
2070                /**
2071                 * @name startOfWeek
2072                 * @category Week Helpers
2073                 * @summary Return the start of a week for the given date.
2074                 *

2375// optional / simple context binding
2376                var aFunction = __webpack_require__(51);
2377                module.exports = function (fn, that, length) {
2378                    aFunction(fn);
2379                    if (that === undefined) return fn;
2380                    switch (length) {
2381                        case 1:
2382                            return function (a) {
2383                                return fn.call(that, a);
2384                            };
2385                        case 2:
2386                            return function (a, b) {
2387                                return fn.call(that, a, b);
2388                            };
2389                        case 3:
2390                            return function (a, b, c) {
2391                                return fn.call(that, a, b, c);
2392                            };
2393                    }
2394                    return function (/* ...args */) {
2395                        return fn.apply(that, arguments);
2396                    };
2397                };
2398
2399
2400                /***/
2401            }),
2402            /* 30 */
2403            /***/ (function (module, exports) {
2404
2405                module.exports = function (exec) {
2406                    try {
2407                        return !!exec();
2408                    } catch (e) {
2409                        return true;
2410                    }
2411                };
2412
2413
2414                /***/
2415            }),
2416            /* 31 */
2417            /***/ (function (module, exports) {
2418
2419                module.exports = {};
2420
2421
2422                /***/
2423            }),
2424            /* 32 */
2425            /***/ (function (module, exports, __webpack_require__) {
2426
2427// to indexed object, toObject with fallback for non-array-like ES3 strings
2428                var IObject = __webpack_require__(104);
2429                var defined = __webpack_require__(70);
2430                module.exports = function (it) {
2431                    return IObject(defined(it));
2432                };
2433
2434
2435                /***/
2436            }),
2437            /* 33 */
2438            /***/ (function (module, exports, __webpack_require__) {
2439
2440// 7.1.13 ToObject(argument)
2441                var defined = __webpack_require__(70);
2442                module.exports = function (it) {
2443                    return Object(defined(it));
2444                };
2445
2446
2447                /***/
2448            }),
2449            /* 34 */
2450            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2451
2452                "use strict";
2453                /* harmony export (immutable) */
2454                __webpack_exports__["a"] = getISOWeekYear;
2455                /* harmony import */
2456                var __WEBPACK_IMPORTED_MODULE_0__toDate_index_js__ = __webpack_require__(1);
2457                /* harmony import */
2458                var __WEBPACK_IMPORTED_MODULE_1__startOfISOWeek_index_js__ = __webpack_require__(25);
2459                /* harmony import */
2460                var __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__ = __webpack_require__(0);
2461
2462
2463                /**
2464                 * @name getISOWeekYear
2465                 * @category ISO Week-Numbering Year Helpers
2466                 * @summary Get the ISO week-numbering year of the given date.
2467                 *
2468                 * @description
2469                 * Get the ISO week-numbering year of the given date,
2470                 * which always starts 3 days before the year's first Thursday.
2471                 *
2472                 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
2473                 *
2474                 * ### v2.0.0 breaking changes:
2475                 *
2476                 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
2477                 *
2478                 * - The function was renamed from `getISOYear` to `getISOWeekYear`.
2479                 *   "ISO week year" is short for [ISO week-numbering year](https://en.wikipedia.org/wiki/ISO_week_date).
2480                 *   This change makes the name consistent with
2481                 *   locale-dependent week-numbering year helpers, e.g., `getWeekYear`.
2482                 *
2483                 * @param {Date|Number} date - the given date
2484                 * @returns {Number} the ISO week-numbering year
2485                 * @throws {TypeError} 1 argument required
2486                 *
2487                 * @example
2488                 * // Which ISO-week numbering year is 2 January 2005?
2489                 * var result = getISOWeekYear(new Date(2005, 0, 2))
2490                 * //=> 2004
2491                 */
2492
2493                function getISOWeekYear(dirtyDate) {
2494                    __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__["a" /* default */](1, arguments);
2495                    var date = __WEBPACK_IMPORTED_MODULE_0__toDate_index_js__["a" /* default */](dirtyDate);
2496                    var year = date.getFullYear();
2497                    var fourthOfJanuaryOfNextYear = new Date(0);
2498                    fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
2499                    fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
2500                    var startOfNextYear = __WEBPACK_IMPORTED_MODULE_1__startOfISOWeek_index_js__["a" /* default */](fourthOfJanuaryOfNextYear);
2501                    var fourthOfJanuaryOfThisYear = new Date(0);
2502                    fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
2503                    fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
2504                    var startOfThisYear = __WEBPACK_IMPORTED_MODULE_1__startOfISOWeek_index_js__["a" /* default */](fourthOfJanuaryOfThisYear);
2505
2506                    if (date.getTime() >= startOfNextYear.getTime()) {
2507                        return year + 1;
2508                    } else if (date.getTime() >= startOfThisYear.getTime()) {
2509                        return year;
2510                    } else {
2511                        return year - 1;
2512                    }
2513                }
2514
2515                /***/
2516            }),
2517            /* 35 */
2518            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2519
2520                "use strict";
2521                /* harmony export (immutable) */
2522                __webpack_exports__["a"] = formatRelative;
2523                var formatRelativeLocale = {
2524                    lastWeek: "'last' eeee 'at' p",
2525                    yesterday: "'yesterday at' p",
2526                    today: "'today at' p",
2527                    tomorrow: "'tomorrow at' p",
2528                    nextWeek: "eeee 'at' p",
2529                    other: 'P'
2530                };
2531
2532                function formatRelative(token, _date, _baseDate, _options) {
2533                    return formatRelativeLocale[token];
2534                }
2535
2536                /***/
2537            }),
2538            /* 36 */
2539            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2540
2541                "use strict";
2542                /* harmony import */
2543                var __WEBPACK_IMPORTED_MODULE_0__lib_buildLocalizeFn_index_js__ = __webpack_require__(3);
2544
2545                var eraValues = {
2546                    narrow: ['B', 'A'],
2547                    abbreviated: ['BC', 'AD'],
2548                    wide: ['Before Christ', 'Anno Domini']
2549                };
2550                var quarterValues = {
2551                    narrow: ['1', '2', '3', '4'],
2552                    abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
2553                    wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter'] // Note: in English, the names of days of the week and months are capitalized.
2554                    // If you are making a new locale based on this one, check if the same is true for the language you're working on.
2555                    // Generally, formatted dates should look like they are in the middle of a sentence,
2556                    // e.g. in Spanish language the weekdays and months should be in the lowercase.
2557
2558                };
2559                var monthValues = {
2560                    narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
2561                    abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
2562                    wide: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
2563                };
2564                var dayValues = {
2565                    narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
2566                    short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
2567                    abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
2568                    wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
2569                };
2570                var dayPeriodValues = {
2571                    narrow: {
2572                        am: 'a',
2573                        pm: 'p',
2574                        midnight: 'mi',
2575                        noon: 'n',
2576                        morning: 'morning',
2577                        afternoon: 'afternoon',
2578                        evening: 'evening',
2579                        night: 'night'
2580                    },
2581                    abbreviated: {
2582                        am: 'AM',
2583                        pm: 'PM',
2584                        midnight: 'midnight',
2585                        noon: 'noon',
2586                        morning: 'morning',
2587                        afternoon: 'afternoon',
2588                        evening: 'evening',
2589                        night: 'night'
2590                    },
2591                    wide: {
2592                        am: 'a.m.',
2593                        pm: 'p.m.',
2594                        midnight: 'midnight',
2595                        noon: 'noon',
2596                        morning: 'morning',
2597                        afternoon: 'afternoon',
2598                        evening: 'evening',
2599                        night: 'night'
2600                    }
2601                };
2602                var formattingDayPeriodValues = {
2603                    narrow: {
2604                        am: 'a',
2605                        pm: 'p',
2606                        midnight: 'mi',
2607                        noon: 'n',
2608                        morning: 'in the morning',
2609                        afternoon: 'in the afternoon',
2610                        evening: 'in the evening',
2611                        night: 'at night'
2612                    },
2613                    abbreviated: {
2614                        am: 'AM',
2615                        pm: 'PM',
2616                        midnight: 'midnight',
2617                        noon: 'noon',
2618                        morning: 'in the morning',
2619                        afternoon: 'in the afternoon',
2620                        evening: 'in the evening',
2621                        night: 'at night'
2622                    },
2623                    wide: {
2624                        am: 'a.m.',
2625                        pm: 'p.m.',
2626                        midnight: 'midnight',
2627                        noon: 'noon',
2628                        morning: 'in the morning',
2629                        afternoon: 'in the afternoon',
2630                        evening: 'in the evening',
2631                        night: 'at night'
2632                    }
2633                };
2634
2635                function ordinalNumber(dirtyNumber, _dirtyOptions) {
2636                    var number = Number(dirtyNumber); // If ordinal numbers depend on context, for example,
2637                    // if they are different for different grammatical genders,
2638                    // use `options.unit`:
2639                    //
2640                    //   var options = dirtyOptions || {}
2641                    //   var unit = String(options.unit)
2642                    //
2643                    // where `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
2644                    // 'day', 'hour', 'minute', 'second'
2645
2646                    var rem100 = number % 100;
2647
2648                    if (rem100 > 20 || rem100 < 10) {
2649                        switch (rem100 % 10) {
2650                            case 1:
2651                                return number + 'st';
2652
2653                            case 2:
2654                                return number + 'nd';
2655
2656                            case 3:
2657                                return number + 'rd';
2658                        }
2659                    }
2660
2661                    return number + 'th';
2662                }
2663
2664                var localize = {
2665                    ordinalNumber: ordinalNumber,
2666                    era: __WEBPACK_IMPORTED_MODULE_0__lib_buildLocalizeFn_index_js__["a" /* default */]({
2667                        values: eraValues,
2668                        defaultWidth: 'wide'
2669                    }),
2670                    quarter: __WEBPACK_IMPORTED_MODULE_0__lib_buildLocalizeFn_index_js__["a" /* default */]({
2671                        values: quarterValues,
2672                        defaultWidth: 'wide',
2673                        argumentCallback: function (quarter) {
2674                            return Number(quarter) - 1;
2675                        }
2676                    }),
2677                    month: __WEBPACK_IMPORTED_MODULE_0__lib_buildLocalizeFn_index_js__["a" /* default */]({
2678                        values: monthValues,
2679                        defaultWidth: 'wide'
2680                    }),
2681                    day: __WEBPACK_IMPORTED_MODULE_0__lib_buildLocalizeFn_index_js__["a" /* default */]({
2682                        values: dayValues,
2683                        defaultWidth: 'wide'
2684                    }),
2685                    dayPeriod: __WEBPACK_IMPORTED_MODULE_0__lib_buildLocalizeFn_index_js__["a" /* default */]({
2686                        values: dayPeriodValues,
2687                        defaultWidth: 'wide',
2688                        formattingValues: formattingDayPeriodValues,
2689                        defaultFormattingWidth: 'wide'
2690                    })
2691                };
2692                /* harmony default export */
2693                __webpack_exports__["a"] = (localize);
2694
2695                /***/
2696            }),
2697            /* 37 */
2698            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2699
2700                "use strict";
2701                /* harmony import */
2702                var __WEBPACK_IMPORTED_MODULE_0__lib_buildMatchPatternFn_index_js__ = __webpack_require__(4);
2703                /* harmony import */
2704                var __WEBPACK_IMPORTED_MODULE_1__lib_buildMatchFn_index_js__ = __webpack_require__(5);
2705
2706
2707                var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
2708                var parseOrdinalNumberPattern = /\d+/i;
2709                var matchEraPatterns = {
2710                    narrow: /^(b|a)/i,
2711                    abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
2712                    wide: /^(before christ|before common era|anno domini|common era)/i
2713                };
2714                var parseEraPatterns = {
2715                    any: [/^b/i, /^(a|c)/i]
2716                };
2717                var matchQuarterPatterns = {
2718                    narrow: /^[1234]/i,
2719                    abbreviated: /^q[1234]/i,
2720                    wide: /^[1234](th|st|nd|rd)? quarter/i
2721                };
2722                var parseQuarterPatterns = {
2723                    any: [/1/i, /2/i, /3/i, /4/i]
2724                };
2725                var matchMonthPatterns = {
2726                    narrow: /^[jfmasond]/i,
2727                    abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
2728                    wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
2729                };
2730                var parseMonthPatterns = {
2731                    narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
2732                    any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
2733                };
2734                var matchDayPatterns = {
2735                    narrow: /^[smtwf]/i,
2736                    short: /^(su|mo|tu|we|th|fr|sa)/i,
2737                    abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
2738                    wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
2739                };
2740                var parseDayPatterns = {
2741                    narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
2742                    any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
2743                };
2744                var matchDayPeriodPatterns = {
2745                    narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
2746                    any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
2747                };
2748                var parseDayPeriodPatterns = {
2749                    any: {
2750                        am: /^a/i,
2751                        pm: /^p/i,
2752                        midnight: /^mi/i,
2753                        noon: /^no/i,
2754                        morning: /morning/i,
2755                        afternoon: /afternoon/i,
2756                        evening: /evening/i,
2757                        night: /night/i
2758                    }
2759                };
2760                var match = {
2761                    ordinalNumber: __WEBPACK_IMPORTED_MODULE_0__lib_buildMatchPatternFn_index_js__["a" /* default */]({
2762                        matchPattern: matchOrdinalNumberPattern,
2763                        parsePattern: parseOrdinalNumberPattern,
2764                        valueCallback: function (value) {
2765                            return parseInt(value, 10);
2766                        }
2767                    }),
2768                    era: __WEBPACK_IMPORTED_MODULE_1__lib_buildMatchFn_index_js__["a" /* default */]({
2769                        matchPatterns: matchEraPatterns,
2770                        defaultMatchWidth: 'wide',
2771                        parsePatterns: parseEraPatterns,
2772                        defaultParseWidth: 'any'
2773                    }),
2774                    quarter: __WEBPACK_IMPORTED_MODULE_1__lib_buildMatchFn_index_js__["a" /* default */]({
2775                        matchPatterns: matchQuarterPatterns,
2776                        defaultMatchWidth: 'wide',
2777                        parsePatterns: parseQuarterPatterns,
2778                        defaultParseWidth: 'any',
2779                        valueCallback: function (index) {
2780                            return index + 1;
2781                        }
2782                    }),
2783                    month: __WEBPACK_IMPORTED_MODULE_1__lib_buildMatchFn_index_js__["a" /* default */]({
2784                        matchPatterns: matchMonthPatterns,
2785                        defaultMatchWidth: 'wide',
2786                        parsePatterns: parseMonthPatterns,
2787                        defaultParseWidth: 'any'
2788                    }),
2789                    day: __WEBPACK_IMPORTED_MODULE_1__lib_buildMatchFn_index_js__["a" /* default */]({
2790                        matchPatterns: matchDayPatterns,
2791                        defaultMatchWidth: 'wide',
2792                        parsePatterns: parseDayPatterns,
2793                        defaultParseWidth: 'any'
2794                    }),
2795                    dayPeriod: __WEBPACK_IMPORTED_MODULE_1__lib_buildMatchFn_index_js__["a" /* default */]({
2796                        matchPatterns: matchDayPeriodPatterns,
2797                        defaultMatchWidth: 'any',
2798                        parsePatterns: parseDayPeriodPatterns,
2799                        defaultParseWidth: 'any'
2800                    })
2801                };
2802                /* harmony default export */
2803                __webpack_exports__["a"] = (match);
2804
2805                /***/
2806            }),
2807            /* 38 */
2808            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2809
2810                "use strict";
2811                /* harmony export (immutable) */
2812                __webpack_exports__["a"] = addLeadingZeros;
2813
2814                function addLeadingZeros(number, targetLength) {
2815                    var sign = number < 0 ? '-' : '';
2816                    var output = Math.abs(number).toString();
2817
2818                    while (output.length < targetLength) {
2819                        output = '0' + output;
2820                    }
2821
2822                    return sign + output;
2823                }
2824
2825                /***/
2826            }),
2827            /* 39 */
2828            /***/ (function (module, exports) {
2829
2830                module.exports = function (bitmap, value) {
2831                    return {
2832                        enumerable: !(bitmap & 1),
2833                        configurable: !(bitmap & 2),
2834                        writable: !(bitmap & 4),
2835                        value: value
2836                    };
2837                };
2838
2839
2840                /***/
2841            }),
2842            /* 40 */
2843            /***/ (function (module, exports, __webpack_require__) {
2844
2845                "use strict";
2846
2847                var $at = __webpack_require__(210)(true);
2848
2849// 21.1.3.27 String.prototype[@@iterator]()
2850                __webpack_require__(101)(String, 'String', function (iterated) {
2851                    this._t = String(iterated); // target
2852                    this._i = 0;                // next index
2853// 21.1.5.2.1 %StringIteratorPrototype%.next()
2854                }, function () {
2855                    var O = this._t;
2856                    var index = this._i;
2857                    var point;
2858                    if (index >= O.length) return {value: undefined, done: true};
2859                    point = $at(O, index);
2860                    this._i += point.length;
2861                    return {value: point, done: false};
2862                });
2863
2864
2865                /***/
2866            }),
2867            /* 41 */
2868            /***/ (function (module, exports) {
2869
2870                module.exports = true;
2871
2872
2873                /***/
2874            }),
2875            /* 42 */
2876            /***/ (function (module, exports, __webpack_require__) {
2877
2878// 19.1.2.14 / 15.2.3.14 Object.keys(O)
2879                var $keys = __webpack_require__(103);
2880                var enumBugKeys = __webpack_require__(75);
2881
2882                module.exports = Object.keys || function keys(O) {
2883                    return $keys(O, enumBugKeys);
2884                };
2885
2886
2887                /***/
2888            }),
2889            /* 43 */
2890            /***/ (function (module, exports) {
2891
2892                var toString = {}.toString;
2893
2894                module.exports = function (it) {
2895                    return toString.call(it).slice(8, -1);
2896                };
2897
2898
2899                /***/
2900            }),
2901            /* 44 */
2902            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2903
2904                "use strict";
2905                /* harmony export (immutable) */
2906                __webpack_exports__["a"] = addMonths;
2907                /* harmony import */
2908                var __WEBPACK_IMPORTED_MODULE_0__lib_toInteger_index_js__ = __webpack_require__(6);
2909                /* harmony import */
2910                var __WEBPACK_IMPORTED_MODULE_1__toDate_index_js__ = __webpack_require__(1);
2911                /* harmony import */
2912                var __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__ = __webpack_require__(0);
2913
2914
2915                /**
2916                 * @name addMonths
2917                 * @category Month Helpers
2918                 * @summary Add the specified number of months to the given date.
2919                 *
2920                 * @description
2921                 * Add the specified number of months to the given date.
2922                 *
2923                 * ### v2.0.0 breaking changes:
2924                 *
2925                 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
2926                 *
2927                 * @param {Date|Number} date - the date to be changed
2928                 * @param {Number} amount - the amount of months to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
2929                 * @returns {Date} the new date with the months added
2930                 * @throws {TypeError} 2 arguments required
2931                 *
2932                 * @example
2933                 * // Add 5 months to 1 September 2014:
2934                 * var result = addMonths(new Date(2014, 8, 1), 5)
2935                 * //=> Sun Feb 01 2015 00:00:00
2936                 */
2937
2938                function addMonths(dirtyDate, dirtyAmount) {
2939                    __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__["a" /* default */](2, arguments);
2940                    var date = __WEBPACK_IMPORTED_MODULE_1__toDate_index_js__["a" /* default */](dirtyDate);
2941                    var amount = __WEBPACK_IMPORTED_MODULE_0__lib_toInteger_index_js__["a" /* default */](dirtyAmount);
2942
2943                    if (isNaN(amount)) {
2944                        return new Date(NaN);
2945                    }
2946
2947                    if (!amount) {
2948                        // If 0 months, no-op to avoid changing times in the hour before end of DST
2949                        return date;
2950                    }
2951
2952                    var dayOfMonth = date.getDate(); // The JS Date object supports date math by accepting out-of-bounds values for
2953                    // month, day, etc. For example, new Date(2020, 1, 0) returns 31 Dec 2019 and
2954                    // new Date(2020, 13, 1) returns 1 Feb 2021.  This is *almost* the behavior we
2955                    // want except that dates will wrap around the end of a month, meaning that
2956                    // new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
2957                    // we'll default to the end of the desired month by adding 1 to the desired
2958                    // month and using a date of 0 to back up one day to the end of the desired
2959                    // month.
2960
2961                    var endOfDesiredMonth = new Date(date.getTime());
2962                    endOfDesiredMonth.setMonth(date.getMonth() + amount + 1, 0);
2963                    var daysInMonth = endOfDesiredMonth.getDate();
2964
2965                    if (dayOfMonth >= daysInMonth) {
2966                        // If we're already at the end of the month, then this is the correct date
2967                        // and we're done.
2968                        return endOfDesiredMonth;
2969                    } else {
2970                        // Otherwise, we now know that setting the original day-of-month value won't
2971                        // cause an overflow, so set the desired day-of-month. Note that we can't
2972                        // just set the date of `endOfDesiredMonth` because that object may have had
2973                        // its time changed in the unusual case where where a DST transition was on
2974                        // the last day of the month and its local time was in the hour skipped or
2975                        // repeated next to a DST transition.  So we use `date` instead which is
2976                        // guaranteed to still have the original time.
2977                        date.setFullYear(endOfDesiredMonth.getFullYear(), endOfDesiredMonth.getMonth(), dayOfMonth);
2978                        return date;
2979                    }
2980                }
2981
2982                /***/
2983            }),
2984            /* 45 */
2985            /***/ (function (module, __webpack_exports__, __webpack_require__) {
2986
2987                "use strict";
2988                /* harmony export (immutable) */
2989                __webpack_exports__["a"] = addMilliseconds;
2990                /* harmony import */
2991                var __WEBPACK_IMPORTED_MODULE_0__lib_toInteger_index_js__ = __webpack_require__(6);
2992                /* harmony import */
2993                var __WEBPACK_IMPORTED_MODULE_1__toDate_index_js__ = __webpack_require__(1);
2994                /* harmony import */
2995                var __WEBPACK_IMPORTED_MODULE_2__lib_requiredArgs_index_js__ = __webpack_require__(0);
2996
2997
2998                /**
2999                 * @name addMilliseconds
3000                 * @category Millisecond Helpers
3001                 * @summary Add the specified number of milliseconds to the given date.
3002                 *