text: /******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 670:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var isObject = __webpack_require__(111);
  
  module.exports = function (it) {
    if (!isObject(it)) {
      throw TypeError(String(it) + ' is not an object');
    } return it;
  };
  
  
  /***/ }),
  
  /***/ 318:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var toIndexedObject = __webpack_require__(656);
  var toLength = __webpack_require__(466);
  var toAbsoluteIndex = __webpack_require__(400);
  
  // `Array.prototype.{ indexOf, includes }` methods implementation
  var createMethod = function (IS_INCLUDES) {
    return function ($this, el, fromIndex) {
      var O = toIndexedObject($this);
      var length = toLength(O.length);
      var index = toAbsoluteIndex(fromIndex, length);
      var value;
      // Array#includes uses SameValueZero equality algorithm
      // eslint-disable-next-line no-self-compare
      if (IS_INCLUDES && el != el) while (length > index) {
        value = O[index++];
        // eslint-disable-next-line no-self-compare
        if (value != value) return true;
      // Array#indexOf ignores holes, Array#includes - not
      } else for (;length > index; index++) {
        if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
      } return !IS_INCLUDES && -1;
    };
  };
  
  module.exports = {
    // `Array.prototype.includes` method
    // https://tc39.es/ecma262/#sec-array.prototype.includes
    includes: createMethod(true),
    // `Array.prototype.indexOf` method
    // https://tc39.es/ecma262/#sec-array.prototype.indexof
    indexOf: createMethod(false)
  };
  
  
  /***/ }),
  
  /***/ 326:
  /***/ ((module) => {
  
  var toString = {}.toString;
  
  module.exports = function (it) {
    return toString.call(it).slice(8, -1);
  };
  
  
  /***/ }),
  
  /***/ 920:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var has = __webpack_require__(871);
  var ownKeys = __webpack_require__(887);
  var getOwnPropertyDescriptorModule = __webpack_require__(236);
  var definePropertyModule = __webpack_require__(70);
  
  module.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));
    }
  };
  
  
  /***/ }),
  
  /***/ 880:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var DESCRIPTORS = __webpack_require__(781);
  var definePropertyModule = __webpack_require__(70);
  var createPropertyDescriptor = __webpack_require__(114);
  
  module.exports = DESCRIPTORS ? function (object, key, value) {
    return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
  } : function (object, key, value) {
    object[key] = value;
    return object;
  };
  
  
  /***/ }),
  
  /***/ 114:
  /***/ ((module) => {
  
  module.exports = function (bitmap, value) {
    return {
      enumerable: !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable: !(bitmap & 4),
      value: value
    };
  };
  
  
  /***/ }),
  
  /***/ 781:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var fails = __webpack_require__(293);
  
  // Detect IE8's incomplete defineProperty implementation
  module.exports = !fails(function () {
    return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
  });
  
  
  /***/ }),
  
  /***/ 317:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var global = __webpack_require__(854);
  var isObject = __webpack_require__(111);
  
  var document = global.document;
  // typeof document.createElement is 'object' in old IE
  var EXISTS = isObject(document) && isObject(document.createElement);
  
  module.exports = function (it) {
    return EXISTS ? document.createElement(it) : {};
  };
  
  
  /***/ }),
  
  /***/ 748:
  /***/ ((module) => {
  
  // IE8- don't enum bug keys
  module.exports = [
    'constructor',
    'hasOwnProperty',
    'isPrototypeOf',
    'propertyIsEnumerable',
    'toLocaleString',
    'toString',
    'valueOf'
  ];
  
  
  /***/ }),
  
  /***/ 109:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var global = __webpack_require__(854);
  var getOwnPropertyDescriptor = __webpack_require__(236).f;
  var createNonEnumerableProperty = __webpack_require__(880);
  var redefine = __webpack_require__(320);
  var setGlobal = __webpack_require__(505);
  var copyConstructorProperties = __webpack_require__(920);
  var isForced = __webpack_require__(705);
  
  /*
    options.target      - name of the target object
    options.global      - target is the global object
    options.stat        - export as static methods of target
    options.proto       - export as prototype methods of target
    options.real        - real prototype method for the `pure` version
    options.forced      - export even if the native feature is available
    options.bind        - bind methods to the target, required for the `pure` version
    options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
    options.unsafe      - use the simple assignment of property instead of delete + defineProperty
    options.sham        - add a flag to not completely full polyfills
    options.enumerable  - export as enumerable property
    options.noTargetGet - prevent calling a getter on target
  */
  module.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 = global;
    } else if (STATIC) {
      target = global[TARGET] || setGlobal(TARGET, {});
    } else {
      target = (global[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);
      // contained in target
      if (!FORCED && targetProperty !== undefined) {
        if (typeof sourceProperty === typeof targetProperty) continue;
        copyConstructorProperties(sourceProperty, targetProperty);
      }
      // add a flag to not completely full polyfills
      if (options.sham || (targetProperty && targetProperty.sham)) {
        createNonEnumerableProperty(sourceProperty, 'sham', true);
      }
      // extend global
      redefine(target, key, sourceProperty, options);
    }
  };
  
  
  /***/ }),
  
  /***/ 293:
  /***/ ((module) => {
  
  module.exports = function (exec) {
    try {
      return !!exec();
    } catch (error) {
      return true;
    }
  };
  
  
  /***/ }),
  
  /***/ 5:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var path = __webpack_require__(857);
  var global = __webpack_require__(854);
  
  var aFunction = function (variable) {
    return typeof variable == 'function' ? variable : undefined;
  };
  
  module.exports = function (namespace, method) {
    return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])
      : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
  };
  
  
  /***/ }),
  
  /***/ 854:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var check = function (it) {
    return it && it.Math == Math && it;
  };
  
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  module.exports =
    // eslint-disable-next-line no-undef
    check(typeof globalThis == 'object' && globalThis) ||
    check(typeof window == 'object' && window) ||
    check(typeof self == 'object' && self) ||
    check(typeof __webpack_require__.g == 'object' && __webpack_require__.g) ||
    // eslint-disable-next-line no-new-func
    (function () { return this; })() || Function('return this')();
  
  
  /***/ }),
  
  /***/ 871:
  /***/ ((module) => {
  
  var hasOwnProperty = {}.hasOwnProperty;
  
  module.exports = function (it, key) {
    return hasOwnProperty.call(it, key);
  };
  
  
  /***/ }),
  
  /***/ 501:
  /***/ ((module) => {
  
  module.exports = {};
  
  
  /***/ }),
  
  /***/ 664:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var DESCRIPTORS = __webpack_require__(781);
  var fails = __webpack_require__(293);
  var createElement = __webpack_require__(317);
  
  // Thank's IE8 for his funny defineProperty
  module.exports = !DESCRIPTORS && !fails(function () {
    return Object.defineProperty(createElement('div'), 'a', {
      get: function () { return 7; }
    }).a != 7;
  });
  
  
  /***/ }),
  
  /***/ 361:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var fails = __webpack_require__(293);
  var classof = __webpack_require__(326);
  
  var split = ''.split;
  
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
  module.exports = fails(function () {
    // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
    // eslint-disable-next-line no-prototype-builtins
    return !Object('z').propertyIsEnumerable(0);
  }) ? function (it) {
    return classof(it) == 'String' ? split.call(it, '') : Object(it);
  } : Object;
  
  
  /***/ }),
  
  /***/ 788:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var store = __webpack_require__(465);
  
  var functionToString = Function.toString;
  
  // this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper
  if (typeof store.inspectSource != 'function') {
    store.inspectSource = function (it) {
      return functionToString.call(it);
    };
  }
  
  module.exports = store.inspectSource;
  
  
  /***/ }),
  
  /***/ 909:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var NATIVE_WEAK_MAP = __webpack_require__(536);
  var global = __webpack_require__(854);
  var isObject = __webpack_require__(111);
  var createNonEnumerableProperty = __webpack_require__(880);
  var objectHas = __webpack_require__(871);
  var shared = __webpack_require__(465);
  var sharedKey = __webpack_require__(200);
  var hiddenKeys = __webpack_require__(501);
  
  var WeakMap = global.WeakMap;
  var set, get, has;
  
  var enforce = function (it) {
    return has(it) ? get(it) : set(it, {});
  };
  
  var getterFor = function (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) {
    var store = shared.state || (shared.state = new WeakMap());
    var wmget = store.get;
    var wmhas = store.has;
    var wmset = store.set;
    set = function (it, metadata) {
      metadata.facade = it;
      wmset.call(store, it, metadata);
      return metadata;
    };
    get = function (it) {
      return wmget.call(store, it) || {};
    };
    has = function (it) {
      return wmhas.call(store, it);
    };
  } else {
    var STATE = sharedKey('state');
    hiddenKeys[STATE] = true;
    set = function (it, metadata) {
      metadata.facade = it;
      createNonEnumerableProperty(it, STATE, metadata);
      return metadata;
    };
    get = function (it) {
      return objectHas(it, STATE) ? it[STATE] : {};
    };
    has = function (it) {
      return objectHas(it, STATE);
    };
  }
  
  module.exports = {
    set: set,
    get: get,
    has: has,
    enforce: enforce,
    getterFor: getterFor
  };
  
  
  /***/ }),
  
  /***/ 705:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var fails = __webpack_require__(293);
  
  var replacement = /#|\.prototype\./;
  
  var isForced = function (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 (string) {
    return String(string).replace(replacement, '.').toLowerCase();
  };
  
  var data = isForced.data = {};
  var NATIVE = isForced.NATIVE = 'N';
  var POLYFILL = isForced.POLYFILL = 'P';
  
  module.exports = isForced;
  
  
  /***/ }),
  
  /***/ 111:
  /***/ ((module) => {
  
  module.exports = function (it) {
    return typeof it === 'object' ? it !== null : typeof it === 'function';
  };
  
  
  /***/ }),
  
  /***/ 913:
  /***/ ((module) => {
  
  module.exports = false;
  
  
  /***/ }),
  
  /***/ 536:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var global = __webpack_require__(854);
  var inspectSource = __webpack_require__(788);
  
  var WeakMap = global.WeakMap;
  
  module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));
  
  
  /***/ }),
  
  /***/ 70:
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
  
  var DESCRIPTORS = __webpack_require__(781);
  var IE8_DOM_DEFINE = __webpack_require__(664);
  var anObject = __webpack_require__(670);
  var toPrimitive = __webpack_require__(593);
  
  var nativeDefineProperty = Object.defineProperty;
  
  // `Object.defineProperty` method
  // https://tc39.es/ecma262/#sec-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) { /* empty */ }
    if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
    if ('value' in Attributes) O[P] = Attributes.value;
    return O;
  };
  
  
  /***/ }),
  
  /***/ 236:
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
  
  var DESCRIPTORS = __webpack_require__(781);
  var propertyIsEnumerableModule = __webpack_require__(296);
  var createPropertyDescriptor = __webpack_require__(114);
  var toIndexedObject = __webpack_require__(656);
  var toPrimitive = __webpack_require__(593);
  var has = __webpack_require__(871);
  var IE8_DOM_DEFINE = __webpack_require__(664);
  
  var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  
  // `Object.getOwnPropertyDescriptor` method
  // https://tc39.es/ecma262/#sec-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) { /* empty */ }
    if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
  };
  
  
  /***/ }),
  
  /***/ 6:
  /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
  
  var internalObjectKeys = __webpack_require__(324);
  var enumBugKeys = __webpack_require__(748);
  
  var hiddenKeys = enumBugKeys.concat('length', 'prototype');
  
  // `Object.getOwnPropertyNames` method
  // https://tc39.es/ecma262/#sec-object.getownpropertynames
  exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
    return internalObjectKeys(O, hiddenKeys);
  };
  
  
  /***/ }),
  
  /***/ 181:
  /***/ ((__unused_webpack_module, exports) => {
  
  exports.f = Object.getOwnPropertySymbols;
  
  
  /***/ }),
  
  /***/ 324:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var has = __webpack_require__(871);
  var toIndexedObject = __webpack_require__(656);
  var indexOf = __webpack_require__(318).indexOf;
  var hiddenKeys = __webpack_require__(501);
  
  module.exports = function (object, names) {
    var O = toIndexedObject(object);
    var i = 0;
    var result = [];
    var key;
    for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
    // Don't enum bug & hidden keys
    while (names.length > i) if (has(O, key = names[i++])) {
      ~indexOf(result, key) || result.push(key);
    }
    return result;
  };
  
  
  /***/ }),
  
  /***/ 296:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  
  // Nashorn ~ JDK8 bug
  var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
  
  // `Object.prototype.propertyIsEnumerable` method implementation
  // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
  exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
    var descriptor = getOwnPropertyDescriptor(this, V);
    return !!descriptor && descriptor.enumerable;
  } : nativePropertyIsEnumerable;
  
  
  /***/ }),
  
  /***/ 887:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var getBuiltIn = __webpack_require__(5);
  var getOwnPropertyNamesModule = __webpack_require__(6);
  var getOwnPropertySymbolsModule = __webpack_require__(181);
  var anObject = __webpack_require__(670);
  
  // all object keys, includes non-enumerable and symbols
  module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
    var keys = getOwnPropertyNamesModule.f(anObject(it));
    var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
    return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
  };
  
  
  /***/ }),
  
  /***/ 857:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var global = __webpack_require__(854);
  
  module.exports = global;
  
  
  /***/ }),
  
  /***/ 320:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var global = __webpack_require__(854);
  var createNonEnumerableProperty = __webpack_require__(880);
  var has = __webpack_require__(871);
  var setGlobal = __webpack_require__(505);
  var inspectSource = __webpack_require__(788);
  var InternalStateModule = __webpack_require__(909);
  
  var getInternalState = InternalStateModule.get;
  var enforceInternalState = InternalStateModule.enforce;
  var TEMPLATE = String(String).split('String');
  
  (module.exports = function (O, key, value, options) {
    var unsafe = options ? !!options.unsafe : false;
    var simple = options ? !!options.enumerable : false;
    var noTargetGet = options ? !!options.noTargetGet : false;
    var state;
    if (typeof value == 'function') {
      if (typeof key == 'string' && !has(value, 'name')) {
        createNonEnumerableProperty(value, 'name', key);
      }
      state = enforceInternalState(value);
      if (!state.source) {
        state.source = TEMPLATE.join(typeof key == 'string' ? key : '');
      }
    }
    if (O === global) {
      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);
  // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
  })(Function.prototype, 'toString', function toString() {
    return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
  });
  
  
  /***/ }),
  
  /***/ 66:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  "use strict";
  
  var anObject = __webpack_require__(670);
  
  // `RegExp.prototype.flags` getter implementation
  // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
  module.exports = function () {
    var that = anObject(this);
    var result = '';
    if (that.global) result += 'g';
    if (that.ignoreCase) result += 'i';
    if (that.multiline) result += 'm';
    if (that.dotAll) result += 's';
    if (that.unicode) result += 'u';
    if (that.sticky) result += 'y';
    return result;
  };
  
  
  /***/ }),
  
  /***/ 488:
  /***/ ((module) => {
  
  // `RequireObjectCoercible` abstract operation
  // https://tc39.es/ecma262/#sec-requireobjectcoercible
  module.exports = function (it) {
    if (it == undefined) throw TypeError("Can't call method on " + it);
    return it;
  };
  
  
  /***/ }),
  
  /***/ 505:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var global = __webpack_require__(854);
  var createNonEnumerableProperty = __webpack_require__(880);
  
  module.exports = function (key, value) {
    try {
      createNonEnumerableProperty(global, key, value);
    } catch (error) {
      global[key] = value;
    } return value;
  };
  
  
  /***/ }),
  
  /***/ 200:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var shared = __webpack_require__(309);
  var uid = __webpack_require__(711);
  
  var keys = shared('keys');
  
  module.exports = function (key) {
    return keys[key] || (keys[key] = uid(key));
  };
  
  
  /***/ }),
  
  /***/ 465:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var global = __webpack_require__(854);
  var setGlobal = __webpack_require__(505);
  
  var SHARED = '__core-js_shared__';
  var store = global[SHARED] || setGlobal(SHARED, {});
  
  module.exports = store;
  
  
  /***/ }),
  
  /***/ 309:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var IS_PURE = __webpack_require__(913);
  var store = __webpack_require__(465);
  
  (module.exports = function (key, value) {
    return store[key] || (store[key] = value !== undefined ? value : {});
  })('versions', []).push({
    version: '3.8.3',
    mode: IS_PURE ? 'pure' : 'global',
    copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
  });
  
  
  /***/ }),
  
  /***/ 400:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var toInteger = __webpack_require__(958);
  
  var max = Math.max;
  var min = Math.min;
  
  // Helper for a popular repeating case of the spec:
  // Let integer be ? ToInteger(index).
  // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
  module.exports = function (index, length) {
    var integer = toInteger(index);
    return integer < 0 ? max(integer + length, 0) : min(integer, length);
  };
  
  
  /***/ }),
  
  /***/ 656:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  // toObject with fallback for non-array-like ES3 strings
  var IndexedObject = __webpack_require__(361);
  var requireObjectCoercible = __webpack_require__(488);
  
  module.exports = function (it) {
    return IndexedObject(requireObjectCoercible(it));
  };
  
  
  /***/ }),
  
  /***/ 958:
  /***/ ((module) => {
  
  var ceil = Math.ceil;
  var floor = Math.floor;
  
  // `ToInteger` abstract operation
  // https://tc39.es/ecma262/#sec-tointeger
  module.exports = function (argument) {
    return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
  };
  
  
  /***/ }),
  
  /***/ 466:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var toInteger = __webpack_require__(958);
  
  var min = Math.min;
  
  // `ToLength` abstract operation
  // https://tc39.es/ecma262/#sec-tolength
  module.exports = function (argument) {
    return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
  };
  
  
  /***/ }),
  
  /***/ 593:
  /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
  
  var isObject = __webpack_require__(111);
  
  // `ToPrimitive` abstract operation
  // https://tc39.es/ecma262/#sec-toprimitive
  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string
  module.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");
  };
  
  
  /***/ }),
  
  /***/ 711:
  /***/ ((module) => {
  
  var id = 0;
  var postfix = Math.random();
  
  module.exports = function (key) {
    return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
  };
  
  
  /***/ }),
  
  /***/ 714:
  /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
  
  "use strict";
  
  var redefine = __webpack_require__(320);
  var anObject = __webpack_require__(670);
  var fails = __webpack_require__(293);
  var flags = __webpack_require__(66);
  
  var TO_STRING = 'toString';
  var RegExpPrototype = RegExp.prototype;
  var nativeToString = RegExpPrototype[TO_STRING];
  
  var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
  // FF44- RegExp#toString has a wrong name
  var INCORRECT_NAME = nativeToString.name != TO_STRING;
  
  // `RegExp.prototype.toString` method
  // https://tc39.es/ecma262/#sec-regexp.prototype.tostring
  if (NOT_GENERIC || INCORRECT_NAME) {
    redefine(RegExp.prototype, TO_STRING, function toString() {
      var R = anObject(this);
      var p = String(R.source);
      var rf = R.flags;
      var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? flags.call(R) : rf);
      return '/' + p + '/' + f;
    }, { unsafe: true });
  }
  
  
  /***/ }),
  
  /***/ 817:
  /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
  
  "use strict";
  // `Symbol.prototype.description` getter
  // https://tc39.es/ecma262/#sec-symbol.prototype.description
  
  var $ = __webpack_require__(109);
  var DESCRIPTORS = __webpack_require__(781);
  var global = __webpack_require__(854);
  var has = __webpack_require__(871);
  var isObject = __webpack_require__(111);
  var defineProperty = __webpack_require__(70).f;
  var copyConstructorProperties = __webpack_require__(920);
  
  var NativeSymbol = global.Symbol;
  
  if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||
    // Safari 12 bug
    NativeSymbol().description !== undefined
  )) {
    var EmptyStringDescriptionStore = {};
    // wrap Symbol constructor for correct work with undefined description
    var SymbolWrapper = function Symbol() {
      var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);
      var result = this instanceof SymbolWrapper
        ? new NativeSymbol(description)
        // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
        : description === undefined ? NativeSymbol() : NativeSymbol(description);
      if (description === '') EmptyStringDescriptionStore[result] = true;
      return result;
    };
    copyConstructorProperties(SymbolWrapper, NativeSymbol);
    var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;
    symbolPrototype.constructor = SymbolWrapper;
  
    var symbolToString = symbolPrototype.toString;
    var native = String(NativeSymbol('test')) == 'Symbol(test)';
    var regexp = /^Symbol\((.*)\)[^)]+$/;
    defineProperty(symbolPrototype, 'description', {
      configurable: true,
      get: function description() {
        var symbol = isObject(this) ? this.valueOf() : this;
        var string = symbolToString.call(symbol);
        if (has(EmptyStringDescriptionStore, symbol)) return '';
        var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');
        return desc === '' ? undefined : desc;
      }
    });
  
    $({ global: true, forced: true }, {
      Symbol: SymbolWrapper
    });
  }
  
  
  /***/ })
  
  /******/ 	});
  /************************************************************************/
  /******/ 	// The module cache
  /******/ 	var __webpack_module_cache__ = {};
  /******/ 	
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/ 		// Check if module is in cache
  /******/ 		if(__webpack_module_cache__[moduleId]) {
  /******/ 			return __webpack_module_cache__[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = __webpack_module_cache__[moduleId] = {
  /******/ 			// no module.id needed
  /******/ 			// no module.loaded needed
  /******/ 			exports: {}
  /******/ 		};
  /******/ 	
  /******/ 		// Execute the module function
  /******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/global */
  /******/ 	(() => {
  /******/ 		__webpack_require__.g = (function() {
  /******/ 			if (typeof globalThis === 'object') return globalThis;
  /******/ 			try {
  /******/ 				return this || new Function('return this')();
  /******/ 			} catch (e) {
  /******/ 				if (typeof window === 'object') return window;
  /******/ 			}
  /******/ 		})();
  /******/ 	})();
  /******/ 	
  /************************************************************************/
  (() => {
  "use strict";
  
  // EXTERNAL MODULE: ./node_modules/core-js/modules/es.symbol.description.js
  var es_symbol_description = __webpack_require__(817);
  ;// CONCATENATED MODULE: ./node_modules/@mrhenry/core-web/helpers/_ESAbstract.Type.js
  
  
  function _ESAbstract_Type_Type(x) {
    switch (typeof x) {
      case 'undefined':
        return 'undefined';
  
      case 'boolean':
        return 'boolean';
  
      case 'number':
        return 'number';
  
      case 'string':
        return 'string';
  
      case 'symbol':
        return 'symbol';
  
      default:
        if (x === null) return 'null';
        if ('Symbol' in self && (x instanceof self.Symbol || x.constructor === self.Symbol)) return 'symbol';
        return 'object';
    }
  }
  
  /* harmony default export */ const _ESAbstract_Type = ((/* unused pure expression or super */ null && (_ESAbstract_Type_Type)));
  // EXTERNAL MODULE: ./node_modules/core-js/modules/es.regexp.to-string.js
  var es_regexp_to_string = __webpack_require__(714);
  ;// CONCATENATED MODULE: ./node_modules/@mrhenry/core-web/helpers/_ESAbstract.Call.js
  
  
  function _ESAbstract_Call_Call(F, V) {
    var argumentsList = arguments.length > 2 ? arguments[2] : [];
  
    if (IsCallable(F) === false) {
      throw new TypeError(Object.prototype.toString.call(F) + 'is not a function.');
    }
  
    return F.apply(V, argumentsList);
  }
  
  /* harmony default export */ const _ESAbstract_Call = ((/* unused pure expression or super */ null && (_ESAbstract_Call_Call)));
  ;// CONCATENATED MODULE: ./node_modules/@mrhenry/core-web/helpers/_ESAbstract.OrdinaryToPrimitive.js
  
  
  
  
  
  function _ESAbstract_OrdinaryToPrimitive_OrdinaryToPrimitive(O, hint) {
    if (hint === 'string') {
      var methodNames = ['toString', 'valueOf'];
    } else {
      methodNames = ['valueOf', 'toString'];
    }
  
    for (var i = 0; i < methodNames.length; ++i) {
      var name = methodNames[i];
      var method = Get(O, name);
  
      if (IsCallable(method)) {
        var result = Call(method, O);
  
        if (Type(result) !== 'object') {
          return result;
        }
      }
    }
  
    throw new TypeError('Cannot convert to primitive.');
  }
  
  /* harmony default export */ const _ESAbstract_OrdinaryToPrimitive = ((/* unused pure expression or super */ null && (_ESAbstract_OrdinaryToPrimitive_OrdinaryToPrimitive)));
  ;// CONCATENATED MODULE: ./node_modules/@mrhenry/core-web/helpers/_ESAbstract.ToPrimitive.js
  
  
  
  
  
  
  
  
  
  
  function _ESAbstract_ToPrimitive_ToPrimitive(input) {
    var PreferredType = arguments.length > 1 ? arguments[1] : undefined;
  
    if (Type(input) === 'object') {
      if (arguments.length < 2) {
        var hint = 'default';
      } else if (PreferredType === String) {
        hint = 'string';
      } else if (PreferredType === Number) {
        hint = 'number';
      }
  
      var exoticToPrim = typeof self.Symbol === 'function' && typeof self.Symbol.toPrimitive === 'symbol' ? GetMethod(input, self.Symbol.toPrimitive) : undefined;
  
      if (exoticToPrim !== undefined) {
        var result = Call(exoticToPrim, input, [hint]);
  
        if (Type(result) !== 'object') {
          return result;
        }
  
        throw new TypeError('Cannot convert exotic object to primitive.');
      }
  
      if (hint === 'default') {
        hint = 'number';
      }
  
      return OrdinaryToPrimitive(input, hint);
    }
  
    return input;
  }
  
  /* harmony default export */ const _ESAbstract_ToPrimitive = ((/* unused pure expression or super */ null && (_ESAbstract_ToPrimitive_ToPrimitive)));
  ;// CONCATENATED MODULE: ./node_modules/@mrhenry/core-web/helpers/_ESAbstract.ToString.js
  
  
  
  
  
  
  
  
  
  
  function _ESAbstract_ToString_ToString(argument) {
    switch (Type(argument)) {
      case 'symbol':
        throw new TypeError('Cannot convert a Symbol value to a string');
  
      case 'object':
        var primValue = ToPrimitive(argument, String);
        return _ESAbstract_ToString_ToString(primValue);
  
      default:
        return String(argument);
    }
  }
  
  /* harmony default export */ const _ESAbstract_ToString = ((/* unused pure expression or super */ null && (_ESAbstract_ToString_ToString)));
  ;// CONCATENATED MODULE: ./node_modules/@mrhenry/core-web/helpers/_ESAbstract.ToPropertyKey.js
  
  
  
  
  
  
  
  
  
  
  
  function ToPropertyKey(argument) {
    var key = ToPrimitive(argument, String);
  
    if (Type(key) === 'symbol') {
      return key;
    }
  
    return ToString(key);
  }
  
  /* harmony default export */ const _ESAbstract_ToPropertyKey = ((/* unused pure expression or super */ null && (ToPropertyKey)));
  ;// CONCATENATED MODULE: ./node_modules/@mrhenry/core-web/modules/DOMRect.js
  
  
  
  
  
  
  
  
  
  
  
  
  
  (function (undefined) {
    if (!("DOMRect" in self && function (e) {
      try {
        return new e();
      } catch (t) {
        return !1;
      }
    }(self.DOMRect))) {
      (function (global) {
        function number(v) {
          return v === undefined ? 0 : Number(v);
        }
  
        function different(u, v) {
          return u !== v && !(isNaN(u) && isNaN(v));
        }
  
        function DOMRect(xArg, yArg, wArg, hArg) {
          var x, y, width, height, left, right, top, bottom;
          x = number(xArg);
          y = number(yArg);
          width = number(wArg);
          height = number(hArg);
          Object.defineProperties(this, {
            x: {
              get: function () {
                return x;
              },
              set: function (newX) {
                if (different(x, newX)) {
                  x = newX;
                  left = right = undefined;
                }
              },
              enumerable: true
            },
            y: {
              get: function () {
                return y;
              },
              set: function (newY) {
                if (different(y, newY)) {
                  y = newY;
                  top = bottom = undefined;
                }
              },
              enumerable: true
            },
            width: {
              get: function () {
                return width;
              },
              set: function (newWidth) {
                if (different(width, newWidth)) {
                  width = newWidth;
                  left = right = undefined;
                }
              },
              enumerable: true
            },
            height: {
              get: function () {
                return height;
              },
              set: function (newHeight) {
                if (different(height, newHeight)) {
                  height = newHeight;
                  top = bottom = undefined;
                }
              },
              enumerable: true
            },
            left: {
              get: function () {
                if (left === undefined) {
                  left = x + Math.min(0, width);
                }
  
                return left;
              },
              enumerable: true
            },
            right: {
              get: function () {
                if (right === undefined) {
                  right = x + Math.max(0, width);
                }
  
                return right;
              },
              enumerable: true
            },
            top: {
              get: function () {
                if (top === undefined) {
                  top = y + Math.min(0, height);
                }
  
                return top;
              },
              enumerable: true
            },
            bottom: {
              get: function () {
                if (bottom === undefined) {
                  bottom = y + Math.max(0, height);
                }
  
                return bottom;
              },
              enumerable: true
            }
          });
        }
  
        global.DOMRect = DOMRect;
      })(self);
    }
  }).call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof __webpack_require__.g && __webpack_require__.g || {});
  ;// CONCATENATED MODULE: ./specifications/w3c/geometry-1/3.DOMRect/test.pure.js
  
  
  (function (cb) {
    var domRect = new DOMRect();
    cb(!!domRect);
  })(callback);
  })();
  
  /******/ })()
  ;