diff --git a/dist/react_with_react_dom.esm.js b/dist/react_with_react_dom.esm.js new file mode 100644 index 00000000..8227540b --- /dev/null +++ b/dist/react_with_react_dom.esm.js @@ -0,0 +1,29040 @@ +function _assert_this_initialized(self1) { + if (self1 === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return self1; +} +function _class_call_check(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for(var i = 0; i < props.length; i++){ + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} +function _create_class(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} +function _get_prototype_of(o) { + _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _get_prototype_of(o); +} +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _set_prototype_of(subClass, superClass); +} +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} +function _possible_constructor_return(self1, call) { + if (call && (_type_of(call) === "object" || typeof call === "function")) { + return call; + } + return _assert_this_initialized(self1); +} +function _set_prototype_of(o, p) { + _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + return _set_prototype_of(o, p); +} +function _type_of(obj) { + "@swc/helpers - typeof"; + return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; +} +function _is_native_reflect_construct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + try { + Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {})); + return true; + } catch (e) { + return false; + } +} +function _create_super(Derived) { + var hasNativeReflectConstruct = _is_native_reflect_construct(); + return function _createSuperInternal() { + var Super = _get_prototype_of(Derived), result; + if (hasNativeReflectConstruct) { + var NewTarget = _get_prototype_of(this).constructor; + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + return _possible_constructor_return(this, result); + }; +} +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __esm = function(fn, res) { + return function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; + }; +}; +var __commonJS = function(cb, mod) { + return function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { + exports: {} + }).exports, mod), mod.exports; + }; +}; +var __export = function(target, all) { + for(var name in all)__defProp(target, name, { + get: all[name], + enumerable: true + }); +}; +var __copyProps = function(to, from, except, desc) { + if (from && typeof from === "object" || typeof from === "function") { + var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined; + try { + var _loop = function() { + var key = _step.value; + if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { + get: function() { + return from[key]; + }, + enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable + }); + }; + for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop(); + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally{ + try { + if (!_iteratorNormalCompletion && _iterator.return != null) { + _iterator.return(); + } + } finally{ + if (_didIteratorError) { + throw _iteratorError; + } + } + } + } + return to; +}; +var __toESM = function(mod, isNodeMode, target) { + return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { + value: mod, + enumerable: true + }) : target, mod); +}; +var __toCommonJS = function(mod) { + return __copyProps(__defProp({}, "__esModule", { + value: true + }), mod); +}; +// node_modules/core-js/internals/global.js +var require_global = __commonJS({ + "node_modules/core-js/internals/global.js": function(exports, module2) { + var check = function check(it) { + return it && it.Math == Math && it; + }; + module2.exports = check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || check(typeof self == "object" && self) || check(typeof global == "object" && global) || // eslint-disable-next-line no-new-func + Function("return this")(); + } +}); +// node_modules/core-js/internals/fails.js +var require_fails = __commonJS({ + "node_modules/core-js/internals/fails.js": function(exports, module2) { + module2.exports = function(exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + } +}); +// node_modules/core-js/internals/descriptors.js +var require_descriptors = __commonJS({ + "node_modules/core-js/internals/descriptors.js": function(exports, module2) { + var fails = require_fails(); + module2.exports = !fails(function() { + return Object.defineProperty({}, 1, { + get: function get() { + return 7; + } + })[1] != 7; + }); + } +}); +// node_modules/core-js/internals/object-property-is-enumerable.js +var require_object_property_is_enumerable = __commonJS({ + "node_modules/core-js/internals/object-property-is-enumerable.js": function(exports) { + "use strict"; + var nativePropertyIsEnumerable = {}.propertyIsEnumerable; + var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ + 1: 2 + }, 1); + exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; + } : nativePropertyIsEnumerable; + } +}); +// node_modules/core-js/internals/create-property-descriptor.js +var require_create_property_descriptor = __commonJS({ + "node_modules/core-js/internals/create-property-descriptor.js": function(exports, module2) { + module2.exports = function(bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + } +}); +// node_modules/core-js/internals/classof-raw.js +var require_classof_raw = __commonJS({ + "node_modules/core-js/internals/classof-raw.js": function(exports, module2) { + var toString = {}.toString; + module2.exports = function(it) { + return toString.call(it).slice(8, -1); + }; + } +}); +// node_modules/core-js/internals/indexed-object.js +var require_indexed_object = __commonJS({ + "node_modules/core-js/internals/indexed-object.js": function(exports, module2) { + var fails = require_fails(); + var classof = require_classof_raw(); + var split = "".split; + module2.exports = fails(function() { + return !Object("z").propertyIsEnumerable(0); + }) ? function(it) { + return classof(it) == "String" ? split.call(it, "") : Object(it); + } : Object; + } +}); +// node_modules/core-js/internals/require-object-coercible.js +var require_require_object_coercible = __commonJS({ + "node_modules/core-js/internals/require-object-coercible.js": function(exports, module2) { + module2.exports = function(it) { + if (it == void 0) throw TypeError("Can't call method on " + it); + return it; + }; + } +}); +// node_modules/core-js/internals/to-indexed-object.js +var require_to_indexed_object = __commonJS({ + "node_modules/core-js/internals/to-indexed-object.js": function(exports, module2) { + var IndexedObject = require_indexed_object(); + var requireObjectCoercible = require_require_object_coercible(); + module2.exports = function(it) { + return IndexedObject(requireObjectCoercible(it)); + }; + } +}); +// node_modules/core-js/internals/is-object.js +var require_is_object = __commonJS({ + "node_modules/core-js/internals/is-object.js": function(exports, module2) { + module2.exports = function(it) { + return typeof it === "object" ? it !== null : typeof it === "function"; + }; + } +}); +// node_modules/core-js/internals/to-primitive.js +var require_to_primitive = __commonJS({ + "node_modules/core-js/internals/to-primitive.js": function(exports, module2) { + var isObject = require_is_object(); + module2.exports = function(input, PREFERRED_STRING) { + if (!isObject(input)) return input; + var fn, val; + if (PREFERRED_STRING && typeof (fn = input.toString) == "function" && !isObject(val = fn.call(input))) return val; + if (typeof (fn = input.valueOf) == "function" && !isObject(val = fn.call(input))) return val; + if (!PREFERRED_STRING && typeof (fn = input.toString) == "function" && !isObject(val = fn.call(input))) return val; + throw TypeError("Can't convert object to primitive value"); + }; + } +}); +// node_modules/core-js/internals/has.js +var require_has = __commonJS({ + "node_modules/core-js/internals/has.js": function(exports, module2) { + var hasOwnProperty = {}.hasOwnProperty; + module2.exports = function(it, key) { + return hasOwnProperty.call(it, key); + }; + } +}); +// node_modules/core-js/internals/document-create-element.js +var require_document_create_element = __commonJS({ + "node_modules/core-js/internals/document-create-element.js": function(exports, module2) { + var global2 = require_global(); + var isObject = require_is_object(); + var document2 = global2.document; + var EXISTS = isObject(document2) && isObject(document2.createElement); + module2.exports = function(it) { + return EXISTS ? document2.createElement(it) : {}; + }; + } +}); +// node_modules/core-js/internals/ie8-dom-define.js +var require_ie8_dom_define = __commonJS({ + "node_modules/core-js/internals/ie8-dom-define.js": function(exports, module2) { + var DESCRIPTORS = require_descriptors(); + var fails = require_fails(); + var createElement = require_document_create_element(); + module2.exports = !DESCRIPTORS && !fails(function() { + return Object.defineProperty(createElement("div"), "a", { + get: function get() { + return 7; + } + }).a != 7; + }); + } +}); +// node_modules/core-js/internals/object-get-own-property-descriptor.js +var require_object_get_own_property_descriptor = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-descriptor.js": function(exports) { + var DESCRIPTORS = require_descriptors(); + var propertyIsEnumerableModule = require_object_property_is_enumerable(); + var createPropertyDescriptor = require_create_property_descriptor(); + var toIndexedObject = require_to_indexed_object(); + var toPrimitive = require_to_primitive(); + var has = require_has(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPrimitive(P, true); + if (IE8_DOM_DEFINE) try { + return nativeGetOwnPropertyDescriptor(O, P); + } catch (error) {} + if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); + }; + } +}); +// node_modules/core-js/internals/an-object.js +var require_an_object = __commonJS({ + "node_modules/core-js/internals/an-object.js": function(exports, module2) { + var isObject = require_is_object(); + module2.exports = function(it) { + if (!isObject(it)) { + throw TypeError(String(it) + " is not an object"); + } + return it; + }; + } +}); +// node_modules/core-js/internals/object-define-property.js +var require_object_define_property = __commonJS({ + "node_modules/core-js/internals/object-define-property.js": function(exports) { + var DESCRIPTORS = require_descriptors(); + var IE8_DOM_DEFINE = require_ie8_dom_define(); + var anObject = require_an_object(); + var toPrimitive = require_to_primitive(); + var nativeDefineProperty = Object.defineProperty; + exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return nativeDefineProperty(O, P, Attributes); + } catch (error) {} + if ("get" in Attributes || "set" in Attributes) throw TypeError("Accessors not supported"); + if ("value" in Attributes) O[P] = Attributes.value; + return O; + }; + } +}); +// node_modules/core-js/internals/create-non-enumerable-property.js +var require_create_non_enumerable_property = __commonJS({ + "node_modules/core-js/internals/create-non-enumerable-property.js": function(exports, module2) { + var DESCRIPTORS = require_descriptors(); + var definePropertyModule = require_object_define_property(); + var createPropertyDescriptor = require_create_property_descriptor(); + module2.exports = DESCRIPTORS ? function(object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); + } : function(object, key, value) { + object[key] = value; + return object; + }; + } +}); +// node_modules/core-js/internals/set-global.js +var require_set_global = __commonJS({ + "node_modules/core-js/internals/set-global.js": function(exports, module2) { + var global2 = require_global(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + module2.exports = function(key, value) { + try { + createNonEnumerableProperty(global2, key, value); + } catch (error) { + global2[key] = value; + } + return value; + }; + } +}); +// node_modules/core-js/internals/shared-store.js +var require_shared_store = __commonJS({ + "node_modules/core-js/internals/shared-store.js": function(exports, module2) { + var global2 = require_global(); + var setGlobal = require_set_global(); + var SHARED = "__core-js_shared__"; + var store = global2[SHARED] || setGlobal(SHARED, {}); + module2.exports = store; + } +}); +// node_modules/core-js/internals/inspect-source.js +var require_inspect_source = __commonJS({ + "node_modules/core-js/internals/inspect-source.js": function(exports, module2) { + var store = require_shared_store(); + var functionToString = Function.toString; + if (typeof store.inspectSource != "function") { + store.inspectSource = function(it) { + return functionToString.call(it); + }; + } + module2.exports = store.inspectSource; + } +}); +// node_modules/core-js/internals/native-weak-map.js +var require_native_weak_map = __commonJS({ + "node_modules/core-js/internals/native-weak-map.js": function(exports, module2) { + var global2 = require_global(); + var inspectSource = require_inspect_source(); + var WeakMap2 = global2.WeakMap; + module2.exports = typeof WeakMap2 === "function" && /native code/.test(inspectSource(WeakMap2)); + } +}); +// node_modules/core-js/internals/is-pure.js +var require_is_pure = __commonJS({ + "node_modules/core-js/internals/is-pure.js": function(exports, module2) { + module2.exports = false; + } +}); +// node_modules/core-js/internals/shared.js +var require_shared = __commonJS({ + "node_modules/core-js/internals/shared.js": function(exports, module2) { + var IS_PURE = require_is_pure(); + var store = require_shared_store(); + (module2.exports = function(key, value) { + return store[key] || (store[key] = value !== void 0 ? value : {}); + })("versions", []).push({ + version: "3.6.5", + mode: IS_PURE ? "pure" : "global", + copyright: "\xa9 2020 Denis Pushkarev (zloirock.ru)" + }); + } +}); +// node_modules/core-js/internals/uid.js +var require_uid = __commonJS({ + "node_modules/core-js/internals/uid.js": function(exports, module2) { + var id = 0; + var postfix = Math.random(); + module2.exports = function(key) { + return "Symbol(" + String(key === void 0 ? "" : key) + ")_" + (++id + postfix).toString(36); + }; + } +}); +// node_modules/core-js/internals/shared-key.js +var require_shared_key = __commonJS({ + "node_modules/core-js/internals/shared-key.js": function(exports, module2) { + var shared = require_shared(); + var uid = require_uid(); + var keys = shared("keys"); + module2.exports = function(key) { + return keys[key] || (keys[key] = uid(key)); + }; + } +}); +// node_modules/core-js/internals/hidden-keys.js +var require_hidden_keys = __commonJS({ + "node_modules/core-js/internals/hidden-keys.js": function(exports, module2) { + module2.exports = {}; + } +}); +// node_modules/core-js/internals/internal-state.js +var require_internal_state = __commonJS({ + "node_modules/core-js/internals/internal-state.js": function(exports, module2) { + var NATIVE_WEAK_MAP = require_native_weak_map(); + var global2 = require_global(); + var isObject = require_is_object(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var objectHas = require_has(); + var sharedKey = require_shared_key(); + var hiddenKeys = require_hidden_keys(); + var WeakMap2 = global2.WeakMap; + var set; + var get; + var has; + var enforce = function enforce(it) { + return has(it) ? get(it) : set(it, {}); + }; + var getterFor = function getterFor(TYPE) { + return function(it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw TypeError("Incompatible receiver, " + TYPE + " required"); + } + return state; + }; + }; + if (NATIVE_WEAK_MAP) { + store = new WeakMap2(); + wmget = store.get; + wmhas = store.has; + wmset = store.set; + set = function set(it, metadata) { + wmset.call(store, it, metadata); + return metadata; + }; + get = function get(it) { + return wmget.call(store, it) || {}; + }; + has = function has(it) { + return wmhas.call(store, it); + }; + } else { + STATE = sharedKey("state"); + hiddenKeys[STATE] = true; + set = function set(it, metadata) { + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }; + get = function get(it) { + return objectHas(it, STATE) ? it[STATE] : {}; + }; + has = function has(it) { + return objectHas(it, STATE); + }; + } + var store; + var wmget; + var wmhas; + var wmset; + var STATE; + module2.exports = { + set: set, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor + }; + } +}); +// node_modules/core-js/internals/redefine.js +var require_redefine = __commonJS({ + "node_modules/core-js/internals/redefine.js": function(exports, module2) { + var global2 = require_global(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var has = require_has(); + var setGlobal = require_set_global(); + var inspectSource = require_inspect_source(); + var InternalStateModule = require_internal_state(); + var getInternalState = InternalStateModule.get; + var enforceInternalState = InternalStateModule.enforce; + var TEMPLATE = String(String).split("String"); + (module2.exports = function(O, key, value, options) { + var unsafe = options ? !!options.unsafe : false; + var simple = options ? !!options.enumerable : false; + var noTargetGet = options ? !!options.noTargetGet : false; + if (typeof value == "function") { + if (typeof key == "string" && !has(value, "name")) createNonEnumerableProperty(value, "name", key); + enforceInternalState(value).source = TEMPLATE.join(typeof key == "string" ? key : ""); + } + if (O === global2) { + if (simple) O[key] = value; + else setGlobal(key, value); + return; + } else if (!unsafe) { + delete O[key]; + } else if (!noTargetGet && O[key]) { + simple = true; + } + if (simple) O[key] = value; + else createNonEnumerableProperty(O, key, value); + })(Function.prototype, "toString", function toString() { + return typeof this == "function" && getInternalState(this).source || inspectSource(this); + }); + } +}); +// node_modules/core-js/internals/path.js +var require_path = __commonJS({ + "node_modules/core-js/internals/path.js": function(exports, module2) { + var global2 = require_global(); + module2.exports = global2; + } +}); +// node_modules/core-js/internals/get-built-in.js +var require_get_built_in = __commonJS({ + "node_modules/core-js/internals/get-built-in.js": function(exports, module2) { + var path = require_path(); + var global2 = require_global(); + var aFunction = function aFunction(variable) { + return typeof variable == "function" ? variable : void 0; + }; + module2.exports = function(namespace, method) { + return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global2[namespace]) : path[namespace] && path[namespace][method] || global2[namespace] && global2[namespace][method]; + }; + } +}); +// node_modules/core-js/internals/to-integer.js +var require_to_integer = __commonJS({ + "node_modules/core-js/internals/to-integer.js": function(exports, module2) { + var ceil = Math.ceil; + var floor = Math.floor; + module2.exports = function(argument) { + return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); + }; + } +}); +// node_modules/core-js/internals/to-length.js +var require_to_length = __commonJS({ + "node_modules/core-js/internals/to-length.js": function(exports, module2) { + var toInteger = require_to_integer(); + var min = Math.min; + module2.exports = function(argument) { + return argument > 0 ? min(toInteger(argument), 9007199254740991) : 0; + }; + } +}); +// node_modules/core-js/internals/to-absolute-index.js +var require_to_absolute_index = __commonJS({ + "node_modules/core-js/internals/to-absolute-index.js": function(exports, module2) { + var toInteger = require_to_integer(); + var max = Math.max; + var min = Math.min; + module2.exports = function(index, length) { + var integer = toInteger(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); + }; + } +}); +// node_modules/core-js/internals/array-includes.js +var require_array_includes = __commonJS({ + "node_modules/core-js/internals/array-includes.js": function(exports, module2) { + var toIndexedObject = require_to_indexed_object(); + var toLength = require_to_length(); + var toAbsoluteIndex = require_to_absolute_index(); + var createMethod = function createMethod(IS_INCLUDES) { + return function($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + if (IS_INCLUDES && el != el) while(length > index){ + value = O[index++]; + if (value != value) return true; + } + else for(; length > index; index++){ + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } + return !IS_INCLUDES && -1; + }; + }; + module2.exports = { + // `Array.prototype.includes` method + // https://tc39.github.io/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.github.io/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) + }; + } +}); +// node_modules/core-js/internals/object-keys-internal.js +var require_object_keys_internal = __commonJS({ + "node_modules/core-js/internals/object-keys-internal.js": function(exports, module2) { + var has = require_has(); + var toIndexedObject = require_to_indexed_object(); + var indexOf = require_array_includes().indexOf; + var hiddenKeys = require_hidden_keys(); + module2.exports = function(object, names) { + var O = toIndexedObject(object); + var i = 0; + var result2 = []; + var key; + for(key in O)!has(hiddenKeys, key) && has(O, key) && result2.push(key); + while(names.length > i)if (has(O, key = names[i++])) { + ~indexOf(result2, key) || result2.push(key); + } + return result2; + }; + } +}); +// node_modules/core-js/internals/enum-bug-keys.js +var require_enum_bug_keys = __commonJS({ + "node_modules/core-js/internals/enum-bug-keys.js": function(exports, module2) { + module2.exports = [ + "constructor", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "toLocaleString", + "toString", + "valueOf" + ]; + } +}); +// node_modules/core-js/internals/object-get-own-property-names.js +var require_object_get_own_property_names = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-names.js": function(exports) { + var internalObjectKeys = require_object_keys_internal(); + var enumBugKeys = require_enum_bug_keys(); + var hiddenKeys = enumBugKeys.concat("length", "prototype"); + exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); + }; + } +}); +// node_modules/core-js/internals/object-get-own-property-symbols.js +var require_object_get_own_property_symbols = __commonJS({ + "node_modules/core-js/internals/object-get-own-property-symbols.js": function(exports) { + exports.f = Object.getOwnPropertySymbols; + } +}); +// node_modules/core-js/internals/own-keys.js +var require_own_keys = __commonJS({ + "node_modules/core-js/internals/own-keys.js": function(exports, module2) { + var getBuiltIn = require_get_built_in(); + var getOwnPropertyNamesModule = require_object_get_own_property_names(); + var getOwnPropertySymbolsModule = require_object_get_own_property_symbols(); + var anObject = require_an_object(); + module2.exports = getBuiltIn("Reflect", "ownKeys") || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; + }; + } +}); +// node_modules/core-js/internals/copy-constructor-properties.js +var require_copy_constructor_properties = __commonJS({ + "node_modules/core-js/internals/copy-constructor-properties.js": function(exports, module2) { + var has = require_has(); + var ownKeys = require_own_keys(); + var getOwnPropertyDescriptorModule = require_object_get_own_property_descriptor(); + var definePropertyModule = require_object_define_property(); + module2.exports = function(target, source) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for(var i = 0; i < keys.length; i++){ + var key = keys[i]; + if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + }; + } +}); +// node_modules/core-js/internals/is-forced.js +var require_is_forced = __commonJS({ + "node_modules/core-js/internals/is-forced.js": function(exports, module2) { + var fails = require_fails(); + var replacement = /#|\.prototype\./; + var isForced = function isForced(feature, detection) { + var value = data[normalize(feature)]; + return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == "function" ? fails(detection) : !!detection; + }; + var normalize = isForced.normalize = function normalize(string) { + return String(string).replace(replacement, ".").toLowerCase(); + }; + var data = isForced.data = {}; + var NATIVE = isForced.NATIVE = "N"; + var POLYFILL = isForced.POLYFILL = "P"; + module2.exports = isForced; + } +}); +// node_modules/core-js/internals/export.js +var require_export = __commonJS({ + "node_modules/core-js/internals/export.js": function(exports, module2) { + var global2 = require_global(); + var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f; + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var redefine = require_redefine(); + var setGlobal = require_set_global(); + var copyConstructorProperties = require_copy_constructor_properties(); + var isForced = require_is_forced(); + module2.exports = function(options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global2; + } else if (STATIC) { + target = global2[TARGET] || setGlobal(TARGET, {}); + } else { + target = (global2[TARGET] || {}).prototype; + } + if (target) for(key in source){ + sourceProperty = source[key]; + if (options.noTargetGet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced); + if (!FORCED && targetProperty !== void 0) { + if ((typeof sourceProperty === "undefined" ? "undefined" : _type_of(sourceProperty)) === (typeof targetProperty === "undefined" ? "undefined" : _type_of(targetProperty))) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + if (options.sham || targetProperty && targetProperty.sham) { + createNonEnumerableProperty(sourceProperty, "sham", true); + } + redefine(target, key, sourceProperty, options); + } + }; + } +}); +// node_modules/core-js/internals/freezing.js +var require_freezing = __commonJS({ + "node_modules/core-js/internals/freezing.js": function(exports, module2) { + var fails = require_fails(); + module2.exports = !fails(function() { + return Object.isExtensible(Object.preventExtensions({})); + }); + } +}); +// node_modules/core-js/internals/internal-metadata.js +var require_internal_metadata = __commonJS({ + "node_modules/core-js/internals/internal-metadata.js": function(exports, module2) { + var hiddenKeys = require_hidden_keys(); + var isObject = require_is_object(); + var has = require_has(); + var defineProperty = require_object_define_property().f; + var uid = require_uid(); + var FREEZING = require_freezing(); + var METADATA = uid("meta"); + var id = 0; + var isExtensible = Object.isExtensible || function() { + return true; + }; + var setMetadata = function setMetadata(it) { + defineProperty(it, METADATA, { + value: { + objectID: "O" + ++id, + // object ID + weakData: {} + } + }); + }; + var fastKey = function fastKey(it, create) { + if (!isObject(it)) return (typeof it === "undefined" ? "undefined" : _type_of(it)) == "symbol" ? it : (typeof it == "string" ? "S" : "P") + it; + if (!has(it, METADATA)) { + if (!isExtensible(it)) return "F"; + if (!create) return "E"; + setMetadata(it); + } + return it[METADATA].objectID; + }; + var getWeakData = function getWeakData(it, create) { + if (!has(it, METADATA)) { + if (!isExtensible(it)) return true; + if (!create) return false; + setMetadata(it); + } + return it[METADATA].weakData; + }; + var onFreeze = function onFreeze(it) { + if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it); + return it; + }; + var meta = module2.exports = { + REQUIRED: false, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze + }; + hiddenKeys[METADATA] = true; + } +}); +// node_modules/core-js/internals/native-symbol.js +var require_native_symbol = __commonJS({ + "node_modules/core-js/internals/native-symbol.js": function(exports, module2) { + var fails = require_fails(); + module2.exports = !!Object.getOwnPropertySymbols && !fails(function() { + return !String(Symbol()); + }); + } +}); +// node_modules/core-js/internals/use-symbol-as-uid.js +var require_use_symbol_as_uid = __commonJS({ + "node_modules/core-js/internals/use-symbol-as-uid.js": function(exports, module2) { + var NATIVE_SYMBOL = require_native_symbol(); + module2.exports = NATIVE_SYMBOL && !Symbol.sham && _type_of(Symbol.iterator) == "symbol"; + } +}); +// node_modules/core-js/internals/well-known-symbol.js +var require_well_known_symbol = __commonJS({ + "node_modules/core-js/internals/well-known-symbol.js": function(exports, module2) { + var global2 = require_global(); + var shared = require_shared(); + var has = require_has(); + var uid = require_uid(); + var NATIVE_SYMBOL = require_native_symbol(); + var USE_SYMBOL_AS_UID = require_use_symbol_as_uid(); + var WellKnownSymbolsStore = shared("wks"); + var Symbol2 = global2.Symbol; + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2 : Symbol2 && Symbol2.withoutSetter || uid; + module2.exports = function(name) { + if (!has(WellKnownSymbolsStore, name)) { + if (NATIVE_SYMBOL && has(Symbol2, name)) WellKnownSymbolsStore[name] = Symbol2[name]; + else WellKnownSymbolsStore[name] = createWellKnownSymbol("Symbol." + name); + } + return WellKnownSymbolsStore[name]; + }; + } +}); +// node_modules/core-js/internals/iterators.js +var require_iterators = __commonJS({ + "node_modules/core-js/internals/iterators.js": function(exports, module2) { + module2.exports = {}; + } +}); +// node_modules/core-js/internals/is-array-iterator-method.js +var require_is_array_iterator_method = __commonJS({ + "node_modules/core-js/internals/is-array-iterator-method.js": function(exports, module2) { + var wellKnownSymbol = require_well_known_symbol(); + var Iterators = require_iterators(); + var ITERATOR = wellKnownSymbol("iterator"); + var ArrayPrototype = Array.prototype; + module2.exports = function(it) { + return it !== void 0 && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); + }; + } +}); +// node_modules/core-js/internals/a-function.js +var require_a_function = __commonJS({ + "node_modules/core-js/internals/a-function.js": function(exports, module2) { + module2.exports = function(it) { + if (typeof it != "function") { + throw TypeError(String(it) + " is not a function"); + } + return it; + }; + } +}); +// node_modules/core-js/internals/function-bind-context.js +var require_function_bind_context = __commonJS({ + "node_modules/core-js/internals/function-bind-context.js": function(exports, module2) { + var aFunction = require_a_function(); + module2.exports = function(fn, that, length) { + aFunction(fn); + if (that === void 0) return fn; + switch(length){ + case 0: + return function() { + return fn.call(that); + }; + case 1: + return function(a) { + return fn.call(that, a); + }; + case 2: + return function(a, b) { + return fn.call(that, a, b); + }; + case 3: + return function(a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function() { + return fn.apply(that, arguments); + }; + }; + } +}); +// node_modules/core-js/internals/to-string-tag-support.js +var require_to_string_tag_support = __commonJS({ + "node_modules/core-js/internals/to-string-tag-support.js": function(exports, module2) { + var wellKnownSymbol = require_well_known_symbol(); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var test = {}; + test[TO_STRING_TAG] = "z"; + module2.exports = String(test) === "[object z]"; + } +}); +// node_modules/core-js/internals/classof.js +var require_classof = __commonJS({ + "node_modules/core-js/internals/classof.js": function(exports, module2) { + var TO_STRING_TAG_SUPPORT = require_to_string_tag_support(); + var classofRaw = require_classof_raw(); + var wellKnownSymbol = require_well_known_symbol(); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var CORRECT_ARGUMENTS = classofRaw(function() { + return arguments; + }()) == "Arguments"; + var tryGet = function tryGet(it, key) { + try { + return it[key]; + } catch (error) {} + }; + module2.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function(it) { + var O, tag, result2; + return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result2 = classofRaw(O)) == "Object" && typeof O.callee == "function" ? "Arguments" : result2; + }; + } +}); +// node_modules/core-js/internals/get-iterator-method.js +var require_get_iterator_method = __commonJS({ + "node_modules/core-js/internals/get-iterator-method.js": function(exports, module2) { + var classof = require_classof(); + var Iterators = require_iterators(); + var wellKnownSymbol = require_well_known_symbol(); + var ITERATOR = wellKnownSymbol("iterator"); + module2.exports = function(it) { + if (it != void 0) return it[ITERATOR] || it["@@iterator"] || Iterators[classof(it)]; + }; + } +}); +// node_modules/core-js/internals/call-with-safe-iteration-closing.js +var require_call_with_safe_iteration_closing = __commonJS({ + "node_modules/core-js/internals/call-with-safe-iteration-closing.js": function(exports, module2) { + var anObject = require_an_object(); + module2.exports = function(iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + } catch (error) { + var returnMethod = iterator["return"]; + if (returnMethod !== void 0) anObject(returnMethod.call(iterator)); + throw error; + } + }; + } +}); +// node_modules/core-js/internals/iterate.js +var require_iterate = __commonJS({ + "node_modules/core-js/internals/iterate.js": function(exports, module2) { + var anObject = require_an_object(); + var isArrayIteratorMethod = require_is_array_iterator_method(); + var toLength = require_to_length(); + var bind = require_function_bind_context(); + var getIteratorMethod = require_get_iterator_method(); + var callWithSafeIterationClosing = require_call_with_safe_iteration_closing(); + var Result = function Result(stopped, result2) { + this.stopped = stopped; + this.result = result2; + }; + var iterate = module2.exports = function iterate(iterable, fn, that, AS_ENTRIES, IS_ITERATOR) { + var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1); + var iterator, iterFn, index, length, result2, next, step; + if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (typeof iterFn != "function") throw TypeError("Target is not iterable"); + if (isArrayIteratorMethod(iterFn)) { + for(index = 0, length = toLength(iterable.length); length > index; index++){ + result2 = AS_ENTRIES ? boundFunction(anObject(step = iterable[index])[0], step[1]) : boundFunction(iterable[index]); + if (result2 && _instanceof(result2, Result)) return result2; + } + return new Result(false); + } + iterator = iterFn.call(iterable); + } + next = iterator.next; + while(!(step = next.call(iterator)).done){ + result2 = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES); + if (typeof result2 == "object" && result2 && _instanceof(result2, Result)) return result2; + } + return new Result(false); + }; + iterate.stop = function(result2) { + return new Result(true, result2); + }; + } +}); +// node_modules/core-js/internals/an-instance.js +var require_an_instance = __commonJS({ + "node_modules/core-js/internals/an-instance.js": function(exports, module2) { + module2.exports = function(it, Constructor, name) { + if (!_instanceof(it, Constructor)) { + throw TypeError("Incorrect " + (name ? name + " " : "") + "invocation"); + } + return it; + }; + } +}); +// node_modules/core-js/internals/check-correctness-of-iteration.js +var require_check_correctness_of_iteration = __commonJS({ + "node_modules/core-js/internals/check-correctness-of-iteration.js": function(exports, module2) { + var wellKnownSymbol = require_well_known_symbol(); + var ITERATOR = wellKnownSymbol("iterator"); + var SAFE_CLOSING = false; + try { + called = 0; + iteratorWithReturn = { + next: function next() { + return { + done: !!called++ + }; + }, + "return": function() { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function() { + return this; + }; + Array.from(iteratorWithReturn, function() { + throw 2; + }); + } catch (error) {} + var called; + var iteratorWithReturn; + module2.exports = function(exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function() { + return { + next: function next() { + return { + done: ITERATION_SUPPORT = true + }; + } + }; + }; + exec(object); + } catch (error) {} + return ITERATION_SUPPORT; + }; + } +}); +// node_modules/core-js/internals/set-to-string-tag.js +var require_set_to_string_tag = __commonJS({ + "node_modules/core-js/internals/set-to-string-tag.js": function(exports, module2) { + var defineProperty = require_object_define_property().f; + var has = require_has(); + var wellKnownSymbol = require_well_known_symbol(); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + module2.exports = function(it, TAG, STATIC) { + if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { + defineProperty(it, TO_STRING_TAG, { + configurable: true, + value: TAG + }); + } + }; + } +}); +// node_modules/core-js/internals/a-possible-prototype.js +var require_a_possible_prototype = __commonJS({ + "node_modules/core-js/internals/a-possible-prototype.js": function(exports, module2) { + var isObject = require_is_object(); + module2.exports = function(it) { + if (!isObject(it) && it !== null) { + throw TypeError("Can't set " + String(it) + " as a prototype"); + } + return it; + }; + } +}); +// node_modules/core-js/internals/object-set-prototype-of.js +var require_object_set_prototype_of = __commonJS({ + "node_modules/core-js/internals/object-set-prototype-of.js": function(exports, module2) { + var anObject = require_an_object(); + var aPossiblePrototype = require_a_possible_prototype(); + module2.exports = Object.setPrototypeOf || ("__proto__" in {} ? function() { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__").set; + setter.call(test, []); + CORRECT_SETTER = _instanceof(test, Array); + } catch (error) {} + return function setPrototypeOf(O, proto) { + anObject(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter.call(O, proto); + else O.__proto__ = proto; + return O; + }; + }() : void 0); + } +}); +// node_modules/core-js/internals/inherit-if-required.js +var require_inherit_if_required = __commonJS({ + "node_modules/core-js/internals/inherit-if-required.js": function(exports, module2) { + var isObject = require_is_object(); + var setPrototypeOf = require_object_set_prototype_of(); + module2.exports = function($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if (// it can work only with native `setPrototypeOf` + setPrototypeOf && // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + typeof (NewTarget = dummy.constructor) == "function" && NewTarget !== Wrapper && isObject(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype) setPrototypeOf($this, NewTargetPrototype); + return $this; + }; + } +}); +// node_modules/core-js/internals/collection.js +var require_collection = __commonJS({ + "node_modules/core-js/internals/collection.js": function(exports, module2) { + "use strict"; + var $ = require_export(); + var global2 = require_global(); + var isForced = require_is_forced(); + var redefine = require_redefine(); + var InternalMetadataModule = require_internal_metadata(); + var iterate = require_iterate(); + var anInstance = require_an_instance(); + var isObject = require_is_object(); + var fails = require_fails(); + var checkCorrectnessOfIteration = require_check_correctness_of_iteration(); + var setToStringTag = require_set_to_string_tag(); + var inheritIfRequired = require_inherit_if_required(); + module2.exports = function(CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf("Map") !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf("Weak") !== -1; + var ADDER = IS_MAP ? "set" : "add"; + var NativeConstructor = global2[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + var fixMethod = function fixMethod(KEY) { + var nativeMethod = NativePrototype[KEY]; + redefine(NativePrototype, KEY, KEY == "add" ? function add(value) { + nativeMethod.call(this, value === 0 ? 0 : value); + return this; + } : KEY == "delete" ? function(key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == "get" ? function get(key) { + return IS_WEAK && !isObject(key) ? void 0 : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == "has" ? function has(key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : function set(key, value) { + nativeMethod.call(this, key === 0 ? 0 : key, value); + return this; + }); + }; + if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != "function" || !(IS_WEAK || NativePrototype.forEach && !fails(function() { + new NativeConstructor().entries().next(); + })))) { + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.REQUIRED = true; + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + var THROWS_ON_PRIMITIVES = fails(function() { + instance.has(1); + }); + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function(iterable) { + new NativeConstructor(iterable); + }); + var BUGGY_ZERO = !IS_WEAK && fails(function() { + var $instance = new NativeConstructor(); + var index = 5; + while(index--)$instance[ADDER](index, index); + return !$instance.has(-0); + }); + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function(dummy, iterable) { + anInstance(dummy, Constructor, CONSTRUCTOR_NAME); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (iterable != void 0) iterate(iterable, that[ADDER], that, IS_MAP); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod("delete"); + fixMethod("has"); + IS_MAP && fixMethod("get"); + } + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + exported[CONSTRUCTOR_NAME] = Constructor; + $({ + global: true, + forced: Constructor != NativeConstructor + }, exported); + setToStringTag(Constructor, CONSTRUCTOR_NAME); + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + return Constructor; + }; + } +}); +// node_modules/core-js/internals/object-keys.js +var require_object_keys = __commonJS({ + "node_modules/core-js/internals/object-keys.js": function(exports, module2) { + var internalObjectKeys = require_object_keys_internal(); + var enumBugKeys = require_enum_bug_keys(); + module2.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); + }; + } +}); +// node_modules/core-js/internals/object-define-properties.js +var require_object_define_properties = __commonJS({ + "node_modules/core-js/internals/object-define-properties.js": function(exports, module2) { + var DESCRIPTORS = require_descriptors(); + var definePropertyModule = require_object_define_property(); + var anObject = require_an_object(); + var objectKeys = require_object_keys(); + module2.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while(length > index)definePropertyModule.f(O, key = keys[index++], Properties[key]); + return O; + }; + } +}); +// node_modules/core-js/internals/html.js +var require_html = __commonJS({ + "node_modules/core-js/internals/html.js": function(exports, module2) { + var getBuiltIn = require_get_built_in(); + module2.exports = getBuiltIn("document", "documentElement"); + } +}); +// node_modules/core-js/internals/object-create.js +var require_object_create = __commonJS({ + "node_modules/core-js/internals/object-create.js": function(exports, module2) { + var anObject = require_an_object(); + var defineProperties = require_object_define_properties(); + var enumBugKeys = require_enum_bug_keys(); + var hiddenKeys = require_hidden_keys(); + var html = require_html(); + var documentCreateElement = require_document_create_element(); + var sharedKey = require_shared_key(); + var GT = ">"; + var LT = "<"; + var PROTOTYPE = "prototype"; + var SCRIPT = "script"; + var IE_PROTO = sharedKey("IE_PROTO"); + var EmptyConstructor = function EmptyConstructor() {}; + var scriptTag = function scriptTag(content) { + return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT; + }; + var NullProtoObjectViaActiveX = function NullProtoObjectViaActiveX(activeXDocument2) { + activeXDocument2.write(scriptTag("")); + activeXDocument2.close(); + var temp = activeXDocument2.parentWindow.Object; + activeXDocument2 = null; + return temp; + }; + var NullProtoObjectViaIFrame = function NullProtoObjectViaIFrame() { + var iframe = documentCreateElement("iframe"); + var JS = "java" + SCRIPT + ":"; + var iframeDocument; + iframe.style.display = "none"; + html.appendChild(iframe); + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag("document.F=Object")); + iframeDocument.close(); + return iframeDocument.F; + }; + var activeXDocument; + var NullProtoObject = function NullProtoObject1() { + try { + activeXDocument = document.domain && new ActiveXObject("htmlfile"); + } catch (error) {} + NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); + var length = enumBugKeys.length; + while(length--)delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); + }; + hiddenKeys[IE_PROTO] = true; + module2.exports = Object.create || function create(O, Properties) { + var result2; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result2 = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + result2[IE_PROTO] = O; + } else result2 = NullProtoObject(); + return Properties === void 0 ? result2 : defineProperties(result2, Properties); + }; + } +}); +// node_modules/core-js/internals/redefine-all.js +var require_redefine_all = __commonJS({ + "node_modules/core-js/internals/redefine-all.js": function(exports, module2) { + var redefine = require_redefine(); + module2.exports = function(target, src, options) { + for(var key in src)redefine(target, key, src[key], options); + return target; + }; + } +}); +// node_modules/core-js/internals/to-object.js +var require_to_object = __commonJS({ + "node_modules/core-js/internals/to-object.js": function(exports, module2) { + var requireObjectCoercible = require_require_object_coercible(); + module2.exports = function(argument) { + return Object(requireObjectCoercible(argument)); + }; + } +}); +// node_modules/core-js/internals/correct-prototype-getter.js +var require_correct_prototype_getter = __commonJS({ + "node_modules/core-js/internals/correct-prototype-getter.js": function(exports, module2) { + var fails = require_fails(); + module2.exports = !fails(function() { + var F = function F() {}; + F.prototype.constructor = null; + return Object.getPrototypeOf(new F()) !== F.prototype; + }); + } +}); +// node_modules/core-js/internals/object-get-prototype-of.js +var require_object_get_prototype_of = __commonJS({ + "node_modules/core-js/internals/object-get-prototype-of.js": function(exports, module2) { + var has = require_has(); + var toObject = require_to_object(); + var sharedKey = require_shared_key(); + var CORRECT_PROTOTYPE_GETTER = require_correct_prototype_getter(); + var IE_PROTO = sharedKey("IE_PROTO"); + var ObjectPrototype = Object.prototype; + module2.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function(O) { + O = toObject(O); + if (has(O, IE_PROTO)) return O[IE_PROTO]; + if (typeof O.constructor == "function" && _instanceof(O, O.constructor)) { + return O.constructor.prototype; + } + return _instanceof(O, Object) ? ObjectPrototype : null; + }; + } +}); +// node_modules/core-js/internals/iterators-core.js +var require_iterators_core = __commonJS({ + "node_modules/core-js/internals/iterators-core.js": function(exports, module2) { + "use strict"; + var getPrototypeOf = require_object_get_prototype_of(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var has = require_has(); + var wellKnownSymbol = require_well_known_symbol(); + var IS_PURE = require_is_pure(); + var ITERATOR = wellKnownSymbol("iterator"); + var BUGGY_SAFARI_ITERATORS = false; + var returnThis = function returnThis() { + return this; + }; + var IteratorPrototype; + var PrototypeOfArrayIteratorPrototype; + var arrayIterator; + if ([].keys) { + arrayIterator = [].keys(); + if (!("next" in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } + } + if (IteratorPrototype == void 0) IteratorPrototype = {}; + if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) { + createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis); + } + module2.exports = { + IteratorPrototype: IteratorPrototype, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS + }; + } +}); +// node_modules/core-js/internals/create-iterator-constructor.js +var require_create_iterator_constructor = __commonJS({ + "node_modules/core-js/internals/create-iterator-constructor.js": function(exports, module2) { + "use strict"; + var IteratorPrototype = require_iterators_core().IteratorPrototype; + var create = require_object_create(); + var createPropertyDescriptor = require_create_property_descriptor(); + var setToStringTag = require_set_to_string_tag(); + var Iterators = require_iterators(); + var returnThis = function returnThis() { + return this; + }; + module2.exports = function(IteratorConstructor, NAME, next) { + var TO_STRING_TAG = NAME + " Iterator"; + IteratorConstructor.prototype = create(IteratorPrototype, { + next: createPropertyDescriptor(1, next) + }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); + Iterators[TO_STRING_TAG] = returnThis; + return IteratorConstructor; + }; + } +}); +// node_modules/core-js/internals/define-iterator.js +var require_define_iterator = __commonJS({ + "node_modules/core-js/internals/define-iterator.js": function(exports, module2) { + "use strict"; + var $ = require_export(); + var createIteratorConstructor = require_create_iterator_constructor(); + var getPrototypeOf = require_object_get_prototype_of(); + var setPrototypeOf = require_object_set_prototype_of(); + var setToStringTag = require_set_to_string_tag(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var redefine = require_redefine(); + var wellKnownSymbol = require_well_known_symbol(); + var IS_PURE = require_is_pure(); + var Iterators = require_iterators(); + var IteratorsCore = require_iterators_core(); + var IteratorPrototype = IteratorsCore.IteratorPrototype; + var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; + var ITERATOR = wellKnownSymbol("iterator"); + var KEYS = "keys"; + var VALUES = "values"; + var ENTRIES = "entries"; + var returnThis = function returnThis() { + return this; + }; + module2.exports = function(Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + var getIterationMethod = function getIterationMethod(KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND]; + switch(KIND){ + case KEYS: + return function keys() { + return new IteratorConstructor(this, KIND); + }; + case VALUES: + return function values() { + return new IteratorConstructor(this, KIND); + }; + case ENTRIES: + return function entries() { + return new IteratorConstructor(this, KIND); + }; + } + return function() { + return new IteratorConstructor(this); + }; + }; + var TO_STRING_TAG = NAME + " Iterator"; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype["@@iterator"] || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME == "Array" ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf) { + setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); + } else if (typeof CurrentIteratorPrototype[ITERATOR] != "function") { + createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis); + } + } + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); + if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis; + } + } + if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { + return nativeIterator.call(this); + }; + } + if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { + createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator); + } + Iterators[NAME] = defaultIterator; + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for(KEY in methods){ + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + redefine(IterablePrototype, KEY, methods[KEY]); + } + } + else $({ + target: NAME, + proto: true, + forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME + }, methods); + } + return methods; + }; + } +}); +// node_modules/core-js/internals/set-species.js +var require_set_species = __commonJS({ + "node_modules/core-js/internals/set-species.js": function(exports, module2) { + "use strict"; + var getBuiltIn = require_get_built_in(); + var definePropertyModule = require_object_define_property(); + var wellKnownSymbol = require_well_known_symbol(); + var DESCRIPTORS = require_descriptors(); + var SPECIES = wellKnownSymbol("species"); + module2.exports = function(CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn(CONSTRUCTOR_NAME); + var defineProperty = definePropertyModule.f; + if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { + defineProperty(Constructor, SPECIES, { + configurable: true, + get: function get() { + return this; + } + }); + } + }; + } +}); +// node_modules/core-js/internals/collection-strong.js +var require_collection_strong = __commonJS({ + "node_modules/core-js/internals/collection-strong.js": function(exports, module2) { + "use strict"; + var defineProperty = require_object_define_property().f; + var create = require_object_create(); + var redefineAll = require_redefine_all(); + var bind = require_function_bind_context(); + var anInstance = require_an_instance(); + var iterate = require_iterate(); + var defineIterator = require_define_iterator(); + var setSpecies = require_set_species(); + var DESCRIPTORS = require_descriptors(); + var fastKey = require_internal_metadata().fastKey; + var InternalStateModule = require_internal_state(); + var setInternalState = InternalStateModule.set; + var internalStateGetterFor = InternalStateModule.getterFor; + module2.exports = { + getConstructor: function getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function(that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create(null), + first: void 0, + last: void 0, + size: 0 + }); + if (!DESCRIPTORS) that.size = 0; + if (iterable != void 0) iterate(iterable, that[ADDER], that, IS_MAP); + }); + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + var define = function define(that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + if (entry) { + entry.value = value; + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: void 0, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS) state.size++; + else that.size++; + if (index !== "F") state.index[index] = entry; + } + return that; + }; + var getEntry = function getEntry(that, key) { + var state = getInternalState(that); + var index = fastKey(key); + var entry; + if (index !== "F") return state.index[index]; + for(entry = state.first; entry; entry = entry.next){ + if (entry.key == key) return entry; + } + }; + redefineAll(C.prototype, { + // 23.1.3.1 Map.prototype.clear() + // 23.2.3.2 Set.prototype.clear() + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while(entry){ + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = void 0; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = void 0; + if (DESCRIPTORS) state.size = 0; + else that.size = 0; + }, + // 23.1.3.3 Map.prototype.delete(key) + // 23.2.3.4 Set.prototype.delete(value) + "delete": function(key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first == entry) state.first = next; + if (state.last == entry) state.last = prev; + if (DESCRIPTORS) state.size--; + else that.size--; + } + return !!entry; + }, + // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined) + // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined) + forEach: function forEach(callbackfn) { + var state = getInternalState(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : void 0, 3); + var entry; + while(entry = entry ? entry.next : state.first){ + boundFunction(entry.value, entry.key, this); + while(entry && entry.removed)entry = entry.previous; + } + }, + // 23.1.3.7 Map.prototype.has(key) + // 23.2.3.7 Set.prototype.has(value) + has: function has(key) { + return !!getEntry(this, key); + } + }); + redefineAll(C.prototype, IS_MAP ? { + // 23.1.3.6 Map.prototype.get(key) + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // 23.1.3.9 Map.prototype.set(key, value) + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // 23.2.3.1 Set.prototype.add(value) + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS) defineProperty(C.prototype, "size", { + get: function get() { + return getInternalState(this).size; + } + }); + return C; + }, + setStrong: function setStrong(C, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + " Iterator"; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + defineIterator(C, CONSTRUCTOR_NAME, function(iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: void 0 + }); + }, function() { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + while(entry && entry.removed)entry = entry.previous; + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + state.target = void 0; + return { + value: void 0, + done: true + }; + } + if (kind == "keys") return { + value: entry.key, + done: false + }; + if (kind == "values") return { + value: entry.value, + done: false + }; + return { + value: [ + entry.key, + entry.value + ], + done: false + }; + }, IS_MAP ? "entries" : "values", !IS_MAP, true); + setSpecies(CONSTRUCTOR_NAME); + } + }; + } +}); +// node_modules/core-js/modules/es.map.js +var require_es_map = __commonJS({ + "node_modules/core-js/modules/es.map.js": function(exports, module2) { + "use strict"; + var collection = require_collection(); + var collectionStrong = require_collection_strong(); + module2.exports = collection("Map", function(init) { + return function Map2() { + return init(this, arguments.length ? arguments[0] : void 0); + }; + }, collectionStrong); + } +}); +// node_modules/core-js/internals/object-to-string.js +var require_object_to_string = __commonJS({ + "node_modules/core-js/internals/object-to-string.js": function(exports, module2) { + "use strict"; + var TO_STRING_TAG_SUPPORT = require_to_string_tag_support(); + var classof = require_classof(); + module2.exports = TO_STRING_TAG_SUPPORT ? ({}).toString : function toString() { + return "[object " + classof(this) + "]"; + }; + } +}); +// node_modules/core-js/modules/es.object.to-string.js +var require_es_object_to_string = __commonJS({ + "node_modules/core-js/modules/es.object.to-string.js": function() { + var TO_STRING_TAG_SUPPORT = require_to_string_tag_support(); + var redefine = require_redefine(); + var toString = require_object_to_string(); + if (!TO_STRING_TAG_SUPPORT) { + redefine(Object.prototype, "toString", toString, { + unsafe: true + }); + } + } +}); +// node_modules/core-js/internals/string-multibyte.js +var require_string_multibyte = __commonJS({ + "node_modules/core-js/internals/string-multibyte.js": function(exports, module2) { + var toInteger = require_to_integer(); + var requireObjectCoercible = require_require_object_coercible(); + var createMethod = function createMethod(CONVERT_TO_STRING) { + return function($this, pos) { + var S = String(requireObjectCoercible($this)); + var position = toInteger(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? "" : void 0; + first = S.charCodeAt(position); + return first < 55296 || first > 56319 || position + 1 === size || (second = S.charCodeAt(position + 1)) < 56320 || second > 57343 ? CONVERT_TO_STRING ? S.charAt(position) : first : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 55296 << 10) + (second - 56320) + 65536; + }; + }; + module2.exports = { + // `String.prototype.codePointAt` method + // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod(true) + }; + } +}); +// node_modules/core-js/modules/es.string.iterator.js +var require_es_string_iterator = __commonJS({ + "node_modules/core-js/modules/es.string.iterator.js": function() { + "use strict"; + var charAt = require_string_multibyte().charAt; + var InternalStateModule = require_internal_state(); + var defineIterator = require_define_iterator(); + var STRING_ITERATOR = "String Iterator"; + var setInternalState = InternalStateModule.set; + var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + defineIterator(String, "String", function(iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: String(iterated), + index: 0 + }); + }, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return { + value: void 0, + done: true + }; + point = charAt(string, index); + state.index += point.length; + return { + value: point, + done: false + }; + }); + } +}); +// node_modules/core-js/internals/dom-iterables.js +var require_dom_iterables = __commonJS({ + "node_modules/core-js/internals/dom-iterables.js": function(exports, module2) { + module2.exports = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 + }; + } +}); +// node_modules/core-js/internals/add-to-unscopables.js +var require_add_to_unscopables = __commonJS({ + "node_modules/core-js/internals/add-to-unscopables.js": function(exports, module2) { + var wellKnownSymbol = require_well_known_symbol(); + var create = require_object_create(); + var definePropertyModule = require_object_define_property(); + var UNSCOPABLES = wellKnownSymbol("unscopables"); + var ArrayPrototype = Array.prototype; + if (ArrayPrototype[UNSCOPABLES] == void 0) { + definePropertyModule.f(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); + } + module2.exports = function(key) { + ArrayPrototype[UNSCOPABLES][key] = true; + }; + } +}); +// node_modules/core-js/modules/es.array.iterator.js +var require_es_array_iterator = __commonJS({ + "node_modules/core-js/modules/es.array.iterator.js": function(exports, module2) { + "use strict"; + var toIndexedObject = require_to_indexed_object(); + var addToUnscopables = require_add_to_unscopables(); + var Iterators = require_iterators(); + var InternalStateModule = require_internal_state(); + var defineIterator = require_define_iterator(); + var ARRAY_ITERATOR = "Array Iterator"; + var setInternalState = InternalStateModule.set; + var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); + module2.exports = defineIterator(Array, "Array", function(iterated, kind) { + setInternalState(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), + // target + index: 0, + // next index + kind: kind + }); + }, function() { + var state = getInternalState(this); + var target = state.target; + var kind = state.kind; + var index = state.index++; + if (!target || index >= target.length) { + state.target = void 0; + return { + value: void 0, + done: true + }; + } + if (kind == "keys") return { + value: index, + done: false + }; + if (kind == "values") return { + value: target[index], + done: false + }; + return { + value: [ + index, + target[index] + ], + done: false + }; + }, "values"); + Iterators.Arguments = Iterators.Array; + addToUnscopables("keys"); + addToUnscopables("values"); + addToUnscopables("entries"); + } +}); +// node_modules/core-js/modules/web.dom-collections.iterator.js +var require_web_dom_collections_iterator = __commonJS({ + "node_modules/core-js/modules/web.dom-collections.iterator.js": function() { + var global2 = require_global(); + var DOMIterables = require_dom_iterables(); + var ArrayIteratorMethods = require_es_array_iterator(); + var createNonEnumerableProperty = require_create_non_enumerable_property(); + var wellKnownSymbol = require_well_known_symbol(); + var ITERATOR = wellKnownSymbol("iterator"); + var TO_STRING_TAG = wellKnownSymbol("toStringTag"); + var ArrayValues = ArrayIteratorMethods.values; + for(COLLECTION_NAME in DOMIterables){ + Collection = global2[COLLECTION_NAME]; + CollectionPrototype = Collection && Collection.prototype; + if (CollectionPrototype) { + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + if (!CollectionPrototype[TO_STRING_TAG]) { + createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME); + } + if (DOMIterables[COLLECTION_NAME]) for(METHOD_NAME in ArrayIteratorMethods){ + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } + } + var Collection; + var CollectionPrototype; + var METHOD_NAME; + var COLLECTION_NAME; + } +}); +// node_modules/core-js/es/map/index.js +var require_map = __commonJS({ + "node_modules/core-js/es/map/index.js": function(exports, module2) { + require_es_map(); + require_es_object_to_string(); + require_es_string_iterator(); + require_web_dom_collections_iterator(); + var path = require_path(); + module2.exports = path.Map; + } +}); +// node_modules/core-js/modules/es.set.js +var require_es_set = __commonJS({ + "node_modules/core-js/modules/es.set.js": function(exports, module2) { + "use strict"; + var collection = require_collection(); + var collectionStrong = require_collection_strong(); + module2.exports = collection("Set", function(init) { + return function Set2() { + return init(this, arguments.length ? arguments[0] : void 0); + }; + }, collectionStrong); + } +}); +// node_modules/core-js/es/set/index.js +var require_set = __commonJS({ + "node_modules/core-js/es/set/index.js": function(exports, module2) { + require_es_set(); + require_es_object_to_string(); + require_es_string_iterator(); + require_web_dom_collections_iterator(); + var path = require_path(); + module2.exports = path.Set; + } +}); +// node_modules/core-js/modules/es.reflect.delete-property.js +var require_es_reflect_delete_property = __commonJS({ + "node_modules/core-js/modules/es.reflect.delete-property.js": function() { + var $ = require_export(); + var anObject = require_an_object(); + var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f; + $({ + target: "Reflect", + stat: true + }, { + deleteProperty: function deleteProperty(target, propertyKey) { + var descriptor = getOwnPropertyDescriptor(anObject(target), propertyKey); + return descriptor && !descriptor.configurable ? false : delete target[propertyKey]; + } + }); + } +}); +// node_modules/core-js/es/reflect/delete-property.js +var require_delete_property = __commonJS({ + "node_modules/core-js/es/reflect/delete-property.js": function(exports, module2) { + require_es_reflect_delete_property(); + var path = require_path(); + module2.exports = path.Reflect.deleteProperty; + } +}); +// node_modules/core-js/stable/reflect/delete-property.js +var require_delete_property2 = __commonJS({ + "node_modules/core-js/stable/reflect/delete-property.js": function(exports, module2) { + var parent = require_delete_property(); + module2.exports = parent; + } +}); +// node_modules/core-js/internals/object-assign.js +var require_object_assign = __commonJS({ + "node_modules/core-js/internals/object-assign.js": function(exports, module2) { + "use strict"; + var DESCRIPTORS = require_descriptors(); + var fails = require_fails(); + var objectKeys = require_object_keys(); + var getOwnPropertySymbolsModule = require_object_get_own_property_symbols(); + var propertyIsEnumerableModule = require_object_property_is_enumerable(); + var toObject = require_to_object(); + var IndexedObject = require_indexed_object(); + var nativeAssign = Object.assign; + var defineProperty = Object.defineProperty; + module2.exports = !nativeAssign || fails(function() { + if (DESCRIPTORS && nativeAssign({ + b: 1 + }, nativeAssign(defineProperty({}, "a", { + enumerable: true, + get: function get() { + defineProperty(this, "b", { + value: 3, + enumerable: false + }); + } + }), { + b: 2 + })).b !== 1) return true; + var A = {}; + var B = {}; + var symbol = Symbol(); + var alphabet = "abcdefghijklmnopqrst"; + A[symbol] = 7; + alphabet.split("").forEach(function(chr) { + B[chr] = chr; + }); + return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join("") != alphabet; + }) ? function assign(target, source) { + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while(argumentsLength > index){ + var S = IndexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while(length > j){ + key = keys[j++]; + if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key]; + } + } + return T; + } : nativeAssign; + } +}); +// node_modules/core-js/modules/es.object.assign.js +var require_es_object_assign = __commonJS({ + "node_modules/core-js/modules/es.object.assign.js": function() { + var $ = require_export(); + var assign = require_object_assign(); + $({ + target: "Object", + stat: true, + forced: Object.assign !== assign + }, { + assign: assign + }); + } +}); +// node_modules/core-js/es/object/assign.js +var require_assign = __commonJS({ + "node_modules/core-js/es/object/assign.js": function(exports, module2) { + require_es_object_assign(); + var path = require_path(); + module2.exports = path.Object.assign; + } +}); +// node_modules/core-js/stable/object/assign.js +var require_assign2 = __commonJS({ + "node_modules/core-js/stable/object/assign.js": function(exports, module2) { + var parent = require_assign(); + module2.exports = parent; + } +}); +// node_modules/core-js/internals/is-regexp.js +var require_is_regexp = __commonJS({ + "node_modules/core-js/internals/is-regexp.js": function(exports, module2) { + var isObject = require_is_object(); + var classof = require_classof_raw(); + var wellKnownSymbol = require_well_known_symbol(); + var MATCH = wellKnownSymbol("match"); + module2.exports = function(it) { + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== void 0 ? !!isRegExp : classof(it) == "RegExp"); + }; + } +}); +// node_modules/core-js/internals/not-a-regexp.js +var require_not_a_regexp = __commonJS({ + "node_modules/core-js/internals/not-a-regexp.js": function(exports, module2) { + var isRegExp = require_is_regexp(); + module2.exports = function(it) { + if (isRegExp(it)) { + throw TypeError("The method doesn't accept regular expressions"); + } + return it; + }; + } +}); +// node_modules/core-js/internals/correct-is-regexp-logic.js +var require_correct_is_regexp_logic = __commonJS({ + "node_modules/core-js/internals/correct-is-regexp-logic.js": function(exports, module2) { + var wellKnownSymbol = require_well_known_symbol(); + var MATCH = wellKnownSymbol("match"); + module2.exports = function(METHOD_NAME) { + var regexp = /./; + try { + "/./"[METHOD_NAME](regexp); + } catch (e) { + try { + regexp[MATCH] = false; + return "/./"[METHOD_NAME](regexp); + } catch (f) {} + } + return false; + }; + } +}); +// node_modules/core-js/modules/es.string.starts-with.js +var require_es_string_starts_with = __commonJS({ + "node_modules/core-js/modules/es.string.starts-with.js": function() { + "use strict"; + var $ = require_export(); + var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f; + var toLength = require_to_length(); + var notARegExp = require_not_a_regexp(); + var requireObjectCoercible = require_require_object_coercible(); + var correctIsRegExpLogic = require_correct_is_regexp_logic(); + var IS_PURE = require_is_pure(); + var nativeStartsWith = "".startsWith; + var min = Math.min; + var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic("startsWith"); + var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function() { + var descriptor = getOwnPropertyDescriptor(String.prototype, "startsWith"); + return descriptor && !descriptor.writable; + }(); + $({ + target: "String", + proto: true, + forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC + }, { + startsWith: function startsWith(searchString) { + var that = String(requireObjectCoercible(this)); + notARegExp(searchString); + var index = toLength(min(arguments.length > 1 ? arguments[1] : void 0, that.length)); + var search = String(searchString); + return nativeStartsWith ? nativeStartsWith.call(that, search, index) : that.slice(index, index + search.length) === search; + } + }); + } +}); +// node_modules/core-js/internals/entry-unbind.js +var require_entry_unbind = __commonJS({ + "node_modules/core-js/internals/entry-unbind.js": function(exports, module2) { + var global2 = require_global(); + var bind = require_function_bind_context(); + var call = Function.call; + module2.exports = function(CONSTRUCTOR, METHOD, length) { + return bind(call, global2[CONSTRUCTOR].prototype[METHOD], length); + }; + } +}); +// node_modules/core-js/es/string/starts-with.js +var require_starts_with = __commonJS({ + "node_modules/core-js/es/string/starts-with.js": function(exports, module2) { + require_es_string_starts_with(); + var entryUnbind = require_entry_unbind(); + module2.exports = entryUnbind("String", "startsWith"); + } +}); +// node_modules/core-js/stable/string/starts-with.js +var require_starts_with2 = __commonJS({ + "node_modules/core-js/stable/string/starts-with.js": function(exports, module2) { + var parent = require_starts_with(); + module2.exports = parent; + } +}); +// js_src/_dart_helpers.js +function _throwErrorFromJS(error) { + throw error; +} +function _createReactDartComponentClass(dartInteropStatics, componentStatics, jsConfig) { + var ReactDartComponent = /*#__PURE__*/ function(_React_Component) { + "use strict"; + _inherits(ReactDartComponent, _React_Component); + var _super = _create_super(ReactDartComponent); + function ReactDartComponent(props, context) { + _class_call_check(this, ReactDartComponent); + var _this; + _this = _super.call(this, props, context); + _this.dartComponent = dartInteropStatics.initComponent(_assert_this_initialized(_this), _this.props.internal, _this.context, componentStatics); + return _this; + } + _create_class(ReactDartComponent, [ + { + key: "UNSAFE_componentWillMount", + value: function UNSAFE_componentWillMount() { + dartInteropStatics.handleComponentWillMount(this.dartComponent); + } + }, + { + key: "componentDidMount", + value: function componentDidMount() { + dartInteropStatics.handleComponentDidMount(this.dartComponent); + } + }, + { + /* + /// This cannot be used with UNSAFE_ lifecycle methods. + getDerivedStateFromProps(nextProps, prevState) { + return dartInteropStatics.handleGetDerivedStateFromProps(this.props.internal, nextProps.internal); + } + */ key: "UNSAFE_componentWillReceiveProps", + value: function UNSAFE_componentWillReceiveProps(nextProps, nextContext) { + dartInteropStatics.handleComponentWillReceiveProps(this.dartComponent, nextProps.internal, nextContext); + } + }, + { + key: "shouldComponentUpdate", + value: function shouldComponentUpdate(nextProps, nextState, nextContext) { + return dartInteropStatics.handleShouldComponentUpdate(this.dartComponent, nextContext); + } + }, + { + /* + /// This cannot be used with UNSAFE_ lifecycle methods. + getSnapshotBeforeUpdate() { + return dartInteropStatics.handleGetSnapshotBeforeUpdate(this.props.internal, prevProps.internal); + } + */ key: "UNSAFE_componentWillUpdate", + value: function UNSAFE_componentWillUpdate(nextProps, nextState, nextContext) { + dartInteropStatics.handleComponentWillUpdate(this.dartComponent, nextContext); + } + }, + { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps, prevState) { + dartInteropStatics.handleComponentDidUpdate(this.dartComponent, prevProps.internal); + } + }, + { + key: "componentWillUnmount", + value: function componentWillUnmount() { + dartInteropStatics.handleComponentWillUnmount(this.dartComponent); + } + }, + { + key: "render", + value: function render() { + var result2 = dartInteropStatics.handleRender(this.dartComponent); + if (typeof result2 === "undefined") result2 = null; + return result2; + } + } + ]); + return ReactDartComponent; + }(React.Component); + var childContextKeys = jsConfig && jsConfig.childContextKeys; + var contextKeys = jsConfig && jsConfig.contextKeys; + if (childContextKeys && childContextKeys.length !== 0) { + ReactDartComponent.childContextTypes = {}; + for(var i = 0; i < childContextKeys.length; i++){ + ReactDartComponent.childContextTypes[childContextKeys[i]] = React.PropTypes.object; + } + ReactDartComponent.prototype["getChildContext"] = function() { + return dartInteropStatics.handleGetChildContext(this.dartComponent); + }; + } + if (contextKeys && contextKeys.length !== 0) { + ReactDartComponent.contextTypes = {}; + for(var i = 0; i < contextKeys.length; i++){ + ReactDartComponent.contextTypes[contextKeys[i]] = React.PropTypes.object; + } + } + return ReactDartComponent; +} +function _createReactDartComponentClass2(dartInteropStatics, componentStatics, jsConfig) { + var ReactDartComponent2 = /*#__PURE__*/ function(_React_Component) { + "use strict"; + _inherits(ReactDartComponent2, _React_Component); + var _super = _create_super(ReactDartComponent2); + function ReactDartComponent2(props, context) { + _class_call_check(this, ReactDartComponent2); + var _this; + _this = _super.call(this, props, context); + _this.dartComponent = dartInteropStatics.initComponent(_assert_this_initialized(_this), componentStatics); + return _this; + } + _create_class(ReactDartComponent2, [ + { + key: "componentDidMount", + value: function componentDidMount() { + dartInteropStatics.handleComponentDidMount(this.dartComponent); + } + }, + { + key: "shouldComponentUpdate", + value: function shouldComponentUpdate(nextProps, nextState) { + return dartInteropStatics.handleShouldComponentUpdate(this.dartComponent, nextProps, nextState); + } + }, + { + key: "getSnapshotBeforeUpdate", + value: function getSnapshotBeforeUpdate(prevProps, prevState) { + var snapshot = dartInteropStatics.handleGetSnapshotBeforeUpdate(this.dartComponent, prevProps, prevState); + return typeof snapshot !== "undefined" ? snapshot : null; + } + }, + { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps, prevState, snapshot) { + dartInteropStatics.handleComponentDidUpdate(this.dartComponent, this, prevProps, prevState, snapshot); + } + }, + { + key: "componentWillUnmount", + value: function componentWillUnmount() { + dartInteropStatics.handleComponentWillUnmount(this.dartComponent); + } + }, + { + key: "componentDidCatch", + value: function componentDidCatch(error, info) { + dartInteropStatics.handleComponentDidCatch(this.dartComponent, error, info); + } + }, + { + key: "render", + value: function render() { + var result2 = dartInteropStatics.handleRender(this.dartComponent, this.props, this.state, this.context); + if (typeof result2 === "undefined") result2 = null; + return result2; + } + } + ], [ + { + key: "getDerivedStateFromProps", + value: function getDerivedStateFromProps(nextProps, prevState) { + if (true) { + React.PropTypes.checkPropTypes(jsConfig.propTypes, nextProps, "prop", ReactDartComponent2.displayName); + } + var derivedState = dartInteropStatics.handleGetDerivedStateFromProps(componentStatics, nextProps, prevState); + return typeof derivedState !== "undefined" ? derivedState : null; + } + }, + { + key: "getDerivedStateFromError", + value: function getDerivedStateFromError(error) { + var derivedState = dartInteropStatics.handleGetDerivedStateFromError(componentStatics, error); + return typeof derivedState !== "undefined" ? derivedState : null; + } + } + ]); + return ReactDartComponent2; + }(React.Component); + if (jsConfig) { + jsConfig.skipMethods.forEach(function(method) { + if (ReactDartComponent2[method]) { + delete ReactDartComponent2[method]; + } else { + delete ReactDartComponent2.prototype[method]; + } + }); + if (jsConfig.contextType) { + ReactDartComponent2.contextType = jsConfig.contextType; + } + if (jsConfig.defaultProps) { + ReactDartComponent2.defaultProps = jsConfig.defaultProps; + } + } + return ReactDartComponent2; +} +function _markChildValidated(child) { + var store = child._store; + if (store) store.validated = true; +} +var _reactDartSymbolPrefix, _reactDartContextSymbol, _jsNull, dart_helpers_default; +var init_dart_helpers = __esm({ + "js_src/_dart_helpers.js": function() { + _reactDartSymbolPrefix = "react-dart."; + _reactDartContextSymbol = Symbol(_reactDartSymbolPrefix + "context"); + _jsNull = null; + dart_helpers_default = { + _reactDartContextSymbol: _reactDartContextSymbol, + _createReactDartComponentClass: _createReactDartComponentClass, + _createReactDartComponentClass2: _createReactDartComponentClass2, + _markChildValidated: _markChildValidated, + _throwErrorFromJS: _throwErrorFromJS, + _jsNull: _jsNull + }; + } +}); +// node_modules/object-assign/index.js +var require_object_assign2 = __commonJS({ + "node_modules/object-assign/index.js": function(exports, module2) { + "use strict"; + var toObject = function toObject(val) { + if (val === null || val === void 0) { + throw new TypeError("Object.assign cannot be called with null or undefined"); + } + return Object(val); + }; + var shouldUseNative = function shouldUseNative() { + try { + if (!Object.assign) { + return false; + } + var test1 = new String("abc"); + test1[5] = "de"; + if (Object.getOwnPropertyNames(test1)[0] === "5") { + return false; + } + var test2 = {}; + for(var i = 0; i < 10; i++){ + test2["_" + String.fromCharCode(i)] = i; + } + var order2 = Object.getOwnPropertyNames(test2).map(function(n) { + return test2[n]; + }); + if (order2.join("") !== "0123456789") { + return false; + } + var test3 = {}; + "abcdefghijklmnopqrst".split("").forEach(function(letter) { + test3[letter] = letter; + }); + if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") { + return false; + } + return true; + } catch (err) { + return false; + } + }; + var getOwnPropertySymbols = Object.getOwnPropertySymbols; + var hasOwnProperty = Object.prototype.hasOwnProperty; + var propIsEnumerable = Object.prototype.propertyIsEnumerable; + module2.exports = shouldUseNative() ? Object.assign : function(target, source) { + var from; + var to = toObject(target); + var symbols; + for(var s = 1; s < arguments.length; s++){ + from = Object(arguments[s]); + for(var key in from){ + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for(var i = 0; i < symbols.length; i++){ + if (propIsEnumerable.call(from, symbols[i])) { + to[symbols[i]] = from[symbols[i]]; + } + } + } + } + return to; + }; + } +}); +// node_modules/react/cjs/react.development.js +var require_react_development = __commonJS({ + "node_modules/react/cjs/react.development.js": function(exports) { + "use strict"; + if (true) { + (function() { + "use strict"; + var getIteratorFn = function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== "object") { + return null; + } + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + if (typeof maybeIterator === "function") { + return maybeIterator; + } + return null; + }; + var setExtraStackFrame = function setExtraStackFrame(stack) { + { + currentExtraStackFrame = stack; + } + }; + var warn = function warn(format) { + { + for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){ + args[_key - 1] = arguments[_key]; + } + printWarning("warn", format, args); + } + }; + var error = function error(format) { + { + for(var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++){ + args[_key2 - 1] = arguments[_key2]; + } + printWarning("error", format, args); + } + }; + var printWarning = function printWarning(level, format, args) { + { + var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame2.getStackAddendum(); + if (stack !== "") { + format += "%s"; + args = args.concat([ + stack + ]); + } + var argsWithFormat = args.map(function(item) { + return "" + item; + }); + argsWithFormat.unshift("Warning: " + format); + Function.prototype.apply.call(console[level], console, argsWithFormat); + } + }; + var warnNoop = function warnNoop(publicInstance, callerName) { + { + var _constructor = publicInstance.constructor; + var componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass"; + var warningKey = componentName + "." + callerName; + if (didWarnStateUpdateForUnmountedComponent[warningKey]) { + return; + } + error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, componentName); + didWarnStateUpdateForUnmountedComponent[warningKey] = true; + } + }; + var Component = function Component(props, context, updater) { + this.props = props; + this.context = context; + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; + }; + var ComponentDummy = function ComponentDummy() {}; + var PureComponent = function PureComponent(props, context, updater) { + this.props = props; + this.context = context; + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; + }; + var createRef = function createRef() { + var refObject = { + current: null + }; + { + Object.seal(refObject); + } + return refObject; + }; + var getWrappedName = function getWrappedName(outerType, innerType, wrapperName) { + var functionName = innerType.displayName || innerType.name || ""; + return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName); + }; + var getContextName = function getContextName(type) { + return type.displayName || "Context"; + }; + var hasValidRef = function hasValidRef(config) { + { + if (hasOwnProperty.call(config, "ref")) { + var getter = Object.getOwnPropertyDescriptor(config, "ref").get; + if (getter && getter.isReactWarning) { + return false; + } + } + } + return config.ref !== void 0; + }; + var hasValidKey = function hasValidKey(config) { + { + if (hasOwnProperty.call(config, "key")) { + var getter = Object.getOwnPropertyDescriptor(config, "key").get; + if (getter && getter.isReactWarning) { + return false; + } + } + } + return config.key !== void 0; + }; + var defineKeyPropWarningGetter = function defineKeyPropWarningGetter(props, displayName) { + var warnAboutAccessingKey = function warnAboutAccessingKey() { + { + if (!specialPropKeyWarningShown) { + specialPropKeyWarningShown = true; + error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName); + } + } + }; + warnAboutAccessingKey.isReactWarning = true; + Object.defineProperty(props, "key", { + get: warnAboutAccessingKey, + configurable: true + }); + }; + var defineRefPropWarningGetter = function defineRefPropWarningGetter(props, displayName) { + var warnAboutAccessingRef = function warnAboutAccessingRef() { + { + if (!specialPropRefWarningShown) { + specialPropRefWarningShown = true; + error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName); + } + } + }; + warnAboutAccessingRef.isReactWarning = true; + Object.defineProperty(props, "ref", { + get: warnAboutAccessingRef, + configurable: true + }); + }; + var warnIfStringRefCannotBeAutoConverted = function warnIfStringRefCannotBeAutoConverted(config) { + { + if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) { + var componentName = getComponentName(ReactCurrentOwner.current.type); + if (!didWarnAboutStringRefs[componentName]) { + error('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref); + didWarnAboutStringRefs[componentName] = true; + } + } + } + }; + var createElement = function createElement(type, config, children) { + var propName; + var props = {}; + var key = null; + var ref = null; + var self2 = null; + var source = null; + if (config != null) { + if (hasValidRef(config)) { + ref = config.ref; + { + warnIfStringRefCannotBeAutoConverted(config); + } + } + if (hasValidKey(config)) { + key = "" + config.key; + } + self2 = config.__self === void 0 ? null : config.__self; + source = config.__source === void 0 ? null : config.__source; + for(propName in config){ + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + props[propName] = config[propName]; + } + } + } + var childrenLength = arguments.length - 2; + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + for(var i = 0; i < childrenLength; i++){ + childArray[i] = arguments[i + 2]; + } + { + if (Object.freeze) { + Object.freeze(childArray); + } + } + props.children = childArray; + } + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + for(propName in defaultProps){ + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } + { + if (key || ref) { + var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type; + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + if (ref) { + defineRefPropWarningGetter(props, displayName); + } + } + } + return ReactElement(type, key, ref, self2, source, ReactCurrentOwner.current, props); + }; + var cloneAndReplaceKey = function cloneAndReplaceKey(oldElement, newKey) { + var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); + return newElement; + }; + var cloneElement = function cloneElement(element, config, children) { + if (!!(element === null || element === void 0)) { + { + throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + "."); + } + } + var propName; + var props = _assign({}, element.props); + var key = element.key; + var ref = element.ref; + var self2 = element._self; + var source = element._source; + var owner = element._owner; + if (config != null) { + if (hasValidRef(config)) { + ref = config.ref; + owner = ReactCurrentOwner.current; + } + if (hasValidKey(config)) { + key = "" + config.key; + } + var defaultProps; + if (element.type && element.type.defaultProps) { + defaultProps = element.type.defaultProps; + } + for(propName in config){ + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + if (config[propName] === void 0 && defaultProps !== void 0) { + props[propName] = defaultProps[propName]; + } else { + props[propName] = config[propName]; + } + } + } + } + var childrenLength = arguments.length - 2; + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + for(var i = 0; i < childrenLength; i++){ + childArray[i] = arguments[i + 2]; + } + props.children = childArray; + } + return ReactElement(element.type, key, ref, self2, source, owner, props); + }; + var isValidElement = function isValidElement(object) { + return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + }; + var escape = function escape(key) { + var escapeRegex = /[=:]/g; + var escaperLookup = { + "=": "=0", + ":": "=2" + }; + var escapedString = key.replace(escapeRegex, function(match2) { + return escaperLookup[match2]; + }); + return "$" + escapedString; + }; + var escapeUserProvidedKey = function escapeUserProvidedKey(text) { + return text.replace(userProvidedKeyEscapeRegex, "$&/"); + }; + var getElementKey = function getElementKey(element, index) { + if (typeof element === "object" && element !== null && element.key != null) { + return escape("" + element.key); + } + return index.toString(36); + }; + var mapChildren = function mapChildren(children, func, context) { + if (children == null) { + return children; + } + var result2 = []; + var count = 0; + mapIntoArray(children, result2, "", "", function(child) { + return func.call(context, child, count++); + }); + return result2; + }; + var countChildren = function countChildren(children) { + var n = 0; + mapChildren(children, function() { + n++; + }); + return n; + }; + var forEachChildren = function forEachChildren(children, forEachFunc, forEachContext) { + mapChildren(children, function() { + forEachFunc.apply(this, arguments); + }, forEachContext); + }; + var toArray = function toArray(children) { + return mapChildren(children, function(child) { + return child; + }) || []; + }; + var onlyChild = function onlyChild(children) { + if (!isValidElement(children)) { + { + throw Error("React.Children.only expected to receive a single React element child."); + } + } + return children; + }; + var createContext = function createContext(defaultValue, calculateChangedBits) { + if (calculateChangedBits === void 0) { + calculateChangedBits = null; + } else { + { + if (calculateChangedBits !== null && typeof calculateChangedBits !== "function") { + error("createContext: Expected the optional second argument to be a function. Instead received: %s", calculateChangedBits); + } + } + } + var context = { + $$typeof: REACT_CONTEXT_TYPE, + _calculateChangedBits: calculateChangedBits, + // As a workaround to support multiple concurrent renderers, we categorize + // some renderers as primary and others as secondary. We only expect + // there to be two concurrent renderers at most: React Native (primary) and + // Fabric (secondary); React DOM (primary) and React ART (secondary). + // Secondary renderers store their context values on separate fields. + _currentValue: defaultValue, + _currentValue2: defaultValue, + // Used to track how many concurrent renderers this context currently + // supports within in a single renderer. Such as parallel server rendering. + _threadCount: 0, + // These are circular + Provider: null, + Consumer: null + }; + context.Provider = { + $$typeof: REACT_PROVIDER_TYPE, + _context: context + }; + var hasWarnedAboutUsingNestedContextConsumers = false; + var hasWarnedAboutUsingConsumerProvider = false; + var hasWarnedAboutDisplayNameOnConsumer = false; + { + var Consumer = { + $$typeof: REACT_CONTEXT_TYPE, + _context: context, + _calculateChangedBits: context._calculateChangedBits + }; + Object.defineProperties(Consumer, { + Provider: { + get: function get() { + if (!hasWarnedAboutUsingConsumerProvider) { + hasWarnedAboutUsingConsumerProvider = true; + error("Rendering is not supported and will be removed in a future major release. Did you mean to render instead?"); + } + return context.Provider; + }, + set: function set(_Provider) { + context.Provider = _Provider; + } + }, + _currentValue: { + get: function get() { + return context._currentValue; + }, + set: function set(_currentValue) { + context._currentValue = _currentValue; + } + }, + _currentValue2: { + get: function get() { + return context._currentValue2; + }, + set: function set(_currentValue2) { + context._currentValue2 = _currentValue2; + } + }, + _threadCount: { + get: function get() { + return context._threadCount; + }, + set: function set(_threadCount) { + context._threadCount = _threadCount; + } + }, + Consumer: { + get: function get() { + if (!hasWarnedAboutUsingNestedContextConsumers) { + hasWarnedAboutUsingNestedContextConsumers = true; + error("Rendering is not supported and will be removed in a future major release. Did you mean to render instead?"); + } + return context.Consumer; + } + }, + displayName: { + get: function get() { + return context.displayName; + }, + set: function set(displayName) { + if (!hasWarnedAboutDisplayNameOnConsumer) { + warn("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", displayName); + hasWarnedAboutDisplayNameOnConsumer = true; + } + } + } + }); + context.Consumer = Consumer; + } + { + context._currentRenderer = null; + context._currentRenderer2 = null; + } + return context; + }; + var lazyInitializer = function lazyInitializer(payload) { + if (payload._status === Uninitialized) { + var ctor = payload._result; + var thenable = ctor(); + var pending = payload; + pending._status = Pending; + pending._result = thenable; + thenable.then(function(moduleObject) { + if (payload._status === Pending) { + var defaultExport = moduleObject.default; + { + if (defaultExport === void 0) { + error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n const MyComponent = lazy(() => import('./MyComponent'))", moduleObject); + } + } + var resolved = payload; + resolved._status = Resolved; + resolved._result = defaultExport; + } + }, function(error2) { + if (payload._status === Pending) { + var rejected = payload; + rejected._status = Rejected; + rejected._result = error2; + } + }); + } + if (payload._status === Resolved) { + return payload._result; + } else { + throw payload._result; + } + }; + var lazy = function lazy(ctor) { + var payload = { + // We use these fields to store the result. + _status: -1, + _result: ctor + }; + var lazyType = { + $$typeof: REACT_LAZY_TYPE, + _payload: payload, + _init: lazyInitializer + }; + { + var defaultProps; + var propTypes; + Object.defineProperties(lazyType, { + defaultProps: { + configurable: true, + get: function get() { + return defaultProps; + }, + set: function set(newDefaultProps) { + error("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."); + defaultProps = newDefaultProps; + Object.defineProperty(lazyType, "defaultProps", { + enumerable: true + }); + } + }, + propTypes: { + configurable: true, + get: function get() { + return propTypes; + }, + set: function set(newPropTypes) { + error("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."); + propTypes = newPropTypes; + Object.defineProperty(lazyType, "propTypes", { + enumerable: true + }); + } + } + }); + } + return lazyType; + }; + var forwardRef = function forwardRef(render) { + { + if (render != null && render.$$typeof === REACT_MEMO_TYPE) { + error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."); + } else if (typeof render !== "function") { + error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render === "undefined" ? "undefined" : _type_of(render)); + } else { + if (render.length !== 0 && render.length !== 2) { + error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."); + } + } + if (render != null) { + if (render.defaultProps != null || render.propTypes != null) { + error("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?"); + } + } + } + var elementType = { + $$typeof: REACT_FORWARD_REF_TYPE, + render: render + }; + { + var ownName; + Object.defineProperty(elementType, "displayName", { + enumerable: false, + configurable: true, + get: function get() { + return ownName; + }, + set: function set(name) { + ownName = name; + if (render.displayName == null) { + render.displayName = name; + } + } + }); + } + return elementType; + }; + var isValidElementType2 = function isValidElementType2(type) { + if (typeof type === "string" || typeof type === "function") { + return true; + } + if (type === exports.Fragment || type === exports.Profiler || type === REACT_DEBUG_TRACING_MODE_TYPE || type === exports.StrictMode || type === exports.Suspense || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) { + return true; + } + if (typeof type === "object" && type !== null) { + if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) { + return true; + } + } + return false; + }; + var memo = function memo(type, compare) { + { + if (!isValidElementType2(type)) { + error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type === "undefined" ? "undefined" : _type_of(type)); + } + } + var elementType = { + $$typeof: REACT_MEMO_TYPE, + type: type, + compare: compare === void 0 ? null : compare + }; + { + var ownName; + Object.defineProperty(elementType, "displayName", { + enumerable: false, + configurable: true, + get: function get() { + return ownName; + }, + set: function set(name) { + ownName = name; + if (type.displayName == null) { + type.displayName = name; + } + } + }); + } + return elementType; + }; + var resolveDispatcher = function resolveDispatcher() { + var dispatcher = ReactCurrentDispatcher.current; + if (!(dispatcher !== null)) { + { + throw Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."); + } + } + return dispatcher; + }; + var useContext5 = function useContext5(Context, unstable_observedBits) { + var dispatcher = resolveDispatcher(); + { + if (unstable_observedBits !== void 0) { + error("useContext() second argument is reserved for future use in React. Passing it is not supported. You passed: %s.%s", unstable_observedBits, typeof unstable_observedBits === "number" && Array.isArray(arguments[2]) ? "\n\nDid you call array.map(useContext)? Calling Hooks inside a loop is not supported. Learn more at https://reactjs.org/link/rules-of-hooks" : ""); + } + if (Context._context !== void 0) { + var realContext = Context._context; + if (realContext.Consumer === Context) { + error("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?"); + } else if (realContext.Provider === Context) { + error("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?"); + } + } + } + return dispatcher.useContext(Context, unstable_observedBits); + }; + var useState = function useState(initialState) { + var dispatcher = resolveDispatcher(); + return dispatcher.useState(initialState); + }; + var useReducer3 = function useReducer3(reducer, initialArg, init) { + var dispatcher = resolveDispatcher(); + return dispatcher.useReducer(reducer, initialArg, init); + }; + var useRef3 = function useRef3(initialValue) { + var dispatcher = resolveDispatcher(); + return dispatcher.useRef(initialValue); + }; + var useEffect3 = function useEffect3(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useEffect(create, deps); + }; + var useLayoutEffect2 = function useLayoutEffect2(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useLayoutEffect(create, deps); + }; + var useCallback = function useCallback(callback, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useCallback(callback, deps); + }; + var useMemo4 = function useMemo4(create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useMemo(create, deps); + }; + var useImperativeHandle = function useImperativeHandle(ref, create, deps) { + var dispatcher = resolveDispatcher(); + return dispatcher.useImperativeHandle(ref, create, deps); + }; + var useDebugValue2 = function useDebugValue2(value, formatterFn) { + { + var dispatcher = resolveDispatcher(); + return dispatcher.useDebugValue(value, formatterFn); + } + }; + var disabledLog = function disabledLog() {}; + var disableLogs = function disableLogs() { + { + if (disabledDepth === 0) { + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + } + disabledDepth++; + } + }; + var reenableLogs = function reenableLogs() { + { + disabledDepth--; + if (disabledDepth === 0) { + var props = { + configurable: true, + enumerable: true, + writable: true + }; + Object.defineProperties(console, { + log: _assign({}, props, { + value: prevLog + }), + info: _assign({}, props, { + value: prevInfo + }), + warn: _assign({}, props, { + value: prevWarn + }), + error: _assign({}, props, { + value: prevError + }), + group: _assign({}, props, { + value: prevGroup + }), + groupCollapsed: _assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: _assign({}, props, { + value: prevGroupEnd + }) + }); + } + if (disabledDepth < 0) { + error("disabledDepth fell below zero. This is a bug in React. Please file an issue."); + } + } + }; + var describeBuiltInComponentFrame = function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === void 0) { + try { + throw Error(); + } catch (x) { + var match2 = x.stack.trim().match(/\n( *(at )?)/); + prefix = match2 && match2[1] || ""; + } + } + return "\n" + prefix + name; + } + }; + var describeNativeComponentFrame = function describeNativeComponentFrame(fn, construct) { + if (!fn || reentry) { + return ""; + } + { + var frame = componentFrameCache.get(fn); + if (frame !== void 0) { + return frame; + } + } + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + var previousDispatcher; + { + previousDispatcher = ReactCurrentDispatcher$1.current; + ReactCurrentDispatcher$1.current = null; + disableLogs(); + } + try { + if (construct) { + var Fake = function Fake() { + throw Error(); + }; + Object.defineProperty(Fake.prototype, "props", { + set: function set() { + throw Error(); + } + }); + if (typeof Reflect === "object" && Reflect.construct) { + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + fn(); + } + } catch (sample) { + if (sample && control && typeof sample.stack === "string") { + var sampleLines = sample.stack.split("\n"); + var controlLines = control.stack.split("\n"); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + while(s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]){ + c--; + } + for(; s >= 1 && c >= 0; s--, c--){ + if (sampleLines[s] !== controlLines[c]) { + if (s !== 1 || c !== 1) { + do { + s--; + c--; + if (c < 0 || sampleLines[s] !== controlLines[c]) { + var _frame = "\n" + sampleLines[s].replace(" at new ", " at "); + { + if (typeof fn === "function") { + componentFrameCache.set(fn, _frame); + } + } + return _frame; + } + }while (s >= 1 && c >= 0); + } + break; + } + } + } + } finally{ + reentry = false; + { + ReactCurrentDispatcher$1.current = previousDispatcher; + reenableLogs(); + } + Error.prepareStackTrace = previousPrepareStackTrace; + } + var name = fn ? fn.displayName || fn.name : ""; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ""; + { + if (typeof fn === "function") { + componentFrameCache.set(fn, syntheticFrame); + } + } + return syntheticFrame; + }; + var describeFunctionComponentFrame = function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } + }; + var shouldConstruct = function shouldConstruct(Component2) { + var prototype = Component2.prototype; + return !!(prototype && prototype.isReactComponent); + }; + var setCurrentlyValidatingElement = function setCurrentlyValidatingElement(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + ReactDebugCurrentFrame$1.setExtraStackFrame(stack); + } else { + ReactDebugCurrentFrame$1.setExtraStackFrame(null); + } + } + }; + var checkPropTypes = function checkPropTypes(typeSpecs, values, location, componentName, element) { + { + var has = Function.call.bind(Object.prototype.hasOwnProperty); + for(var typeSpecName in typeSpecs){ + if (has(typeSpecs, typeSpecName)) { + var error$1 = void 0; + try { + if (typeof typeSpecs[typeSpecName] !== "function") { + var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + _type_of(typeSpecs[typeSpecName]) + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."); + err.name = "Invariant Violation"; + throw err; + } + error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"); + } catch (ex) { + error$1 = ex; + } + if (error$1 && !_instanceof(error$1, Error)) { + setCurrentlyValidatingElement(element); + error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1 === "undefined" ? "undefined" : _type_of(error$1)); + setCurrentlyValidatingElement(null); + } + if (_instanceof(error$1, Error) && !(error$1.message in loggedTypeFailures)) { + loggedTypeFailures[error$1.message] = true; + setCurrentlyValidatingElement(element); + error("Failed %s type: %s", location, error$1.message); + setCurrentlyValidatingElement(null); + } + } + } + } + }; + var setCurrentlyValidatingElement$1 = function setCurrentlyValidatingElement$1(element) { + { + if (element) { + var owner = element._owner; + var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); + setExtraStackFrame(stack); + } else { + setExtraStackFrame(null); + } + } + }; + var getDeclarationErrorAddendum = function getDeclarationErrorAddendum() { + if (ReactCurrentOwner.current) { + var name = getComponentName(ReactCurrentOwner.current.type); + if (name) { + return "\n\nCheck the render method of `" + name + "`."; + } + } + return ""; + }; + var getSourceInfoErrorAddendum = function getSourceInfoErrorAddendum(source) { + if (source !== void 0) { + var fileName = source.fileName.replace(/^.*[\\\/]/, ""); + var lineNumber = source.lineNumber; + return "\n\nCheck your code at " + fileName + ":" + lineNumber + "."; + } + return ""; + }; + var getSourceInfoErrorAddendumForProps = function getSourceInfoErrorAddendumForProps(elementProps) { + if (elementProps !== null && elementProps !== void 0) { + return getSourceInfoErrorAddendum(elementProps.__source); + } + return ""; + }; + var getCurrentComponentErrorInfo = function getCurrentComponentErrorInfo(parentType) { + var info = getDeclarationErrorAddendum(); + if (!info) { + var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name; + if (parentName) { + info = "\n\nCheck the top-level render call using <" + parentName + ">."; + } + } + return info; + }; + var validateExplicitKey = function validateExplicitKey(element, parentType) { + if (!element._store || element._store.validated || element.key != null) { + return; + } + element._store.validated = true; + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; + var childOwner = ""; + if (element && element._owner && element._owner !== ReactCurrentOwner.current) { + childOwner = " It was passed a child from " + getComponentName(element._owner.type) + "."; + } + { + setCurrentlyValidatingElement$1(element); + error('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner); + setCurrentlyValidatingElement$1(null); + } + }; + var validateChildKeys = function validateChildKeys(node, parentType) { + if (typeof node !== "object") { + return; + } + if (Array.isArray(node)) { + for(var i = 0; i < node.length; i++){ + var child = node[i]; + if (isValidElement(child)) { + validateExplicitKey(child, parentType); + } + } + } else if (isValidElement(node)) { + if (node._store) { + node._store.validated = true; + } + } else if (node) { + var iteratorFn = getIteratorFn(node); + if (typeof iteratorFn === "function") { + if (iteratorFn !== node.entries) { + var iterator = iteratorFn.call(node); + var step; + while(!(step = iterator.next()).done){ + if (isValidElement(step.value)) { + validateExplicitKey(step.value, parentType); + } + } + } + } + } + }; + var validatePropTypes = function validatePropTypes(element) { + { + var type = element.type; + if (type === null || type === void 0 || typeof type === "string") { + return; + } + var propTypes; + if (typeof type === "function") { + propTypes = type.propTypes; + } else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here. + // Inner props are checked in the reconciler. + type.$$typeof === REACT_MEMO_TYPE)) { + propTypes = type.propTypes; + } else { + return; + } + if (propTypes) { + var name = getComponentName(type); + checkPropTypes(propTypes, element.props, "prop", name, element); + } else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) { + propTypesMisspellWarningShown = true; + var _name = getComponentName(type); + error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown"); + } + if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) { + error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead."); + } + } + }; + var validateFragmentProps = function validateFragmentProps(fragment) { + { + var keys = Object.keys(fragment.props); + for(var i = 0; i < keys.length; i++){ + var key = keys[i]; + if (key !== "children" && key !== "key") { + setCurrentlyValidatingElement$1(fragment); + error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key); + setCurrentlyValidatingElement$1(null); + break; + } + } + if (fragment.ref !== null) { + setCurrentlyValidatingElement$1(fragment); + error("Invalid attribute `ref` supplied to `React.Fragment`."); + setCurrentlyValidatingElement$1(null); + } + } + }; + var createElementWithValidation = function createElementWithValidation(type, props, children) { + var validType = isValidElementType2(type); + if (!validType) { + var info = ""; + if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) { + info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports."; + } + var sourceInfo = getSourceInfoErrorAddendumForProps(props); + if (sourceInfo) { + info += sourceInfo; + } else { + info += getDeclarationErrorAddendum(); + } + var typeString; + if (type === null) { + typeString = "null"; + } else if (Array.isArray(type)) { + typeString = "array"; + } else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) { + typeString = "<" + (getComponentName(type.type) || "Unknown") + " />"; + info = " Did you accidentally export a JSX literal instead of a component?"; + } else { + typeString = typeof type === "undefined" ? "undefined" : _type_of(type); + } + { + error("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info); + } + } + var element = createElement.apply(this, arguments); + if (element == null) { + return element; + } + if (validType) { + for(var i = 2; i < arguments.length; i++){ + validateChildKeys(arguments[i], type); + } + } + if (type === exports.Fragment) { + validateFragmentProps(element); + } else { + validatePropTypes(element); + } + return element; + }; + var createFactoryWithValidation = function createFactoryWithValidation(type) { + var validatedFactory = createElementWithValidation.bind(null, type); + validatedFactory.type = type; + { + if (!didWarnAboutDeprecatedCreateFactory) { + didWarnAboutDeprecatedCreateFactory = true; + warn("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead."); + } + Object.defineProperty(validatedFactory, "type", { + enumerable: false, + get: function get() { + warn("Factory.type is deprecated. Access the class directly before passing it to createFactory."); + Object.defineProperty(this, "type", { + value: type + }); + return type; + } + }); + } + return validatedFactory; + }; + var cloneElementWithValidation = function cloneElementWithValidation(element, props, children) { + var newElement = cloneElement.apply(this, arguments); + for(var i = 2; i < arguments.length; i++){ + validateChildKeys(arguments[i], newElement.type); + } + validatePropTypes(newElement); + return newElement; + }; + var _assign = require_object_assign2(); + var ReactVersion = "17.0.1"; + var REACT_ELEMENT_TYPE = 60103; + var REACT_PORTAL_TYPE = 60106; + exports.Fragment = 60107; + exports.StrictMode = 60108; + exports.Profiler = 60114; + var REACT_PROVIDER_TYPE = 60109; + var REACT_CONTEXT_TYPE = 60110; + var REACT_FORWARD_REF_TYPE = 60112; + exports.Suspense = 60113; + var REACT_SUSPENSE_LIST_TYPE = 60120; + var REACT_MEMO_TYPE = 60115; + var REACT_LAZY_TYPE = 60116; + var REACT_BLOCK_TYPE = 60121; + var REACT_SERVER_BLOCK_TYPE = 60122; + var REACT_FUNDAMENTAL_TYPE = 60117; + var REACT_SCOPE_TYPE = 60119; + var REACT_OPAQUE_ID_TYPE = 60128; + var REACT_DEBUG_TRACING_MODE_TYPE = 60129; + var REACT_OFFSCREEN_TYPE = 60130; + var REACT_LEGACY_HIDDEN_TYPE = 60131; + if (typeof Symbol === "function" && Symbol.for) { + var symbolFor = Symbol.for; + REACT_ELEMENT_TYPE = symbolFor("react.element"); + REACT_PORTAL_TYPE = symbolFor("react.portal"); + exports.Fragment = symbolFor("react.fragment"); + exports.StrictMode = symbolFor("react.strict_mode"); + exports.Profiler = symbolFor("react.profiler"); + REACT_PROVIDER_TYPE = symbolFor("react.provider"); + REACT_CONTEXT_TYPE = symbolFor("react.context"); + REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref"); + exports.Suspense = symbolFor("react.suspense"); + REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list"); + REACT_MEMO_TYPE = symbolFor("react.memo"); + REACT_LAZY_TYPE = symbolFor("react.lazy"); + REACT_BLOCK_TYPE = symbolFor("react.block"); + REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block"); + REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental"); + REACT_SCOPE_TYPE = symbolFor("react.scope"); + REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id"); + REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode"); + REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen"); + REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden"); + } + var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = "@@iterator"; + var ReactCurrentDispatcher = { + /** + * @internal + * @type {ReactComponent} + */ current: null + }; + var ReactCurrentBatchConfig = { + transition: 0 + }; + var ReactCurrentOwner = { + /** + * @internal + * @type {ReactComponent} + */ current: null + }; + var ReactDebugCurrentFrame = {}; + var currentExtraStackFrame = null; + { + ReactDebugCurrentFrame.setExtraStackFrame = function(stack) { + { + currentExtraStackFrame = stack; + } + }; + ReactDebugCurrentFrame.getCurrentStack = null; + ReactDebugCurrentFrame.getStackAddendum = function() { + var stack = ""; + if (currentExtraStackFrame) { + stack += currentExtraStackFrame; + } + var impl = ReactDebugCurrentFrame.getCurrentStack; + if (impl) { + stack += impl() || ""; + } + return stack; + }; + } + var IsSomeRendererActing = { + current: false + }; + var ReactSharedInternals = { + ReactCurrentDispatcher: ReactCurrentDispatcher, + ReactCurrentBatchConfig: ReactCurrentBatchConfig, + ReactCurrentOwner: ReactCurrentOwner, + IsSomeRendererActing: IsSomeRendererActing, + // Used by renderers to avoid bundling object-assign twice in UMD bundles: + assign: _assign + }; + { + ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame; + } + var didWarnStateUpdateForUnmountedComponent = {}; + var ReactNoopUpdateQueue = { + /** + * Checks whether or not this composite component is mounted. + * @param {ReactClass} publicInstance The instance we want to test. + * @return {boolean} True if mounted, false otherwise. + * @protected + * @final + */ isMounted: function isMounted(publicInstance) { + return false; + }, + /** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ enqueueForceUpdate: function enqueueForceUpdate(publicInstance, callback, callerName) { + warnNoop(publicInstance, "forceUpdate"); + }, + /** + * Replaces all of the state. Always use this or `setState` to mutate state. + * You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} completeState Next state. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ enqueueReplaceState: function enqueueReplaceState(publicInstance, completeState, callback, callerName) { + warnNoop(publicInstance, "replaceState"); + }, + /** + * Sets a subset of the state. This only exists because _pendingState is + * internal. This provides a merging strategy that is not available to deep + * properties which is confusing. TODO: Expose pendingState or don't use it + * during the merge. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} partialState Next partial state to be merged with state. + * @param {?function} callback Called after component is updated. + * @param {?string} Name of the calling function in the public API. + * @internal + */ enqueueSetState: function enqueueSetState(publicInstance, partialState, callback, callerName) { + warnNoop(publicInstance, "setState"); + } + }; + var emptyObject = {}; + { + Object.freeze(emptyObject); + } + Component.prototype.isReactComponent = {}; + Component.prototype.setState = function(partialState, callback) { + if (!(typeof partialState === "object" || typeof partialState === "function" || partialState == null)) { + { + throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables."); + } + } + this.updater.enqueueSetState(this, partialState, callback, "setState"); + }; + Component.prototype.forceUpdate = function(callback) { + this.updater.enqueueForceUpdate(this, callback, "forceUpdate"); + }; + { + var deprecatedAPIs = { + isMounted: [ + "isMounted", + "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks." + ], + replaceState: [ + "replaceState", + "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)." + ] + }; + var defineDeprecationWarning = function defineDeprecationWarning(methodName, info) { + Object.defineProperty(Component.prototype, methodName, { + get: function get() { + warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]); + return void 0; + } + }); + }; + for(var fnName in deprecatedAPIs){ + if (deprecatedAPIs.hasOwnProperty(fnName)) { + defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); + } + } + } + ComponentDummy.prototype = Component.prototype; + var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); + pureComponentPrototype.constructor = PureComponent; + _assign(pureComponentPrototype, Component.prototype); + pureComponentPrototype.isPureReactComponent = true; + function getComponentName(type) { + if (type == null) { + return null; + } + { + if (typeof type.tag === "number") { + error("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue."); + } + } + if (typeof type === "function") { + return type.displayName || type.name || null; + } + if (typeof type === "string") { + return type; + } + switch(type){ + case exports.Fragment: + return "Fragment"; + case REACT_PORTAL_TYPE: + return "Portal"; + case exports.Profiler: + return "Profiler"; + case exports.StrictMode: + return "StrictMode"; + case exports.Suspense: + return "Suspense"; + case REACT_SUSPENSE_LIST_TYPE: + return "SuspenseList"; + } + if (typeof type === "object") { + switch(type.$$typeof){ + case REACT_CONTEXT_TYPE: + var context = type; + return getContextName(context) + ".Consumer"; + case REACT_PROVIDER_TYPE: + var provider = type; + return getContextName(provider._context) + ".Provider"; + case REACT_FORWARD_REF_TYPE: + return getWrappedName(type, type.render, "ForwardRef"); + case REACT_MEMO_TYPE: + return getComponentName(type.type); + case REACT_BLOCK_TYPE: + return getComponentName(type._render); + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return getComponentName(init(payload)); + } catch (x) { + return null; + } + } + } + } + return null; + } + var hasOwnProperty = Object.prototype.hasOwnProperty; + var RESERVED_PROPS = { + key: true, + ref: true, + __self: true, + __source: true + }; + var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs; + { + didWarnAboutStringRefs = {}; + } + var ReactElement = function ReactElement(type, key, ref, self2, source, owner, props) { + var element = { + // This tag allows us to uniquely identify this as a React Element + $$typeof: REACT_ELEMENT_TYPE, + // Built-in properties that belong on the element + type: type, + key: key, + ref: ref, + props: props, + // Record the component responsible for creating this element. + _owner: owner + }; + { + element._store = {}; + Object.defineProperty(element._store, "validated", { + configurable: false, + enumerable: false, + writable: true, + value: false + }); + Object.defineProperty(element, "_self", { + configurable: false, + enumerable: false, + writable: false, + value: self2 + }); + Object.defineProperty(element, "_source", { + configurable: false, + enumerable: false, + writable: false, + value: source + }); + if (Object.freeze) { + Object.freeze(element.props); + Object.freeze(element); + } + } + return element; + }; + var SEPARATOR = "."; + var SUBSEPARATOR = ":"; + var didWarnAboutMaps = false; + var userProvidedKeyEscapeRegex = /\/+/g; + function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { + var type = typeof children === "undefined" ? "undefined" : _type_of(children); + if (type === "undefined" || type === "boolean") { + children = null; + } + var invokeCallback = false; + if (children === null) { + invokeCallback = true; + } else { + switch(type){ + case "string": + case "number": + invokeCallback = true; + break; + case "object": + switch(children.$$typeof){ + case REACT_ELEMENT_TYPE: + case REACT_PORTAL_TYPE: + invokeCallback = true; + } + } + } + if (invokeCallback) { + var _child = children; + var mappedChild = callback(_child); + var childKey = nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar; + if (Array.isArray(mappedChild)) { + var escapedChildKey = ""; + if (childKey != null) { + escapedChildKey = escapeUserProvidedKey(childKey) + "/"; + } + mapIntoArray(mappedChild, array, escapedChildKey, "", function(c) { + return c; + }); + } else if (mappedChild != null) { + if (isValidElement(mappedChild)) { + mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as + // traverseAllChildren used to do for objects as children + escapedPrefix + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key + (mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number + escapeUserProvidedKey("" + mappedChild.key) + "/" : "") + childKey); + } + array.push(mappedChild); + } + return 1; + } + var child; + var nextName; + var subtreeCount = 0; + var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR; + if (Array.isArray(children)) { + for(var i = 0; i < children.length; i++){ + child = children[i]; + nextName = nextNamePrefix + getElementKey(child, i); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else { + var iteratorFn = getIteratorFn(children); + if (typeof iteratorFn === "function") { + var iterableChildren = children; + { + if (iteratorFn === iterableChildren.entries) { + if (!didWarnAboutMaps) { + warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."); + } + didWarnAboutMaps = true; + } + } + var iterator = iteratorFn.call(iterableChildren); + var step; + var ii = 0; + while(!(step = iterator.next()).done){ + child = step.value; + nextName = nextNamePrefix + getElementKey(child, ii++); + subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); + } + } else if (type === "object") { + var childrenString = "" + children; + { + { + throw Error("Objects are not valid as a React child (found: " + (childrenString === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString) + "). If you meant to render a collection of children, use an array instead."); + } + } + } + } + return subtreeCount; + } + var Uninitialized = -1; + var Pending = 0; + var Resolved = 1; + var Rejected = 2; + var enableScopeAPI = false; + var disabledDepth = 0; + var prevLog; + var prevInfo; + var prevWarn; + var prevError; + var prevGroup; + var prevGroupCollapsed; + var prevGroupEnd; + disabledLog.__reactDisabledLog = true; + var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher; + var prefix; + var reentry = false; + var componentFrameCache; + { + var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map; + componentFrameCache = new PossiblyWeakMap(); + } + function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { + if (type == null) { + return ""; + } + if (typeof type === "function") { + { + return describeNativeComponentFrame(type, shouldConstruct(type)); + } + } + if (typeof type === "string") { + return describeBuiltInComponentFrame(type); + } + switch(type){ + case exports.Suspense: + return describeBuiltInComponentFrame("Suspense"); + case REACT_SUSPENSE_LIST_TYPE: + return describeBuiltInComponentFrame("SuspenseList"); + } + if (typeof type === "object") { + switch(type.$$typeof){ + case REACT_FORWARD_REF_TYPE: + return describeFunctionComponentFrame(type.render); + case REACT_MEMO_TYPE: + return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); + case REACT_BLOCK_TYPE: + return describeFunctionComponentFrame(type._render); + case REACT_LAZY_TYPE: + { + var lazyComponent = type; + var payload = lazyComponent._payload; + var init = lazyComponent._init; + try { + return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); + } catch (x) {} + } + } + } + return ""; + } + var loggedTypeFailures = {}; + var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame; + var propTypesMisspellWarningShown; + { + propTypesMisspellWarningShown = false; + } + var ownerHasKeyUseWarning = {}; + var didWarnAboutDeprecatedCreateFactory = false; + { + try { + var frozenObject = Object.freeze({}); + /* @__PURE__ */ new Map([ + [ + frozenObject, + null + ] + ]); + /* @__PURE__ */ new Set([ + frozenObject + ]); + } catch (e) {} + } + var createElement$1 = createElementWithValidation; + var cloneElement$1 = cloneElementWithValidation; + var createFactory = createFactoryWithValidation; + var Children = { + map: mapChildren, + forEach: forEachChildren, + count: countChildren, + toArray: toArray, + only: onlyChild + }; + exports.Children = Children; + exports.Component = Component; + exports.PureComponent = PureComponent; + exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals; + exports.cloneElement = cloneElement$1; + exports.createContext = createContext; + exports.createElement = createElement$1; + exports.createFactory = createFactory; + exports.createRef = createRef; + exports.forwardRef = forwardRef; + exports.isValidElement = isValidElement; + exports.lazy = lazy; + exports.memo = memo; + exports.useCallback = useCallback; + exports.useContext = useContext5; + exports.useDebugValue = useDebugValue2; + exports.useEffect = useEffect3; + exports.useImperativeHandle = useImperativeHandle; + exports.useLayoutEffect = useLayoutEffect2; + exports.useMemo = useMemo4; + exports.useReducer = useReducer3; + exports.useRef = useRef3; + exports.useState = useState; + exports.version = ReactVersion; + })(); + } + } +}); +// node_modules/react/index.js +var require_react = __commonJS({ + "node_modules/react/index.js": function(exports, module2) { + "use strict"; + if (false) { + module2.exports = null; + } else { + module2.exports = require_react_development(); + } + } +}); +// node_modules/react-is/cjs/react-is.development.js +var require_react_is_development = __commonJS({ + "node_modules/react-is/cjs/react-is.development.js": function(exports) { + "use strict"; + if (true) { + (function() { + "use strict"; + var isValidElementType2 = function isValidElementType2(type) { + return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. + type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE); + }; + var typeOf = function typeOf(object) { + if (typeof object === "object" && object !== null) { + var $$typeof = object.$$typeof; + switch($$typeof){ + case REACT_ELEMENT_TYPE: + var type = object.type; + switch(type){ + case REACT_ASYNC_MODE_TYPE: + case REACT_CONCURRENT_MODE_TYPE: + case REACT_FRAGMENT_TYPE: + case REACT_PROFILER_TYPE: + case REACT_STRICT_MODE_TYPE: + case REACT_SUSPENSE_TYPE: + return type; + default: + var $$typeofType = type && type.$$typeof; + switch($$typeofType){ + case REACT_CONTEXT_TYPE: + case REACT_FORWARD_REF_TYPE: + case REACT_LAZY_TYPE: + case REACT_MEMO_TYPE: + case REACT_PROVIDER_TYPE: + return $$typeofType; + default: + return $$typeof; + } + } + case REACT_PORTAL_TYPE: + return $$typeof; + } + } + return void 0; + }; + var isAsyncMode = function isAsyncMode(object) { + { + if (!hasWarnedAboutDeprecatedIsAsyncMode) { + hasWarnedAboutDeprecatedIsAsyncMode = true; + console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API."); + } + } + return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE; + }; + var isConcurrentMode = function isConcurrentMode(object) { + return typeOf(object) === REACT_CONCURRENT_MODE_TYPE; + }; + var isContextConsumer2 = function isContextConsumer2(object) { + return typeOf(object) === REACT_CONTEXT_TYPE; + }; + var isContextProvider = function isContextProvider(object) { + return typeOf(object) === REACT_PROVIDER_TYPE; + }; + var isElement = function isElement(object) { + return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + }; + var isForwardRef = function isForwardRef(object) { + return typeOf(object) === REACT_FORWARD_REF_TYPE; + }; + var isFragment = function isFragment(object) { + return typeOf(object) === REACT_FRAGMENT_TYPE; + }; + var isLazy = function isLazy(object) { + return typeOf(object) === REACT_LAZY_TYPE; + }; + var isMemo = function isMemo(object) { + return typeOf(object) === REACT_MEMO_TYPE; + }; + var isPortal = function isPortal(object) { + return typeOf(object) === REACT_PORTAL_TYPE; + }; + var isProfiler = function isProfiler(object) { + return typeOf(object) === REACT_PROFILER_TYPE; + }; + var isStrictMode = function isStrictMode(object) { + return typeOf(object) === REACT_STRICT_MODE_TYPE; + }; + var isSuspense = function isSuspense(object) { + return typeOf(object) === REACT_SUSPENSE_TYPE; + }; + var hasSymbol = typeof Symbol === "function" && Symbol.for; + var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103; + var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106; + var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107; + var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108; + var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114; + var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109; + var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110; + var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111; + var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111; + var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112; + var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113; + var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120; + var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115; + var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116; + var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121; + var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117; + var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118; + var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119; + var AsyncMode = REACT_ASYNC_MODE_TYPE; + var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE; + var ContextConsumer = REACT_CONTEXT_TYPE; + var ContextProvider = REACT_PROVIDER_TYPE; + var Element = REACT_ELEMENT_TYPE; + var ForwardRef = REACT_FORWARD_REF_TYPE; + var Fragment = REACT_FRAGMENT_TYPE; + var Lazy = REACT_LAZY_TYPE; + var Memo = REACT_MEMO_TYPE; + var Portal = REACT_PORTAL_TYPE; + var Profiler = REACT_PROFILER_TYPE; + var StrictMode = REACT_STRICT_MODE_TYPE; + var Suspense = REACT_SUSPENSE_TYPE; + var hasWarnedAboutDeprecatedIsAsyncMode = false; + exports.AsyncMode = AsyncMode; + exports.ConcurrentMode = ConcurrentMode; + exports.ContextConsumer = ContextConsumer; + exports.ContextProvider = ContextProvider; + exports.Element = Element; + exports.ForwardRef = ForwardRef; + exports.Fragment = Fragment; + exports.Lazy = Lazy; + exports.Memo = Memo; + exports.Portal = Portal; + exports.Profiler = Profiler; + exports.StrictMode = StrictMode; + exports.Suspense = Suspense; + exports.isAsyncMode = isAsyncMode; + exports.isConcurrentMode = isConcurrentMode; + exports.isContextConsumer = isContextConsumer2; + exports.isContextProvider = isContextProvider; + exports.isElement = isElement; + exports.isForwardRef = isForwardRef; + exports.isFragment = isFragment; + exports.isLazy = isLazy; + exports.isMemo = isMemo; + exports.isPortal = isPortal; + exports.isProfiler = isProfiler; + exports.isStrictMode = isStrictMode; + exports.isSuspense = isSuspense; + exports.isValidElementType = isValidElementType2; + exports.typeOf = typeOf; + })(); + } + } +}); +// node_modules/react-is/index.js +var require_react_is = __commonJS({ + "node_modules/react-is/index.js": function(exports, module2) { + "use strict"; + if (false) { + module2.exports = null; + } else { + module2.exports = require_react_is_development(); + } + } +}); +// node_modules/prop-types/lib/ReactPropTypesSecret.js +var require_ReactPropTypesSecret = __commonJS({ + "node_modules/prop-types/lib/ReactPropTypesSecret.js": function(exports, module2) { + "use strict"; + var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"; + module2.exports = ReactPropTypesSecret; + } +}); +// node_modules/prop-types/checkPropTypes.js +var require_checkPropTypes = __commonJS({ + "node_modules/prop-types/checkPropTypes.js": function(exports, module2) { + "use strict"; + var checkPropTypes = function checkPropTypes(typeSpecs, values, location, componentName, getStack) { + if (true) { + for(var typeSpecName in typeSpecs){ + if (has(typeSpecs, typeSpecName)) { + var error; + try { + if (typeof typeSpecs[typeSpecName] !== "function") { + var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + _type_of(typeSpecs[typeSpecName]) + "`."); + err.name = "Invariant Violation"; + throw err; + } + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); + } catch (ex) { + error = ex; + } + if (error && !_instanceof(error, Error)) { + printWarning((componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + (typeof error === "undefined" ? "undefined" : _type_of(error)) + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."); + } + if (_instanceof(error, Error) && !(error.message in loggedTypeFailures)) { + loggedTypeFailures[error.message] = true; + var stack = getStack ? getStack() : ""; + printWarning("Failed " + location + " type: " + error.message + (stack != null ? stack : "")); + } + } + } + } + }; + var printWarning = function printWarning() {}; + if (true) { + ReactPropTypesSecret = require_ReactPropTypesSecret(); + loggedTypeFailures = {}; + has = Function.call.bind(Object.prototype.hasOwnProperty); + printWarning = function printWarning(text) { + var message = "Warning: " + text; + if (typeof console !== "undefined") { + console.error(message); + } + try { + throw new Error(message); + } catch (x) {} + }; + } + var ReactPropTypesSecret; + var loggedTypeFailures; + var has; + checkPropTypes.resetWarningCache = function() { + if (true) { + loggedTypeFailures = {}; + } + }; + module2.exports = checkPropTypes; + } +}); +// node_modules/prop-types/factoryWithTypeCheckers.js +var require_factoryWithTypeCheckers = __commonJS({ + "node_modules/prop-types/factoryWithTypeCheckers.js": function(exports, module2) { + "use strict"; + var emptyFunctionThatReturnsNull = function emptyFunctionThatReturnsNull() { + return null; + }; + var ReactIs = require_react_is(); + var assign = require_object_assign2(); + var ReactPropTypesSecret = require_ReactPropTypesSecret(); + var checkPropTypes = require_checkPropTypes(); + var has = Function.call.bind(Object.prototype.hasOwnProperty); + var printWarning = function printWarning() {}; + if (true) { + printWarning = function printWarning(text) { + var message = "Warning: " + text; + if (typeof console !== "undefined") { + console.error(message); + } + try { + throw new Error(message); + } catch (x) {} + }; + } + module2.exports = function(isValidElement, throwOnDirectAccess) { + var getIteratorFn = function getIteratorFn(maybeIterable) { + var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]); + if (typeof iteratorFn === "function") { + return iteratorFn; + } + }; + var is2 = function is2(x, y) { + if (x === y) { + return x !== 0 || 1 / x === 1 / y; + } else { + return x !== x && y !== y; + } + }; + var PropTypeError = function PropTypeError(message) { + this.message = message; + this.stack = ""; + }; + var createChainableTypeChecker = function createChainableTypeChecker(validate) { + if (true) { + var manualPropTypeCallCache = {}; + var manualPropTypeWarningCount = 0; + } + function checkType(isRequired, props, propName, componentName, location, propFullName, secret) { + componentName = componentName || ANONYMOUS; + propFullName = propFullName || propName; + if (secret !== ReactPropTypesSecret) { + if (throwOnDirectAccess) { + var err = new Error("Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"); + err.name = "Invariant Violation"; + throw err; + } else if (typeof console !== "undefined") { + var cacheKey = componentName + ":" + propName; + if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors + manualPropTypeWarningCount < 3) { + printWarning("You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."); + manualPropTypeCallCache[cacheKey] = true; + manualPropTypeWarningCount++; + } + } + } + if (props[propName] == null) { + if (isRequired) { + if (props[propName] === null) { + return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`.")); + } + return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`.")); + } + return null; + } else { + return validate(props, propName, componentName, location, propFullName); + } + } + var chainedCheckType = checkType.bind(null, false); + chainedCheckType.isRequired = checkType.bind(null, true); + return chainedCheckType; + }; + var createPrimitiveTypeChecker = function createPrimitiveTypeChecker(expectedType) { + function validate(props, propName, componentName, location, propFullName, secret) { + var propValue = props[propName]; + var propType = getPropType(propValue); + if (propType !== expectedType) { + var preciseType = getPreciseType(propValue); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`.")); + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createAnyTypeChecker = function createAnyTypeChecker() { + return createChainableTypeChecker(emptyFunctionThatReturnsNull); + }; + var createArrayOfTypeChecker = function createArrayOfTypeChecker(typeChecker) { + function validate(props, propName, componentName, location, propFullName) { + if (typeof typeChecker !== "function") { + return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf."); + } + var propValue = props[propName]; + if (!Array.isArray(propValue)) { + var propType = getPropType(propValue); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array.")); + } + for(var i = 0; i < propValue.length; i++){ + var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret); + if (_instanceof(error, Error)) { + return error; + } + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createElementTypeChecker = function createElementTypeChecker() { + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName]; + if (!isValidElement(propValue)) { + var propType = getPropType(propValue); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement.")); + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createElementTypeTypeChecker = function createElementTypeTypeChecker() { + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName]; + if (!ReactIs.isValidElementType(propValue)) { + var propType = getPropType(propValue); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type.")); + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createInstanceTypeChecker = function createInstanceTypeChecker(expectedClass) { + function validate(props, propName, componentName, location, propFullName) { + if (!_instanceof(props[propName], expectedClass)) { + var expectedClassName = expectedClass.name || ANONYMOUS; + var actualClassName = getClassName(props[propName]); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`.")); + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createEnumTypeChecker = function createEnumTypeChecker(expectedValues) { + if (!Array.isArray(expectedValues)) { + if (true) { + if (arguments.length > 1) { + printWarning("Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."); + } else { + printWarning("Invalid argument supplied to oneOf, expected an array."); + } + } + return emptyFunctionThatReturnsNull; + } + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName]; + for(var i = 0; i < expectedValues.length; i++){ + if (is2(propValue, expectedValues[i])) { + return null; + } + } + var valuesString = JSON.stringify(expectedValues, function replacer(key, value) { + var type = getPreciseType(value); + if (type === "symbol") { + return String(value); + } + return value; + }); + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + ".")); + } + return createChainableTypeChecker(validate); + }; + var createObjectOfTypeChecker = function createObjectOfTypeChecker(typeChecker) { + function validate(props, propName, componentName, location, propFullName) { + if (typeof typeChecker !== "function") { + return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf."); + } + var propValue = props[propName]; + var propType = getPropType(propValue); + if (propType !== "object") { + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object.")); + } + for(var key in propValue){ + if (has(propValue, key)) { + var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret); + if (_instanceof(error, Error)) { + return error; + } + } + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createUnionTypeChecker = function createUnionTypeChecker(arrayOfTypeCheckers) { + if (!Array.isArray(arrayOfTypeCheckers)) { + true ? printWarning("Invalid argument supplied to oneOfType, expected an instance of array.") : void 0; + return emptyFunctionThatReturnsNull; + } + for(var i = 0; i < arrayOfTypeCheckers.length; i++){ + var checker = arrayOfTypeCheckers[i]; + if (typeof checker !== "function") { + printWarning("Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."); + return emptyFunctionThatReturnsNull; + } + } + function validate(props, propName, componentName, location, propFullName) { + for(var i2 = 0; i2 < arrayOfTypeCheckers.length; i2++){ + var checker2 = arrayOfTypeCheckers[i2]; + if (checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) { + return null; + } + } + return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`.")); + } + return createChainableTypeChecker(validate); + }; + var createNodeChecker = function createNodeChecker() { + function validate(props, propName, componentName, location, propFullName) { + if (!isNode(props[propName])) { + return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode.")); + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createShapeTypeChecker = function createShapeTypeChecker(shapeTypes) { + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName]; + var propType = getPropType(propValue); + if (propType !== "object") { + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`.")); + } + for(var key in shapeTypes){ + var checker = shapeTypes[key]; + if (!checker) { + continue; + } + var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret); + if (error) { + return error; + } + } + return null; + } + return createChainableTypeChecker(validate); + }; + var createStrictShapeTypeChecker = function createStrictShapeTypeChecker(shapeTypes) { + function validate(props, propName, componentName, location, propFullName) { + var propValue = props[propName]; + var propType = getPropType(propValue); + if (propType !== "object") { + return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`.")); + } + var allKeys = assign({}, props[propName], shapeTypes); + for(var key in allKeys){ + var checker = shapeTypes[key]; + if (!checker) { + return new PropTypeError("Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, " ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, " ")); + } + var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret); + if (error) { + return error; + } + } + return null; + } + return createChainableTypeChecker(validate); + }; + var isSymbol = function isSymbol(propType, propValue) { + if (propType === "symbol") { + return true; + } + if (!propValue) { + return false; + } + if (propValue["@@toStringTag"] === "Symbol") { + return true; + } + if (typeof Symbol === "function" && _instanceof(propValue, Symbol)) { + return true; + } + return false; + }; + var getPropType = function getPropType(propValue) { + var propType = typeof propValue === "undefined" ? "undefined" : _type_of(propValue); + if (Array.isArray(propValue)) { + return "array"; + } + if (_instanceof(propValue, RegExp)) { + return "object"; + } + if (isSymbol(propType, propValue)) { + return "symbol"; + } + return propType; + }; + var getPreciseType = function getPreciseType(propValue) { + if (typeof propValue === "undefined" || propValue === null) { + return "" + propValue; + } + var propType = getPropType(propValue); + if (propType === "object") { + if (_instanceof(propValue, Date)) { + return "date"; + } else if (_instanceof(propValue, RegExp)) { + return "regexp"; + } + } + return propType; + }; + var getPostfixForTypeWarning = function getPostfixForTypeWarning(value) { + var type = getPreciseType(value); + switch(type){ + case "array": + case "object": + return "an " + type; + case "boolean": + case "date": + case "regexp": + return "a " + type; + default: + return type; + } + }; + var getClassName = function getClassName(propValue) { + if (!propValue.constructor || !propValue.constructor.name) { + return ANONYMOUS; + } + return propValue.constructor.name; + }; + var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = "@@iterator"; + var ANONYMOUS = "<>"; + var ReactPropTypes = { + array: createPrimitiveTypeChecker("array"), + bool: createPrimitiveTypeChecker("boolean"), + func: createPrimitiveTypeChecker("function"), + number: createPrimitiveTypeChecker("number"), + object: createPrimitiveTypeChecker("object"), + string: createPrimitiveTypeChecker("string"), + symbol: createPrimitiveTypeChecker("symbol"), + any: createAnyTypeChecker(), + arrayOf: createArrayOfTypeChecker, + element: createElementTypeChecker(), + elementType: createElementTypeTypeChecker(), + instanceOf: createInstanceTypeChecker, + node: createNodeChecker(), + objectOf: createObjectOfTypeChecker, + oneOf: createEnumTypeChecker, + oneOfType: createUnionTypeChecker, + shape: createShapeTypeChecker, + exact: createStrictShapeTypeChecker + }; + PropTypeError.prototype = Error.prototype; + function isNode(propValue) { + switch(typeof propValue === "undefined" ? "undefined" : _type_of(propValue)){ + case "number": + case "string": + case "undefined": + return true; + case "boolean": + return !propValue; + case "object": + if (Array.isArray(propValue)) { + return propValue.every(isNode); + } + if (propValue === null || isValidElement(propValue)) { + return true; + } + var iteratorFn = getIteratorFn(propValue); + if (iteratorFn) { + var iterator = iteratorFn.call(propValue); + var step; + if (iteratorFn !== propValue.entries) { + while(!(step = iterator.next()).done){ + if (!isNode(step.value)) { + return false; + } + } + } else { + while(!(step = iterator.next()).done){ + var entry = step.value; + if (entry) { + if (!isNode(entry[1])) { + return false; + } + } + } + } + } else { + return false; + } + return true; + default: + return false; + } + } + ReactPropTypes.checkPropTypes = checkPropTypes; + ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache; + ReactPropTypes.PropTypes = ReactPropTypes; + return ReactPropTypes; + }; + } +}); +// node_modules/prop-types/index.js +var require_prop_types = __commonJS({ + "node_modules/prop-types/index.js": function(exports, module2) { + if (true) { + ReactIs = require_react_is(); + throwOnDirectAccess = true; + module2.exports = require_factoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess); + } else { + module2.exports = (null)(); + } + var ReactIs; + var throwOnDirectAccess; + } +}); +// node_modules/create-react-class/factory.js +var require_factory = __commonJS({ + "node_modules/create-react-class/factory.js": function(exports, module2) { + "use strict"; + var _invariant = function _invariant(condition, format, a, b, c, d, e, f) { + validateFormat(format); + if (!condition) { + var error; + if (format === void 0) { + error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."); + } else { + var args = [ + a, + b, + c, + d, + e, + f + ]; + var argIndex = 0; + error = new Error(format.replace(/%s/g, function() { + return args[argIndex++]; + })); + error.name = "Invariant Violation"; + } + error.framesToPop = 1; + throw error; + } + }; + var identity = function identity(fn) { + return fn; + }; + var factory = function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) { + var injectedMixins = []; + var ReactClassInterface = { + /** + * An array of Mixin objects to include when defining your component. + * + * @type {array} + * @optional + */ mixins: "DEFINE_MANY", + /** + * An object containing properties and methods that should be defined on + * the component's constructor instead of its prototype (static methods). + * + * @type {object} + * @optional + */ statics: "DEFINE_MANY", + /** + * Definition of prop types for this component. + * + * @type {object} + * @optional + */ propTypes: "DEFINE_MANY", + /** + * Definition of context types for this component. + * + * @type {object} + * @optional + */ contextTypes: "DEFINE_MANY", + /** + * Definition of context types this component sets for its children. + * + * @type {object} + * @optional + */ childContextTypes: "DEFINE_MANY", + // ==== Definition methods ==== + /** + * Invoked when the component is mounted. Values in the mapping will be set on + * `this.props` if that prop is not specified (i.e. using an `in` check). + * + * This method is invoked before `getInitialState` and therefore cannot rely + * on `this.state` or use `this.setState`. + * + * @return {object} + * @optional + */ getDefaultProps: "DEFINE_MANY_MERGED", + /** + * Invoked once before the component is mounted. The return value will be used + * as the initial value of `this.state`. + * + * getInitialState: function() { + * return { + * isOn: false, + * fooBaz: new BazFoo() + * } + * } + * + * @return {object} + * @optional + */ getInitialState: "DEFINE_MANY_MERGED", + /** + * @return {object} + * @optional + */ getChildContext: "DEFINE_MANY_MERGED", + /** + * Uses props from `this.props` and state from `this.state` to render the + * structure of the component. + * + * No guarantees are made about when or how often this method is invoked, so + * it must not have side effects. + * + * render: function() { + * var name = this.props.name; + * return
Hello, {name}!
; + * } + * + * @return {ReactComponent} + * @required + */ render: "DEFINE_ONCE", + // ==== Delegate methods ==== + /** + * Invoked when the component is initially created and about to be mounted. + * This may have side effects, but any external subscriptions or data created + * by this method must be cleaned up in `componentWillUnmount`. + * + * @optional + */ componentWillMount: "DEFINE_MANY", + /** + * Invoked when the component has been mounted and has a DOM representation. + * However, there is no guarantee that the DOM node is in the document. + * + * Use this as an opportunity to operate on the DOM when the component has + * been mounted (initialized and rendered) for the first time. + * + * @param {DOMElement} rootNode DOM element representing the component. + * @optional + */ componentDidMount: "DEFINE_MANY", + /** + * Invoked before the component receives new props. + * + * Use this as an opportunity to react to a prop transition by updating the + * state using `this.setState`. Current props are accessed via `this.props`. + * + * componentWillReceiveProps: function(nextProps, nextContext) { + * this.setState({ + * likesIncreasing: nextProps.likeCount > this.props.likeCount + * }); + * } + * + * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop + * transition may cause a state change, but the opposite is not true. If you + * need it, you are probably looking for `componentWillUpdate`. + * + * @param {object} nextProps + * @optional + */ componentWillReceiveProps: "DEFINE_MANY", + /** + * Invoked while deciding if the component should be updated as a result of + * receiving new props, state and/or context. + * + * Use this as an opportunity to `return false` when you're certain that the + * transition to the new props/state/context will not require a component + * update. + * + * shouldComponentUpdate: function(nextProps, nextState, nextContext) { + * return !equal(nextProps, this.props) || + * !equal(nextState, this.state) || + * !equal(nextContext, this.context); + * } + * + * @param {object} nextProps + * @param {?object} nextState + * @param {?object} nextContext + * @return {boolean} True if the component should update. + * @optional + */ shouldComponentUpdate: "DEFINE_ONCE", + /** + * Invoked when the component is about to update due to a transition from + * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState` + * and `nextContext`. + * + * Use this as an opportunity to perform preparation before an update occurs. + * + * NOTE: You **cannot** use `this.setState()` in this method. + * + * @param {object} nextProps + * @param {?object} nextState + * @param {?object} nextContext + * @param {ReactReconcileTransaction} transaction + * @optional + */ componentWillUpdate: "DEFINE_MANY", + /** + * Invoked when the component's DOM representation has been updated. + * + * Use this as an opportunity to operate on the DOM when the component has + * been updated. + * + * @param {object} prevProps + * @param {?object} prevState + * @param {?object} prevContext + * @param {DOMElement} rootNode DOM element representing the component. + * @optional + */ componentDidUpdate: "DEFINE_MANY", + /** + * Invoked when the component is about to be removed from its parent and have + * its DOM representation destroyed. + * + * Use this as an opportunity to deallocate any external resources. + * + * NOTE: There is no `componentDidUnmount` since your component will have been + * destroyed by that point. + * + * @optional + */ componentWillUnmount: "DEFINE_MANY", + /** + * Replacement for (deprecated) `componentWillMount`. + * + * @optional + */ UNSAFE_componentWillMount: "DEFINE_MANY", + /** + * Replacement for (deprecated) `componentWillReceiveProps`. + * + * @optional + */ UNSAFE_componentWillReceiveProps: "DEFINE_MANY", + /** + * Replacement for (deprecated) `componentWillUpdate`. + * + * @optional + */ UNSAFE_componentWillUpdate: "DEFINE_MANY", + // ==== Advanced methods ==== + /** + * Updates the component's currently mounted DOM representation. + * + * By default, this implements React's rendering and reconciliation algorithm. + * Sophisticated clients may wish to override this. + * + * @param {ReactReconcileTransaction} transaction + * @internal + * @overridable + */ updateComponent: "OVERRIDE_BASE" + }; + var ReactClassStaticInterface = { + /** + * This method is invoked after a component is instantiated and when it + * receives new props. Return an object to update state in response to + * prop changes. Return null to indicate no change to state. + * + * If an object is returned, its keys will be merged into the existing state. + * + * @return {object || null} + * @optional + */ getDerivedStateFromProps: "DEFINE_MANY_MERGED" + }; + var RESERVED_SPEC_KEYS = { + displayName: function displayName(Constructor, displayName) { + Constructor.displayName = displayName; + }, + mixins: function mixins(Constructor, mixins) { + if (mixins) { + for(var i = 0; i < mixins.length; i++){ + mixSpecIntoComponent(Constructor, mixins[i]); + } + } + }, + childContextTypes: function childContextTypes(Constructor, childContextTypes) { + if (true) { + validateTypeDef(Constructor, childContextTypes, "childContext"); + } + Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes); + }, + contextTypes: function contextTypes(Constructor, contextTypes) { + if (true) { + validateTypeDef(Constructor, contextTypes, "context"); + } + Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes); + }, + /** + * Special case getDefaultProps which should move into statics but requires + * automatic merging. + */ getDefaultProps: function getDefaultProps(Constructor, getDefaultProps) { + if (Constructor.getDefaultProps) { + Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps); + } else { + Constructor.getDefaultProps = getDefaultProps; + } + }, + propTypes: function propTypes(Constructor, propTypes) { + if (true) { + validateTypeDef(Constructor, propTypes, "prop"); + } + Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes); + }, + statics: function statics(Constructor, statics) { + mixStaticSpecIntoComponent(Constructor, statics); + }, + autobind: function autobind() {} + }; + function validateTypeDef(Constructor, typeDef, location) { + for(var propName in typeDef){ + if (typeDef.hasOwnProperty(propName)) { + if (true) { + warning3(typeof typeDef[propName] === "function", "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", Constructor.displayName || "ReactClass", ReactPropTypeLocationNames[location], propName); + } + } + } + } + function validateMethodOverride(isAlreadyDefined, name) { + var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null; + if (ReactClassMixin.hasOwnProperty(name)) { + _invariant(specPolicy === "OVERRIDE_BASE", "ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.", name); + } + if (isAlreadyDefined) { + _invariant(specPolicy === "DEFINE_MANY" || specPolicy === "DEFINE_MANY_MERGED", "ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", name); + } + } + function mixSpecIntoComponent(Constructor, spec) { + if (!spec) { + if (true) { + var typeofSpec = typeof spec === "undefined" ? "undefined" : _type_of(spec); + var isMixinValid = typeofSpec === "object" && spec !== null; + if (true) { + warning3(isMixinValid, "%s: You're attempting to include a mixin that is either null or not an object. Check the mixins included by the component, as well as any mixins they include themselves. Expected object but got %s.", Constructor.displayName || "ReactClass", spec === null ? null : typeofSpec); + } + } + return; + } + _invariant(typeof spec !== "function", "ReactClass: You're attempting to use a component class or function as a mixin. Instead, just use a regular object."); + _invariant(!isValidElement(spec), "ReactClass: You're attempting to use a component as a mixin. Instead, just use a regular object."); + var proto = Constructor.prototype; + var autoBindPairs = proto.__reactAutoBindPairs; + if (spec.hasOwnProperty(MIXINS_KEY)) { + RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins); + } + for(var name in spec){ + if (!spec.hasOwnProperty(name)) { + continue; + } + if (name === MIXINS_KEY) { + continue; + } + var property = spec[name]; + var isAlreadyDefined = proto.hasOwnProperty(name); + validateMethodOverride(isAlreadyDefined, name); + if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) { + RESERVED_SPEC_KEYS[name](Constructor, property); + } else { + var isReactClassMethod = ReactClassInterface.hasOwnProperty(name); + var isFunction = typeof property === "function"; + var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false; + if (shouldAutoBind) { + autoBindPairs.push(name, property); + proto[name] = property; + } else { + if (isAlreadyDefined) { + var specPolicy = ReactClassInterface[name]; + _invariant(isReactClassMethod && (specPolicy === "DEFINE_MANY_MERGED" || specPolicy === "DEFINE_MANY"), "ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.", specPolicy, name); + if (specPolicy === "DEFINE_MANY_MERGED") { + proto[name] = createMergedResultFunction(proto[name], property); + } else if (specPolicy === "DEFINE_MANY") { + proto[name] = createChainedFunction(proto[name], property); + } + } else { + proto[name] = property; + if (true) { + if (typeof property === "function" && spec.displayName) { + proto[name].displayName = spec.displayName + "_" + name; + } + } + } + } + } + } + } + function mixStaticSpecIntoComponent(Constructor, statics) { + if (!statics) { + return; + } + for(var name in statics){ + var property = statics[name]; + if (!statics.hasOwnProperty(name)) { + continue; + } + var isReserved = name in RESERVED_SPEC_KEYS; + _invariant(!isReserved, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', name); + var isAlreadyDefined = name in Constructor; + if (isAlreadyDefined) { + var specPolicy = ReactClassStaticInterface.hasOwnProperty(name) ? ReactClassStaticInterface[name] : null; + _invariant(specPolicy === "DEFINE_MANY_MERGED", "ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", name); + Constructor[name] = createMergedResultFunction(Constructor[name], property); + return; + } + Constructor[name] = property; + } + } + function mergeIntoWithNoDuplicateKeys(one, two) { + _invariant(one && two && typeof one === "object" && typeof two === "object", "mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects."); + for(var key in two){ + if (two.hasOwnProperty(key)) { + _invariant(one[key] === void 0, "mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.", key); + one[key] = two[key]; + } + } + return one; + } + function createMergedResultFunction(one, two) { + return function mergedResult() { + var a = one.apply(this, arguments); + var b = two.apply(this, arguments); + if (a == null) { + return b; + } else if (b == null) { + return a; + } + var c = {}; + mergeIntoWithNoDuplicateKeys(c, a); + mergeIntoWithNoDuplicateKeys(c, b); + return c; + }; + } + function createChainedFunction(one, two) { + return function chainedFunction() { + one.apply(this, arguments); + two.apply(this, arguments); + }; + } + function bindAutoBindMethod(component, method) { + var boundMethod = method.bind(component); + if (true) { + boundMethod.__reactBoundContext = component; + boundMethod.__reactBoundMethod = method; + boundMethod.__reactBoundArguments = null; + var componentName = component.constructor.displayName; + var _bind = boundMethod.bind; + boundMethod.bind = function(newThis) { + for(var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){ + args[_key - 1] = arguments[_key]; + } + if (newThis !== component && newThis !== null) { + if (true) { + warning3(false, "bind(): React component methods may only be bound to the component instance. See %s", componentName); + } + } else if (!args.length) { + if (true) { + warning3(false, "bind(): You are binding a component method to the component. React does this for you automatically in a high-performance way, so you can safely remove this call. See %s", componentName); + } + return boundMethod; + } + var reboundMethod = _bind.apply(boundMethod, arguments); + reboundMethod.__reactBoundContext = component; + reboundMethod.__reactBoundMethod = method; + reboundMethod.__reactBoundArguments = args; + return reboundMethod; + }; + } + return boundMethod; + } + function bindAutoBindMethods(component) { + var pairs = component.__reactAutoBindPairs; + for(var i = 0; i < pairs.length; i += 2){ + var autoBindKey = pairs[i]; + var method = pairs[i + 1]; + component[autoBindKey] = bindAutoBindMethod(component, method); + } + } + var IsMountedPreMixin = { + componentDidMount: function componentDidMount() { + this.__isMounted = true; + } + }; + var IsMountedPostMixin = { + componentWillUnmount: function componentWillUnmount() { + this.__isMounted = false; + } + }; + var ReactClassMixin = { + /** + * TODO: This will be deprecated because state should always keep a consistent + * type signature and the only use case for this, is to avoid that. + */ replaceState: function replaceState(newState, callback) { + this.updater.enqueueReplaceState(this, newState, callback); + }, + /** + * Checks whether or not this composite component is mounted. + * @return {boolean} True if mounted, false otherwise. + * @protected + * @final + */ isMounted: function isMounted() { + if (true) { + warning3(this.__didWarnIsMounted, "%s: isMounted is deprecated. Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks.", this.constructor && this.constructor.displayName || this.name || "Component"); + this.__didWarnIsMounted = true; + } + return !!this.__isMounted; + } + }; + var ReactClassComponent = function ReactClassComponent() {}; + _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin); + function createClass(spec) { + var Constructor = identity(function(props, context, updater) { + if (true) { + warning3(_instanceof(this, Constructor), "Something is calling a React component directly. Use a factory or JSX instead. See: https://fb.me/react-legacyfactory"); + } + if (this.__reactAutoBindPairs.length) { + bindAutoBindMethods(this); + } + this.props = props; + this.context = context; + this.refs = emptyObject; + this.updater = updater || ReactNoopUpdateQueue; + this.state = null; + var initialState = this.getInitialState ? this.getInitialState() : null; + if (true) { + if (initialState === void 0 && this.getInitialState._isMockFunction) { + initialState = null; + } + } + _invariant(typeof initialState === "object" && !Array.isArray(initialState), "%s.getInitialState(): must return an object or null", Constructor.displayName || "ReactCompositeComponent"); + this.state = initialState; + }); + Constructor.prototype = new ReactClassComponent(); + Constructor.prototype.constructor = Constructor; + Constructor.prototype.__reactAutoBindPairs = []; + injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor)); + mixSpecIntoComponent(Constructor, IsMountedPreMixin); + mixSpecIntoComponent(Constructor, spec); + mixSpecIntoComponent(Constructor, IsMountedPostMixin); + if (Constructor.getDefaultProps) { + Constructor.defaultProps = Constructor.getDefaultProps(); + } + if (true) { + if (Constructor.getDefaultProps) { + Constructor.getDefaultProps.isReactClassApproved = {}; + } + if (Constructor.prototype.getInitialState) { + Constructor.prototype.getInitialState.isReactClassApproved = {}; + } + } + _invariant(Constructor.prototype.render, "createClass(...): Class specification must implement a `render` method."); + if (true) { + warning3(!Constructor.prototype.componentShouldUpdate, "%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.", spec.displayName || "A component"); + warning3(!Constructor.prototype.componentWillRecieveProps, "%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", spec.displayName || "A component"); + warning3(!Constructor.prototype.UNSAFE_componentWillRecieveProps, "%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", spec.displayName || "A component"); + } + for(var methodName in ReactClassInterface){ + if (!Constructor.prototype[methodName]) { + Constructor.prototype[methodName] = null; + } + } + return Constructor; + } + return createClass; + }; + var _assign = require_object_assign2(); + var emptyObject = {}; + if (true) { + Object.freeze(emptyObject); + } + var validateFormat = function validateFormat2(format) {}; + if (true) { + validateFormat = function validateFormat2(format) { + if (format === void 0) { + throw new Error("invariant requires an error message argument"); + } + }; + } + var warning3 = function warning3() {}; + if (true) { + printWarning = function printWarning2(format) { + for(var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){ + args[_key - 1] = arguments[_key]; + } + var argIndex = 0; + var message = "Warning: " + format.replace(/%s/g, function() { + return args[argIndex++]; + }); + if (typeof console !== "undefined") { + console.error(message); + } + try { + throw new Error(message); + } catch (x) {} + }; + warning3 = function warning4(condition, format) { + if (format === void 0) { + throw new Error("`warning(condition, format, ...args)` requires a warning message argument"); + } + if (format.indexOf("Failed Composite propType: ") === 0) { + return; + } + if (!condition) { + for(var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++){ + args[_key2 - 2] = arguments[_key2]; + } + printWarning.apply(void 0, [ + format + ].concat(args)); + } + }; + } + var printWarning; + var MIXINS_KEY = "mixins"; + var ReactPropTypeLocationNames; + if (true) { + ReactPropTypeLocationNames = { + prop: "prop", + context: "context", + childContext: "child context" + }; + } else { + ReactPropTypeLocationNames = {}; + } + module2.exports = factory; + } +}); +// node_modules/create-react-class/index.js +var require_create_react_class = __commonJS({ + "node_modules/create-react-class/index.js": function(exports, module2) { + "use strict"; + var React6 = require_react(); + var factory = require_factory(); + if (typeof React6 === "undefined") { + throw Error("create-react-class could not find the React object. If you are using script tags, make sure that React is being loaded before create-react-class."); + } + var ReactNoopUpdateQueue = new React6.Component().updater; + module2.exports = factory(React6.Component, React6.isValidElement, ReactNoopUpdateQueue); + } +}); +// js_src/dart_env_dev.js +var require_dart_env_dev = __commonJS({ + "js_src/dart_env_dev.js": function() { + React.__isDevelopment = true; + if (typeof window.MemoryInfo == "undefined") { + if (typeof window.performance.memory != "undefined") { + window.MemoryInfo = function() {}; + window.MemoryInfo.prototype = window.performance.memory.__proto__; + } + } + var oldConsoleWarn = console.warn; + var hasWarned = false; + console.warn = function() { + var firstArg = arguments[0]; + if (typeof firstArg === "string" && firstArg.startsWith("Cannot find native JavaScript type (Synthetic")) { + if (!hasWarned) { + hasWarned = true; + oldConsoleWarn.apply(console, arguments); + oldConsoleWarn("The above warning is expected and is the result of a workaround to https://github.com/dart-lang/sdk/issues/43939"); + } + } else { + oldConsoleWarn.apply(console, arguments); + } + }; + } +}); +// js_src/react.js +var react_exports = {}; +var import_map, import_set, import_delete_property, import_assign, import_starts_with, React2, PropTypes, CreateReactClass; +var init_react = __esm({ + "js_src/react.js": function() { + import_map = __toESM(require_map()); + import_set = __toESM(require_set()); + import_delete_property = __toESM(require_delete_property2()); + import_assign = __toESM(require_assign2()); + import_starts_with = __toESM(require_starts_with2()); + init_dart_helpers(); + React2 = require_react(); + PropTypes = require_prop_types(); + CreateReactClass = require_create_react_class(); + window.React = React2; + Object.assign(window, dart_helpers_default); + React2.createClass = CreateReactClass; + React2.PropTypes = PropTypes; + if (false) {} else { + require_dart_env_dev(); + } + if (!("baseURI" in Node.prototype)) { + Object.defineProperty(Node.prototype, "baseURI", { + get: function get() { + var base = (this.ownerDocument || this).querySelector("base"); + return (base || window.location).href; + }, + configurable: true, + enumerable: true + }); + } + } +}); +// node_modules/react-redux/es/components/Context.js +var import_react, ReactReduxContext; +var init_Context = __esm({ + "node_modules/react-redux/es/components/Context.js": function() { + import_react = __toESM(require_react()); + ReactReduxContext = /* @__PURE__ */ import_react.default.createContext(null); + if (true) { + ReactReduxContext.displayName = "ReactRedux"; + } + } +}); +// node_modules/react-redux/es/utils/batch.js +function defaultNoopBatch(callback) { + callback(); +} +var batch, setBatch, getBatch; +var init_batch = __esm({ + "node_modules/react-redux/es/utils/batch.js": function() { + batch = defaultNoopBatch; + setBatch = function setBatch2(newBatch) { + return batch = newBatch; + }; + getBatch = function getBatch2() { + return batch; + }; + } +}); +// node_modules/react-redux/es/utils/Subscription.js +function createListenerCollection() { + var batch2 = getBatch(); + var first = null; + var last = null; + return { + clear: function clear() { + first = null; + last = null; + }, + notify: function notify2() { + batch2(function() { + var listener = first; + while(listener){ + listener.callback(); + listener = listener.next; + } + }); + }, + get: function get() { + var listeners = []; + var listener = first; + while(listener){ + listeners.push(listener); + listener = listener.next; + } + return listeners; + }, + subscribe: function subscribe(callback) { + var isSubscribed = true; + var listener = last = { + callback: callback, + next: null, + prev: last + }; + if (listener.prev) { + listener.prev.next = listener; + } else { + first = listener; + } + return function unsubscribe() { + if (!isSubscribed || first === null) return; + isSubscribed = false; + if (listener.next) { + listener.next.prev = listener.prev; + } else { + last = listener.prev; + } + if (listener.prev) { + listener.prev.next = listener.next; + } else { + first = listener.next; + } + }; + } + }; +} +var nullListeners, Subscription; +var init_Subscription = __esm({ + "node_modules/react-redux/es/utils/Subscription.js": function() { + init_batch(); + nullListeners = { + notify: function notify() {} + }; + Subscription = /* @__PURE__ */ function() { + var Subscription2 = function Subscription2(store, parentSub) { + this.store = store; + this.parentSub = parentSub; + this.unsubscribe = null; + this.listeners = nullListeners; + this.handleChangeWrapper = this.handleChangeWrapper.bind(this); + }; + var _proto = Subscription2.prototype; + _proto.addNestedSub = function addNestedSub(listener) { + this.trySubscribe(); + return this.listeners.subscribe(listener); + }; + _proto.notifyNestedSubs = function notifyNestedSubs() { + this.listeners.notify(); + }; + _proto.handleChangeWrapper = function handleChangeWrapper() { + if (this.onStateChange) { + this.onStateChange(); + } + }; + _proto.isSubscribed = function isSubscribed() { + return Boolean(this.unsubscribe); + }; + _proto.trySubscribe = function trySubscribe() { + if (!this.unsubscribe) { + this.unsubscribe = this.parentSub ? this.parentSub.addNestedSub(this.handleChangeWrapper) : this.store.subscribe(this.handleChangeWrapper); + this.listeners = createListenerCollection(); + } + }; + _proto.tryUnsubscribe = function tryUnsubscribe() { + if (this.unsubscribe) { + this.unsubscribe(); + this.unsubscribe = null; + this.listeners.clear(); + this.listeners = nullListeners; + } + }; + return Subscription2; + }(); + } +}); +// node_modules/react-redux/es/components/Provider.js +function Provider(_ref) { + var store = _ref.store, context = _ref.context, children = _ref.children; + var contextValue = (0, import_react2.useMemo)(function() { + var subscription = new Subscription(store); + subscription.onStateChange = subscription.notifyNestedSubs; + return { + store: store, + subscription: subscription + }; + }, [ + store + ]); + var previousState = (0, import_react2.useMemo)(function() { + return store.getState(); + }, [ + store + ]); + (0, import_react2.useEffect)(function() { + var subscription = contextValue.subscription; + subscription.trySubscribe(); + if (previousState !== store.getState()) { + subscription.notifyNestedSubs(); + } + return function() { + subscription.tryUnsubscribe(); + subscription.onStateChange = null; + }; + }, [ + contextValue, + previousState + ]); + var Context = context || ReactReduxContext; + return /* @__PURE__ */ import_react2.default.createElement(Context.Provider, { + value: contextValue + }, children); +} +var import_react2, import_prop_types, Provider_default; +var init_Provider = __esm({ + "node_modules/react-redux/es/components/Provider.js": function() { + import_react2 = __toESM(require_react()); + import_prop_types = __toESM(require_prop_types()); + init_Context(); + init_Subscription(); + if (true) { + Provider.propTypes = { + store: import_prop_types.default.shape({ + subscribe: import_prop_types.default.func.isRequired, + dispatch: import_prop_types.default.func.isRequired, + getState: import_prop_types.default.func.isRequired + }), + context: import_prop_types.default.object, + children: import_prop_types.default.any + }; + } + Provider_default = Provider; + } +}); +// node_modules/@babel/runtime/helpers/esm/extends.js +function _extends() { + _extends = Object.assign || function(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i]; + for(var key in source){ + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); +} +var init_extends = __esm({ + "node_modules/@babel/runtime/helpers/esm/extends.js": function() {} +}); +// node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + for(i = 0; i < sourceKeys.length; i++){ + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + return target; +} +var init_objectWithoutPropertiesLoose = __esm({ + "node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js": function() {} +}); +// node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js +var require_hoist_non_react_statics_cjs = __commonJS({ + "node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js": function(exports, module2) { + "use strict"; + var getStatics = function getStatics(component) { + if (reactIs.isMemo(component)) { + return MEMO_STATICS; + } + return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS; + }; + var reactIs = require_react_is(); + var REACT_STATICS = { + childContextTypes: true, + contextType: true, + contextTypes: true, + defaultProps: true, + displayName: true, + getDefaultProps: true, + getDerivedStateFromError: true, + getDerivedStateFromProps: true, + mixins: true, + propTypes: true, + type: true + }; + var KNOWN_STATICS = { + name: true, + length: true, + prototype: true, + caller: true, + callee: true, + arguments: true, + arity: true + }; + var FORWARD_REF_STATICS = { + "$$typeof": true, + render: true, + defaultProps: true, + displayName: true, + propTypes: true + }; + var MEMO_STATICS = { + "$$typeof": true, + compare: true, + defaultProps: true, + displayName: true, + propTypes: true, + type: true + }; + var TYPE_STATICS = {}; + TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS; + TYPE_STATICS[reactIs.Memo] = MEMO_STATICS; + var defineProperty = Object.defineProperty; + var getOwnPropertyNames = Object.getOwnPropertyNames; + var getOwnPropertySymbols = Object.getOwnPropertySymbols; + var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var getPrototypeOf = Object.getPrototypeOf; + var objectPrototype = Object.prototype; + function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) { + if (typeof sourceComponent !== "string") { + if (objectPrototype) { + var inheritedComponent = getPrototypeOf(sourceComponent); + if (inheritedComponent && inheritedComponent !== objectPrototype) { + hoistNonReactStatics(targetComponent, inheritedComponent, blacklist); + } + } + var keys = getOwnPropertyNames(sourceComponent); + if (getOwnPropertySymbols) { + keys = keys.concat(getOwnPropertySymbols(sourceComponent)); + } + var targetStatics = getStatics(targetComponent); + var sourceStatics = getStatics(sourceComponent); + for(var i = 0; i < keys.length; ++i){ + var key = keys[i]; + if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) { + var descriptor = getOwnPropertyDescriptor(sourceComponent, key); + try { + defineProperty(targetComponent, key, descriptor); + } catch (e) {} + } + } + } + return targetComponent; + } + module2.exports = hoistNonReactStatics; + } +}); +// node_modules/react-redux/es/utils/useIsomorphicLayoutEffect.js +var import_react3, useIsomorphicLayoutEffect; +var init_useIsomorphicLayoutEffect = __esm({ + "node_modules/react-redux/es/utils/useIsomorphicLayoutEffect.js": function() { + import_react3 = __toESM(require_react()); + useIsomorphicLayoutEffect = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined" ? import_react3.useLayoutEffect : import_react3.useEffect; + } +}); +// node_modules/react-redux/es/components/connectAdvanced.js +function storeStateUpdatesReducer(state, action) { + var updateCount = state[1]; + return [ + action.payload, + updateCount + 1 + ]; +} +function useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) { + useIsomorphicLayoutEffect(function() { + return effectFunc.apply(void 0, effectArgs); + }, dependencies); +} +function captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, actualChildProps, childPropsFromStoreUpdate, notifyNestedSubs) { + lastWrapperProps.current = wrapperProps; + lastChildProps.current = actualChildProps; + renderIsScheduled.current = false; + if (childPropsFromStoreUpdate.current) { + childPropsFromStoreUpdate.current = null; + notifyNestedSubs(); + } +} +function subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, childPropsFromStoreUpdate, notifyNestedSubs, forceComponentUpdateDispatch) { + if (!shouldHandleStateChanges) return; + var didUnsubscribe = false; + var lastThrownError = null; + var checkForUpdates = function checkForUpdates2() { + if (didUnsubscribe) { + return; + } + var latestStoreState = store.getState(); + var newChildProps, error; + try { + newChildProps = childPropsSelector(latestStoreState, lastWrapperProps.current); + } catch (e) { + error = e; + lastThrownError = e; + } + if (!error) { + lastThrownError = null; + } + if (newChildProps === lastChildProps.current) { + if (!renderIsScheduled.current) { + notifyNestedSubs(); + } + } else { + lastChildProps.current = newChildProps; + childPropsFromStoreUpdate.current = newChildProps; + renderIsScheduled.current = true; + forceComponentUpdateDispatch({ + type: "STORE_UPDATED", + payload: { + error: error + } + }); + } + }; + subscription.onStateChange = checkForUpdates; + subscription.trySubscribe(); + checkForUpdates(); + var unsubscribeWrapper = function unsubscribeWrapper2() { + didUnsubscribe = true; + subscription.tryUnsubscribe(); + subscription.onStateChange = null; + if (lastThrownError) { + throw lastThrownError; + } + }; + return unsubscribeWrapper; +} +function connectAdvanced(selectorFactory, _ref) { + if (_ref === void 0) { + _ref = {}; + } + var _ref2 = _ref, _ref2$getDisplayName = _ref2.getDisplayName, getDisplayName = _ref2$getDisplayName === void 0 ? function getDisplayName(name) { + return "ConnectAdvanced(" + name + ")"; + } : _ref2$getDisplayName, _ref2$methodName = _ref2.methodName, methodName = _ref2$methodName === void 0 ? "connectAdvanced" : _ref2$methodName, _ref2$renderCountProp = _ref2.renderCountProp, renderCountProp = _ref2$renderCountProp === void 0 ? void 0 : _ref2$renderCountProp, _ref2$shouldHandleSta = _ref2.shouldHandleStateChanges, shouldHandleStateChanges = _ref2$shouldHandleSta === void 0 ? true : _ref2$shouldHandleSta, _ref2$storeKey = _ref2.storeKey, storeKey = _ref2$storeKey === void 0 ? "store" : _ref2$storeKey, _ref2$withRef = _ref2.withRef, withRef = _ref2$withRef === void 0 ? false : _ref2$withRef, _ref2$forwardRef = _ref2.forwardRef, forwardRef = _ref2$forwardRef === void 0 ? false : _ref2$forwardRef, _ref2$context = _ref2.context, context = _ref2$context === void 0 ? ReactReduxContext : _ref2$context, connectOptions = _objectWithoutPropertiesLoose(_ref2, [ + "getDisplayName", + "methodName", + "renderCountProp", + "shouldHandleStateChanges", + "storeKey", + "withRef", + "forwardRef", + "context" + ]); + if (true) { + if (renderCountProp !== void 0) { + throw new Error("renderCountProp is removed. render counting is built into the latest React Dev Tools profiling extension"); + } + if (withRef) { + throw new Error("withRef is removed. To access the wrapped instance, use a ref on the connected component"); + } + var customStoreWarningMessage = "To use a custom Redux store for specific components, create a custom React context with React.createContext(), and pass the context object to React Redux's Provider and specific components like: . You may also pass a {context : MyContext} option to connect"; + if (storeKey !== "store") { + throw new Error("storeKey has been removed and does not do anything. " + customStoreWarningMessage); + } + } + var Context = context; + return function wrapWithConnect(WrappedComponent) { + var createChildSelector = function createChildSelector(store) { + return selectorFactory(store.dispatch, selectorFactoryOptions); + }; + var ConnectFunction = function ConnectFunction(props) { + var _useMemo = (0, import_react4.useMemo)(function() { + var reactReduxForwardedRef2 = props.reactReduxForwardedRef, wrapperProps2 = _objectWithoutPropertiesLoose(props, [ + "reactReduxForwardedRef" + ]); + return [ + props.context, + reactReduxForwardedRef2, + wrapperProps2 + ]; + }, [ + props + ]), propsContext = _useMemo[0], reactReduxForwardedRef = _useMemo[1], wrapperProps = _useMemo[2]; + var ContextToUse = (0, import_react4.useMemo)(function() { + return propsContext && propsContext.Consumer && (0, import_react_is.isContextConsumer)(/* @__PURE__ */ import_react4.default.createElement(propsContext.Consumer, null)) ? propsContext : Context; + }, [ + propsContext, + Context + ]); + var contextValue = (0, import_react4.useContext)(ContextToUse); + var didStoreComeFromProps = Boolean(props.store) && Boolean(props.store.getState) && Boolean(props.store.dispatch); + var didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store); + if (!didStoreComeFromProps && !didStoreComeFromContext) { + throw new Error('Could not find "store" in the context of ' + ('"' + displayName + '". Either wrap the root component in a , ') + "or pass a custom React context provider to and the corresponding " + ("React context consumer to " + displayName + " in connect options.")); + } + var store = didStoreComeFromProps ? props.store : contextValue.store; + var childPropsSelector = (0, import_react4.useMemo)(function() { + return createChildSelector(store); + }, [ + store + ]); + var _useMemo2 = (0, import_react4.useMemo)(function() { + if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY; + var subscription2 = new Subscription(store, didStoreComeFromProps ? null : contextValue.subscription); + var notifyNestedSubs2 = subscription2.notifyNestedSubs.bind(subscription2); + return [ + subscription2, + notifyNestedSubs2 + ]; + }, [ + store, + didStoreComeFromProps, + contextValue + ]), subscription = _useMemo2[0], notifyNestedSubs = _useMemo2[1]; + var overriddenContextValue = (0, import_react4.useMemo)(function() { + if (didStoreComeFromProps) { + return contextValue; + } + return _extends({}, contextValue, { + subscription: subscription + }); + }, [ + didStoreComeFromProps, + contextValue, + subscription + ]); + var _useReducer = (0, import_react4.useReducer)(storeStateUpdatesReducer, EMPTY_ARRAY, initStateUpdates), _useReducer$ = _useReducer[0], previousStateUpdateResult = _useReducer$[0], forceComponentUpdateDispatch = _useReducer[1]; + if (previousStateUpdateResult && previousStateUpdateResult.error) { + throw previousStateUpdateResult.error; + } + var lastChildProps = (0, import_react4.useRef)(); + var lastWrapperProps = (0, import_react4.useRef)(wrapperProps); + var childPropsFromStoreUpdate = (0, import_react4.useRef)(); + var renderIsScheduled = (0, import_react4.useRef)(false); + var actualChildProps = usePureOnlyMemo(function() { + if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) { + return childPropsFromStoreUpdate.current; + } + return childPropsSelector(store.getState(), wrapperProps); + }, [ + store, + previousStateUpdateResult, + wrapperProps + ]); + useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [ + lastWrapperProps, + lastChildProps, + renderIsScheduled, + wrapperProps, + actualChildProps, + childPropsFromStoreUpdate, + notifyNestedSubs + ]); + useIsomorphicLayoutEffectWithArgs(subscribeUpdates, [ + shouldHandleStateChanges, + store, + subscription, + childPropsSelector, + lastWrapperProps, + lastChildProps, + renderIsScheduled, + childPropsFromStoreUpdate, + notifyNestedSubs, + forceComponentUpdateDispatch + ], [ + store, + subscription, + childPropsSelector + ]); + var renderedWrappedComponent = (0, import_react4.useMemo)(function() { + return /* @__PURE__ */ import_react4.default.createElement(WrappedComponent, _extends({}, actualChildProps, { + ref: reactReduxForwardedRef + })); + }, [ + reactReduxForwardedRef, + WrappedComponent, + actualChildProps + ]); + var renderedChild = (0, import_react4.useMemo)(function() { + if (shouldHandleStateChanges) { + return /* @__PURE__ */ import_react4.default.createElement(ContextToUse.Provider, { + value: overriddenContextValue + }, renderedWrappedComponent); + } + return renderedWrappedComponent; + }, [ + ContextToUse, + renderedWrappedComponent, + overriddenContextValue + ]); + return renderedChild; + }; + if (!(0, import_react_is.isValidElementType)(WrappedComponent)) { + throw new Error("You must pass a component to the function returned by " + (methodName + ". Instead received " + stringifyComponent(WrappedComponent))); + } + var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || "Component"; + var displayName = getDisplayName(wrappedComponentName); + var selectorFactoryOptions = _extends({}, connectOptions, { + getDisplayName: getDisplayName, + methodName: methodName, + renderCountProp: renderCountProp, + shouldHandleStateChanges: shouldHandleStateChanges, + storeKey: storeKey, + displayName: displayName, + wrappedComponentName: wrappedComponentName, + WrappedComponent: WrappedComponent + }); + var pure = connectOptions.pure; + var usePureOnlyMemo = pure ? import_react4.useMemo : function usePureOnlyMemo(callback) { + return callback(); + }; + var Connect = pure ? import_react4.default.memo(ConnectFunction) : ConnectFunction; + Connect.WrappedComponent = WrappedComponent; + Connect.displayName = displayName; + if (forwardRef) { + var forwarded = import_react4.default.forwardRef(function forwardConnectRef(props, ref) { + return /* @__PURE__ */ import_react4.default.createElement(Connect, _extends({}, props, { + reactReduxForwardedRef: ref + })); + }); + forwarded.displayName = displayName; + forwarded.WrappedComponent = WrappedComponent; + return (0, import_hoist_non_react_statics.default)(forwarded, WrappedComponent); + } + return (0, import_hoist_non_react_statics.default)(Connect, WrappedComponent); + }; +} +var import_hoist_non_react_statics, import_react4, import_react_is, EMPTY_ARRAY, NO_SUBSCRIPTION_ARRAY, stringifyComponent, initStateUpdates; +var init_connectAdvanced = __esm({ + "node_modules/react-redux/es/components/connectAdvanced.js": function() { + init_extends(); + init_objectWithoutPropertiesLoose(); + import_hoist_non_react_statics = __toESM(require_hoist_non_react_statics_cjs()); + import_react4 = __toESM(require_react()); + import_react_is = __toESM(require_react_is()); + init_Subscription(); + init_useIsomorphicLayoutEffect(); + init_Context(); + EMPTY_ARRAY = []; + NO_SUBSCRIPTION_ARRAY = [ + null, + null + ]; + stringifyComponent = function stringifyComponent2(Comp) { + try { + return JSON.stringify(Comp); + } catch (err) { + return String(Comp); + } + }; + initStateUpdates = function initStateUpdates2() { + return [ + null, + 0 + ]; + }; + } +}); +// node_modules/react-redux/es/utils/shallowEqual.js +function is(x, y) { + if (x === y) { + return x !== 0 || y !== 0 || 1 / x === 1 / y; + } else { + return x !== x && y !== y; + } +} +function shallowEqual(objA, objB) { + if (is(objA, objB)) return true; + if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) { + return false; + } + var keysA = Object.keys(objA); + var keysB = Object.keys(objB); + if (keysA.length !== keysB.length) return false; + for(var i = 0; i < keysA.length; i++){ + if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { + return false; + } + } + return true; +} +var init_shallowEqual = __esm({ + "node_modules/react-redux/es/utils/shallowEqual.js": function() {} +}); +// node_modules/symbol-observable/es/ponyfill.js +function symbolObservablePonyfill(root2) { + var result2; + var Symbol2 = root2.Symbol; + if (typeof Symbol2 === "function") { + if (Symbol2.observable) { + result2 = Symbol2.observable; + } else { + result2 = Symbol2("observable"); + Symbol2.observable = result2; + } + } else { + result2 = "@@observable"; + } + return result2; +} +var init_ponyfill = __esm({ + "node_modules/symbol-observable/es/ponyfill.js": function() {} +}); +// node_modules/symbol-observable/es/index.js +var root, result; +var init_es = __esm({ + "node_modules/symbol-observable/es/index.js": function() { + init_ponyfill(); + if (typeof self !== "undefined") { + root = self; + } else if (typeof window !== "undefined") { + root = window; + } else if (typeof global !== "undefined") { + root = global; + } else if (typeof module !== "undefined") { + root = module; + } else { + root = Function("return this")(); + } + result = symbolObservablePonyfill(root); + } +}); +// node_modules/redux/es/redux.js +function warning(message) { + if (typeof console !== "undefined" && typeof console.error === "function") { + console.error(message); + } + try { + throw new Error(message); + } catch (e) {} +} +function bindActionCreator(actionCreator, dispatch) { + return function() { + return dispatch(actionCreator.apply(this, arguments)); + }; +} +function bindActionCreators(actionCreators, dispatch) { + if (typeof actionCreators === "function") { + return bindActionCreator(actionCreators, dispatch); + } + if (typeof actionCreators !== "object" || actionCreators === null) { + throw new Error("bindActionCreators expected an object or a function, instead received " + (actionCreators === null ? "null" : typeof actionCreators === "undefined" ? "undefined" : _type_of(actionCreators)) + '. Did you write "import ActionCreators from" instead of "import * as ActionCreators from"?'); + } + var boundActionCreators = {}; + for(var key in actionCreators){ + var actionCreator = actionCreators[key]; + if (typeof actionCreator === "function") { + boundActionCreators[key] = bindActionCreator(actionCreator, dispatch); + } + } + return boundActionCreators; +} +function isCrushed() {} +var randomString, ActionTypes; +var init_redux = __esm({ + "node_modules/redux/es/redux.js": function() { + init_es(); + randomString = function randomString2() { + return Math.random().toString(36).substring(7).split("").join("."); + }; + ActionTypes = { + INIT: "@@redux/INIT" + randomString(), + REPLACE: "@@redux/REPLACE" + randomString(), + PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() { + return "@@redux/PROBE_UNKNOWN_ACTION" + randomString(); + } + }; + if (typeof isCrushed.name === "string" && isCrushed.name !== "isCrushed") { + warning('You are currently using minified code outside of NODE_ENV === "production". This means that you are running a slower development build of Redux. You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify or setting mode to production in webpack (https://webpack.js.org/concepts/mode/) to ensure you have the correct code for your production build.'); + } + } +}); +// node_modules/react-redux/es/utils/isPlainObject.js +function isPlainObject(obj) { + if (typeof obj !== "object" || obj === null) return false; + var proto = Object.getPrototypeOf(obj); + if (proto === null) return true; + var baseProto = proto; + while(Object.getPrototypeOf(baseProto) !== null){ + baseProto = Object.getPrototypeOf(baseProto); + } + return proto === baseProto; +} +var init_isPlainObject = __esm({ + "node_modules/react-redux/es/utils/isPlainObject.js": function() {} +}); +// node_modules/react-redux/es/utils/warning.js +function warning2(message) { + if (typeof console !== "undefined" && typeof console.error === "function") { + console.error(message); + } + try { + throw new Error(message); + } catch (e) {} +} +var init_warning = __esm({ + "node_modules/react-redux/es/utils/warning.js": function() {} +}); +// node_modules/react-redux/es/utils/verifyPlainObject.js +function verifyPlainObject(value, displayName, methodName) { + if (!isPlainObject(value)) { + warning2(methodName + "() in " + displayName + " must return a plain object. Instead received " + value + "."); + } +} +var init_verifyPlainObject = __esm({ + "node_modules/react-redux/es/utils/verifyPlainObject.js": function() { + init_isPlainObject(); + init_warning(); + } +}); +// node_modules/react-redux/es/connect/wrapMapToProps.js +function wrapMapToPropsConstant(getConstant) { + return function initConstantSelector(dispatch, options) { + var constantSelector = function constantSelector() { + return constant; + }; + var constant = getConstant(dispatch, options); + constantSelector.dependsOnOwnProps = false; + return constantSelector; + }; +} +function getDependsOnOwnProps(mapToProps) { + return mapToProps.dependsOnOwnProps !== null && mapToProps.dependsOnOwnProps !== void 0 ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1; +} +function wrapMapToPropsFunc(mapToProps, methodName) { + return function initProxySelector(dispatch, _ref) { + var displayName = _ref.displayName; + var proxy = function mapToPropsProxy(stateOrDispatch, ownProps) { + return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch); + }; + proxy.dependsOnOwnProps = true; + proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) { + proxy.mapToProps = mapToProps; + proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps); + var props = proxy(stateOrDispatch, ownProps); + if (typeof props === "function") { + proxy.mapToProps = props; + proxy.dependsOnOwnProps = getDependsOnOwnProps(props); + props = proxy(stateOrDispatch, ownProps); + } + if (true) verifyPlainObject(props, displayName, methodName); + return props; + }; + return proxy; + }; +} +var init_wrapMapToProps = __esm({ + "node_modules/react-redux/es/connect/wrapMapToProps.js": function() { + init_verifyPlainObject(); + } +}); +// node_modules/react-redux/es/connect/mapDispatchToProps.js +function whenMapDispatchToPropsIsFunction(mapDispatchToProps) { + return typeof mapDispatchToProps === "function" ? wrapMapToPropsFunc(mapDispatchToProps, "mapDispatchToProps") : void 0; +} +function whenMapDispatchToPropsIsMissing(mapDispatchToProps) { + return !mapDispatchToProps ? wrapMapToPropsConstant(function(dispatch) { + return { + dispatch: dispatch + }; + }) : void 0; +} +function whenMapDispatchToPropsIsObject(mapDispatchToProps) { + return mapDispatchToProps && typeof mapDispatchToProps === "object" ? wrapMapToPropsConstant(function(dispatch) { + return bindActionCreators(mapDispatchToProps, dispatch); + }) : void 0; +} +var mapDispatchToProps_default; +var init_mapDispatchToProps = __esm({ + "node_modules/react-redux/es/connect/mapDispatchToProps.js": function() { + init_redux(); + init_wrapMapToProps(); + mapDispatchToProps_default = [ + whenMapDispatchToPropsIsFunction, + whenMapDispatchToPropsIsMissing, + whenMapDispatchToPropsIsObject + ]; + } +}); +// node_modules/react-redux/es/connect/mapStateToProps.js +function whenMapStateToPropsIsFunction(mapStateToProps) { + return typeof mapStateToProps === "function" ? wrapMapToPropsFunc(mapStateToProps, "mapStateToProps") : void 0; +} +function whenMapStateToPropsIsMissing(mapStateToProps) { + return !mapStateToProps ? wrapMapToPropsConstant(function() { + return {}; + }) : void 0; +} +var mapStateToProps_default; +var init_mapStateToProps = __esm({ + "node_modules/react-redux/es/connect/mapStateToProps.js": function() { + init_wrapMapToProps(); + mapStateToProps_default = [ + whenMapStateToPropsIsFunction, + whenMapStateToPropsIsMissing + ]; + } +}); +// node_modules/react-redux/es/connect/mergeProps.js +function defaultMergeProps(stateProps, dispatchProps, ownProps) { + return _extends({}, ownProps, stateProps, dispatchProps); +} +function wrapMergePropsFunc(mergeProps) { + return function initMergePropsProxy(dispatch, _ref) { + var displayName = _ref.displayName, pure = _ref.pure, areMergedPropsEqual = _ref.areMergedPropsEqual; + var hasRunOnce = false; + var mergedProps; + return function mergePropsProxy(stateProps, dispatchProps, ownProps) { + var nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps); + if (hasRunOnce) { + if (!pure || !areMergedPropsEqual(nextMergedProps, mergedProps)) mergedProps = nextMergedProps; + } else { + hasRunOnce = true; + mergedProps = nextMergedProps; + if (true) verifyPlainObject(mergedProps, displayName, "mergeProps"); + } + return mergedProps; + }; + }; +} +function whenMergePropsIsFunction(mergeProps) { + return typeof mergeProps === "function" ? wrapMergePropsFunc(mergeProps) : void 0; +} +function whenMergePropsIsOmitted(mergeProps) { + return !mergeProps ? function() { + return defaultMergeProps; + } : void 0; +} +var mergeProps_default; +var init_mergeProps = __esm({ + "node_modules/react-redux/es/connect/mergeProps.js": function() { + init_extends(); + init_verifyPlainObject(); + mergeProps_default = [ + whenMergePropsIsFunction, + whenMergePropsIsOmitted + ]; + } +}); +// node_modules/react-redux/es/connect/verifySubselectors.js +function verify(selector, methodName, displayName) { + if (!selector) { + throw new Error("Unexpected value for " + methodName + " in " + displayName + "."); + } else if (methodName === "mapStateToProps" || methodName === "mapDispatchToProps") { + if (!Object.prototype.hasOwnProperty.call(selector, "dependsOnOwnProps")) { + warning2("The selector for " + methodName + " of " + displayName + " did not specify a value for dependsOnOwnProps."); + } + } +} +function verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, displayName) { + verify(mapStateToProps, "mapStateToProps", displayName); + verify(mapDispatchToProps, "mapDispatchToProps", displayName); + verify(mergeProps, "mergeProps", displayName); +} +var init_verifySubselectors = __esm({ + "node_modules/react-redux/es/connect/verifySubselectors.js": function() { + init_warning(); + } +}); +// node_modules/react-redux/es/connect/selectorFactory.js +function impureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch) { + return function impureFinalPropsSelector(state, ownProps) { + return mergeProps(mapStateToProps(state, ownProps), mapDispatchToProps(dispatch, ownProps), ownProps); + }; +} +function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, _ref) { + var handleFirstCall = function handleFirstCall(firstState, firstOwnProps) { + state = firstState; + ownProps = firstOwnProps; + stateProps = mapStateToProps(state, ownProps); + dispatchProps = mapDispatchToProps(dispatch, ownProps); + mergedProps = mergeProps(stateProps, dispatchProps, ownProps); + hasRunAtLeastOnce = true; + return mergedProps; + }; + var handleNewPropsAndNewState = function handleNewPropsAndNewState() { + stateProps = mapStateToProps(state, ownProps); + if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps); + mergedProps = mergeProps(stateProps, dispatchProps, ownProps); + return mergedProps; + }; + var handleNewProps = function handleNewProps() { + if (mapStateToProps.dependsOnOwnProps) stateProps = mapStateToProps(state, ownProps); + if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps); + mergedProps = mergeProps(stateProps, dispatchProps, ownProps); + return mergedProps; + }; + var handleNewState = function handleNewState() { + var nextStateProps = mapStateToProps(state, ownProps); + var statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps); + stateProps = nextStateProps; + if (statePropsChanged) mergedProps = mergeProps(stateProps, dispatchProps, ownProps); + return mergedProps; + }; + var handleSubsequentCalls = function handleSubsequentCalls(nextState, nextOwnProps) { + var propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps); + var stateChanged = !areStatesEqual(nextState, state); + state = nextState; + ownProps = nextOwnProps; + if (propsChanged && stateChanged) return handleNewPropsAndNewState(); + if (propsChanged) return handleNewProps(); + if (stateChanged) return handleNewState(); + return mergedProps; + }; + var areStatesEqual = _ref.areStatesEqual, areOwnPropsEqual = _ref.areOwnPropsEqual, areStatePropsEqual = _ref.areStatePropsEqual; + var hasRunAtLeastOnce = false; + var state; + var ownProps; + var stateProps; + var dispatchProps; + var mergedProps; + return function pureFinalPropsSelector(nextState, nextOwnProps) { + return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) : handleFirstCall(nextState, nextOwnProps); + }; +} +function finalPropsSelectorFactory(dispatch, _ref2) { + var initMapStateToProps = _ref2.initMapStateToProps, initMapDispatchToProps = _ref2.initMapDispatchToProps, initMergeProps = _ref2.initMergeProps, options = _objectWithoutPropertiesLoose(_ref2, [ + "initMapStateToProps", + "initMapDispatchToProps", + "initMergeProps" + ]); + var mapStateToProps = initMapStateToProps(dispatch, options); + var mapDispatchToProps = initMapDispatchToProps(dispatch, options); + var mergeProps = initMergeProps(dispatch, options); + if (true) { + verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, options.displayName); + } + var selectorFactory = options.pure ? pureFinalPropsSelectorFactory : impureFinalPropsSelectorFactory; + return selectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options); +} +var init_selectorFactory = __esm({ + "node_modules/react-redux/es/connect/selectorFactory.js": function() { + init_objectWithoutPropertiesLoose(); + init_verifySubselectors(); + } +}); +// node_modules/react-redux/es/connect/connect.js +function match(arg, factories, name) { + for(var i = factories.length - 1; i >= 0; i--){ + var result2 = factories[i](arg); + if (result2) return result2; + } + return function(dispatch, options) { + throw new Error("Invalid value of type " + (typeof arg === "undefined" ? "undefined" : _type_of(arg)) + " for " + name + " argument when connecting component " + options.wrappedComponentName + "."); + }; +} +function strictEqual(a, b) { + return a === b; +} +function createConnect(_temp) { + var _ref = _temp === void 0 ? {} : _temp, _ref$connectHOC = _ref.connectHOC, connectHOC = _ref$connectHOC === void 0 ? connectAdvanced : _ref$connectHOC, _ref$mapStateToPropsF = _ref.mapStateToPropsFactories, mapStateToPropsFactories = _ref$mapStateToPropsF === void 0 ? mapStateToProps_default : _ref$mapStateToPropsF, _ref$mapDispatchToPro = _ref.mapDispatchToPropsFactories, mapDispatchToPropsFactories = _ref$mapDispatchToPro === void 0 ? mapDispatchToProps_default : _ref$mapDispatchToPro, _ref$mergePropsFactor = _ref.mergePropsFactories, mergePropsFactories = _ref$mergePropsFactor === void 0 ? mergeProps_default : _ref$mergePropsFactor, _ref$selectorFactory = _ref.selectorFactory, selectorFactory = _ref$selectorFactory === void 0 ? finalPropsSelectorFactory : _ref$selectorFactory; + return function connect(mapStateToProps, mapDispatchToProps, mergeProps, _ref2) { + if (_ref2 === void 0) { + _ref2 = {}; + } + var _ref3 = _ref2, _ref3$pure = _ref3.pure, pure = _ref3$pure === void 0 ? true : _ref3$pure, _ref3$areStatesEqual = _ref3.areStatesEqual, areStatesEqual = _ref3$areStatesEqual === void 0 ? strictEqual : _ref3$areStatesEqual, _ref3$areOwnPropsEqua = _ref3.areOwnPropsEqual, areOwnPropsEqual = _ref3$areOwnPropsEqua === void 0 ? shallowEqual : _ref3$areOwnPropsEqua, _ref3$areStatePropsEq = _ref3.areStatePropsEqual, areStatePropsEqual = _ref3$areStatePropsEq === void 0 ? shallowEqual : _ref3$areStatePropsEq, _ref3$areMergedPropsE = _ref3.areMergedPropsEqual, areMergedPropsEqual = _ref3$areMergedPropsE === void 0 ? shallowEqual : _ref3$areMergedPropsE, extraOptions = _objectWithoutPropertiesLoose(_ref3, [ + "pure", + "areStatesEqual", + "areOwnPropsEqual", + "areStatePropsEqual", + "areMergedPropsEqual" + ]); + var initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories, "mapStateToProps"); + var initMapDispatchToProps = match(mapDispatchToProps, mapDispatchToPropsFactories, "mapDispatchToProps"); + var initMergeProps = match(mergeProps, mergePropsFactories, "mergeProps"); + return connectHOC(selectorFactory, _extends({ + // used in error messages + methodName: "connect", + // used to compute Connect's displayName from the wrapped component's displayName. + getDisplayName: function getDisplayName(name) { + return "Connect(" + name + ")"; + }, + // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes + shouldHandleStateChanges: Boolean(mapStateToProps), + // passed through to selectorFactory + initMapStateToProps: initMapStateToProps, + initMapDispatchToProps: initMapDispatchToProps, + initMergeProps: initMergeProps, + pure: pure, + areStatesEqual: areStatesEqual, + areOwnPropsEqual: areOwnPropsEqual, + areStatePropsEqual: areStatePropsEqual, + areMergedPropsEqual: areMergedPropsEqual + }, extraOptions)); + }; +} +var connect_default; +var init_connect = __esm({ + "node_modules/react-redux/es/connect/connect.js": function() { + init_extends(); + init_objectWithoutPropertiesLoose(); + init_connectAdvanced(); + init_shallowEqual(); + init_mapDispatchToProps(); + init_mapStateToProps(); + init_mergeProps(); + init_selectorFactory(); + connect_default = /* @__PURE__ */ createConnect(); + } +}); +// node_modules/react-redux/es/hooks/useReduxContext.js +function useReduxContext() { + var contextValue = (0, import_react5.useContext)(ReactReduxContext); + if (!contextValue) { + throw new Error("could not find react-redux context value; please ensure the component is wrapped in a "); + } + return contextValue; +} +var import_react5; +var init_useReduxContext = __esm({ + "node_modules/react-redux/es/hooks/useReduxContext.js": function() { + import_react5 = __toESM(require_react()); + init_Context(); + } +}); +// node_modules/react-redux/es/hooks/useStore.js +function createStoreHook(context) { + if (context === void 0) { + context = ReactReduxContext; + } + var useReduxContext2 = context === ReactReduxContext ? useReduxContext : function useReduxContext2() { + return (0, import_react6.useContext)(context); + }; + return function useStore2() { + var _useReduxContext = useReduxContext2(), store = _useReduxContext.store; + return store; + }; +} +var import_react6, useStore; +var init_useStore = __esm({ + "node_modules/react-redux/es/hooks/useStore.js": function() { + import_react6 = __toESM(require_react()); + init_Context(); + init_useReduxContext(); + useStore = /* @__PURE__ */ createStoreHook(); + } +}); +// node_modules/react-redux/es/hooks/useDispatch.js +function createDispatchHook(context) { + if (context === void 0) { + context = ReactReduxContext; + } + var useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context); + return function useDispatch2() { + var store = useStore2(); + return store.dispatch; + }; +} +var useDispatch; +var init_useDispatch = __esm({ + "node_modules/react-redux/es/hooks/useDispatch.js": function() { + init_Context(); + init_useStore(); + useDispatch = /* @__PURE__ */ createDispatchHook(); + } +}); +// node_modules/react-redux/es/hooks/useSelector.js +function useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub) { + var _useReducer = (0, import_react7.useReducer)(function(s) { + return s + 1; + }, 0), forceRender = _useReducer[1]; + var subscription = (0, import_react7.useMemo)(function() { + return new Subscription(store, contextSub); + }, [ + store, + contextSub + ]); + var latestSubscriptionCallbackError = (0, import_react7.useRef)(); + var latestSelector = (0, import_react7.useRef)(); + var latestStoreState = (0, import_react7.useRef)(); + var latestSelectedState = (0, import_react7.useRef)(); + var storeState = store.getState(); + var selectedState; + try { + if (selector !== latestSelector.current || storeState !== latestStoreState.current || latestSubscriptionCallbackError.current) { + selectedState = selector(storeState); + } else { + selectedState = latestSelectedState.current; + } + } catch (err) { + if (latestSubscriptionCallbackError.current) { + err.message += "\nThe error may be correlated with this previous error:\n" + latestSubscriptionCallbackError.current.stack + "\n\n"; + } + throw err; + } + useIsomorphicLayoutEffect(function() { + latestSelector.current = selector; + latestStoreState.current = storeState; + latestSelectedState.current = selectedState; + latestSubscriptionCallbackError.current = void 0; + }); + useIsomorphicLayoutEffect(function() { + var checkForUpdates = function checkForUpdates() { + try { + var newSelectedState = latestSelector.current(store.getState()); + if (equalityFn(newSelectedState, latestSelectedState.current)) { + return; + } + latestSelectedState.current = newSelectedState; + } catch (err) { + latestSubscriptionCallbackError.current = err; + } + forceRender(); + }; + subscription.onStateChange = checkForUpdates; + subscription.trySubscribe(); + checkForUpdates(); + return function() { + return subscription.tryUnsubscribe(); + }; + }, [ + store, + subscription + ]); + return selectedState; +} +function createSelectorHook(context) { + if (context === void 0) { + context = ReactReduxContext; + } + var useReduxContext2 = context === ReactReduxContext ? useReduxContext : function useReduxContext2() { + return (0, import_react7.useContext)(context); + }; + return function useSelector2(selector, equalityFn) { + if (equalityFn === void 0) { + equalityFn = refEquality; + } + if (!selector) { + throw new Error("You must pass a selector to useSelector"); + } + var _useReduxContext = useReduxContext2(), store = _useReduxContext.store, contextSub = _useReduxContext.subscription; + var selectedState = useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub); + (0, import_react7.useDebugValue)(selectedState); + return selectedState; + }; +} +var import_react7, refEquality, useSelector; +var init_useSelector = __esm({ + "node_modules/react-redux/es/hooks/useSelector.js": function() { + import_react7 = __toESM(require_react()); + init_useReduxContext(); + init_Subscription(); + init_useIsomorphicLayoutEffect(); + init_Context(); + refEquality = function refEquality2(a, b) { + return a === b; + }; + useSelector = /* @__PURE__ */ createSelectorHook(); + } +}); +// node_modules/scheduler/cjs/scheduler.development.js +var require_scheduler_development = __commonJS({ + "node_modules/scheduler/cjs/scheduler.development.js": function(exports) { + "use strict"; + if (true) { + (function() { + "use strict"; + var push = function push(heap, node) { + var index = heap.length; + heap.push(node); + siftUp(heap, node, index); + }; + var peek = function peek(heap) { + var first = heap[0]; + return first === void 0 ? null : first; + }; + var pop = function pop(heap) { + var first = heap[0]; + if (first !== void 0) { + var last = heap.pop(); + if (last !== first) { + heap[0] = last; + siftDown(heap, last, 0); + } + return first; + } else { + return null; + } + }; + var siftUp = function siftUp(heap, node, i) { + var index = i; + while(true){ + var parentIndex = index - 1 >>> 1; + var parent = heap[parentIndex]; + if (parent !== void 0 && compare(parent, node) > 0) { + heap[parentIndex] = node; + heap[index] = parent; + index = parentIndex; + } else { + return; + } + } + }; + var siftDown = function siftDown(heap, node, i) { + var index = i; + var length = heap.length; + while(index < length){ + var leftIndex = (index + 1) * 2 - 1; + var left = heap[leftIndex]; + var rightIndex = leftIndex + 1; + var right = heap[rightIndex]; + if (left !== void 0 && compare(left, node) < 0) { + if (right !== void 0 && compare(right, left) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + heap[index] = left; + heap[leftIndex] = node; + index = leftIndex; + } + } else if (right !== void 0 && compare(right, node) < 0) { + heap[index] = right; + heap[rightIndex] = node; + index = rightIndex; + } else { + return; + } + } + }; + var compare = function compare(a, b) { + var diff = a.sortIndex - b.sortIndex; + return diff !== 0 ? diff : a.id - b.id; + }; + var logEvent = function logEvent(entries) { + if (eventLog !== null) { + var offset = eventLogIndex; + eventLogIndex += entries.length; + if (eventLogIndex + 1 > eventLogSize) { + eventLogSize *= 2; + if (eventLogSize > MAX_EVENT_LOG_SIZE) { + console["error"]("Scheduler Profiling: Event log exceeded maximum size. Don't forget to call `stopLoggingProfilingEvents()`."); + stopLoggingProfilingEvents(); + return; + } + var newEventLog = new Int32Array(eventLogSize * 4); + newEventLog.set(eventLog); + eventLogBuffer = newEventLog.buffer; + eventLog = newEventLog; + } + eventLog.set(entries, offset); + } + }; + var startLoggingProfilingEvents = function startLoggingProfilingEvents() { + eventLogSize = INITIAL_EVENT_LOG_SIZE; + eventLogBuffer = new ArrayBuffer(eventLogSize * 4); + eventLog = new Int32Array(eventLogBuffer); + eventLogIndex = 0; + }; + var stopLoggingProfilingEvents = function stopLoggingProfilingEvents() { + var buffer = eventLogBuffer; + eventLogSize = 0; + eventLogBuffer = null; + eventLog = null; + eventLogIndex = 0; + return buffer; + }; + var markTaskStart = function markTaskStart(task, ms) { + { + profilingState[QUEUE_SIZE]++; + if (eventLog !== null) { + logEvent([ + TaskStartEvent, + ms * 1e3, + task.id, + task.priorityLevel + ]); + } + } + }; + var markTaskCompleted = function markTaskCompleted(task, ms) { + { + profilingState[PRIORITY] = NoPriority; + profilingState[CURRENT_TASK_ID] = 0; + profilingState[QUEUE_SIZE]--; + if (eventLog !== null) { + logEvent([ + TaskCompleteEvent, + ms * 1e3, + task.id + ]); + } + } + }; + var markTaskCanceled = function markTaskCanceled(task, ms) { + { + profilingState[QUEUE_SIZE]--; + if (eventLog !== null) { + logEvent([ + TaskCancelEvent, + ms * 1e3, + task.id + ]); + } + } + }; + var markTaskErrored = function markTaskErrored(task, ms) { + { + profilingState[PRIORITY] = NoPriority; + profilingState[CURRENT_TASK_ID] = 0; + profilingState[QUEUE_SIZE]--; + if (eventLog !== null) { + logEvent([ + TaskErrorEvent, + ms * 1e3, + task.id + ]); + } + } + }; + var markTaskRun = function markTaskRun(task, ms) { + { + runIdCounter++; + profilingState[PRIORITY] = task.priorityLevel; + profilingState[CURRENT_TASK_ID] = task.id; + profilingState[CURRENT_RUN_ID] = runIdCounter; + if (eventLog !== null) { + logEvent([ + TaskRunEvent, + ms * 1e3, + task.id, + runIdCounter + ]); + } + } + }; + var markTaskYield = function markTaskYield(task, ms) { + { + profilingState[PRIORITY] = NoPriority; + profilingState[CURRENT_TASK_ID] = 0; + profilingState[CURRENT_RUN_ID] = 0; + if (eventLog !== null) { + logEvent([ + TaskYieldEvent, + ms * 1e3, + task.id, + runIdCounter + ]); + } + } + }; + var markSchedulerSuspended = function markSchedulerSuspended(ms) { + { + mainThreadIdCounter++; + if (eventLog !== null) { + logEvent([ + SchedulerSuspendEvent, + ms * 1e3, + mainThreadIdCounter + ]); + } + } + }; + var markSchedulerUnsuspended = function markSchedulerUnsuspended(ms) { + { + if (eventLog !== null) { + logEvent([ + SchedulerResumeEvent, + ms * 1e3, + mainThreadIdCounter + ]); + } + } + }; + var advanceTimers = function advanceTimers(currentTime) { + var timer = peek(timerQueue); + while(timer !== null){ + if (timer.callback === null) { + pop(timerQueue); + } else if (timer.startTime <= currentTime) { + pop(timerQueue); + timer.sortIndex = timer.expirationTime; + push(taskQueue, timer); + { + markTaskStart(timer, currentTime); + timer.isQueued = true; + } + } else { + return; + } + timer = peek(timerQueue); + } + }; + var flushWork = function flushWork(hasTimeRemaining, initialTime2) { + { + markSchedulerUnsuspended(initialTime2); + } + isHostCallbackScheduled = false; + if (isHostTimeoutScheduled) { + isHostTimeoutScheduled = false; + cancelHostTimeout(); + } + isPerformingWork = true; + var previousPriorityLevel = currentPriorityLevel; + try { + if (enableProfiling) { + try { + return workLoop(hasTimeRemaining, initialTime2); + } catch (error) { + if (currentTask !== null) { + var currentTime = exports.unstable_now(); + markTaskErrored(currentTask, currentTime); + currentTask.isQueued = false; + } + throw error; + } + } else { + return workLoop(hasTimeRemaining, initialTime2); + } + } finally{ + currentTask = null; + currentPriorityLevel = previousPriorityLevel; + isPerformingWork = false; + { + var _currentTime = exports.unstable_now(); + markSchedulerSuspended(_currentTime); + } + } + }; + var workLoop = function workLoop(hasTimeRemaining, initialTime2) { + var currentTime = initialTime2; + advanceTimers(currentTime); + currentTask = peek(taskQueue); + while(currentTask !== null && !enableSchedulerDebugging){ + if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || exports.unstable_shouldYield())) { + break; + } + var callback = currentTask.callback; + if (typeof callback === "function") { + currentTask.callback = null; + currentPriorityLevel = currentTask.priorityLevel; + var didUserCallbackTimeout = currentTask.expirationTime <= currentTime; + markTaskRun(currentTask, currentTime); + var continuationCallback = callback(didUserCallbackTimeout); + currentTime = exports.unstable_now(); + if (typeof continuationCallback === "function") { + currentTask.callback = continuationCallback; + markTaskYield(currentTask, currentTime); + } else { + { + markTaskCompleted(currentTask, currentTime); + currentTask.isQueued = false; + } + if (currentTask === peek(taskQueue)) { + pop(taskQueue); + } + } + advanceTimers(currentTime); + } else { + pop(taskQueue); + } + currentTask = peek(taskQueue); + } + if (currentTask !== null) { + return true; + } else { + var firstTimer = peek(timerQueue); + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + return false; + } + }; + var unstable_runWithPriority = function unstable_runWithPriority(priorityLevel, eventHandler) { + switch(priorityLevel){ + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + case LowPriority: + case IdlePriority: + break; + default: + priorityLevel = NormalPriority; + } + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + try { + return eventHandler(); + } finally{ + currentPriorityLevel = previousPriorityLevel; + } + }; + var unstable_next = function unstable_next(eventHandler) { + var priorityLevel; + switch(currentPriorityLevel){ + case ImmediatePriority: + case UserBlockingPriority: + case NormalPriority: + priorityLevel = NormalPriority; + break; + default: + priorityLevel = currentPriorityLevel; + break; + } + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = priorityLevel; + try { + return eventHandler(); + } finally{ + currentPriorityLevel = previousPriorityLevel; + } + }; + var unstable_wrapCallback = function unstable_wrapCallback(callback) { + var parentPriorityLevel = currentPriorityLevel; + return function() { + var previousPriorityLevel = currentPriorityLevel; + currentPriorityLevel = parentPriorityLevel; + try { + return callback.apply(this, arguments); + } finally{ + currentPriorityLevel = previousPriorityLevel; + } + }; + }; + var unstable_scheduleCallback = function unstable_scheduleCallback(priorityLevel, callback, options) { + var currentTime = exports.unstable_now(); + var startTime; + if (typeof options === "object" && options !== null) { + var delay = options.delay; + if (typeof delay === "number" && delay > 0) { + startTime = currentTime + delay; + } else { + startTime = currentTime; + } + } else { + startTime = currentTime; + } + var timeout; + switch(priorityLevel){ + case ImmediatePriority: + timeout = IMMEDIATE_PRIORITY_TIMEOUT; + break; + case UserBlockingPriority: + timeout = USER_BLOCKING_PRIORITY_TIMEOUT; + break; + case IdlePriority: + timeout = IDLE_PRIORITY_TIMEOUT; + break; + case LowPriority: + timeout = LOW_PRIORITY_TIMEOUT; + break; + case NormalPriority: + default: + timeout = NORMAL_PRIORITY_TIMEOUT; + break; + } + var expirationTime = startTime + timeout; + var newTask = { + id: taskIdCounter++, + callback: callback, + priorityLevel: priorityLevel, + startTime: startTime, + expirationTime: expirationTime, + sortIndex: -1 + }; + { + newTask.isQueued = false; + } + if (startTime > currentTime) { + newTask.sortIndex = startTime; + push(timerQueue, newTask); + if (peek(taskQueue) === null && newTask === peek(timerQueue)) { + if (isHostTimeoutScheduled) { + cancelHostTimeout(); + } else { + isHostTimeoutScheduled = true; + } + requestHostTimeout(handleTimeout, startTime - currentTime); + } + } else { + newTask.sortIndex = expirationTime; + push(taskQueue, newTask); + { + markTaskStart(newTask, currentTime); + newTask.isQueued = true; + } + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + } + return newTask; + }; + var unstable_pauseExecution = function unstable_pauseExecution() {}; + var unstable_continueExecution = function unstable_continueExecution() { + if (!isHostCallbackScheduled && !isPerformingWork) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } + }; + var unstable_getFirstCallbackNode = function unstable_getFirstCallbackNode() { + return peek(taskQueue); + }; + var unstable_cancelCallback = function unstable_cancelCallback(task) { + { + if (task.isQueued) { + var currentTime = exports.unstable_now(); + markTaskCanceled(task, currentTime); + task.isQueued = false; + } + } + task.callback = null; + }; + var unstable_getCurrentPriorityLevel = function unstable_getCurrentPriorityLevel() { + return currentPriorityLevel; + }; + var enableSchedulerDebugging = false; + var enableProfiling = true; + var requestHostCallback; + var requestHostTimeout; + var cancelHostTimeout; + var requestPaint; + var hasPerformanceNow = typeof performance === "object" && typeof performance.now === "function"; + if (hasPerformanceNow) { + var localPerformance = performance; + exports.unstable_now = function() { + return localPerformance.now(); + }; + } else { + var localDate = Date; + var initialTime = localDate.now(); + exports.unstable_now = function() { + return localDate.now() - initialTime; + }; + } + if (// If Scheduler runs in a non-DOM environment, it falls back to a naive + // implementation using setTimeout. + typeof window === "undefined" || // Check if MessageChannel is supported, too. + typeof MessageChannel !== "function") { + var _callback = null; + var _timeoutID = null; + var _flushCallback = function _flushCallback1() { + if (_callback !== null) { + try { + var currentTime = exports.unstable_now(); + var hasRemainingTime = true; + _callback(hasRemainingTime, currentTime); + _callback = null; + } catch (e) { + setTimeout(_flushCallback, 0); + throw e; + } + } + }; + requestHostCallback = function(cb) { + if (_callback !== null) { + setTimeout(requestHostCallback, 0, cb); + } else { + _callback = cb; + setTimeout(_flushCallback, 0); + } + }; + requestHostTimeout = function requestHostTimeout(cb, ms) { + _timeoutID = setTimeout(cb, ms); + }; + cancelHostTimeout = function cancelHostTimeout() { + clearTimeout(_timeoutID); + }; + exports.unstable_shouldYield = function() { + return false; + }; + requestPaint = exports.unstable_forceFrameRate = function requestPaint() {}; + } else { + var _setTimeout = window.setTimeout; + var _clearTimeout = window.clearTimeout; + if (typeof console !== "undefined") { + var requestAnimationFrame = window.requestAnimationFrame; + var cancelAnimationFrame = window.cancelAnimationFrame; + if (typeof requestAnimationFrame !== "function") { + console["error"]("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"); + } + if (typeof cancelAnimationFrame !== "function") { + console["error"]("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"); + } + } + var isMessageLoopRunning = false; + var scheduledHostCallback = null; + var taskTimeoutID = -1; + var yieldInterval = 5; + var deadline = 0; + { + exports.unstable_shouldYield = function() { + return exports.unstable_now() >= deadline; + }; + requestPaint = function requestPaint() {}; + } + exports.unstable_forceFrameRate = function(fps) { + if (fps < 0 || fps > 125) { + console["error"]("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"); + return; + } + if (fps > 0) { + yieldInterval = Math.floor(1e3 / fps); + } else { + yieldInterval = 5; + } + }; + var performWorkUntilDeadline = function performWorkUntilDeadline() { + if (scheduledHostCallback !== null) { + var currentTime = exports.unstable_now(); + deadline = currentTime + yieldInterval; + var hasTimeRemaining = true; + try { + var hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime); + if (!hasMoreWork) { + isMessageLoopRunning = false; + scheduledHostCallback = null; + } else { + port.postMessage(null); + } + } catch (error) { + port.postMessage(null); + throw error; + } + } else { + isMessageLoopRunning = false; + } + }; + var channel = new MessageChannel(); + var port = channel.port2; + channel.port1.onmessage = performWorkUntilDeadline; + requestHostCallback = function requestHostCallback(callback) { + scheduledHostCallback = callback; + if (!isMessageLoopRunning) { + isMessageLoopRunning = true; + port.postMessage(null); + } + }; + requestHostTimeout = function requestHostTimeout(callback, ms) { + taskTimeoutID = _setTimeout(function() { + callback(exports.unstable_now()); + }, ms); + }; + cancelHostTimeout = function cancelHostTimeout() { + _clearTimeout(taskTimeoutID); + taskTimeoutID = -1; + }; + } + var NoPriority = 0; + var ImmediatePriority = 1; + var UserBlockingPriority = 2; + var NormalPriority = 3; + var LowPriority = 4; + var IdlePriority = 5; + var runIdCounter = 0; + var mainThreadIdCounter = 0; + var profilingStateSize = 4; + var sharedProfilingBuffer = // $FlowFixMe Flow doesn't know about SharedArrayBuffer + typeof SharedArrayBuffer === "function" ? new SharedArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : // $FlowFixMe Flow doesn't know about ArrayBuffer + typeof ArrayBuffer === "function" ? new ArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : null; + var profilingState = sharedProfilingBuffer !== null ? new Int32Array(sharedProfilingBuffer) : []; + var PRIORITY = 0; + var CURRENT_TASK_ID = 1; + var CURRENT_RUN_ID = 2; + var QUEUE_SIZE = 3; + { + profilingState[PRIORITY] = NoPriority; + profilingState[QUEUE_SIZE] = 0; + profilingState[CURRENT_TASK_ID] = 0; + } + var INITIAL_EVENT_LOG_SIZE = 131072; + var MAX_EVENT_LOG_SIZE = 524288; + var eventLogSize = 0; + var eventLogBuffer = null; + var eventLog = null; + var eventLogIndex = 0; + var TaskStartEvent = 1; + var TaskCompleteEvent = 2; + var TaskErrorEvent = 3; + var TaskCancelEvent = 4; + var TaskRunEvent = 5; + var TaskYieldEvent = 6; + var SchedulerSuspendEvent = 7; + var SchedulerResumeEvent = 8; + var maxSigned31BitInt = 1073741823; + var IMMEDIATE_PRIORITY_TIMEOUT = -1; + var USER_BLOCKING_PRIORITY_TIMEOUT = 250; + var NORMAL_PRIORITY_TIMEOUT = 5e3; + var LOW_PRIORITY_TIMEOUT = 1e4; + var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; + var taskQueue = []; + var timerQueue = []; + var taskIdCounter = 1; + var currentTask = null; + var currentPriorityLevel = NormalPriority; + var isPerformingWork = false; + var isHostCallbackScheduled = false; + var isHostTimeoutScheduled = false; + function handleTimeout(currentTime) { + isHostTimeoutScheduled = false; + advanceTimers(currentTime); + if (!isHostCallbackScheduled) { + if (peek(taskQueue) !== null) { + isHostCallbackScheduled = true; + requestHostCallback(flushWork); + } else { + var firstTimer = peek(timerQueue); + if (firstTimer !== null) { + requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime); + } + } + } + } + var unstable_requestPaint = requestPaint; + var unstable_Profiling = { + startLoggingProfilingEvents: startLoggingProfilingEvents, + stopLoggingProfilingEvents: stopLoggingProfilingEvents, + sharedProfilingBuffer: sharedProfilingBuffer + }; + exports.unstable_IdlePriority = IdlePriority; + exports.unstable_ImmediatePriority = ImmediatePriority; + exports.unstable_LowPriority = LowPriority; + exports.unstable_NormalPriority = NormalPriority; + exports.unstable_Profiling = unstable_Profiling; + exports.unstable_UserBlockingPriority = UserBlockingPriority; + exports.unstable_cancelCallback = unstable_cancelCallback; + exports.unstable_continueExecution = unstable_continueExecution; + exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel; + exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode; + exports.unstable_next = unstable_next; + exports.unstable_pauseExecution = unstable_pauseExecution; + exports.unstable_requestPaint = unstable_requestPaint; + exports.unstable_runWithPriority = unstable_runWithPriority; + exports.unstable_scheduleCallback = unstable_scheduleCallback; + exports.unstable_wrapCallback = unstable_wrapCallback; + })(); + } + } +}); +// node_modules/scheduler/index.js +var require_scheduler = __commonJS({ + "node_modules/scheduler/index.js": function(exports, module2) { + "use strict"; + if (false) { + module2.exports = null; + } else { + module2.exports = require_scheduler_development(); + } + } +}); +// node_modules/scheduler/cjs/scheduler-tracing.development.js +var require_scheduler_tracing_development = __commonJS({ + "node_modules/scheduler/cjs/scheduler-tracing.development.js": function(exports) { + "use strict"; + if (true) { + (function() { + "use strict"; + var unstable_clear = function unstable_clear(callback) { + var prevInteractions = exports.__interactionsRef.current; + exports.__interactionsRef.current = /* @__PURE__ */ new Set(); + try { + return callback(); + } finally{ + exports.__interactionsRef.current = prevInteractions; + } + }; + var unstable_getCurrent = function unstable_getCurrent() { + { + return exports.__interactionsRef.current; + } + }; + var unstable_getThreadID = function unstable_getThreadID() { + return ++threadIDCounter; + }; + var unstable_trace = function unstable_trace(name, timestamp, callback) { + var threadID = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : DEFAULT_THREAD_ID; + var interaction = { + __count: 1, + id: interactionIDCounter++, + name: name, + timestamp: timestamp + }; + var prevInteractions = exports.__interactionsRef.current; + var interactions = new Set(prevInteractions); + interactions.add(interaction); + exports.__interactionsRef.current = interactions; + var subscriber = exports.__subscriberRef.current; + var returnValue; + try { + if (subscriber !== null) { + subscriber.onInteractionTraced(interaction); + } + } finally{ + try { + if (subscriber !== null) { + subscriber.onWorkStarted(interactions, threadID); + } + } finally{ + try { + returnValue = callback(); + } finally{ + exports.__interactionsRef.current = prevInteractions; + try { + if (subscriber !== null) { + subscriber.onWorkStopped(interactions, threadID); + } + } finally{ + interaction.__count--; + if (subscriber !== null && interaction.__count === 0) { + subscriber.onInteractionScheduledWorkCompleted(interaction); + } + } + } + } + } + return returnValue; + }; + var unstable_wrap = function unstable_wrap(callback) { + var threadID = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_THREAD_ID; + var wrappedInteractions = exports.__interactionsRef.current; + var subscriber = exports.__subscriberRef.current; + if (subscriber !== null) { + subscriber.onWorkScheduled(wrappedInteractions, threadID); + } + wrappedInteractions.forEach(function(interaction) { + interaction.__count++; + }); + var hasRun = false; + function wrapped() { + var prevInteractions = exports.__interactionsRef.current; + exports.__interactionsRef.current = wrappedInteractions; + subscriber = exports.__subscriberRef.current; + try { + var returnValue; + try { + if (subscriber !== null) { + subscriber.onWorkStarted(wrappedInteractions, threadID); + } + } finally{ + try { + returnValue = callback.apply(void 0, arguments); + } finally{ + exports.__interactionsRef.current = prevInteractions; + if (subscriber !== null) { + subscriber.onWorkStopped(wrappedInteractions, threadID); + } + } + } + return returnValue; + } finally{ + if (!hasRun) { + hasRun = true; + wrappedInteractions.forEach(function(interaction) { + interaction.__count--; + if (subscriber !== null && interaction.__count === 0) { + subscriber.onInteractionScheduledWorkCompleted(interaction); + } + }); + } + } + } + wrapped.cancel = function cancel() { + subscriber = exports.__subscriberRef.current; + try { + if (subscriber !== null) { + subscriber.onWorkCanceled(wrappedInteractions, threadID); + } + } finally{ + wrappedInteractions.forEach(function(interaction) { + interaction.__count--; + if (subscriber && interaction.__count === 0) { + subscriber.onInteractionScheduledWorkCompleted(interaction); + } + }); + } + }; + return wrapped; + }; + var unstable_subscribe = function unstable_subscribe(subscriber) { + { + subscribers.add(subscriber); + if (subscribers.size === 1) { + exports.__subscriberRef.current = { + onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted, + onInteractionTraced: onInteractionTraced, + onWorkCanceled: onWorkCanceled, + onWorkScheduled: onWorkScheduled, + onWorkStarted: onWorkStarted, + onWorkStopped: onWorkStopped + }; + } + } + }; + var unstable_unsubscribe = function unstable_unsubscribe(subscriber) { + { + subscribers.delete(subscriber); + if (subscribers.size === 0) { + exports.__subscriberRef.current = null; + } + } + }; + var onInteractionTraced = function onInteractionTraced(interaction) { + var didCatchError = false; + var caughtError = null; + subscribers.forEach(function(subscriber) { + try { + subscriber.onInteractionTraced(interaction); + } catch (error) { + if (!didCatchError) { + didCatchError = true; + caughtError = error; + } + } + }); + if (didCatchError) { + throw caughtError; + } + }; + var onInteractionScheduledWorkCompleted = function onInteractionScheduledWorkCompleted(interaction) { + var didCatchError = false; + var caughtError = null; + subscribers.forEach(function(subscriber) { + try { + subscriber.onInteractionScheduledWorkCompleted(interaction); + } catch (error) { + if (!didCatchError) { + didCatchError = true; + caughtError = error; + } + } + }); + if (didCatchError) { + throw caughtError; + } + }; + var onWorkScheduled = function onWorkScheduled(interactions, threadID) { + var didCatchError = false; + var caughtError = null; + subscribers.forEach(function(subscriber) { + try { + subscriber.onWorkScheduled(interactions, threadID); + } catch (error) { + if (!didCatchError) { + didCatchError = true; + caughtError = error; + } + } + }); + if (didCatchError) { + throw caughtError; + } + }; + var onWorkStarted = function onWorkStarted(interactions, threadID) { + var didCatchError = false; + var caughtError = null; + subscribers.forEach(function(subscriber) { + try { + subscriber.onWorkStarted(interactions, threadID); + } catch (error) { + if (!didCatchError) { + didCatchError = true; + caughtError = error; + } + } + }); + if (didCatchError) { + throw caughtError; + } + }; + var onWorkStopped = function onWorkStopped(interactions, threadID) { + var didCatchError = false; + var caughtError = null; + subscribers.forEach(function(subscriber) { + try { + subscriber.onWorkStopped(interactions, threadID); + } catch (error) { + if (!didCatchError) { + didCatchError = true; + caughtError = error; + } + } + }); + if (didCatchError) { + throw caughtError; + } + }; + var onWorkCanceled = function onWorkCanceled(interactions, threadID) { + var didCatchError = false; + var caughtError = null; + subscribers.forEach(function(subscriber) { + try { + subscriber.onWorkCanceled(interactions, threadID); + } catch (error) { + if (!didCatchError) { + didCatchError = true; + caughtError = error; + } + } + }); + if (didCatchError) { + throw caughtError; + } + }; + var DEFAULT_THREAD_ID = 0; + var interactionIDCounter = 0; + var threadIDCounter = 0; + exports.__interactionsRef = null; + exports.__subscriberRef = null; + { + exports.__interactionsRef = { + current: /* @__PURE__ */ new Set() + }; + exports.__subscriberRef = { + current: null + }; + } + var subscribers = null; + { + subscribers = /* @__PURE__ */ new Set(); + } + exports.unstable_clear = unstable_clear; + exports.unstable_getCurrent = unstable_getCurrent; + exports.unstable_getThreadID = unstable_getThreadID; + exports.unstable_subscribe = unstable_subscribe; + exports.unstable_trace = unstable_trace; + exports.unstable_unsubscribe = unstable_unsubscribe; + exports.unstable_wrap = unstable_wrap; + })(); + } + } +}); +// node_modules/scheduler/tracing.js +var require_tracing = __commonJS({ + "node_modules/scheduler/tracing.js": function(exports, module2) { + "use strict"; + if (false) { + module2.exports = null; + } else { + module2.exports = require_scheduler_tracing_development(); + } + } +}); +// node_modules/react-dom/cjs/react-dom.development.js +var require_react_dom_development = __commonJS({ + "node_modules/react-dom/cjs/react-dom.development.js": function(exports) { + "use strict"; + if (true) { + (function() { + "use strict"; + var warn = function warn(format) { + { + for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){ + args[_key - 1] = arguments[_key]; + } + printWarning("warn", format, args); + } + }; + var error = function error(format) { + { + for(var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++){ + args[_key2 - 1] = arguments[_key2]; + } + printWarning("error", format, args); + } + }; + var printWarning = function printWarning(level, format, args) { + { + var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame; + var stack = ReactDebugCurrentFrame2.getStackAddendum(); + if (stack !== "") { + format += "%s"; + args = args.concat([ + stack + ]); + } + var argsWithFormat = args.map(function(item) { + return "" + item; + }); + argsWithFormat.unshift("Warning: " + format); + Function.prototype.apply.call(console[level], console, argsWithFormat); + } + }; + var registerTwoPhaseEvent = function registerTwoPhaseEvent(registrationName, dependencies) { + registerDirectEvent(registrationName, dependencies); + registerDirectEvent(registrationName + "Capture", dependencies); + }; + var registerDirectEvent = function registerDirectEvent(registrationName, dependencies) { + { + if (registrationNameDependencies[registrationName]) { + error("EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.", registrationName); + } + } + registrationNameDependencies[registrationName] = dependencies; + { + var lowerCasedName = registrationName.toLowerCase(); + possibleRegistrationNames[lowerCasedName] = registrationName; + if (registrationName === "onDoubleClick") { + possibleRegistrationNames.ondblclick = registrationName; + } + } + for(var i = 0; i < dependencies.length; i++){ + allNativeEvents.add(dependencies[i]); + } + }; + var isAttributeNameSafe = function isAttributeNameSafe(attributeName) { + if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) { + return true; + } + if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) { + return false; + } + if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) { + validatedAttributeNameCache[attributeName] = true; + return true; + } + illegalAttributeNameCache[attributeName] = true; + { + error("Invalid attribute name: `%s`", attributeName); + } + return false; + }; + var shouldIgnoreAttribute = function shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null) { + return propertyInfo.type === RESERVED; + } + if (isCustomComponentTag) { + return false; + } + if (name.length > 2 && (name[0] === "o" || name[0] === "O") && (name[1] === "n" || name[1] === "N")) { + return true; + } + return false; + }; + var shouldRemoveAttributeWithWarning = function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) { + if (propertyInfo !== null && propertyInfo.type === RESERVED) { + return false; + } + switch(typeof value === "undefined" ? "undefined" : _type_of(value)){ + case "function": + case "symbol": + return true; + case "boolean": + { + if (isCustomComponentTag) { + return false; + } + if (propertyInfo !== null) { + return !propertyInfo.acceptsBooleans; + } else { + var prefix2 = name.toLowerCase().slice(0, 5); + return prefix2 !== "data-" && prefix2 !== "aria-"; + } + } + default: + return false; + } + }; + var shouldRemoveAttribute = function shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) { + if (value === null || typeof value === "undefined") { + return true; + } + if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) { + return true; + } + if (isCustomComponentTag) { + return false; + } + if (propertyInfo !== null) { + switch(propertyInfo.type){ + case BOOLEAN: + return !value; + case OVERLOADED_BOOLEAN: + return value === false; + case NUMERIC: + return isNaN(value); + case POSITIVE_NUMERIC: + return isNaN(value) || value < 1; + } + } + return false; + }; + var getPropertyInfo = function getPropertyInfo(name) { + return properties.hasOwnProperty(name) ? properties[name] : null; + }; + var PropertyInfoRecord = function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL2, removeEmptyString) { + this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN; + this.attributeName = attributeName; + this.attributeNamespace = attributeNamespace; + this.mustUseProperty = mustUseProperty; + this.propertyName = name; + this.type = type; + this.sanitizeURL = sanitizeURL2; + this.removeEmptyString = removeEmptyString; + }; + var sanitizeURL = function sanitizeURL(url) { + { + if (!didWarn && isJavaScriptProtocol.test(url)) { + didWarn = true; + error("A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe HTML try using dangerouslySetInnerHTML instead. React was passed %s.", JSON.stringify(url)); + } + } + }; + var getValueForProperty = function getValueForProperty(node, name, expected, propertyInfo) { + { + if (propertyInfo.mustUseProperty) { + var propertyName = propertyInfo.propertyName; + return node[propertyName]; + } else { + if (propertyInfo.sanitizeURL) { + sanitizeURL("" + expected); + } + var attributeName = propertyInfo.attributeName; + var stringValue = null; + if (propertyInfo.type === OVERLOADED_BOOLEAN) { + if (node.hasAttribute(attributeName)) { + var value = node.getAttribute(attributeName); + if (value === "") { + return true; + } + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return value; + } + if (value === "" + expected) { + return expected; + } + return value; + } + } else if (node.hasAttribute(attributeName)) { + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return node.getAttribute(attributeName); + } + if (propertyInfo.type === BOOLEAN) { + return expected; + } + stringValue = node.getAttribute(attributeName); + } + if (shouldRemoveAttribute(name, expected, propertyInfo, false)) { + return stringValue === null ? expected : stringValue; + } else if (stringValue === "" + expected) { + return expected; + } else { + return stringValue; + } + } + } + }; + var getValueForAttribute = function getValueForAttribute(node, name, expected) { + { + if (!isAttributeNameSafe(name)) { + return; + } + if (isOpaqueHydratingObject(expected)) { + return expected; + } + if (!node.hasAttribute(name)) { + return expected === void 0 ? void 0 : null; + } + var value = node.getAttribute(name); + if (value === "" + expected) { + return expected; + } + return value; + } + }; + var setValueForProperty = function setValueForProperty(node, name, value, isCustomComponentTag) { + var propertyInfo = getPropertyInfo(name); + if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) { + return; + } + if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) { + value = null; + } + if (isCustomComponentTag || propertyInfo === null) { + if (isAttributeNameSafe(name)) { + var _attributeName = name; + if (value === null) { + node.removeAttribute(_attributeName); + } else { + node.setAttribute(_attributeName, "" + value); + } + } + return; + } + var mustUseProperty = propertyInfo.mustUseProperty; + if (mustUseProperty) { + var propertyName = propertyInfo.propertyName; + if (value === null) { + var type = propertyInfo.type; + node[propertyName] = type === BOOLEAN ? false : ""; + } else { + node[propertyName] = value; + } + return; + } + var attributeName = propertyInfo.attributeName, attributeNamespace = propertyInfo.attributeNamespace; + if (value === null) { + node.removeAttribute(attributeName); + } else { + var _type = propertyInfo.type; + var attributeValue; + if (_type === BOOLEAN || _type === OVERLOADED_BOOLEAN && value === true) { + attributeValue = ""; + } else { + { + attributeValue = "" + value; + } + if (propertyInfo.sanitizeURL) { + sanitizeURL(attributeValue.toString()); + } + } + if (attributeNamespace) { + node.setAttributeNS(attributeNamespace, attributeName, attributeValue); + } else { + node.setAttribute(attributeName, attributeValue); + } + } + }; + var getIteratorFn = function getIteratorFn(maybeIterable) { + if (maybeIterable === null || typeof maybeIterable !== "object") { + return null; + } + var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; + if (typeof maybeIterator === "function") { + return maybeIterator; + } + return null; + }; + var disabledLog = function disabledLog() {}; + var disableLogs = function disableLogs() { + { + if (disabledDepth === 0) { + prevLog = console.log; + prevInfo = console.info; + prevWarn = console.warn; + prevError = console.error; + prevGroup = console.group; + prevGroupCollapsed = console.groupCollapsed; + prevGroupEnd = console.groupEnd; + var props = { + configurable: true, + enumerable: true, + value: disabledLog, + writable: true + }; + Object.defineProperties(console, { + info: props, + log: props, + warn: props, + error: props, + group: props, + groupCollapsed: props, + groupEnd: props + }); + } + disabledDepth++; + } + }; + var reenableLogs = function reenableLogs() { + { + disabledDepth--; + if (disabledDepth === 0) { + var props = { + configurable: true, + enumerable: true, + writable: true + }; + Object.defineProperties(console, { + log: _assign({}, props, { + value: prevLog + }), + info: _assign({}, props, { + value: prevInfo + }), + warn: _assign({}, props, { + value: prevWarn + }), + error: _assign({}, props, { + value: prevError + }), + group: _assign({}, props, { + value: prevGroup + }), + groupCollapsed: _assign({}, props, { + value: prevGroupCollapsed + }), + groupEnd: _assign({}, props, { + value: prevGroupEnd + }) + }); + } + if (disabledDepth < 0) { + error("disabledDepth fell below zero. This is a bug in React. Please file an issue."); + } + } + }; + var describeBuiltInComponentFrame = function describeBuiltInComponentFrame(name, source, ownerFn) { + { + if (prefix === void 0) { + try { + throw Error(); + } catch (x) { + var match2 = x.stack.trim().match(/\n( *(at )?)/); + prefix = match2 && match2[1] || ""; + } + } + return "\n" + prefix + name; + } + }; + var describeNativeComponentFrame = function describeNativeComponentFrame(fn, construct) { + if (!fn || reentry) { + return ""; + } + { + var frame = componentFrameCache.get(fn); + if (frame !== void 0) { + return frame; + } + } + var control; + reentry = true; + var previousPrepareStackTrace = Error.prepareStackTrace; + Error.prepareStackTrace = void 0; + var previousDispatcher; + { + previousDispatcher = ReactCurrentDispatcher.current; + ReactCurrentDispatcher.current = null; + disableLogs(); + } + try { + if (construct) { + var Fake = function Fake() { + throw Error(); + }; + Object.defineProperty(Fake.prototype, "props", { + set: function set() { + throw Error(); + } + }); + if (typeof Reflect === "object" && Reflect.construct) { + try { + Reflect.construct(Fake, []); + } catch (x) { + control = x; + } + Reflect.construct(fn, [], Fake); + } else { + try { + Fake.call(); + } catch (x) { + control = x; + } + fn.call(Fake.prototype); + } + } else { + try { + throw Error(); + } catch (x) { + control = x; + } + fn(); + } + } catch (sample) { + if (sample && control && typeof sample.stack === "string") { + var sampleLines = sample.stack.split("\n"); + var controlLines = control.stack.split("\n"); + var s = sampleLines.length - 1; + var c = controlLines.length - 1; + while(s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]){ + c--; + } + for(; s >= 1 && c >= 0; s--, c--){ + if (sampleLines[s] !== controlLines[c]) { + if (s !== 1 || c !== 1) { + do { + s--; + c--; + if (c < 0 || sampleLines[s] !== controlLines[c]) { + var _frame = "\n" + sampleLines[s].replace(" at new ", " at "); + { + if (typeof fn === "function") { + componentFrameCache.set(fn, _frame); + } + } + return _frame; + } + }while (s >= 1 && c >= 0); + } + break; + } + } + } + } finally{ + reentry = false; + { + ReactCurrentDispatcher.current = previousDispatcher; + reenableLogs(); + } + Error.prepareStackTrace = previousPrepareStackTrace; + } + var name = fn ? fn.displayName || fn.name : ""; + var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ""; + { + if (typeof fn === "function") { + componentFrameCache.set(fn, syntheticFrame); + } + } + return syntheticFrame; + }; + var describeClassComponentFrame = function describeClassComponentFrame(ctor, source, ownerFn) { + { + return describeNativeComponentFrame(ctor, true); + } + }; + var describeFunctionComponentFrame = function describeFunctionComponentFrame(fn, source, ownerFn) { + { + return describeNativeComponentFrame(fn, false); + } + }; + var shouldConstruct = function shouldConstruct(Component) { + var prototype = Component.prototype; + return !!(prototype && prototype.isReactComponent); + }; + var describeFiber = function describeFiber(fiber) { + var owner = fiber._debugOwner ? fiber._debugOwner.type : null; + var source = fiber._debugSource; + switch(fiber.tag){ + case HostComponent: + return describeBuiltInComponentFrame(fiber.type); + case LazyComponent: + return describeBuiltInComponentFrame("Lazy"); + case SuspenseComponent: + return describeBuiltInComponentFrame("Suspense"); + case SuspenseListComponent: + return describeBuiltInComponentFrame("SuspenseList"); + case FunctionComponent: + case IndeterminateComponent: + case SimpleMemoComponent: + return describeFunctionComponentFrame(fiber.type); + case ForwardRef: + return describeFunctionComponentFrame(fiber.type.render); + case Block: + return describeFunctionComponentFrame(fiber.type._render); + case ClassComponent: + return describeClassComponentFrame(fiber.type); + default: + return ""; + } + }; + var getStackByFiberInDevAndProd = function getStackByFiberInDevAndProd(workInProgress2) { + try { + var info = ""; + var node = workInProgress2; + do { + info += describeFiber(node); + node = node.return; + }while (node); + return info; + } catch (x) { + return "\nError generating stack: " + x.message + "\n" + x.stack; + } + }; + var getWrappedName = function getWrappedName(outerType, innerType, wrapperName) { + var functionName = innerType.displayName || innerType.name || ""; + return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName); + }; + var getContextName = function getContextName(type) { + return type.displayName || "Context"; + }; + var getCurrentFiberOwnerNameInDevOrNull = function getCurrentFiberOwnerNameInDevOrNull() { + { + if (current === null) { + return null; + } + var owner = current._debugOwner; + if (owner !== null && typeof owner !== "undefined") { + return getComponentName(owner.type); + } + } + return null; + }; + var getCurrentFiberStackInDev = function getCurrentFiberStackInDev() { + { + if (current === null) { + return ""; + } + return getStackByFiberInDevAndProd(current); + } + }; + var resetCurrentFiber = function resetCurrentFiber() { + { + ReactDebugCurrentFrame.getCurrentStack = null; + current = null; + isRendering = false; + } + }; + var setCurrentFiber = function setCurrentFiber(fiber) { + { + ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev; + current = fiber; + isRendering = false; + } + }; + var setIsRendering = function setIsRendering(rendering) { + { + isRendering = rendering; + } + }; + var getIsRendering = function getIsRendering() { + { + return isRendering; + } + }; + var toString = function toString(value) { + return "" + value; + }; + var getToStringValue = function getToStringValue(value) { + switch(typeof value === "undefined" ? "undefined" : _type_of(value)){ + case "boolean": + case "number": + case "object": + case "string": + case "undefined": + return value; + default: + return ""; + } + }; + var checkControlledValueProps = function checkControlledValueProps(tagName, props) { + { + if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) { + error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`."); + } + if (!(props.onChange || props.readOnly || props.disabled || props.checked == null)) { + error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`."); + } + } + }; + var isCheckable = function isCheckable(elem) { + var type = elem.type; + var nodeName = elem.nodeName; + return nodeName && nodeName.toLowerCase() === "input" && (type === "checkbox" || type === "radio"); + }; + var getTracker = function getTracker(node) { + return node._valueTracker; + }; + var detachTracker = function detachTracker(node) { + node._valueTracker = null; + }; + var getValueFromNode = function getValueFromNode(node) { + var value = ""; + if (!node) { + return value; + } + if (isCheckable(node)) { + value = node.checked ? "true" : "false"; + } else { + value = node.value; + } + return value; + }; + var trackValueOnNode = function trackValueOnNode(node) { + var valueField = isCheckable(node) ? "checked" : "value"; + var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField); + var currentValue = "" + node[valueField]; + if (node.hasOwnProperty(valueField) || typeof descriptor === "undefined" || typeof descriptor.get !== "function" || typeof descriptor.set !== "function") { + return; + } + var get2 = descriptor.get, set2 = descriptor.set; + Object.defineProperty(node, valueField, { + configurable: true, + get: function get() { + return get2.call(this); + }, + set: function set(value) { + currentValue = "" + value; + set2.call(this, value); + } + }); + Object.defineProperty(node, valueField, { + enumerable: descriptor.enumerable + }); + var tracker = { + getValue: function getValue() { + return currentValue; + }, + setValue: function setValue(value) { + currentValue = "" + value; + }, + stopTracking: function stopTracking() { + detachTracker(node); + delete node[valueField]; + } + }; + return tracker; + }; + var track = function track(node) { + if (getTracker(node)) { + return; + } + node._valueTracker = trackValueOnNode(node); + }; + var updateValueIfChanged = function updateValueIfChanged(node) { + if (!node) { + return false; + } + var tracker = getTracker(node); + if (!tracker) { + return true; + } + var lastValue = tracker.getValue(); + var nextValue = getValueFromNode(node); + if (nextValue !== lastValue) { + tracker.setValue(nextValue); + return true; + } + return false; + }; + var getActiveElement = function getActiveElement(doc) { + doc = doc || (typeof document !== "undefined" ? document : void 0); + if (typeof doc === "undefined") { + return null; + } + try { + return doc.activeElement || doc.body; + } catch (e) { + return doc.body; + } + }; + var isControlled = function isControlled(props) { + var usesChecked = props.type === "checkbox" || props.type === "radio"; + return usesChecked ? props.checked != null : props.value != null; + }; + var getHostProps = function getHostProps(element, props) { + var node = element; + var checked = props.checked; + var hostProps = _assign({}, props, { + defaultChecked: void 0, + defaultValue: void 0, + value: void 0, + checked: checked != null ? checked : node._wrapperState.initialChecked + }); + return hostProps; + }; + var initWrapperState = function initWrapperState(element, props) { + { + checkControlledValueProps("input", props); + if (props.checked !== void 0 && props.defaultChecked !== void 0 && !didWarnCheckedDefaultChecked) { + error("%s contains an input of type %s with both checked and defaultChecked props. Input elements must be either controlled or uncontrolled (specify either the checked prop, or the defaultChecked prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type); + didWarnCheckedDefaultChecked = true; + } + if (props.value !== void 0 && props.defaultValue !== void 0 && !didWarnValueDefaultValue) { + error("%s contains an input of type %s with both value and defaultValue props. Input elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://reactjs.org/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component", props.type); + didWarnValueDefaultValue = true; + } + } + var node = element; + var defaultValue = props.defaultValue == null ? "" : props.defaultValue; + node._wrapperState = { + initialChecked: props.checked != null ? props.checked : props.defaultChecked, + initialValue: getToStringValue(props.value != null ? props.value : defaultValue), + controlled: isControlled(props) + }; + }; + var updateChecked = function updateChecked(element, props) { + var node = element; + var checked = props.checked; + if (checked != null) { + setValueForProperty(node, "checked", checked, false); + } + }; + var updateWrapper = function updateWrapper(element, props) { + var node = element; + { + var controlled = isControlled(props); + if (!node._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) { + error("A component is changing an uncontrolled input to be controlled. This is likely caused by the value changing from undefined to a defined value, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"); + didWarnUncontrolledToControlled = true; + } + if (node._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) { + error("A component is changing a controlled input to be uncontrolled. This is likely caused by the value changing from a defined to undefined, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://reactjs.org/link/controlled-components"); + didWarnControlledToUncontrolled = true; + } + } + updateChecked(element, props); + var value = getToStringValue(props.value); + var type = props.type; + if (value != null) { + if (type === "number") { + if (value === 0 && node.value === "" || // We explicitly want to coerce to number here if possible. + // eslint-disable-next-line + node.value != value) { + node.value = toString(value); + } + } else if (node.value !== toString(value)) { + node.value = toString(value); + } + } else if (type === "submit" || type === "reset") { + node.removeAttribute("value"); + return; + } + { + if (props.hasOwnProperty("value")) { + setDefaultValue(node, props.type, value); + } else if (props.hasOwnProperty("defaultValue")) { + setDefaultValue(node, props.type, getToStringValue(props.defaultValue)); + } + } + { + if (props.checked == null && props.defaultChecked != null) { + node.defaultChecked = !!props.defaultChecked; + } + } + }; + var postMountWrapper = function postMountWrapper(element, props, isHydrating2) { + var node = element; + if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) { + var type = props.type; + var isButton = type === "submit" || type === "reset"; + if (isButton && (props.value === void 0 || props.value === null)) { + return; + } + var initialValue = toString(node._wrapperState.initialValue); + if (!isHydrating2) { + { + if (initialValue !== node.value) { + node.value = initialValue; + } + } + } + { + node.defaultValue = initialValue; + } + } + var name = node.name; + if (name !== "") { + node.name = ""; + } + { + node.defaultChecked = !node.defaultChecked; + node.defaultChecked = !!node._wrapperState.initialChecked; + } + if (name !== "") { + node.name = name; + } + }; + var restoreControlledState = function restoreControlledState(element, props) { + var node = element; + updateWrapper(node, props); + updateNamedCousins(node, props); + }; + var updateNamedCousins = function updateNamedCousins(rootNode, props) { + var name = props.name; + if (props.type === "radio" && name != null) { + var queryRoot = rootNode; + while(queryRoot.parentNode){ + queryRoot = queryRoot.parentNode; + } + var group = queryRoot.querySelectorAll("input[name=" + JSON.stringify("" + name) + '][type="radio"]'); + for(var i = 0; i < group.length; i++){ + var otherNode = group[i]; + if (otherNode === rootNode || otherNode.form !== rootNode.form) { + continue; + } + var otherProps = getFiberCurrentPropsFromNode(otherNode); + if (!otherProps) { + { + throw Error("ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported."); + } + } + updateValueIfChanged(otherNode); + updateWrapper(otherNode, otherProps); + } + } + }; + var setDefaultValue = function setDefaultValue(node, type, value) { + if (// Focused number inputs synchronize on blur. See ChangeEventPlugin.js + type !== "number" || getActiveElement(node.ownerDocument) !== node) { + if (value == null) { + node.defaultValue = toString(node._wrapperState.initialValue); + } else if (node.defaultValue !== toString(value)) { + node.defaultValue = toString(value); + } + } + }; + var flattenChildren = function flattenChildren(children) { + var content = ""; + React6.Children.forEach(children, function(child) { + if (child == null) { + return; + } + content += child; + }); + return content; + }; + var validateProps = function validateProps(element, props) { + { + if (typeof props.children === "object" && props.children !== null) { + React6.Children.forEach(props.children, function(child) { + if (child == null) { + return; + } + if (typeof child === "string" || typeof child === "number") { + return; + } + if (typeof child.type !== "string") { + return; + } + if (!didWarnInvalidChild) { + didWarnInvalidChild = true; + error("Only strings and numbers are supported as