n8n-editor-ui
Version:
Workflow Editor UI for n8n
4,837 lines • 188 kB
JavaScript
(function() {
var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var require_global_this = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var check = function(it) {
return it && it.Math === Math && it;
};
module.exports = check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || check(typeof self == "object" && self) || check(typeof global == "object" && global) || check(typeof exports == "object" && exports) || (function() {
return this;
})() || Function("return this")();
}));
var require_fails = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function(exec$4) {
try {
return !!exec$4();
} catch (error) {
return true;
}
};
}));
var require_descriptors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = !require_fails()(function() {
return Object.defineProperty({}, 1, { get: function() {
return 7;
} })[1] !== 7;
});
}));
var require_function_bind_native = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = !require_fails()(function() {
var test$1 = (function() {}).bind();
return typeof test$1 != "function" || test$1.hasOwnProperty("prototype");
});
}));
var require_function_call = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var NATIVE_BIND$3 = require_function_bind_native();
var call$24 = Function.prototype.call;
module.exports = NATIVE_BIND$3 ? call$24.bind(call$24) : function() {
return call$24.apply(call$24, arguments);
};
}));
var require_object_property_is_enumerable = /* @__PURE__ */ __commonJSMin(((exports) => {
var $propertyIsEnumerable = {}.propertyIsEnumerable;
var getOwnPropertyDescriptor$5 = Object.getOwnPropertyDescriptor;
exports.f = getOwnPropertyDescriptor$5 && !$propertyIsEnumerable.call({ 1: 2 }, 1) ? function propertyIsEnumerable(V) {
var descriptor$3 = getOwnPropertyDescriptor$5(this, V);
return !!descriptor$3 && descriptor$3.enumerable;
} : $propertyIsEnumerable;
}));
var require_create_property_descriptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function(bitmap, value) {
return {
enumerable: !(bitmap & 1),
configurable: !(bitmap & 2),
writable: !(bitmap & 4),
value
};
};
}));
var require_function_uncurry_this = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var NATIVE_BIND$2 = require_function_bind_native();
var FunctionPrototype$2 = Function.prototype;
var call$23 = FunctionPrototype$2.call;
var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$2.bind.bind(call$23, call$23);
module.exports = NATIVE_BIND$2 ? uncurryThisWithBind : function(fn) {
return function() {
return call$23.apply(fn, arguments);
};
};
}));
var require_classof_raw = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$28 = require_function_uncurry_this();
var toString$5 = uncurryThis$28({}.toString);
var stringSlice$2 = uncurryThis$28("".slice);
module.exports = function(it) {
return stringSlice$2(toString$5(it), 8, -1);
};
}));
var require_indexed_object = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$27 = require_function_uncurry_this();
var fails$19 = require_fails();
var classof$10 = require_classof_raw();
var $Object$4 = Object;
var split = uncurryThis$27("".split);
module.exports = fails$19(function() {
return !$Object$4("z").propertyIsEnumerable(0);
}) ? function(it) {
return classof$10(it) === "String" ? split(it, "") : $Object$4(it);
} : $Object$4;
}));
var require_is_null_or_undefined = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function(it) {
return it === null || it === void 0;
};
}));
var require_require_object_coercible = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isNullOrUndefined$3 = require_is_null_or_undefined();
var $TypeError$21 = TypeError;
module.exports = function(it) {
if (isNullOrUndefined$3(it)) throw new $TypeError$21("Can't call method on " + it);
return it;
};
}));
var require_to_indexed_object = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var IndexedObject$1 = require_indexed_object();
var requireObjectCoercible$2 = require_require_object_coercible();
module.exports = function(it) {
return IndexedObject$1(requireObjectCoercible$2(it));
};
}));
var require_is_callable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var documentAll = typeof document == "object" && document.all;
module.exports = typeof documentAll == "undefined" && documentAll !== void 0 ? function(argument) {
return typeof argument == "function" || argument === documentAll;
} : function(argument) {
return typeof argument == "function";
};
}));
var require_is_object = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isCallable$21 = require_is_callable();
module.exports = function(it) {
return typeof it == "object" ? it !== null : isCallable$21(it);
};
}));
var require_get_built_in = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$38 = require_global_this();
var isCallable$20 = require_is_callable();
var aFunction = function(argument) {
return isCallable$20(argument) ? argument : void 0;
};
module.exports = function(namespace, method) {
return arguments.length < 2 ? aFunction(globalThis$38[namespace]) : globalThis$38[namespace] && globalThis$38[namespace][method];
};
}));
var require_object_is_prototype_of = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_function_uncurry_this()({}.isPrototypeOf);
}));
var require_environment_user_agent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var navigator = require_global_this().navigator;
var userAgent$3 = navigator && navigator.userAgent;
module.exports = userAgent$3 ? String(userAgent$3) : "";
}));
var require_environment_v8_version = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$37 = require_global_this();
var userAgent$2 = require_environment_user_agent();
var process$1 = globalThis$37.process;
var Deno$1 = globalThis$37.Deno;
var versions = process$1 && process$1.versions || Deno$1 && Deno$1.version;
var v8 = versions && versions.v8;
var match, version;
if (v8) {
match = v8.split(".");
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
}
if (!version && userAgent$2) {
match = userAgent$2.match(/Edge\/(\d+)/);
if (!match || match[1] >= 74) {
match = userAgent$2.match(/Chrome\/(\d+)/);
if (match) version = +match[1];
}
}
module.exports = version;
}));
var require_symbol_constructor_detection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var V8_VERSION = require_environment_v8_version();
var fails$18 = require_fails();
var $String$6 = require_global_this().String;
module.exports = !!Object.getOwnPropertySymbols && !fails$18(function() {
var symbol = Symbol("symbol detection");
return !$String$6(symbol) || !(Object(symbol) instanceof Symbol) || !Symbol.sham && V8_VERSION && V8_VERSION < 41;
});
}));
var require_use_symbol_as_uid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_symbol_constructor_detection() && !Symbol.sham && typeof Symbol.iterator == "symbol";
}));
var require_is_symbol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var getBuiltIn$8 = require_get_built_in();
var isCallable$19 = require_is_callable();
var isPrototypeOf$5 = require_object_is_prototype_of();
var USE_SYMBOL_AS_UID$1 = require_use_symbol_as_uid();
var $Object$3 = Object;
module.exports = USE_SYMBOL_AS_UID$1 ? function(it) {
return typeof it == "symbol";
} : function(it) {
var $Symbol = getBuiltIn$8("Symbol");
return isCallable$19($Symbol) && isPrototypeOf$5($Symbol.prototype, $Object$3(it));
};
}));
var require_try_to_string = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $String$5 = String;
module.exports = function(argument) {
try {
return $String$5(argument);
} catch (error) {
return "Object";
}
};
}));
var require_a_callable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isCallable$18 = require_is_callable();
var tryToString$3 = require_try_to_string();
var $TypeError$20 = TypeError;
module.exports = function(argument) {
if (isCallable$18(argument)) return argument;
throw new $TypeError$20(tryToString$3(argument) + " is not a function");
};
}));
var require_get_method = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aCallable$12 = require_a_callable();
var isNullOrUndefined$2 = require_is_null_or_undefined();
module.exports = function(V, P) {
var func = V[P];
return isNullOrUndefined$2(func) ? void 0 : aCallable$12(func);
};
}));
var require_ordinary_to_primitive = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$22 = require_function_call();
var isCallable$17 = require_is_callable();
var isObject$12 = require_is_object();
var $TypeError$19 = TypeError;
module.exports = function(input, pref) {
var fn, val;
if (pref === "string" && isCallable$17(fn = input.toString) && !isObject$12(val = call$22(fn, input))) return val;
if (isCallable$17(fn = input.valueOf) && !isObject$12(val = call$22(fn, input))) return val;
if (pref !== "string" && isCallable$17(fn = input.toString) && !isObject$12(val = call$22(fn, input))) return val;
throw new $TypeError$19("Can't convert object to primitive value");
};
}));
var require_is_pure = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = false;
}));
var require_define_global_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$36 = require_global_this();
var defineProperty$7 = Object.defineProperty;
module.exports = function(key$1, value) {
try {
defineProperty$7(globalThis$36, key$1, {
value,
configurable: true,
writable: true
});
} catch (error) {
globalThis$36[key$1] = value;
}
return value;
};
}));
var require_shared_store = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var IS_PURE$10 = require_is_pure();
var globalThis$35 = require_global_this();
var defineGlobalProperty$2 = require_define_global_property();
var SHARED = "__core-js_shared__";
var store$3 = module.exports = globalThis$35[SHARED] || defineGlobalProperty$2(SHARED, {});
(store$3.versions || (store$3.versions = [])).push({
version: "3.46.0",
mode: IS_PURE$10 ? "pure" : "global",
copyright: "© 2014-2025 Denis Pushkarev (zloirock.ru), 2025 CoreJS Company (core-js.io)",
license: "https://github.com/zloirock/core-js/blob/v3.46.0/LICENSE",
source: "https://github.com/zloirock/core-js"
});
}));
var require_shared = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var store$2 = require_shared_store();
module.exports = function(key$1, value) {
return store$2[key$1] || (store$2[key$1] = value || {});
};
}));
var require_to_object = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var requireObjectCoercible$1 = require_require_object_coercible();
var $Object$2 = Object;
module.exports = function(argument) {
return $Object$2(requireObjectCoercible$1(argument));
};
}));
var require_has_own_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$25 = require_function_uncurry_this();
var toObject$3 = require_to_object();
var hasOwnProperty = uncurryThis$25({}.hasOwnProperty);
module.exports = Object.hasOwn || function hasOwn$20(it, key$1) {
return hasOwnProperty(toObject$3(it), key$1);
};
}));
var require_uid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$24 = require_function_uncurry_this();
var id = 0;
var postfix = Math.random();
var toString$4 = uncurryThis$24(1.1.toString);
module.exports = function(key$1) {
return "Symbol(" + (key$1 === void 0 ? "" : key$1) + ")_" + toString$4(++id + postfix, 36);
};
}));
var require_well_known_symbol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$34 = require_global_this();
var shared$3 = require_shared();
var hasOwn$19 = require_has_own_property();
var uid$3 = require_uid();
var NATIVE_SYMBOL$1 = require_symbol_constructor_detection();
var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
var Symbol$3 = globalThis$34.Symbol;
var WellKnownSymbolsStore = shared$3("wks");
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$3["for"] || Symbol$3 : Symbol$3 && Symbol$3.withoutSetter || uid$3;
module.exports = function(name) {
if (!hasOwn$19(WellKnownSymbolsStore, name)) WellKnownSymbolsStore[name] = NATIVE_SYMBOL$1 && hasOwn$19(Symbol$3, name) ? Symbol$3[name] : createWellKnownSymbol("Symbol." + name);
return WellKnownSymbolsStore[name];
};
}));
var require_to_primitive = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$21 = require_function_call();
var isObject$11 = require_is_object();
var isSymbol$2 = require_is_symbol();
var getMethod$5 = require_get_method();
var ordinaryToPrimitive = require_ordinary_to_primitive();
var wellKnownSymbol$11 = require_well_known_symbol();
var $TypeError$18 = TypeError;
var TO_PRIMITIVE = wellKnownSymbol$11("toPrimitive");
module.exports = function(input, pref) {
if (!isObject$11(input) || isSymbol$2(input)) return input;
var exoticToPrim = getMethod$5(input, TO_PRIMITIVE);
var result;
if (exoticToPrim) {
if (pref === void 0) pref = "default";
result = call$21(exoticToPrim, input, pref);
if (!isObject$11(result) || isSymbol$2(result)) return result;
throw new $TypeError$18("Can't convert object to primitive value");
}
if (pref === void 0) pref = "number";
return ordinaryToPrimitive(input, pref);
};
}));
var require_to_property_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toPrimitive$1 = require_to_primitive();
var isSymbol$1 = require_is_symbol();
module.exports = function(argument) {
var key$1 = toPrimitive$1(argument, "string");
return isSymbol$1(key$1) ? key$1 : key$1 + "";
};
}));
var require_document_create_element = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$33 = require_global_this();
var isObject$10 = require_is_object();
var document$1 = globalThis$33.document;
var EXISTS$1 = isObject$10(document$1) && isObject$10(document$1.createElement);
module.exports = function(it) {
return EXISTS$1 ? document$1.createElement(it) : {};
};
}));
var require_ie8_dom_define = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var DESCRIPTORS$14 = require_descriptors();
var fails$17 = require_fails();
var createElement$1 = require_document_create_element();
module.exports = !DESCRIPTORS$14 && !fails$17(function() {
return Object.defineProperty(createElement$1("div"), "a", { get: function() {
return 7;
} }).a !== 7;
});
}));
var require_object_get_own_property_descriptor = /* @__PURE__ */ __commonJSMin(((exports) => {
var DESCRIPTORS$13 = require_descriptors();
var call$20 = require_function_call();
var propertyIsEnumerableModule = require_object_property_is_enumerable();
var createPropertyDescriptor$5 = require_create_property_descriptor();
var toIndexedObject$3 = require_to_indexed_object();
var toPropertyKey$2 = require_to_property_key();
var hasOwn$18 = require_has_own_property();
var IE8_DOM_DEFINE$1 = require_ie8_dom_define();
var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
exports.f = DESCRIPTORS$13 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor$6(O, P) {
O = toIndexedObject$3(O);
P = toPropertyKey$2(P);
if (IE8_DOM_DEFINE$1) try {
return $getOwnPropertyDescriptor$1(O, P);
} catch (error) {}
if (hasOwn$18(O, P)) return createPropertyDescriptor$5(!call$20(propertyIsEnumerableModule.f, O, P), O[P]);
};
}));
var require_v8_prototype_define_bug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var DESCRIPTORS$12 = require_descriptors();
var fails$16 = require_fails();
module.exports = DESCRIPTORS$12 && fails$16(function() {
return Object.defineProperty(function() {}, "prototype", {
value: 42,
writable: false
}).prototype !== 42;
});
}));
var require_an_object = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isObject$9 = require_is_object();
var $String$4 = String;
var $TypeError$17 = TypeError;
module.exports = function(argument) {
if (isObject$9(argument)) return argument;
throw new $TypeError$17($String$4(argument) + " is not an object");
};
}));
var require_object_define_property = /* @__PURE__ */ __commonJSMin(((exports) => {
var DESCRIPTORS$11 = require_descriptors();
var IE8_DOM_DEFINE = require_ie8_dom_define();
var V8_PROTOTYPE_DEFINE_BUG$1 = require_v8_prototype_define_bug();
var anObject$22 = require_an_object();
var toPropertyKey$1 = require_to_property_key();
var $TypeError$16 = TypeError;
var $defineProperty = Object.defineProperty;
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var ENUMERABLE = "enumerable";
var CONFIGURABLE$1 = "configurable";
var WRITABLE = "writable";
exports.f = DESCRIPTORS$11 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty$8(O, P, Attributes) {
anObject$22(O);
P = toPropertyKey$1(P);
anObject$22(Attributes);
if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
var current = $getOwnPropertyDescriptor(O, P);
if (current && current[WRITABLE]) {
O[P] = Attributes.value;
Attributes = {
configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
writable: false
};
}
}
return $defineProperty(O, P, Attributes);
} : $defineProperty : function defineProperty$8(O, P, Attributes) {
anObject$22(O);
P = toPropertyKey$1(P);
anObject$22(Attributes);
if (IE8_DOM_DEFINE) try {
return $defineProperty(O, P, Attributes);
} catch (error) {}
if ("get" in Attributes || "set" in Attributes) throw new $TypeError$16("Accessors not supported");
if ("value" in Attributes) O[P] = Attributes.value;
return O;
};
}));
var require_create_non_enumerable_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var DESCRIPTORS$10 = require_descriptors();
var definePropertyModule$4 = require_object_define_property();
var createPropertyDescriptor$4 = require_create_property_descriptor();
module.exports = DESCRIPTORS$10 ? function(object, key$1, value) {
return definePropertyModule$4.f(object, key$1, createPropertyDescriptor$4(1, value));
} : function(object, key$1, value) {
object[key$1] = value;
return object;
};
}));
var require_function_name = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var DESCRIPTORS$9 = require_descriptors();
var hasOwn$17 = require_has_own_property();
var FunctionPrototype$1 = Function.prototype;
var getDescriptor = DESCRIPTORS$9 && Object.getOwnPropertyDescriptor;
var EXISTS = hasOwn$17(FunctionPrototype$1, "name");
module.exports = {
EXISTS,
PROPER: EXISTS && (function something() {}).name === "something",
CONFIGURABLE: EXISTS && (!DESCRIPTORS$9 || DESCRIPTORS$9 && getDescriptor(FunctionPrototype$1, "name").configurable)
};
}));
var require_inspect_source = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$23 = require_function_uncurry_this();
var isCallable$16 = require_is_callable();
var store$1 = require_shared_store();
var functionToString = uncurryThis$23(Function.toString);
if (!isCallable$16(store$1.inspectSource)) store$1.inspectSource = function(it) {
return functionToString(it);
};
module.exports = store$1.inspectSource;
}));
var require_weak_map_basic_detection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$32 = require_global_this();
var isCallable$15 = require_is_callable();
var WeakMap$1 = globalThis$32.WeakMap;
module.exports = isCallable$15(WeakMap$1) && /native code/.test(String(WeakMap$1));
}));
var require_shared_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var shared$2 = require_shared();
var uid$2 = require_uid();
var keys$1 = shared$2("keys");
module.exports = function(key$1) {
return keys$1[key$1] || (keys$1[key$1] = uid$2(key$1));
};
}));
var require_hidden_keys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = {};
}));
var require_internal_state = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var NATIVE_WEAK_MAP = require_weak_map_basic_detection();
var globalThis$31 = require_global_this();
var isObject$8 = require_is_object();
var createNonEnumerableProperty$6 = require_create_non_enumerable_property();
var hasOwn$16 = require_has_own_property();
var shared$1 = require_shared_store();
var sharedKey$2 = require_shared_key();
var hiddenKeys$3 = require_hidden_keys();
var OBJECT_ALREADY_INITIALIZED = "Object already initialized";
var TypeError$5 = globalThis$31.TypeError;
var WeakMap = globalThis$31.WeakMap;
var set$1, get, has$6;
var enforce = function(it) {
return has$6(it) ? get(it) : set$1(it, {});
};
var getterFor = function(TYPE) {
return function(it) {
var state;
if (!isObject$8(it) || (state = get(it)).type !== TYPE) throw new TypeError$5("Incompatible receiver, " + TYPE + " required");
return state;
};
};
if (NATIVE_WEAK_MAP || shared$1.state) {
var store = shared$1.state || (shared$1.state = new WeakMap());
store.get = store.get;
store.has = store.has;
store.set = store.set;
set$1 = function(it, metadata) {
if (store.has(it)) throw new TypeError$5(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
store.set(it, metadata);
return metadata;
};
get = function(it) {
return store.get(it) || {};
};
has$6 = function(it) {
return store.has(it);
};
} else {
var STATE = sharedKey$2("state");
hiddenKeys$3[STATE] = true;
set$1 = function(it, metadata) {
if (hasOwn$16(it, STATE)) throw new TypeError$5(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
createNonEnumerableProperty$6(it, STATE, metadata);
return metadata;
};
get = function(it) {
return hasOwn$16(it, STATE) ? it[STATE] : {};
};
has$6 = function(it) {
return hasOwn$16(it, STATE);
};
}
module.exports = {
set: set$1,
get,
has: has$6,
enforce,
getterFor
};
}));
var require_make_built_in = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$22 = require_function_uncurry_this();
var fails$15 = require_fails();
var isCallable$14 = require_is_callable();
var hasOwn$15 = require_has_own_property();
var DESCRIPTORS$8 = require_descriptors();
var CONFIGURABLE_FUNCTION_NAME = require_function_name().CONFIGURABLE;
var inspectSource$1 = require_inspect_source();
var InternalStateModule$2 = require_internal_state();
var enforceInternalState$1 = InternalStateModule$2.enforce;
var getInternalState$1 = InternalStateModule$2.get;
var $String$3 = String;
var defineProperty$6 = Object.defineProperty;
var stringSlice$1 = uncurryThis$22("".slice);
var replace$1 = uncurryThis$22("".replace);
var join = uncurryThis$22([].join);
var CONFIGURABLE_LENGTH = DESCRIPTORS$8 && !fails$15(function() {
return defineProperty$6(function() {}, "length", { value: 8 }).length !== 8;
});
var TEMPLATE = String(String).split("String");
var makeBuiltIn$2 = module.exports = function(value, name, options) {
if (stringSlice$1($String$3(name), 0, 7) === "Symbol(") name = "[" + replace$1($String$3(name), /^Symbol\(([^)]*)\).*$/, "$1") + "]";
if (options && options.getter) name = "get " + name;
if (options && options.setter) name = "set " + name;
if (!hasOwn$15(value, "name") || CONFIGURABLE_FUNCTION_NAME && value.name !== name) if (DESCRIPTORS$8) defineProperty$6(value, "name", {
value: name,
configurable: true
});
else value.name = name;
if (CONFIGURABLE_LENGTH && options && hasOwn$15(options, "arity") && value.length !== options.arity) defineProperty$6(value, "length", { value: options.arity });
try {
if (options && hasOwn$15(options, "constructor") && options.constructor) {
if (DESCRIPTORS$8) defineProperty$6(value, "prototype", { writable: false });
} else if (value.prototype) value.prototype = void 0;
} catch (error) {}
var state = enforceInternalState$1(value);
if (!hasOwn$15(state, "source")) state.source = join(TEMPLATE, typeof name == "string" ? name : "");
return value;
};
Function.prototype.toString = makeBuiltIn$2(function toString$6() {
return isCallable$14(this) && getInternalState$1(this).source || inspectSource$1(this);
}, "toString");
}));
var require_define_built_in = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isCallable$13 = require_is_callable();
var definePropertyModule$3 = require_object_define_property();
var makeBuiltIn$1 = require_make_built_in();
var defineGlobalProperty$1 = require_define_global_property();
module.exports = function(O, key$1, value, options) {
if (!options) options = {};
var simple = options.enumerable;
var name = options.name !== void 0 ? options.name : key$1;
if (isCallable$13(value)) makeBuiltIn$1(value, name, options);
if (options.global) if (simple) O[key$1] = value;
else defineGlobalProperty$1(key$1, value);
else {
try {
if (!options.unsafe) delete O[key$1];
else if (O[key$1]) simple = true;
} catch (error) {}
if (simple) O[key$1] = value;
else definePropertyModule$3.f(O, key$1, {
value,
enumerable: false,
configurable: !options.nonConfigurable,
writable: !options.nonWritable
});
}
return O;
};
}));
var require_math_trunc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var ceil = Math.ceil;
var floor = Math.floor;
module.exports = Math.trunc || function trunc$1(x) {
var n = +x;
return (n > 0 ? floor : ceil)(n);
};
}));
var require_to_integer_or_infinity = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var trunc = require_math_trunc();
module.exports = function(argument) {
var number = +argument;
return number !== number || number === 0 ? 0 : trunc(number);
};
}));
var require_to_absolute_index = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toIntegerOrInfinity$6 = require_to_integer_or_infinity();
var max$1 = Math.max;
var min$3 = Math.min;
module.exports = function(index, length) {
var integer = toIntegerOrInfinity$6(index);
return integer < 0 ? max$1(integer + length, 0) : min$3(integer, length);
};
}));
var require_to_length = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toIntegerOrInfinity$5 = require_to_integer_or_infinity();
var min$2 = Math.min;
module.exports = function(argument) {
var len = toIntegerOrInfinity$5(argument);
return len > 0 ? min$2(len, 9007199254740991) : 0;
};
}));
var require_length_of_array_like = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toLength$1 = require_to_length();
module.exports = function(obj) {
return toLength$1(obj.length);
};
}));
var require_array_includes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toIndexedObject$2 = require_to_indexed_object();
var toAbsoluteIndex = require_to_absolute_index();
var lengthOfArrayLike$7 = require_length_of_array_like();
var createMethod = function(IS_INCLUDES) {
return function($this, el, fromIndex) {
var O = toIndexedObject$2($this);
var length = lengthOfArrayLike$7(O);
if (length === 0) return !IS_INCLUDES && -1;
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;
};
};
module.exports = {
includes: createMethod(true),
indexOf: createMethod(false)
};
}));
var require_object_keys_internal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$21 = require_function_uncurry_this();
var hasOwn$14 = require_has_own_property();
var toIndexedObject$1 = require_to_indexed_object();
var indexOf = require_array_includes().indexOf;
var hiddenKeys$2 = require_hidden_keys();
var push$5 = uncurryThis$21([].push);
module.exports = function(object, names) {
var O = toIndexedObject$1(object);
var i = 0;
var result = [];
var key$1;
for (key$1 in O) !hasOwn$14(hiddenKeys$2, key$1) && hasOwn$14(O, key$1) && push$5(result, key$1);
while (names.length > i) if (hasOwn$14(O, key$1 = names[i++])) ~indexOf(result, key$1) || push$5(result, key$1);
return result;
};
}));
var require_enum_bug_keys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = [
"constructor",
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable",
"toLocaleString",
"toString",
"valueOf"
];
}));
var require_object_get_own_property_names = /* @__PURE__ */ __commonJSMin(((exports) => {
var internalObjectKeys$1 = require_object_keys_internal();
var hiddenKeys$1 = require_enum_bug_keys().concat("length", "prototype");
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
return internalObjectKeys$1(O, hiddenKeys$1);
};
}));
var require_object_get_own_property_symbols = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.f = Object.getOwnPropertySymbols;
}));
var require_own_keys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var getBuiltIn$7 = require_get_built_in();
var uncurryThis$20 = require_function_uncurry_this();
var getOwnPropertyNamesModule = require_object_get_own_property_names();
var getOwnPropertySymbolsModule = require_object_get_own_property_symbols();
var anObject$21 = require_an_object();
var concat = uncurryThis$20([].concat);
module.exports = getBuiltIn$7("Reflect", "ownKeys") || function ownKeys$1(it) {
var keys$2 = getOwnPropertyNamesModule.f(anObject$21(it));
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
return getOwnPropertySymbols ? concat(keys$2, getOwnPropertySymbols(it)) : keys$2;
};
}));
var require_copy_constructor_properties = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var hasOwn$13 = require_has_own_property();
var ownKeys = require_own_keys();
var getOwnPropertyDescriptorModule = require_object_get_own_property_descriptor();
var definePropertyModule$2 = require_object_define_property();
module.exports = function(target, source, exceptions) {
var keys$2 = ownKeys(source);
var defineProperty$8 = definePropertyModule$2.f;
var getOwnPropertyDescriptor$6 = getOwnPropertyDescriptorModule.f;
for (var i = 0; i < keys$2.length; i++) {
var key$1 = keys$2[i];
if (!hasOwn$13(target, key$1) && !(exceptions && hasOwn$13(exceptions, key$1))) defineProperty$8(target, key$1, getOwnPropertyDescriptor$6(source, key$1));
}
};
}));
var require_is_forced = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var fails$14 = require_fails();
var isCallable$12 = require_is_callable();
var replacement = /#|\.prototype\./;
var isForced$1 = function(feature, detection) {
var value = data[normalize(feature)];
return value === POLYFILL ? true : value === NATIVE ? false : isCallable$12(detection) ? fails$14(detection) : !!detection;
};
var normalize = isForced$1.normalize = function(string) {
return String(string).replace(replacement, ".").toLowerCase();
};
var data = isForced$1.data = {};
var NATIVE = isForced$1.NATIVE = "N";
var POLYFILL = isForced$1.POLYFILL = "P";
module.exports = isForced$1;
}));
var require_export = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$30 = require_global_this();
var getOwnPropertyDescriptor$4 = require_object_get_own_property_descriptor().f;
var createNonEnumerableProperty$5 = require_create_non_enumerable_property();
var defineBuiltIn$8 = require_define_built_in();
var defineGlobalProperty = require_define_global_property();
var copyConstructorProperties$1 = require_copy_constructor_properties();
var isForced = require_is_forced();
module.exports = function(options, source) {
var TARGET = options.target;
var GLOBAL = options.global;
var STATIC = options.stat;
var FORCED$5, target, key$1, targetProperty, sourceProperty, descriptor$3;
if (GLOBAL) target = globalThis$30;
else if (STATIC) target = globalThis$30[TARGET] || defineGlobalProperty(TARGET, {});
else target = globalThis$30[TARGET] && globalThis$30[TARGET].prototype;
if (target) for (key$1 in source) {
sourceProperty = source[key$1];
if (options.dontCallGetSet) {
descriptor$3 = getOwnPropertyDescriptor$4(target, key$1);
targetProperty = descriptor$3 && descriptor$3.value;
} else targetProperty = target[key$1];
FORCED$5 = isForced(GLOBAL ? key$1 : TARGET + (STATIC ? "." : "#") + key$1, options.forced);
if (!FORCED$5 && targetProperty !== void 0) {
if (typeof sourceProperty == typeof targetProperty) continue;
copyConstructorProperties$1(sourceProperty, targetProperty);
}
if (options.sham || targetProperty && targetProperty.sham) createNonEnumerableProperty$5(sourceProperty, "sham", true);
defineBuiltIn$8(target, key$1, sourceProperty, options);
}
};
}));
var require_an_instance = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isPrototypeOf$4 = require_object_is_prototype_of();
var $TypeError$15 = TypeError;
module.exports = function(it, Prototype$1) {
if (isPrototypeOf$4(Prototype$1, it)) return it;
throw new $TypeError$15("Incorrect invocation");
};
}));
var require_correct_prototype_getter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = !require_fails()(function() {
function F() {}
F.prototype.constructor = null;
return Object.getPrototypeOf(new F()) !== F.prototype;
});
}));
var require_object_get_prototype_of = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var hasOwn$12 = require_has_own_property();
var isCallable$11 = require_is_callable();
var toObject$2 = require_to_object();
var sharedKey$1 = require_shared_key();
var CORRECT_PROTOTYPE_GETTER = require_correct_prototype_getter();
var IE_PROTO$1 = sharedKey$1("IE_PROTO");
var $Object$1 = Object;
var ObjectPrototype$1 = $Object$1.prototype;
module.exports = CORRECT_PROTOTYPE_GETTER ? $Object$1.getPrototypeOf : function(O) {
var object = toObject$2(O);
if (hasOwn$12(object, IE_PROTO$1)) return object[IE_PROTO$1];
var constructor = object.constructor;
if (isCallable$11(constructor) && object instanceof constructor) return constructor.prototype;
return object instanceof $Object$1 ? ObjectPrototype$1 : null;
};
}));
var require_define_built_in_accessor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var makeBuiltIn = require_make_built_in();
var defineProperty$5 = require_object_define_property();
module.exports = function(target, name, descriptor$3) {
if (descriptor$3.get) makeBuiltIn(descriptor$3.get, name, { getter: true });
if (descriptor$3.set) makeBuiltIn(descriptor$3.set, name, { setter: true });
return defineProperty$5.f(target, name, descriptor$3);
};
}));
var require_create_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var DESCRIPTORS$7 = require_descriptors();
var definePropertyModule$1 = require_object_define_property();
var createPropertyDescriptor$3 = require_create_property_descriptor();
module.exports = function(object, key$1, value) {
if (DESCRIPTORS$7) definePropertyModule$1.f(object, key$1, createPropertyDescriptor$3(0, value));
else object[key$1] = value;
};
}));
var require_object_keys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var internalObjectKeys = require_object_keys_internal();
var enumBugKeys$1 = require_enum_bug_keys();
module.exports = Object.keys || function keys$2(O) {
return internalObjectKeys(O, enumBugKeys$1);
};
}));
var require_object_define_properties = /* @__PURE__ */ __commonJSMin(((exports) => {
var DESCRIPTORS$6 = require_descriptors();
var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
var definePropertyModule = require_object_define_property();
var anObject$20 = require_an_object();
var toIndexedObject = require_to_indexed_object();
var objectKeys$1 = require_object_keys();
exports.f = DESCRIPTORS$6 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
anObject$20(O);
var props = toIndexedObject(Properties);
var keys$2 = objectKeys$1(Properties);
var length = keys$2.length;
var index = 0;
var key$1;
while (length > index) definePropertyModule.f(O, key$1 = keys$2[index++], props[key$1]);
return O;
};
}));
var require_html = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_get_built_in()("document", "documentElement");
}));
var require_object_create = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var anObject$19 = require_an_object();
var definePropertiesModule = require_object_define_properties();
var enumBugKeys = require_enum_bug_keys();
var hiddenKeys = require_hidden_keys();
var html$1 = 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() {};
var scriptTag = function(content) {
return LT + SCRIPT + GT + content + LT + "/" + SCRIPT + GT;
};
var NullProtoObjectViaActiveX = function(activeXDocument$1) {
activeXDocument$1.write(scriptTag(""));
activeXDocument$1.close();
var temp = activeXDocument$1.parentWindow.Object;
activeXDocument$1 = null;
return temp;
};
var NullProtoObjectViaIFrame = function() {
var iframe = documentCreateElement("iframe");
var JS = "java" + SCRIPT + ":";
var iframeDocument;
iframe.style.display = "none";
html$1.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() {
try {
activeXDocument = new ActiveXObject("htmlfile");
} catch (error) {}
NullProtoObject = typeof document != "undefined" ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument);
var length = enumBugKeys.length;
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
return NullProtoObject();
};
hiddenKeys[IE_PROTO] = true;
module.exports = Object.create || function create$5(O, Properties) {
var result;
if (O !== null) {
EmptyConstructor[PROTOTYPE] = anObject$19(O);
result = new EmptyConstructor();
EmptyConstructor[PROTOTYPE] = null;
result[IE_PROTO] = O;
} else result = NullProtoObject();
return Properties === void 0 ? result : definePropertiesModule.f(result, Properties);
};
}));
var require_iterators_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var fails$12 = require_fails();
var isCallable$10 = require_is_callable();
var isObject$7 = require_is_object();
var create$4 = require_object_create();
var getPrototypeOf$4 = require_object_get_prototype_of();
var defineBuiltIn$7 = require_define_built_in();
var wellKnownSymbol$10 = require_well_known_symbol();
var IS_PURE$9 = require_is_pure();
var ITERATOR$3 = wellKnownSymbol$10("iterator");
var BUGGY_SAFARI_ITERATORS = false;
var IteratorPrototype$3, PrototypeOfArrayIteratorPrototype, arrayIterator;
if ([].keys) {
arrayIterator = [].keys();
if (!("next" in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
else {
PrototypeOfArrayIteratorPrototype = getPrototypeOf$4(getPrototypeOf$4(arrayIterator));
if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$3 = PrototypeOfArrayIteratorPrototype;
}
}
if (!isObject$7(IteratorPrototype$3) || fails$12(function() {
var test$1 = {};
return IteratorPrototype$3[ITERATOR$3].call(test$1) !== test$1;
})) IteratorPrototype$3 = {};
else if (IS_PURE$9) IteratorPrototype$3 = create$4(IteratorPrototype$3);
if (!isCallable$10(IteratorPrototype$3[ITERATOR$3])) defineBuiltIn$7(IteratorPrototype$3, ITERATOR$3, function() {
return this;
});
module.exports = {
IteratorPrototype: IteratorPrototype$3,
BUGGY_SAFARI_ITERATORS
};
}));
var $$31 = require_export();
var globalThis$29 = require_global_this();
var anInstance$1 = require_an_instance();
var anObject$18 = require_an_object();
var isCallable$9 = require_is_callable();
var getPrototypeOf$3 = require_object_get_prototype_of();
var defineBuiltInAccessor$2 = require_define_built_in_accessor();
var createProperty$2 = require_create_property();
var fails$11 = require_fails();
var hasOwn$11 = require_has_own_property();
var wellKnownSymbol$9 = require_well_known_symbol();
var IteratorPrototype$2 = require_iterators_core().IteratorPrototype;
var DESCRIPTORS$5 = require_descriptors();
var IS_PURE$8 = require_is_pure();
var CONSTRUCTOR = "constructor";
var ITERATOR$2 = "Iterator";
var TO_STRING_TAG$5 = wellKnownSymbol$9("toStringTag");
var $TypeError$14 = TypeError;
var NativeIterator = globalThis$29[ITERATOR$2];
var FORCED$4 = IS_PURE$8 || !isCallable$9(NativeIterator) || NativeIterator.prototype !== IteratorPrototype$2 || !fails$11(function() {
NativeIterator({});
});
var IteratorConstructor = function Iterator$1() {
anInstance$1(this, IteratorPrototype$2);
if (getPrototypeOf$3(this) === IteratorPrototype$2) throw new $TypeError$14("Abstract class Iterator not directly constructable");
};
var defineIteratorPrototypeAccessor = function(key$1, value) {
if (DESCRIPTORS$5) defineBuiltInAccessor$2(IteratorPrototype$2, key$1, {
configurable: true,
get: function() {
return value;
},
set: function(replacement$1) {
anObject$18(this);
if (this === IteratorPrototype$2) throw new $TypeError$14("You can't redefine this property");
if (hasOwn$11(this, key$1)) this[key$1] = replacement$1;
else createProperty$2(this, key$1, replacement$1);
}
});
else IteratorPrototype$2[key$1] = value;
};
if (!hasOwn$11(IteratorPrototype$2, TO_STRING_TAG$5)) defineIteratorPrototypeAccessor(TO_STRING_TAG$5, ITERATOR$2);
if (FORCED$4 || !hasOwn$11(IteratorPrototype$2, CONSTRUCTOR) || IteratorPrototype$2[CONSTRUCTOR] === Object) defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor);
IteratorConstructor.prototype = IteratorPrototype$2;
$$31({
global: true,
constructor: true,
forced: FORCED$4
}, { Iterator: IteratorConstructor });
var require_function_uncurry_this_clause = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var classofRaw$1 = require_classof_raw();
var uncurryThis$19 = require_function_uncurry_this();
module.exports = function(fn) {
if (classofRaw$1(fn) === "Function") return uncurryThis$19(fn);
};
}));
var require_function_bind_context = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$18 = require_function_uncurry_this_clause();
var aCallable$11 = require_a_callable();
var NATIVE_BIND$1 = require_function_bind_native();
var bind$3 = uncurryThis$18(uncurryThis$18.bind);
module.exports = function(fn, that) {
aCallable$11(fn);
return that === void 0 ? fn : NATIVE_BIND$1 ? bind$3(fn, that) : function() {
return fn.apply(that, arguments);
};
};
}));
var require_iterators = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = {};
}));
var require_is_array_iterator_method = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var wellKnownSymbol$8 = require_well_known_symbol();
var Iterators$1 = require_iterators();
var ITERATOR$1 = wellKnownSymbol$8("iterator");
var ArrayPrototype$1 = Array.prototype;
module.exports = function(it) {
return it !== void 0 && (Iterators$1.Array === it || ArrayPrototype$1[ITERATOR$1] === it);
};
}));
var require_to_string_tag_support = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var TO_STRING_TAG$4 = require_well_known_symbol()("toStringTag");
var test = {};
test[TO_STRING_TAG$4] = "z";
module.exports = String(test) === "[object z]";
}));
var require_classof = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var TO_STRING_TAG_SUPPORT = require_to_string_tag_support();
var isCallable$8 = require_is_callable();
var classofRaw = require_classof_raw();
var TO_STRING_TAG$3 = require_well_known_symbol()("toStringTag");
var $Object = Object;
var CORRECT_ARGUMENTS = classofRaw(function() {
return arguments;
}()) === "Arguments";
var tryGet = function(it, key$1) {
try {
return it[key$1];
} catch (error) {}
};
module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function(it) {
var O, tag, result;
return it === void 0 ? "Undefined" : it === null ? "Null" : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG$3)) == "string" ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) === "Object" && isCallable$8(O.callee) ? "Arguments" : result;
};
}));
var require_get_iterator_method = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var classof$9 = require_classof();
var getMethod$4 = require_get_method();
var isNullOrUndefined$1 = require_is_null_or_undefined();
var Iterators = require_iterators();
var ITERATOR = require_well_known_symbol()("iterator");
module.exports = function(it) {
if (!isNullOrUndefined$1(it)) return getMethod$4(it, ITERATOR) || getMethod$4(it, "@@iterator") || Iterators[classof$9(it)];
};
}));
var require_get_iterator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$19 = require_function_call();
var aCallable$10 = require_a_callable();
var anObject$17 = require_an_object();
var tryToString$2 = require_try_to_string();
var getIteratorMethod$2 = require_get_iterator_method();
var $TypeError$13 = TypeError;
module.exports = function(argument, usingIterator) {
var iteratorMethod = arguments.length < 2 ? getIteratorMethod$2(argument) : usingIterator;
if (aCallable$10(iteratorMethod)) return anObject$17(call$19(iteratorMethod, argument));
throw new $TypeError$13(tryToString$2(argument) + " is not iterable");
};
}));
var require_iterator_close = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$18 = require_function_call();
var anObject$16 = require_an_object();
var getMethod$3 = require_get_method();
module.exports = function(iterator, kind, value) {
var innerResult, innerError;
anObject$16(iterator);
try {
innerResult = getMethod$3(iterator, "return");
if (!innerResult) {
if (kind === "throw") throw value;
return value;
}
innerResult = call$18(innerResult, iterator);
} catch (error) {
innerError = true;
innerResult = error;
}
if (kind === "throw") throw value;
if (innerError) throw innerResult;
anObject$16(innerResult);
return value;
};
}));
var require_iterate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var bind$2 = require_function_bind_context();
var call$17 = require_function_call();
var anObject$15 = require_an_object();
var tryToString$1 = require_try_to_string();
var isArrayIteratorMethod = require_is_array_iterator_method();
var lengthOfArrayLike$6 = require_length_of_array_like();
var isPrototypeOf$3 = require_object_is_prototype_of();
var getIterator = require_get_iterator();
var getIteratorMethod$1 = require_get_iterator_method();
var iteratorClose$14 = require_iterator_close();
var $TypeError$12 = TypeError;
var Result = function(stopped, result) {
this.stopped = stopped;
this.result = result;
};
var ResultPrototype = Result.prototype;
module.exports = function(iterable, unboundFunction, options) {
var that = options && options.that;
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
var IS_RECORD = !!(options && options.IS_RECORD);
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
var INTERRUPTED = !!(options && options.INTERRUPTED);
var fn = bind$2(unboundFunction, that);
var iterator, iterFn, index, length, result, next$1, step;
var stop = function(condition) {
if (iterator) iteratorClose$14(iterator, "normal");
return new Result(true, condition);
};
var callFn = function(value) {
if (AS_ENTRIES) {
anObject$15(value);
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
}
return INTERRUPTED ? fn(value, stop) : fn(value);
};
if (IS_RECORD) iterator = iterable.iterator;
else if (IS_ITERATOR) iterator = iterable;
else {
iterFn = getIteratorMethod$1(iterable);
if (!iterFn) throw new $TypeError$12(tryToString$1(iterable) + " is not iterable");
if (isArrayIteratorMethod(iterFn)) {
for (index = 0, length = lengthOfArrayLike$6(iterable); length > index; index++) {
result = callFn(iterable[index]);
if (result && isPrototypeOf$3(ResultPrototype, result)) return result;
}
return new Result(false);
}
iterator = getIterator(iterable, iterFn);
}
next$1 = IS_RECORD ? iterable.next : iterator.next;
while (!(step = call$17(next$1, iterator)).done) {
try {
result = callFn(step.value);
} catch (error) {
iteratorClose$14(iterator, "throw", error);
}
if (typeof result == "object" && result && isPrototypeOf$3(ResultPrototype, result)) return result;
}
return new Result(false);
};
}));
var require_get_iterator_direct = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function(obj) {
return {
iterator: obj,
next: obj.next,
done: false
};
};
}));
var require_iterator_helper_without_closing_on_early_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$28 = require_global_this();
module.exports = function(METHOD_NAME, ExpectedError) {
var Iterator$1 = globalThis$28.Iterator;
var IteratorPrototype$4 = Iterator$1 && Iterator$1.prototype;
var method = IteratorPrototype$4 && IteratorPrototype$4[METHOD_NAME];
var CLOSED = false;
if (method) try {
method.call({
next: function() {
return { done: true };
},
"return": function() {
CLOSED = true;
}
}, -1);
} catch (error) {
if (!(error instanceof ExpectedError)) CLOSED = false;
}
if (!CLOSED) return method;
};
}));
var $$30 = require_export();
var call$16 = require_function_call();
var iterate$8 = require_iterate();
var aCallable$9 = require_a_callable();
var anObject$14 = require_an_object();
var getIteratorDirect$11 = require_get_iterator_direct();
var iteratorClose$13 = require_iterator_close();
var findWithoutClosingOnEarlyError = require_iterator_helper_without_closing_on_early_error()("find", TypeError);
$$30({
target: "Iterator",
proto: true,
real: true,
forced: findWithoutClosingOnEarlyError
}, { find: function find(predicate) {
anObject$14(this);
try {
aCallable$9(predicate);
} catch (error) {
iteratorClose$13(this, "throw", error);
}
if (findWithoutClosingOnEarlyError) return call$16(findWithoutClosingOnEarlyError, this, predicate);
var record = getIteratorDirect$11(this);
var counter$1 = 0;
return iterate$8(record, function(value, stop) {
if (predicate(value, counter$1++)) return stop(value);
}, {
IS_RECORD: true,
INTERRUPTED: true
}).result;
} });
var require_define_built_ins = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var defineBuiltIn$6 = require_define_built_in();
module.exports = function(target, src, options) {
for (var key$1 in src) defineBuiltIn$6(target, key$1, src[key$1], options);
return target;
};
}));
var require_create_iter_result_object = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function(value, done) {
return {
value,
done
};
};
}));
var require_iterator_close_all = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var iteratorClose$12 = require_iterator_close();
module.exports = function(iters, kind, value) {
for (var i = iters.length - 1; i >= 0; i--) {
if (iters[i] === void 0) continue;
try {
value = iteratorClose$12(iters[i].iterator, kind, value);
} catch (error) {
kind = "throw";
value = error;
}
}
if (kind === "throw") throw value;
return value;
};
}));
var require_iterator_create_proxy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$15 = require_function_call();
var create$3 = require_object_create();
var createNonEnumerableProperty$4 = require_create_non_enumerable_property();
var defineBuiltIns = require_define_built_ins();
var wellKnownSymbol$7 = require_well_known_symbol();
var InternalStateModule$1 = require_internal_state();
var getMethod$2 = require_get_method();
var IteratorPrototype$1 = require_iterators_core().IteratorPrototype;
var createIterResultObject = require_create_iter_result_object();
var iteratorClose$11 = require_iterator_close();
var iteratorCloseAll = require_iterator_close_all();
var TO_STRING_TAG$2 = wellKnownSymbol$7("toStringTag");
var ITERATOR_HELPER = "IteratorHelper";
var WRAP_FOR_VALID_ITERATOR = "WrapForValidIterator";
var NORMAL = "normal";
var THROW = "throw";
var setInternalState = InternalStateModule$1.set;
var createIteratorProxyPrototype = function(IS_ITERATOR) {
var getInternalState$2 = InternalStateModule$1.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
return defineBuiltIns(create$3(IteratorPrototype$1), {
next: function next$1() {
var state = getInternalState$2(this);
if (IS_ITERATOR) return state.nextHandler();
if (state.done) return createIterResultObject(void 0, true);
try {
var result = state.nextHandler();
return state.returnHandlerResult ? result : createIterResultObject(result, state.done);
} catch (error) {
state.done = true;
throw error;
}
},
"return": function() {
var state = getInternalState$2(this);
var iterator = state.iterator;
state.done = true;
if (IS_ITERATOR) {
var returnMethod = getMethod$2(iterator, "return");
return returnMethod ? call$15(returnMethod, iterator) : createIterResultObject(void 0, true);
}
if (state.inner) try {
iteratorClose$11(state.inner.iterator, NORMAL);
} catch (error) {
return iteratorClose$11(iterator, THROW, error);
}
if (state.openIters) try {
iteratorCloseAll(state.openIters, NORMAL);
} catch (error) {
return iteratorClose$11(iterator, THROW, error);
}
if (iterator) iteratorClose$11(iterator, NORMAL);
return createIterResultObject(void 0, true);
}
});
};
var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
var IteratorHelperPrototype = createIteratorProxyPrototype(false);
createNonEnumerableProperty$4(IteratorHelperPrototype, TO_STRING_TAG$2, "Iterator Helper");
module.exports = function(nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) {
var IteratorProxy$4 = function Iterator$1(record, state) {
if (state) {
state.iterator = record.iterator;
state.next = record.next;
} else state = record;
state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
state.returnHandlerResult = !!RETURN_HANDLER_RESULT;
state.nextHandler = nextHandler;
state.counter = 0;
state.done = false;
setInternalState(this, state);
};
IteratorProxy$4.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
return IteratorProxy$4;
};
}));
var require_call_with_safe_iteration_closing = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var anObject$13 = require_an_object();
var iteratorClose$10 = require_iterator_close();
module.exports = function(iterator, fn, value, ENTRIES) {
try {
return ENTRIES ? fn(anObject$13(value)[0], value[1]) : fn(value);
} catch (error) {
iteratorClose$10(iterator, "throw", error);
}
};
}));
var require_iterator_helper_throws_on_invalid_iterator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function(methodName, argument) {
var method = typeof Iterator == "function" && Iterator.prototype[methodName];
if (method) try {
method.call({ next: null }, argument).next();
} catch (error) {
return true;
}
};
}));
var $$29 = require_export();
var call$14 = require_function_call();
var aCallable$8 = require_a_callable();
var anObject$12 = require_an_object();
var getIteratorDirect$10 = require_get_iterator_direct();
var createIteratorProxy$3 = require_iterator_create_proxy();
var callWithSafeIterationClosing$1 = require_call_with_safe_iteration_closing();
var iteratorClose$9 = require_iterator_close();
var iteratorHelperThrowsOnInvalidIterator$3 = require_iterator_helper_throws_on_invalid_iterator();
var iteratorHelperWithoutClosingOnEarlyError$4 = require_iterator_helper_without_closing_on_early_error();
var IS_PURE$7 = require_is_pure();
var MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE$7 && !iteratorHelperThrowsOnInvalidIterator$3("map", function() {});
var mapWithoutClosingOnEarlyError = !IS_PURE$7 && !MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR && iteratorHelperWithoutClosingOnEarlyError$4("map", TypeError);
var FORCED$3 = IS_PURE$7 || MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || mapWithoutClosingOnEarlyError;
var IteratorProxy$3 = createIteratorProxy$3(function() {
var iterator = this.iterator;
var result = anObject$12(call$14(this.next, iterator));
if (!(this.done = !!result.done)) return callWithSafeIterationClosing$1(iterator, this.mapper, [result.value, this.counter++], true);
});
$$29({
target: "Iterator",
proto: true,
real: true,
forced: FORCED$3
}, { map: function map(mapper) {
anObject$12(this);
try {
aCallable$8(mapper);
} catch (error) {
iteratorClose$9(this, "throw", error);
}
if (mapWithoutClosingOnEarlyError) return call$14(mapWithoutClosingOnEarlyError, this, mapper);
return new IteratorProxy$3(getIteratorDirect$10(this), { mapper });
} });
var $$28 = require_export();
var call$13 = require_function_call();
var iterate$7 = require_iterate();
var aCallable$7 = require_a_callable();
var anObject$11 = require_an_object();
var getIteratorDirect$9 = require_get_iterator_direct();
var iteratorClose$8 = require_iterator_close();
var everyWithoutClosingOnEarlyError = require_iterator_helper_without_closing_on_early_error()("every", TypeError);
$$28({
target: "Iterator",
proto: true,
real: true,
forced: everyWithoutClosingOnEarlyError
}, { every: function every(predicate) {
anObject$11(this);
try {
aCallable$7(predicate);
} catch (error) {
iteratorClose$8(this, "throw", error);
}
if (everyWithoutClosingOnEarlyError) return call$13(everyWithoutClosingOnEarlyError, this, predicate);
var record = getIteratorDirect$9(this);
var counter$1 = 0;
return !iterate$7(record, function(value, stop) {
if (!predicate(value, counter$1++)) return stop();
}, {
IS_RECORD: true,
INTERRUPTED: true
}).stopped;
} });
var $$27 = require_export();
var call$12 = require_function_call();
var iterate$6 = require_iterate();
var aCallable$6 = require_a_callable();
var anObject$10 = require_an_object();
var getIteratorDirect$8 = require_get_iterator_direct();
var iteratorClose$7 = require_iterator_close();
var forEachWithoutClosingOnEarlyError = require_iterator_helper_without_closing_on_early_error()("forEach", TypeError);
$$27({
target: "Iterator",
proto: true,
real: true,
forced: forEachWithoutClosingOnEarlyError
}, { forEach: function forEach$2(fn) {
anObject$10(this);
try {
aCallable$6(fn);
} catch (error) {
iteratorClose$7(this, "throw", error);
}
if (forEachWithoutClosingOnEarlyError) return call$12(forEachWithoutClosingOnEarlyError, this, fn);
var record = getIteratorDirect$8(this);
var counter$1 = 0;
iterate$6(record, function(value) {
fn(value, counter$1++);
}, { IS_RECORD: true });
} });
var require_is_array = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var classof$8 = require_classof_raw();
module.exports = Array.isArray || function isArray$2(argument) {
return classof$8(argument) === "Array";
};
}));
var require_array_set_length = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var DESCRIPTORS$4 = require_descriptors();
var isArray$1 = require_is_array();
var $TypeError$11 = TypeError;
var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor;
module.exports = DESCRIPTORS$4 && !function() {
if (this !== void 0) return true;
try {
Object.defineProperty([], "length", { writable: false }).length = 1;
} catch (error) {
return error instanceof TypeError;
}
}() ? function(O, length) {
if (isArray$1(O) && !getOwnPropertyDescriptor$3(O, "length").writable) throw new $TypeError$11("Cannot set read only .length");
return O.length = length;
} : function(O, length) {
return O.length = length;
};
}));
var require_does_not_exceed_safe_integer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $TypeError$10 = TypeError;
var MAX_SAFE_INTEGER = 9007199254740991;
module.exports = function(it) {
if (it > MAX_SAFE_INTEGER) throw $TypeError$10("Maximum allowed index exceeded");
return it;
};
}));
var $$26 = require_export();
var toObject$1 = require_to_object();
var lengthOfArrayLike$5 = require_length_of_array_like();
var setArrayLength = require_array_set_length();
var doesNotExceedSafeInteger = require_does_not_exceed_safe_integer();
var INCORRECT_TO_LENGTH = require_fails()(function() {
return [].push.call({ length: 4294967296 }, 1) !== 4294967297;
});
var properErrorOnNonWritableLength = function() {
try {
Object.defineProperty([], "length", { writable: false }).push();
} catch (error) {
return error instanceof TypeError;
}
};
$$26({
target: "Array",
proto: true,
arity: 1,
forced: INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength()
}, { push: function push$6(item) {
var O = toObject$1(this);
var len = lengthOfArrayLike$5(O);
var argCount = arguments.length;
doesNotExceedSafeInteger(len + argCount);
for (var i = 0; i < argCount; i++) {
O[len] = arguments[i];
len++;
}
setArrayLength(O, len);
return len;
} });
var $$25 = require_export();
var call$11 = require_function_call();
var aCallable$5 = require_a_callable();
var anObject$9 = require_an_object();
var getIteratorDirect$7 = require_get_iterator_direct();
var createIteratorProxy$2 = require_iterator_create_proxy();
var callWithSafeIterationClosing = require_call_with_safe_iteration_closing();
var IS_PURE$6 = require_is_pure();
var iteratorClose$6 = require_iterator_close();
var iteratorHelperThrowsOnInvalidIterator$2 = require_iterator_helper_throws_on_invalid_iterator();
var iteratorHelperWithoutClosingOnEarlyError$3 = require_iterator_helper_without_closing_on_early_error();
var FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE$6 && !iteratorHelperThrowsOnInvalidIterator$2("filter", function() {});
var filterWithoutClosingOnEarlyError = !IS_PURE$6 && !FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR && iteratorHelperWithoutClosingOnEarlyError$3("filter", TypeError);
var FORCED$2 = IS_PURE$6 || FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR || filterWithoutClosingOnEarlyError;
var IteratorProxy$2 = createIteratorProxy$2(function() {
var iterator = this.iterator;
var predicate = this.predicate;
var next$1 = this.next;
var result, done, value;
while (true) {
result = anObject$9(call$11(next$1, iterator));
done = this.done = !!result.done;
if (done) return;
value = result.value;
if (callWithSafeIterationClosing(iterator, predicate, [value, this.counter++], true)) return value;
}
});
$$25({
target: "Iterator",
proto: true,
real: true,
forced: FORCED$2
}, { filter: function filter(predicate) {
anObject$9(this);
try {
aCallable$5(predicate);
} catch (error) {
iteratorClose$6(this, "throw", error);
}
if (filterWithoutClosingOnEarlyError) return call$11(filterWithoutClosingOnEarlyError, this, predicate);
return new IteratorProxy$2(getIteratorDirect$7(this), { predicate });
} });
var require_array_from_constructor_and_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var lengthOfArrayLike$4 = require_length_of_array_like();
module.exports = function(Constructor$1, list, $length) {
var index = 0;
var length = arguments.length > 2 ? $length : lengthOfArrayLike$4(list);
var result = new Constructor$1(length);
while (length > index) result[index] = list[index++];
return result;
};
}));
var require_array_group = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var bind$1 = require_function_bind_context();
var uncurryThis$17 = require_function_uncurry_this();
var IndexedObject = require_indexed_object();
var toObject = require_to_object();
var toPropertyKey = require_to_property_key();
var lengthOfArrayLike$3 = require_length_of_array_like();
var objectCreate = require_object_create();
var arrayFromConstructorAndList = require_array_from_constructor_and_list();
var $Array = Array;
var push$4 = uncurryThis$17([].push);
module.exports = function($this, callbackfn, that, specificConstructor) {
var O = toObject($this);
var self$1 = IndexedObject(O);
var boundFunction = bind$1(callbackfn, that);
var target = objectCreate(null);
var length = lengthOfArrayLike$3(self$1);
var index = 0;
var Constructor$1, key$1, value;
for (; length > index; index++) {
value = self$1[index];
key$1 = toPropertyKey(boundFunction(value, index, O));
if (key$1 in target) push$4(target[key$1], value);
else target[key$1] = [value];
}
if (specificConstructor) {
Constructor$1 = specificConstructor(O);
if (Constructor$1 !== $Array) for (key$1 in target) target[key$1] = arrayFromConstructorAndList(Constructor$1, target[key$1]);
}
return target;
};
}));
var require_add_to_unscopables = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var wellKnownSymbol$6 = require_well_known_symbol();
var create$2 = require_object_create();
var defineProperty$4 = require_object_define_property().f;
var UNSCOPABLES = wellKnownSymbol$6("unscopables");
var ArrayPrototype = Array.prototype;
if (ArrayPrototype[UNSCOPABLES] === void 0) defineProperty$4(ArrayPrototype, UNSCOPABLES, {
configurable: true,
value: create$2(null)
});
module.exports = function(key$1) {
ArrayPrototype[UNSCOPABLES][key$1] = true;
};
}));
var $$24 = require_export();
var $group = require_array_group();
var addToUnscopables = require_add_to_unscopables();
$$24({
target: "Array",
proto: true
}, { group: function group(callbackfn) {
var thisArg = arguments.length > 1 ? arguments[1] : void 0;
return $group(this, callbackfn, thisArg);
} });
addToUnscopables("group");
var require_set_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$16 = require_function_uncurry_this();
var SetPrototype$1 = Set.prototype;
module.exports = {
Set,
add: uncurryThis$16(SetPrototype$1.add),
has: uncurryThis$16(SetPrototype$1.has),
remove: uncurryThis$16(SetPrototype$1["delete"]),
proto: SetPrototype$1
};
}));
var require_a_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var has$5 = require_set_helpers().has;
module.exports = function(it) {
has$5(it);
return it;
};
}));
var require_iterate_simple = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$10 = require_function_call();
module.exports = function(record, fn, ITERATOR_INSTEAD_OF_RECORD) {
var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
var next$1 = record.next;
var step, result;
while (!(step = call$10(next$1, iterator)).done) {
result = fn(step.value);
if (result !== void 0) return result;
}
};
}));
var require_set_iterate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$15 = require_function_uncurry_this();
var iterateSimple$6 = require_iterate_simple();
var SetHelpers$6 = require_set_helpers();
var Set$4 = SetHelpers$6.Set;
var SetPrototype = SetHelpers$6.proto;
var forEach$1 = uncurryThis$15(SetPrototype.forEach);
var keys = uncurryThis$15(SetPrototype.keys);
var next = keys(new Set$4()).next;
module.exports = function(set$2, fn, interruptible) {
return interruptible ? iterateSimple$6({
iterator: keys(set$2),
next
}, fn) : forEach$1(set$2, fn);
};
}));
var require_set_clone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var SetHelpers$5 = require_set_helpers();
var iterate$5 = require_set_iterate();
var Set$3 = SetHelpers$5.Set;
var add$3 = SetHelpers$5.add;
module.exports = function(set$2) {
var result = new Set$3();
iterate$5(set$2, function(it) {
add$3(result, it);
});
return result;
};
}));
var require_function_uncurry_this_accessor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$14 = require_function_uncurry_this();
var aCallable$4 = require_a_callable();
module.exports = function(object, key$1, method) {
try {
return uncurryThis$14(aCallable$4(Object.getOwnPropertyDescriptor(object, key$1)[method]));
} catch (error) {}
};
}));
var require_set_size = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_function_uncurry_this_accessor()(require_set_helpers().proto, "size", "get") || function(set$2) {
return set$2.size;
};
}));
var require_get_set_record = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aCallable$3 = require_a_callable();
var anObject$8 = require_an_object();
var call$9 = require_function_call();
var toIntegerOrInfinity$4 = require_to_integer_or_infinity();
var getIteratorDirect$6 = require_get_iterator_direct();
var INVALID_SIZE = "Invalid size";
var $RangeError$4 = RangeError;
var $TypeError$9 = TypeError;
var max = Math.max;
var SetRecord = function(set$2, intSize) {
this.set = set$2;
this.size = max(intSize, 0);
this.has = aCallable$3(set$2.has);
this.keys = aCallable$3(set$2.keys);
};
SetRecord.prototype = {
getIterator: function() {
return getIteratorDirect$6(anObject$8(call$9(this.keys, this.set)));
},
includes: function(it) {
return call$9(this.has, this.set, it);
}
};
module.exports = function(obj) {
anObject$8(obj);
var numSize = +obj.size;
if (numSize !== numSize) throw new $TypeError$9(INVALID_SIZE);
var intSize = toIntegerOrInfinity$4(numSize);
if (intSize < 0) throw new $RangeError$4(INVALID_SIZE);
return new SetRecord(obj, intSize);
};
}));
var require_set_difference = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aSet$6 = require_a_set();
var SetHelpers$3 = require_set_helpers();
var clone$2 = require_set_clone();
var size$4 = require_set_size();
var getSetRecord$6 = require_get_set_record();
var iterateSet$2 = require_set_iterate();
var iterateSimple$5 = require_iterate_simple();
var has$4 = SetHelpers$3.has;
var remove$1 = SetHelpers$3.remove;
module.exports = function difference$1(other) {
var O = aSet$6(this);
var otherRec = getSetRecord$6(other);
var result = clone$2(O);
if (size$4(O) <= otherRec.size) iterateSet$2(O, function(e) {
if (otherRec.includes(e)) remove$1(result, e);
});
else iterateSimple$5(otherRec.getIterator(), function(e) {
if (has$4(result, e)) remove$1(result, e);
});
return result;
};
}));
var require_set_method_accept_set_like = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var getBuiltIn$5 = require_get_built_in();
var createSetLike = function(size$5) {
return {
size: size$5,
has: function() {
return false;
},
keys: function() {
return { next: function() {
return { done: true };
} };
}
};
};
var createSetLikeWithInfinitySize = function(size$5) {
return {
size: size$5,
has: function() {
return true;
},
keys: function() {
throw new Error("e");
}
};
};
module.exports = function(name, callback) {
var Set$5 = getBuiltIn$5("Set");
try {
new Set$5()[name](createSetLike(0));
try {
new Set$5()[name](createSetLike(-1));
return false;
} catch (error2) {
if (!callback) return true;
try {
new Set$5()[name](createSetLikeWithInfinitySize(-Infinity));
return false;
} catch (error) {
var set$2 = new Set$5();
set$2.add(1);
set$2.add(2);
return callback(set$2[name](createSetLikeWithInfinitySize(Infinity)));
}
}
} catch (error) {
return false;
}
};
}));
var $$23 = require_export();
var difference = require_set_difference();
var fails$10 = require_fails();
$$23({
target: "Set",
proto: true,
real: true,
forced: !require_set_method_accept_set_like()("difference", function(result) {
return result.size === 0;
}) || fails$10(function() {
var setLike = {
size: 1,
has: function() {
return true;
},
keys: function() {
var index = 0;
return { next: function() {
var done = index++ > 1;
if (baseSet.has(1)) baseSet.clear();
return {
done,
value: 2
};
} };
}
};
var baseSet = new Set([
1,
2,
3,
4
]);
return baseSet.difference(setLike).size !== 3;
})
}, { difference });
var require_set_intersection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aSet$5 = require_a_set();
var SetHelpers$2 = require_set_helpers();
var size$3 = require_set_size();
var getSetRecord$5 = require_get_set_record();
var iterateSet$1 = require_set_iterate();
var iterateSimple$4 = require_iterate_simple();
var Set$2 = SetHelpers$2.Set;
var add$2 = SetHelpers$2.add;
var has$3 = SetHelpers$2.has;
module.exports = function intersection$1(other) {
var O = aSet$5(this);
var otherRec = getSetRecord$5(other);
var result = new Set$2();
if (size$3(O) > otherRec.size) iterateSimple$4(otherRec.getIterator(), function(e) {
if (has$3(O, e)) add$2(result, e);
});
else iterateSet$1(O, function(e) {
if (otherRec.includes(e)) add$2(result, e);
});
return result;
};
}));
var $$22 = require_export();
var fails$9 = require_fails();
var intersection = require_set_intersection();
$$22({
target: "Set",
proto: true,
real: true,
forced: !require_set_method_accept_set_like()("intersection", function(result) {
return result.size === 2 && result.has(1) && result.has(2);
}) || fails$9(function() {
return String(Array.from(new Set([
1,
2,
3
]).intersection(new Set([3, 2])))) !== "3,2";
})
}, { intersection });
var require_set_is_disjoint_from = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aSet$4 = require_a_set();
var has$2 = require_set_helpers().has;
var size$2 = require_set_size();
var getSetRecord$4 = require_get_set_record();
var iterateSet = require_set_iterate();
var iterateSimple$3 = require_iterate_simple();
var iteratorClose$5 = require_iterator_close();
module.exports = function isDisjointFrom$1(other) {
var O = aSet$4(this);
var otherRec = getSetRecord$4(other);
if (size$2(O) <= otherRec.size) return iterateSet(O, function(e) {
if (otherRec.includes(e)) return false;
}, true) !== false;
var iterator = otherRec.getIterator();
return iterateSimple$3(iterator, function(e) {
if (has$2(O, e)) return iteratorClose$5(iterator, "normal", false);
}) !== false;
};
}));
var $$21 = require_export();
var isDisjointFrom = require_set_is_disjoint_from();
$$21({
target: "Set",
proto: true,
real: true,
forced: !require_set_method_accept_set_like()("isDisjointFrom", function(result) {
return !result;
})
}, { isDisjointFrom });
var require_set_is_subset_of = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aSet$3 = require_a_set();
var size$1 = require_set_size();
var iterate$4 = require_set_iterate();
var getSetRecord$3 = require_get_set_record();
module.exports = function isSubsetOf$1(other) {
var O = aSet$3(this);
var otherRec = getSetRecord$3(other);
if (size$1(O) > otherRec.size) return false;
return iterate$4(O, function(e) {
if (!otherRec.includes(e)) return false;
}, true) !== false;
};
}));
var $$20 = require_export();
var isSubsetOf = require_set_is_subset_of();
$$20({
target: "Set",
proto: true,
real: true,
forced: !require_set_method_accept_set_like()("isSubsetOf", function(result) {
return result;
})
}, { isSubsetOf });
var require_set_is_superset_of = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aSet$2 = require_a_set();
var has$1 = require_set_helpers().has;
var size = require_set_size();
var getSetRecord$2 = require_get_set_record();
var iterateSimple$2 = require_iterate_simple();
var iteratorClose$4 = require_iterator_close();
module.exports = function isSupersetOf$1(other) {
var O = aSet$2(this);
var otherRec = getSetRecord$2(other);
if (size(O) < otherRec.size) return false;
var iterator = otherRec.getIterator();
return iterateSimple$2(iterator, function(e) {
if (!has$1(O, e)) return iteratorClose$4(iterator, "normal", false);
}) !== false;
};
}));
var $$19 = require_export();
var isSupersetOf = require_set_is_superset_of();
$$19({
target: "Set",
proto: true,
real: true,
forced: !require_set_method_accept_set_like()("isSupersetOf", function(result) {
return !result;
})
}, { isSupersetOf });
var require_set_symmetric_difference = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aSet$1 = require_a_set();
var SetHelpers$1 = require_set_helpers();
var clone$1 = require_set_clone();
var getSetRecord$1 = require_get_set_record();
var iterateSimple$1 = require_iterate_simple();
var add$1 = SetHelpers$1.add;
var has = SetHelpers$1.has;
var remove = SetHelpers$1.remove;
module.exports = function symmetricDifference$1(other) {
var O = aSet$1(this);
var keysIter = getSetRecord$1(other).getIterator();
var result = clone$1(O);
iterateSimple$1(keysIter, function(e) {
if (has(O, e)) remove(result, e);
else add$1(result, e);
});
return result;
};
}));
var require_set_method_get_keys_before_cloning_detection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = function(METHOD_NAME) {
try {
var baseSet = /* @__PURE__ */ new Set();
var result = baseSet[METHOD_NAME]({
size: 0,
has: function() {
return true;
},
keys: function() {
return Object.defineProperty({}, "next", { get: function() {
baseSet.clear();
baseSet.add(4);
return function() {
return { done: true };
};
} });
}
});
return result.size === 1 && result.values().next().value === 4;
} catch (error) {
return false;
}
};
}));
var $$18 = require_export();
var symmetricDifference = require_set_symmetric_difference();
var setMethodGetKeysBeforeCloning$1 = require_set_method_get_keys_before_cloning_detection();
$$18({
target: "Set",
proto: true,
real: true,
forced: !require_set_method_accept_set_like()("symmetricDifference") || !setMethodGetKeysBeforeCloning$1("symmetricDifference")
}, { symmetricDifference });
var require_set_union = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var aSet = require_a_set();
var add = require_set_helpers().add;
var clone = require_set_clone();
var getSetRecord = require_get_set_record();
var iterateSimple = require_iterate_simple();
module.exports = function union$1(other) {
var O = aSet(this);
var keysIter = getSetRecord(other).getIterator();
var result = clone(O);
iterateSimple(keysIter, function(it) {
add(result, it);
});
return result;
};
}));
var $$17 = require_export();
var union = require_set_union();
var setMethodGetKeysBeforeCloning = require_set_method_get_keys_before_cloning_detection();
$$17({
target: "Set",
proto: true,
real: true,
forced: !require_set_method_accept_set_like()("union") || !setMethodGetKeysBeforeCloning("union")
}, { union });
var require_to_string = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var classof$7 = require_classof();
var $String$2 = String;
module.exports = function(argument) {
if (classof$7(argument) === "Symbol") throw new TypeError("Cannot convert a Symbol value to a string");
return $String$2(argument);
};
}));
var require_validate_arguments_length = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $TypeError$8 = TypeError;
module.exports = function(passed, required) {
if (passed < required) throw new $TypeError$8("Not enough arguments");
return passed;
};
}));
var defineBuiltIn$5 = require_define_built_in();
var uncurryThis$13 = require_function_uncurry_this();
var toString$3 = require_to_string();
var validateArgumentsLength$4 = require_validate_arguments_length();
var $URLSearchParams$1 = URLSearchParams;
var URLSearchParamsPrototype$1 = $URLSearchParams$1.prototype;
var append = uncurryThis$13(URLSearchParamsPrototype$1.append);
var $delete = uncurryThis$13(URLSearchParamsPrototype$1["delete"]);
var forEach = uncurryThis$13(URLSearchParamsPrototype$1.forEach);
var push$3 = uncurryThis$13([].push);
var params$1 = new $URLSearchParams$1("a=1&a=2&b=3");
params$1["delete"]("a", 1);
params$1["delete"]("b", void 0);
if (params$1 + "" !== "a=2") defineBuiltIn$5(URLSearchParamsPrototype$1, "delete", function(name) {
var length = arguments.length;
var $value = length < 2 ? void 0 : arguments[1];
if (length && $value === void 0) return $delete(this, name);
var entries = [];
forEach(this, function(v, k) {
push$3(entries, {
key: k,
value: v
});
});
validateArgumentsLength$4(length, 1);
var key$1 = toString$3(name);
var value = toString$3($value);
var index = 0;
var dindex = 0;
var found = false;
var entriesLength = entries.length;
var entry;
while (index < entriesLength) {
entry = entries[index++];
if (found || entry.key === key$1) {
found = true;
$delete(this, entry.key);
} else dindex++;
}
while (dindex < entriesLength) {
entry = entries[dindex++];
if (!(entry.key === key$1 && entry.value === value)) append(this, entry.key, entry.value);
}
}, {
enumerable: true,
unsafe: true
});
var defineBuiltIn$4 = require_define_built_in();
var uncurryThis$12 = require_function_uncurry_this();
var toString$2 = require_to_string();
var validateArgumentsLength$3 = require_validate_arguments_length();
var $URLSearchParams = URLSearchParams;
var URLSearchParamsPrototype = $URLSearchParams.prototype;
var getAll = uncurryThis$12(URLSearchParamsPrototype.getAll);
var $has = uncurryThis$12(URLSearchParamsPrototype.has);
var params = new $URLSearchParams("a=1");
if (params.has("a", 2) || !params.has("a", void 0)) defineBuiltIn$4(URLSearchParamsPrototype, "has", function has$7(name) {
var length = arguments.length;
var $value = length < 2 ? void 0 : arguments[1];
if (length && $value === void 0) return $has(this, name);
var values = getAll(this, name);
validateArgumentsLength$3(length, 1);
var value = toString$2($value);
var index = 0;
while (index < values.length) if (values[index++] === value) return true;
return false;
}, {
enumerable: true,
unsafe: true
});
var require_parse_json_string = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$11 = require_function_uncurry_this();
var hasOwn$10 = require_has_own_property();
var $SyntaxError = SyntaxError;
var $parseInt = parseInt;
var fromCharCode = String.fromCharCode;
var at$2 = uncurryThis$11("".charAt);
var slice$2 = uncurryThis$11("".slice);
var exec$3 = uncurryThis$11(/./.exec);
var codePoints = {
"\\\"": "\"",
"\\\\": "\\",
"\\/": "/",
"\\b": "\b",
"\\f": "\f",
"\\n": "\n",
"\\r": "\r",
"\\t": " "
};
var IS_4_HEX_DIGITS = /^[\da-f]{4}$/i;
var IS_C0_CONTROL_CODE = /^[\u0000-\u001F]$/;
module.exports = function(source, i) {
var unterminated = true;
var value = "";
while (i < source.length) {
var chr = at$2(source, i);
if (chr === "\\") {
var twoChars = slice$2(source, i, i + 2);
if (hasOwn$10(codePoints, twoChars)) {
value += codePoints[twoChars];
i += 2;
} else if (twoChars === "\\u") {
i += 2;
var fourHexDigits = slice$2(source, i, i + 4);
if (!exec$3(IS_4_HEX_DIGITS, fourHexDigits)) throw new $SyntaxError("Bad Unicode escape at: " + i);
value += fromCharCode($parseInt(fourHexDigits, 16));
i += 4;
} else throw new $SyntaxError("Unknown escape sequence: \"" + twoChars + "\"");
} else if (chr === "\"") {
unterminated = false;
i++;
break;
} else {
if (exec$3(IS_C0_CONTROL_CODE, chr)) throw new $SyntaxError("Bad control character in string literal at: " + i);
value += chr;
i++;
}
}
if (unterminated) throw new $SyntaxError("Unterminated string at: " + i);
return {
value,
end: i
};
};
}));
var $$16 = require_export();
var DESCRIPTORS$3 = require_descriptors();
var globalThis$27 = require_global_this();
var getBuiltIn$4 = require_get_built_in();
var uncurryThis$10 = require_function_uncurry_this();
var call$8 = require_function_call();
var isCallable$7 = require_is_callable();
var isObject$6 = require_is_object();
var isArray = require_is_array();
var hasOwn$9 = require_has_own_property();
var toString$1 = require_to_string();
var lengthOfArrayLike$2 = require_length_of_array_like();
var createProperty$1 = require_create_property();
var fails$8 = require_fails();
var parseJSONString = require_parse_json_string();
var NATIVE_SYMBOL = require_symbol_constructor_detection();
var JSON$1 = globalThis$27.JSON;
var Number = globalThis$27.Number;
var SyntaxError$3 = globalThis$27.SyntaxError;
var nativeParse = JSON$1 && JSON$1.parse;
var enumerableOwnProperties = getBuiltIn$4("Object", "keys");
var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor;
var at$1 = uncurryThis$10("".charAt);
var slice$1 = uncurryThis$10("".slice);
var exec$2 = uncurryThis$10(/./.exec);
var push$2 = uncurryThis$10([].push);
var IS_DIGIT = /^\d$/;
var IS_NON_ZERO_DIGIT = /^[1-9]$/;
var IS_NUMBER_START = /^[\d-]$/;
var IS_WHITESPACE = /^[\t\n\r ]$/;
var PRIMITIVE = 0;
var OBJECT = 1;
var $parse = function(source, reviver) {
source = toString$1(source);
var context = new Context(source, 0, "");
var root = context.parse();
var value = root.value;
var endIndex = context.skip(IS_WHITESPACE, root.end);
if (endIndex < source.length) throw new SyntaxError$3("Unexpected extra character: \"" + at$1(source, endIndex) + "\" after the parsed data at: " + endIndex);
return isCallable$7(reviver) ? internalize({ "": value }, "", reviver, root) : value;
};
var internalize = function(holder, name, reviver, node) {
var val = holder[name];
var unmodified = node && val === node.value;
var context = unmodified && typeof node.source == "string" ? { source: node.source } : {};
var elementRecordsLen, keys$2, len, i, P;
if (isObject$6(val)) {
var nodeIsArray = isArray(val);
var nodes = unmodified ? node.nodes : nodeIsArray ? [] : {};
if (nodeIsArray) {
elementRecordsLen = nodes.length;
len = lengthOfArrayLike$2(val);
for (i = 0; i < len; i++) internalizeProperty(val, i, internalize(val, "" + i, reviver, i < elementRecordsLen ? nodes[i] : void 0));
} else {
keys$2 = enumerableOwnProperties(val);
len = lengthOfArrayLike$2(keys$2);
for (i = 0; i < len; i++) {
P = keys$2[i];
internalizeProperty(val, P, internalize(val, P, reviver, hasOwn$9(nodes, P) ? nodes[P] : void 0));
}
}
}
return call$8(reviver, holder, name, val, context);
};
var internalizeProperty = function(object, key$1, value) {
if (DESCRIPTORS$3) {
var descriptor$3 = getOwnPropertyDescriptor$2(object, key$1);
if (descriptor$3 && !descriptor$3.configurable) return;
}
if (value === void 0) delete object[key$1];
else createProperty$1(object, key$1, value);
};
var Node = function(value, end, source, nodes) {
this.value = value;
this.end = end;
this.source = source;
this.nodes = nodes;
};
var Context = function(source, index) {
this.source = source;
this.index = index;
};
Context.prototype = {
fork: function(nextIndex) {
return new Context(this.source, nextIndex);
},
parse: function() {
var source = this.source;
var i = this.skip(IS_WHITESPACE, this.index);
var fork = this.fork(i);
var chr = at$1(source, i);
if (exec$2(IS_NUMBER_START, chr)) return fork.number();
switch (chr) {
case "{": return fork.object();
case "[": return fork.array();
case "\"": return fork.string();
case "t": return fork.keyword(true);
case "f": return fork.keyword(false);
case "n": return fork.keyword(null);
}
throw new SyntaxError$3("Unexpected character: \"" + chr + "\" at: " + i);
},
node: function(type, value, start, end, nodes) {
return new Node(value, end, type ? null : slice$1(this.source, start, end), nodes);
},
object: function() {
var source = this.source;
var i = this.index + 1;
var expectKeypair = false;
var object = {};
var nodes = {};
while (i < source.length) {
i = this.until(["\"", "}"], i);
if (at$1(source, i) === "}" && !expectKeypair) {
i++;
break;
}
var result = this.fork(i).string();
var key$1 = result.value;
i = result.end;
i = this.until([":"], i) + 1;
i = this.skip(IS_WHITESPACE, i);
result = this.fork(i).parse();
createProperty$1(nodes, key$1, result);
createProperty$1(object, key$1, result.value);
i = this.until([",", "}"], result.end);
var chr = at$1(source, i);
if (chr === ",") {
expectKeypair = true;
i++;
} else if (chr === "}") {
i++;
break;
}
}
return this.node(OBJECT, object, this.index, i, nodes);
},
array: function() {
var source = this.source;
var i = this.index + 1;
var expectElement = false;
var array = [];
var nodes = [];
while (i < source.length) {
i = this.skip(IS_WHITESPACE, i);
if (at$1(source, i) === "]" && !expectElement) {
i++;
break;
}
var result = this.fork(i).parse();
push$2(nodes, result);
push$2(array, result.value);
i = this.until([",", "]"], result.end);
if (at$1(source, i) === ",") {
expectElement = true;
i++;
} else if (at$1(source, i) === "]") {
i++;
break;
}
}
return this.node(OBJECT, array, this.index, i, nodes);
},
string: function() {
var index = this.index;
var parsed = parseJSONString(this.source, this.index + 1);
return this.node(PRIMITIVE, parsed.value, index, parsed.end);
},
number: function() {
var source = this.source;
var startIndex = this.index;
var i = startIndex;
if (at$1(source, i) === "-") i++;
if (at$1(source, i) === "0") i++;
else if (exec$2(IS_NON_ZERO_DIGIT, at$1(source, i))) i = this.skip(IS_DIGIT, i + 1);
else throw new SyntaxError$3("Failed to parse number at: " + i);
if (at$1(source, i) === ".") i = this.skip(IS_DIGIT, i + 1);
if (at$1(source, i) === "e" || at$1(source, i) === "E") {
i++;
if (at$1(source, i) === "+" || at$1(source, i) === "-") i++;
var exponentStartIndex = i;
i = this.skip(IS_DIGIT, i);
if (exponentStartIndex === i) throw new SyntaxError$3("Failed to parse number's exponent value at: " + i);
}
return this.node(PRIMITIVE, Number(slice$1(source, startIndex, i)), startIndex, i);
},
keyword: function(value) {
var keyword = "" + value;
var index = this.index;
var endIndex = index + keyword.length;
if (slice$1(this.source, index, endIndex) !== keyword) throw new SyntaxError$3("Failed to parse value at: " + index);
return this.node(PRIMITIVE, value, index, endIndex);
},
skip: function(regex, i) {
var source = this.source;
for (; i < source.length; i++) if (!exec$2(regex, at$1(source, i))) break;
return i;
},
until: function(array, i) {
i = this.skip(IS_WHITESPACE, i);
var chr = at$1(this.source, i);
for (var j = 0; j < array.length; j++) if (array[j] === chr) return i;
throw new SyntaxError$3("Unexpected character: \"" + chr + "\" at: " + i);
}
};
var NO_SOURCE_SUPPORT = fails$8(function() {
var unsafeInt = "9007199254740993";
var source;
nativeParse(unsafeInt, function(key$1, value, context) {
source = context.source;
});
return source !== unsafeInt;
});
var PROPER_BASE_PARSE = NATIVE_SYMBOL && !fails$8(function() {
return 1 / nativeParse("-0 ") !== -Infinity;
});
$$16({
target: "JSON",
stat: true,
forced: NO_SOURCE_SUPPORT
}, { parse: function parse(text, reviver) {
return PROPER_BASE_PARSE && !isCallable$7(reviver) ? nativeParse(text) : $parse(text, reviver);
} });
var require_function_apply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var NATIVE_BIND = require_function_bind_native();
var FunctionPrototype = Function.prototype;
var apply$3 = FunctionPrototype.apply;
var call$7 = FunctionPrototype.call;
module.exports = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call$7.bind(apply$3) : function() {
return call$7.apply(apply$3, arguments);
});
}));
var $$15 = require_export();
var iterate$3 = require_iterate();
var aCallable$2 = require_a_callable();
var anObject$7 = require_an_object();
var getIteratorDirect$5 = require_get_iterator_direct();
var iteratorClose$3 = require_iterator_close();
var iteratorHelperWithoutClosingOnEarlyError$2 = require_iterator_helper_without_closing_on_early_error();
var apply$2 = require_function_apply();
var fails$7 = require_fails();
var $TypeError$7 = TypeError;
var FAILS_ON_INITIAL_UNDEFINED = fails$7(function() {
[].keys().reduce(function() {}, void 0);
});
var reduceWithoutClosingOnEarlyError = !FAILS_ON_INITIAL_UNDEFINED && iteratorHelperWithoutClosingOnEarlyError$2("reduce", $TypeError$7);
$$15({
target: "Iterator",
proto: true,
real: true,
forced: FAILS_ON_INITIAL_UNDEFINED || reduceWithoutClosingOnEarlyError
}, { reduce: function reduce(reducer) {
anObject$7(this);
try {
aCallable$2(reducer);
} catch (error) {
iteratorClose$3(this, "throw", error);
}
var noInitial = arguments.length < 2;
var accumulator = noInitial ? void 0 : arguments[1];
if (reduceWithoutClosingOnEarlyError) return apply$2(reduceWithoutClosingOnEarlyError, this, noInitial ? [reducer] : [reducer, accumulator]);
var record = getIteratorDirect$5(this);
var counter$1 = 0;
iterate$3(record, function(value) {
if (noInitial) {
noInitial = false;
accumulator = value;
} else accumulator = reducer(accumulator, value, counter$1);
counter$1++;
}, { IS_RECORD: true });
if (noInitial) throw new $TypeError$7("Reduce of empty iterator with no initial value");
return accumulator;
} });
var require_array_buffer_basic_detection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = typeof ArrayBuffer != "undefined" && typeof DataView != "undefined";
}));
var require_array_buffer_byte_length = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$26 = require_global_this();
var uncurryThisAccessor$2 = require_function_uncurry_this_accessor();
var classof$6 = require_classof_raw();
var ArrayBuffer$2 = globalThis$26.ArrayBuffer;
var TypeError$4 = globalThis$26.TypeError;
module.exports = ArrayBuffer$2 && uncurryThisAccessor$2(ArrayBuffer$2.prototype, "byteLength", "get") || function(O) {
if (classof$6(O) !== "ArrayBuffer") throw new TypeError$4("ArrayBuffer expected");
return O.byteLength;
};
}));
var require_array_buffer_is_detached = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$25 = require_global_this();
var NATIVE_ARRAY_BUFFER$1 = require_array_buffer_basic_detection();
var arrayBufferByteLength$1 = require_array_buffer_byte_length();
var DataView$2 = globalThis$25.DataView;
module.exports = function(O) {
if (!NATIVE_ARRAY_BUFFER$1 || arrayBufferByteLength$1(O) !== 0) return false;
try {
new DataView$2(O);
return false;
} catch (error) {
return true;
}
};
}));
var DESCRIPTORS$2 = require_descriptors();
var defineBuiltInAccessor$1 = require_define_built_in_accessor();
var isDetached$1 = require_array_buffer_is_detached();
var ArrayBufferPrototype$1 = ArrayBuffer.prototype;
if (DESCRIPTORS$2 && !("detached" in ArrayBufferPrototype$1)) defineBuiltInAccessor$1(ArrayBufferPrototype$1, "detached", {
configurable: true,
get: function detached() {
return isDetached$1(this);
}
});
var require_to_index = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toIntegerOrInfinity$3 = require_to_integer_or_infinity();
var toLength = require_to_length();
var $RangeError$3 = RangeError;
module.exports = function(it) {
if (it === void 0) return 0;
var number = toIntegerOrInfinity$3(it);
var length = toLength(number);
if (number !== length) throw new $RangeError$3("Wrong length or index");
return length;
};
}));
var require_array_buffer_not_detached = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isDetached = require_array_buffer_is_detached();
var $TypeError$6 = TypeError;
module.exports = function(it) {
if (isDetached(it)) throw new $TypeError$6("ArrayBuffer is detached");
return it;
};
}));
var require_environment = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$24 = require_global_this();
var userAgent$1 = require_environment_user_agent();
var classof$5 = require_classof_raw();
var userAgentStartsWith = function(string) {
return userAgent$1.slice(0, string.length) === string;
};
module.exports = (function() {
if (userAgentStartsWith("Bun/")) return "BUN";
if (userAgentStartsWith("Cloudflare-Workers")) return "CLOUDFLARE";
if (userAgentStartsWith("Deno/")) return "DENO";
if (userAgentStartsWith("Node.js/")) return "NODE";
if (globalThis$24.Bun && typeof Bun.version == "string") return "BUN";
if (globalThis$24.Deno && typeof Deno.version == "object") return "DENO";
if (classof$5(globalThis$24.process) === "process") return "NODE";
if (globalThis$24.window && globalThis$24.document) return "BROWSER";
return "REST";
})();
}));
var require_environment_is_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_environment() === "NODE";
}));
var require_get_built_in_node_module = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$23 = require_global_this();
var IS_NODE$1 = require_environment_is_node();
module.exports = function(name) {
if (IS_NODE$1) {
try {
return globalThis$23.process.getBuiltinModule(name);
} catch (error) {}
try {
return Function("return require(\"" + name + "\")")();
} catch (error) {}
}
};
}));
var require_structured_clone_proper_transfer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$22 = require_global_this();
var fails$6 = require_fails();
var V8 = require_environment_v8_version();
var ENVIRONMENT$1 = require_environment();
var structuredClone$2 = globalThis$22.structuredClone;
module.exports = !!structuredClone$2 && !fails$6(function() {
if (ENVIRONMENT$1 === "DENO" && V8 > 92 || ENVIRONMENT$1 === "NODE" && V8 > 94 || ENVIRONMENT$1 === "BROWSER" && V8 > 97) return false;
var buffer$1 = /* @__PURE__ */ new ArrayBuffer(8);
var clone$3 = structuredClone$2(buffer$1, { transfer: [buffer$1] });
return buffer$1.byteLength !== 0 || clone$3.byteLength !== 8;
});
}));
var require_detach_transferable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$21 = require_global_this();
var getBuiltInNodeModule = require_get_built_in_node_module();
var PROPER_STRUCTURED_CLONE_TRANSFER$2 = require_structured_clone_proper_transfer();
var structuredClone$1 = globalThis$21.structuredClone;
var $ArrayBuffer = globalThis$21.ArrayBuffer;
var $MessageChannel = globalThis$21.MessageChannel;
var detach = false;
var WorkerThreads, channel$1, buffer, $detach;
if (PROPER_STRUCTURED_CLONE_TRANSFER$2) detach = function(transferable) {
structuredClone$1(transferable, { transfer: [transferable] });
};
else if ($ArrayBuffer) try {
if (!$MessageChannel) {
WorkerThreads = getBuiltInNodeModule("worker_threads");
if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel;
}
if ($MessageChannel) {
channel$1 = new $MessageChannel();
buffer = new $ArrayBuffer(2);
$detach = function(transferable) {
channel$1.port1.postMessage(null, [transferable]);
};
if (buffer.byteLength === 2) {
$detach(buffer);
if (buffer.byteLength === 0) detach = $detach;
}
}
} catch (error) {}
module.exports = detach;
}));
var require_array_buffer_transfer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$20 = require_global_this();
var uncurryThis$9 = require_function_uncurry_this();
var uncurryThisAccessor$1 = require_function_uncurry_this_accessor();
var toIndex = require_to_index();
var notDetached$4 = require_array_buffer_not_detached();
var arrayBufferByteLength = require_array_buffer_byte_length();
var detachTransferable$1 = require_detach_transferable();
var PROPER_STRUCTURED_CLONE_TRANSFER$1 = require_structured_clone_proper_transfer();
var structuredClone = globalThis$20.structuredClone;
var ArrayBuffer$1 = globalThis$20.ArrayBuffer;
var DataView$1 = globalThis$20.DataView;
var min$1 = Math.min;
var ArrayBufferPrototype = ArrayBuffer$1.prototype;
var DataViewPrototype = DataView$1.prototype;
var slice = uncurryThis$9(ArrayBufferPrototype.slice);
var isResizable = uncurryThisAccessor$1(ArrayBufferPrototype, "resizable", "get");
var maxByteLength = uncurryThisAccessor$1(ArrayBufferPrototype, "maxByteLength", "get");
var getInt8 = uncurryThis$9(DataViewPrototype.getInt8);
var setInt8 = uncurryThis$9(DataViewPrototype.setInt8);
module.exports = (PROPER_STRUCTURED_CLONE_TRANSFER$1 || detachTransferable$1) && function(arrayBuffer, newLength, preserveResizability) {
var byteLength = arrayBufferByteLength(arrayBuffer);
var newByteLength = newLength === void 0 ? byteLength : toIndex(newLength);
var fixedLength = !isResizable || !isResizable(arrayBuffer);
var newBuffer;
notDetached$4(arrayBuffer);
if (PROPER_STRUCTURED_CLONE_TRANSFER$1) {
arrayBuffer = structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
if (byteLength === newByteLength && (preserveResizability || fixedLength)) return arrayBuffer;
}
if (byteLength >= newByteLength && (!preserveResizability || fixedLength)) newBuffer = slice(arrayBuffer, 0, newByteLength);
else {
newBuffer = new ArrayBuffer$1(newByteLength, preserveResizability && !fixedLength && maxByteLength ? { maxByteLength: maxByteLength(arrayBuffer) } : void 0);
var a = new DataView$1(arrayBuffer);
var b = new DataView$1(newBuffer);
var copyLength = min$1(newByteLength, byteLength);
for (var i = 0; i < copyLength; i++) setInt8(b, i, getInt8(a, i));
}
if (!PROPER_STRUCTURED_CLONE_TRANSFER$1) detachTransferable$1(arrayBuffer);
return newBuffer;
};
}));
var $$14 = require_export();
var $transfer$1 = require_array_buffer_transfer();
if ($transfer$1) $$14({
target: "ArrayBuffer",
proto: true
}, { transfer: function transfer() {
return $transfer$1(this, arguments.length ? arguments[0] : void 0, true);
} });
var $$13 = require_export();
var $transfer = require_array_buffer_transfer();
if ($transfer) $$13({
target: "ArrayBuffer",
proto: true
}, { transferToFixedLength: function transferToFixedLength() {
return $transfer(this, arguments.length ? arguments[0] : void 0, false);
} });
var require_get_iterator_flattenable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$6 = require_function_call();
var anObject$6 = require_an_object();
var getIteratorDirect$4 = require_get_iterator_direct();
var getIteratorMethod = require_get_iterator_method();
module.exports = function(obj, stringHandling) {
if (!stringHandling || typeof obj !== "string") anObject$6(obj);
var method = getIteratorMethod(obj);
return getIteratorDirect$4(anObject$6(method !== void 0 ? call$6(method, obj) : obj));
};
}));
var $$12 = require_export();
var call$5 = require_function_call();
var aCallable$1 = require_a_callable();
var anObject$5 = require_an_object();
var getIteratorDirect$3 = require_get_iterator_direct();
var getIteratorFlattenable = require_get_iterator_flattenable();
var createIteratorProxy$1 = require_iterator_create_proxy();
var iteratorClose$2 = require_iterator_close();
var IS_PURE$5 = require_is_pure();
var iteratorHelperThrowsOnInvalidIterator$1 = require_iterator_helper_throws_on_invalid_iterator();
var iteratorHelperWithoutClosingOnEarlyError$1 = require_iterator_helper_without_closing_on_early_error();
var FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE$5 && !iteratorHelperThrowsOnInvalidIterator$1("flatMap", function() {});
var flatMapWithoutClosingOnEarlyError = !IS_PURE$5 && !FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR && iteratorHelperWithoutClosingOnEarlyError$1("flatMap", TypeError);
var FORCED$1 = IS_PURE$5 || FLAT_MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || flatMapWithoutClosingOnEarlyError;
var IteratorProxy$1 = createIteratorProxy$1(function() {
var iterator = this.iterator;
var mapper = this.mapper;
var result, inner;
while (true) {
if (inner = this.inner) try {
result = anObject$5(call$5(inner.next, inner.iterator));
if (!result.done) return result.value;
this.inner = null;
} catch (error) {
iteratorClose$2(iterator, "throw", error);
}
result = anObject$5(call$5(this.next, iterator));
if (this.done = !!result.done) return;
try {
this.inner = getIteratorFlattenable(mapper(result.value, this.counter++), false);
} catch (error) {
iteratorClose$2(iterator, "throw", error);
}
}
});
$$12({
target: "Iterator",
proto: true,
real: true,
forced: FORCED$1
}, { flatMap: function flatMap(mapper) {
anObject$5(this);
try {
aCallable$1(mapper);
} catch (error) {
iteratorClose$2(this, "throw", error);
}
if (flatMapWithoutClosingOnEarlyError) return call$5(flatMapWithoutClosingOnEarlyError, this, mapper);
return new IteratorProxy$1(getIteratorDirect$3(this), {
mapper,
inner: null
});
} });
var $$11 = require_export();
var call$4 = require_function_call();
var iterate$2 = require_iterate();
var aCallable = require_a_callable();
var anObject$4 = require_an_object();
var getIteratorDirect$2 = require_get_iterator_direct();
var iteratorClose$1 = require_iterator_close();
var someWithoutClosingOnEarlyError = require_iterator_helper_without_closing_on_early_error()("some", TypeError);
$$11({
target: "Iterator",
proto: true,
real: true,
forced: someWithoutClosingOnEarlyError
}, { some: function some(predicate) {
anObject$4(this);
try {
aCallable(predicate);
} catch (error) {
iteratorClose$1(this, "throw", error);
}
if (someWithoutClosingOnEarlyError) return call$4(someWithoutClosingOnEarlyError, this, predicate);
var record = getIteratorDirect$2(this);
var counter$1 = 0;
return iterate$2(record, function(value, stop) {
if (predicate(value, counter$1++)) return stop();
}, {
IS_RECORD: true,
INTERRUPTED: true
}).stopped;
} });
var require_array_with = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var lengthOfArrayLike$1 = require_length_of_array_like();
var toIntegerOrInfinity$2 = require_to_integer_or_infinity();
var $RangeError$2 = RangeError;
module.exports = function(O, C, index, value) {
var len = lengthOfArrayLike$1(O);
var relativeIndex = toIntegerOrInfinity$2(index);
var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex;
if (actualIndex >= len || actualIndex < 0) throw new $RangeError$2("Incorrect index");
var A = new C(len);
var k = 0;
for (; k < len; k++) A[k] = k === actualIndex ? value : O[k];
return A;
};
}));
var require_is_possible_prototype = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isObject$5 = require_is_object();
module.exports = function(argument) {
return isObject$5(argument) || argument === null;
};
}));
var require_a_possible_prototype = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isPossiblePrototype = require_is_possible_prototype();
var $String$1 = String;
var $TypeError$5 = TypeError;
module.exports = function(argument) {
if (isPossiblePrototype(argument)) return argument;
throw new $TypeError$5("Can't set " + $String$1(argument) + " as a prototype");
};
}));
var require_object_set_prototype_of = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThisAccessor = require_function_uncurry_this_accessor();
var isObject$4 = require_is_object();
var requireObjectCoercible = require_require_object_coercible();
var aPossiblePrototype = require_a_possible_prototype();
module.exports = Object.setPrototypeOf || ("__proto__" in {} ? function() {
var CORRECT_SETTER = false;
var test$1 = {};
var setter;
try {
setter = uncurryThisAccessor(Object.prototype, "__proto__", "set");
setter(test$1, []);
CORRECT_SETTER = test$1 instanceof Array;
} catch (error) {}
return function setPrototypeOf$3(O, proto) {
requireObjectCoercible(O);
aPossiblePrototype(proto);
if (!isObject$4(O)) return O;
if (CORRECT_SETTER) setter(O, proto);
else O.__proto__ = proto;
return O;
};
}() : void 0);
}));
var require_array_buffer_view_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var NATIVE_ARRAY_BUFFER = require_array_buffer_basic_detection();
var DESCRIPTORS$1 = require_descriptors();
var globalThis$19 = require_global_this();
var isCallable$6 = require_is_callable();
var isObject$3 = require_is_object();
var hasOwn$8 = require_has_own_property();
var classof$4 = require_classof();
var tryToString = require_try_to_string();
var createNonEnumerableProperty$3 = require_create_non_enumerable_property();
var defineBuiltIn$3 = require_define_built_in();
var defineBuiltInAccessor = require_define_built_in_accessor();
var isPrototypeOf$2 = require_object_is_prototype_of();
var getPrototypeOf$2 = require_object_get_prototype_of();
var setPrototypeOf$2 = require_object_set_prototype_of();
var wellKnownSymbol$5 = require_well_known_symbol();
var uid$1 = require_uid();
var InternalStateModule = require_internal_state();
var enforceInternalState = InternalStateModule.enforce;
var getInternalState = InternalStateModule.get;
var Int8Array$1 = globalThis$19.Int8Array;
var Int8ArrayPrototype = Int8Array$1 && Int8Array$1.prototype;
var Uint8ClampedArray = globalThis$19.Uint8ClampedArray;
var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
var TypedArray = Int8Array$1 && getPrototypeOf$2(Int8Array$1);
var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf$2(Int8ArrayPrototype);
var ObjectPrototype = Object.prototype;
var TypeError$3 = globalThis$19.TypeError;
var TO_STRING_TAG$1 = wellKnownSymbol$5("toStringTag");
var TYPED_ARRAY_TAG = uid$1("TYPED_ARRAY_TAG");
var TYPED_ARRAY_CONSTRUCTOR = "TypedArrayConstructor";
var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf$2 && classof$4(globalThis$19.opera) !== "Opera";
var TYPED_ARRAY_TAG_REQUIRED = false;
var NAME, Constructor, Prototype;
var TypedArrayConstructorsList = {
Int8Array: 1,
Uint8Array: 1,
Uint8ClampedArray: 1,
Int16Array: 2,
Uint16Array: 2,
Int32Array: 4,
Uint32Array: 4,
Float32Array: 4,
Float64Array: 8
};
var BigIntArrayConstructorsList = {
BigInt64Array: 8,
BigUint64Array: 8
};
var isView = function isView$1(it) {
if (!isObject$3(it)) return false;
var klass = classof$4(it);
return klass === "DataView" || hasOwn$8(TypedArrayConstructorsList, klass) || hasOwn$8(BigIntArrayConstructorsList, klass);
};
var getTypedArrayConstructor$1 = function(it) {
var proto = getPrototypeOf$2(it);
if (!isObject$3(proto)) return;
var state = getInternalState(proto);
return state && hasOwn$8(state, TYPED_ARRAY_CONSTRUCTOR) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor$1(proto);
};
var isTypedArray = function(it) {
if (!isObject$3(it)) return false;
var klass = classof$4(it);
return hasOwn$8(TypedArrayConstructorsList, klass) || hasOwn$8(BigIntArrayConstructorsList, klass);
};
var aTypedArray$1 = function(it) {
if (isTypedArray(it)) return it;
throw new TypeError$3("Target is not a typed array");
};
var aTypedArrayConstructor = function(C) {
if (isCallable$6(C) && (!setPrototypeOf$2 || isPrototypeOf$2(TypedArray, C))) return C;
throw new TypeError$3(tryToString(C) + " is not a typed array constructor");
};
var exportTypedArrayMethod$1 = function(KEY, property, forced, options) {
if (!DESCRIPTORS$1) return;
if (forced) for (var ARRAY in TypedArrayConstructorsList) {
var TypedArrayConstructor = globalThis$19[ARRAY];
if (TypedArrayConstructor && hasOwn$8(TypedArrayConstructor.prototype, KEY)) try {
delete TypedArrayConstructor.prototype[KEY];
} catch (error) {
try {
TypedArrayConstructor.prototype[KEY] = property;
} catch (error2) {}
}
}
if (!TypedArrayPrototype[KEY] || forced) defineBuiltIn$3(TypedArrayPrototype, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
};
var exportTypedArrayStaticMethod = function(KEY, property, forced) {
var ARRAY, TypedArrayConstructor;
if (!DESCRIPTORS$1) return;
if (setPrototypeOf$2) {
if (forced) for (ARRAY in TypedArrayConstructorsList) {
TypedArrayConstructor = globalThis$19[ARRAY];
if (TypedArrayConstructor && hasOwn$8(TypedArrayConstructor, KEY)) try {
delete TypedArrayConstructor[KEY];
} catch (error) {}
}
if (!TypedArray[KEY] || forced) try {
return defineBuiltIn$3(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
} catch (error) {}
else return;
}
for (ARRAY in TypedArrayConstructorsList) {
TypedArrayConstructor = globalThis$19[ARRAY];
if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) defineBuiltIn$3(TypedArrayConstructor, KEY, property);
}
};
for (NAME in TypedArrayConstructorsList) {
Constructor = globalThis$19[NAME];
Prototype = Constructor && Constructor.prototype;
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
else NATIVE_ARRAY_BUFFER_VIEWS = false;
}
for (NAME in BigIntArrayConstructorsList) {
Constructor = globalThis$19[NAME];
Prototype = Constructor && Constructor.prototype;
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
}
if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable$6(TypedArray) || TypedArray === Function.prototype) {
TypedArray = function TypedArray$1() {
throw new TypeError$3("Incorrect invocation");
};
if (NATIVE_ARRAY_BUFFER_VIEWS) {
for (NAME in TypedArrayConstructorsList) if (globalThis$19[NAME]) setPrototypeOf$2(globalThis$19[NAME], TypedArray);
}
}
if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
TypedArrayPrototype = TypedArray.prototype;
if (NATIVE_ARRAY_BUFFER_VIEWS) {
for (NAME in TypedArrayConstructorsList) if (globalThis$19[NAME]) setPrototypeOf$2(globalThis$19[NAME].prototype, TypedArrayPrototype);
}
}
if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf$2(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) setPrototypeOf$2(Uint8ClampedArrayPrototype, TypedArrayPrototype);
if (DESCRIPTORS$1 && !hasOwn$8(TypedArrayPrototype, TO_STRING_TAG$1)) {
TYPED_ARRAY_TAG_REQUIRED = true;
defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG$1, {
configurable: true,
get: function() {
return isObject$3(this) ? this[TYPED_ARRAY_TAG] : void 0;
}
});
for (NAME in TypedArrayConstructorsList) if (globalThis$19[NAME]) createNonEnumerableProperty$3(globalThis$19[NAME], TYPED_ARRAY_TAG, NAME);
}
module.exports = {
NATIVE_ARRAY_BUFFER_VIEWS,
TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
aTypedArray: aTypedArray$1,
aTypedArrayConstructor,
exportTypedArrayMethod: exportTypedArrayMethod$1,
exportTypedArrayStaticMethod,
getTypedArrayConstructor: getTypedArrayConstructor$1,
isView,
isTypedArray,
TypedArray,
TypedArrayPrototype
};
}));
var require_is_big_int_array = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var classof$3 = require_classof();
module.exports = function(it) {
var klass = classof$3(it);
return klass === "BigInt64Array" || klass === "BigUint64Array";
};
}));
var require_to_big_int = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toPrimitive = require_to_primitive();
var $TypeError$4 = TypeError;
module.exports = function(argument) {
var prim = toPrimitive(argument, "number");
if (typeof prim == "number") throw new $TypeError$4("Can't convert number to bigint");
return BigInt(prim);
};
}));
var arrayWith = require_array_with();
var ArrayBufferViewCore = require_array_buffer_view_core();
var isBigIntArray = require_is_big_int_array();
var toIntegerOrInfinity$1 = require_to_integer_or_infinity();
var toBigInt = require_to_big_int();
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var PROPER_ORDER = function() {
try {
new Int8Array(1)["with"](2, { valueOf: function() {
throw 8;
} });
} catch (error) {
return error === 8;
}
}();
var THROW_ON_NEGATIVE_FRACTIONAL_INDEX = PROPER_ORDER && function() {
try {
new Int8Array(1)["with"](-.5, 1);
} catch (error) {
return true;
}
}();
exportTypedArrayMethod("with", { "with": function(index, value) {
var O = aTypedArray(this);
var relativeIndex = toIntegerOrInfinity$1(index);
var actualValue = isBigIntArray(O) ? toBigInt(value) : +value;
return arrayWith(O, getTypedArrayConstructor(O), relativeIndex, actualValue);
} }["with"], !PROPER_ORDER || THROW_ON_NEGATIVE_FRACTIONAL_INDEX);
var require_an_object_or_undefined = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isObject$2 = require_is_object();
var $String = String;
var $TypeError$3 = TypeError;
module.exports = function(argument) {
if (argument === void 0 || isObject$2(argument)) return argument;
throw new $TypeError$3($String(argument) + " is not an object or undefined");
};
}));
var require_a_string = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $TypeError$2 = TypeError;
module.exports = function(argument) {
if (typeof argument == "string") return argument;
throw new $TypeError$2("Argument is not a string");
};
}));
var require_base64_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var commonAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
var base64Alphabet$2 = commonAlphabet + "+/";
var base64UrlAlphabet$2 = commonAlphabet + "-_";
var inverse = function(characters) {
var result = {};
var index = 0;
for (; index < 64; index++) result[characters.charAt(index)] = index;
return result;
};
module.exports = {
i2c: base64Alphabet$2,
c2i: inverse(base64Alphabet$2),
i2cUrl: base64UrlAlphabet$2,
c2iUrl: inverse(base64UrlAlphabet$2)
};
}));
var require_get_alphabet_option = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $TypeError$1 = TypeError;
module.exports = function(options) {
var alphabet = options && options.alphabet;
if (alphabet === void 0 || alphabet === "base64" || alphabet === "base64url") return alphabet || "base64";
throw new $TypeError$1("Incorrect `alphabet` option");
};
}));
var require_uint8_from_base64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$18 = require_global_this();
var uncurryThis$8 = require_function_uncurry_this();
var anObjectOrUndefined$1 = require_an_object_or_undefined();
var aString$1 = require_a_string();
var hasOwn$7 = require_has_own_property();
var base64Map$1 = require_base64_map();
var getAlphabetOption$1 = require_get_alphabet_option();
var notDetached$3 = require_array_buffer_not_detached();
var base64Alphabet$1 = base64Map$1.c2i;
var base64UrlAlphabet$1 = base64Map$1.c2iUrl;
var SyntaxError$2 = globalThis$18.SyntaxError;
var TypeError$2 = globalThis$18.TypeError;
var at = uncurryThis$8("".charAt);
var skipAsciiWhitespace = function(string, index) {
var length = string.length;
for (; index < length; index++) {
var chr = at(string, index);
if (chr !== " " && chr !== " " && chr !== "\n" && chr !== "\f" && chr !== "\r") break;
}
return index;
};
var decodeBase64Chunk = function(chunk, alphabet, throwOnExtraBits) {
var chunkLength = chunk.length;
if (chunkLength < 4) chunk += chunkLength === 2 ? "AA" : "A";
var triplet = (alphabet[at(chunk, 0)] << 18) + (alphabet[at(chunk, 1)] << 12) + (alphabet[at(chunk, 2)] << 6) + alphabet[at(chunk, 3)];
var chunkBytes = [
triplet >> 16 & 255,
triplet >> 8 & 255,
triplet & 255
];
if (chunkLength === 2) {
if (throwOnExtraBits && chunkBytes[1] !== 0) throw new SyntaxError$2("Extra bits");
return [chunkBytes[0]];
}
if (chunkLength === 3) {
if (throwOnExtraBits && chunkBytes[2] !== 0) throw new SyntaxError$2("Extra bits");
return [chunkBytes[0], chunkBytes[1]];
}
return chunkBytes;
};
var writeBytes = function(bytes, elements, written) {
var elementsLength = elements.length;
for (var index = 0; index < elementsLength; index++) bytes[written + index] = elements[index];
return written + elementsLength;
};
module.exports = function(string, options, into, maxLength) {
aString$1(string);
anObjectOrUndefined$1(options);
var alphabet = getAlphabetOption$1(options) === "base64" ? base64Alphabet$1 : base64UrlAlphabet$1;
var lastChunkHandling = options ? options.lastChunkHandling : void 0;
if (lastChunkHandling === void 0) lastChunkHandling = "loose";
if (lastChunkHandling !== "loose" && lastChunkHandling !== "strict" && lastChunkHandling !== "stop-before-partial") throw new TypeError$2("Incorrect `lastChunkHandling` option");
if (into) notDetached$3(into.buffer);
var stringLength = string.length;
var bytes = into || [];
var written = 0;
var read = 0;
var chunk = "";
var index = 0;
if (maxLength) while (true) {
index = skipAsciiWhitespace(string, index);
if (index === stringLength) {
if (chunk.length > 0) {
if (lastChunkHandling === "stop-before-partial") break;
if (lastChunkHandling === "loose") {
if (chunk.length === 1) throw new SyntaxError$2("Malformed padding: exactly one additional character");
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written);
} else throw new SyntaxError$2("Missing padding");
}
read = stringLength;
break;
}
var chr = at(string, index);
++index;
if (chr === "=") {
if (chunk.length < 2) throw new SyntaxError$2("Padding is too early");
index = skipAsciiWhitespace(string, index);
if (chunk.length === 2) {
if (index === stringLength) {
if (lastChunkHandling === "stop-before-partial") break;
throw new SyntaxError$2("Malformed padding: only one =");
}
if (at(string, index) === "=") {
++index;
index = skipAsciiWhitespace(string, index);
}
}
if (index < stringLength) throw new SyntaxError$2("Unexpected character after padding");
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, lastChunkHandling === "strict"), written);
read = stringLength;
break;
}
if (!hasOwn$7(alphabet, chr)) throw new SyntaxError$2("Unexpected character");
var remainingBytes = maxLength - written;
if (remainingBytes === 1 && chunk.length === 2 || remainingBytes === 2 && chunk.length === 3) break;
chunk += chr;
if (chunk.length === 4) {
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written);
chunk = "";
read = index;
if (written === maxLength) break;
}
}
return {
bytes,
read,
written
};
};
}));
var require_an_uint8_array = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var classof$2 = require_classof();
var $TypeError = TypeError;
module.exports = function(argument) {
if (classof$2(argument) === "Uint8Array") return argument;
throw new $TypeError("Argument is not an Uint8Array");
};
}));
(/* @__PURE__ */ __commonJSMin((() => {
var $$10 = require_export();
var globalThis$17 = require_global_this();
var $fromBase64 = require_uint8_from_base64();
var anUint8Array$3 = require_an_uint8_array();
var Uint8Array$4 = globalThis$17.Uint8Array;
var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$2 = !Uint8Array$4 || !Uint8Array$4.prototype.setFromBase64 || !function() {
var target = new Uint8Array$4([
255,
255,
255,
255,
255
]);
try {
target.setFromBase64("", null);
return;
} catch (error) {}
try {
target.setFromBase64("a");
return;
} catch (error) {}
try {
target.setFromBase64("MjYyZg===");
} catch (error) {
return target[0] === 50 && target[1] === 54 && target[2] === 50 && target[3] === 255 && target[4] === 255;
}
}();
if (Uint8Array$4) $$10({
target: "Uint8Array",
proto: true,
forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$2
}, { setFromBase64: function setFromBase64(string) {
anUint8Array$3(this);
var result = $fromBase64(string, arguments.length > 1 ? arguments[1] : void 0, this, this.length);
return {
read: result.read,
written: result.written
};
} });
})))();
var require_uint8_from_hex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$16 = require_global_this();
var uncurryThis$7 = require_function_uncurry_this();
var Uint8Array$3 = globalThis$16.Uint8Array;
var SyntaxError$1 = globalThis$16.SyntaxError;
var parseInt$1 = globalThis$16.parseInt;
var min = Math.min;
var NOT_HEX = /[^\da-f]/i;
var exec$1 = uncurryThis$7(NOT_HEX.exec);
var stringSlice = uncurryThis$7("".slice);
module.exports = function(string, into) {
var stringLength = string.length;
if (stringLength % 2 !== 0) throw new SyntaxError$1("String should be an even number of characters");
var maxLength = into ? min(into.length, stringLength / 2) : stringLength / 2;
var bytes = into || new Uint8Array$3(maxLength);
var read = 0;
var written = 0;
while (written < maxLength) {
var hexits = stringSlice(string, read, read += 2);
if (exec$1(NOT_HEX, hexits)) throw new SyntaxError$1("String should only contain hex characters");
bytes[written++] = parseInt$1(hexits, 16);
}
return {
bytes,
read
};
};
}));
(/* @__PURE__ */ __commonJSMin((() => {
var $$9 = require_export();
var globalThis$15 = require_global_this();
var aString = require_a_string();
var anUint8Array$2 = require_an_uint8_array();
var notDetached$2 = require_array_buffer_not_detached();
var $fromHex = require_uint8_from_hex();
if (globalThis$15.Uint8Array) $$9({
target: "Uint8Array",
proto: true
}, { setFromHex: function setFromHex(string) {
anUint8Array$2(this);
aString(string);
notDetached$2(this.buffer);
var read = $fromHex(string, this).read;
return {
read,
written: read / 2
};
} });
})))();
(/* @__PURE__ */ __commonJSMin((() => {
var $$8 = require_export();
var globalThis$14 = require_global_this();
var uncurryThis$6 = require_function_uncurry_this();
var anObjectOrUndefined = require_an_object_or_undefined();
var anUint8Array$1 = require_an_uint8_array();
var notDetached$1 = require_array_buffer_not_detached();
var base64Map = require_base64_map();
var getAlphabetOption = require_get_alphabet_option();
var base64Alphabet = base64Map.i2c;
var base64UrlAlphabet = base64Map.i2cUrl;
var charAt = uncurryThis$6("".charAt);
var Uint8Array$2 = globalThis$14.Uint8Array;
var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$1 = !Uint8Array$2 || !Uint8Array$2.prototype.toBase64 || !function() {
try {
new Uint8Array$2().toBase64(null);
} catch (error) {
return true;
}
}();
if (Uint8Array$2) $$8({
target: "Uint8Array",
proto: true,
forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS$1
}, { toBase64: function toBase64() {
var array = anUint8Array$1(this);
var options = arguments.length ? anObjectOrUndefined(arguments[0]) : void 0;
var alphabet = getAlphabetOption(options) === "base64" ? base64Alphabet : base64UrlAlphabet;
var omitPadding = !!options && !!options.omitPadding;
notDetached$1(this.buffer);
var result = "";
var i = 0;
var length = array.length;
var triplet;
var at$3 = function(shift) {
return charAt(alphabet, triplet >> 6 * shift & 63);
};
for (; i + 2 < length; i += 3) {
triplet = (array[i] << 16) + (array[i + 1] << 8) + array[i + 2];
result += at$3(3) + at$3(2) + at$3(1) + at$3(0);
}
if (i + 2 === length) {
triplet = (array[i] << 16) + (array[i + 1] << 8);
result += at$3(3) + at$3(2) + at$3(1) + (omitPadding ? "" : "=");
} else if (i + 1 === length) {
triplet = array[i] << 16;
result += at$3(3) + at$3(2) + (omitPadding ? "" : "==");
}
return result;
} });
})))();
(/* @__PURE__ */ __commonJSMin((() => {
var $$7 = require_export();
var globalThis$13 = require_global_this();
var uncurryThis$5 = require_function_uncurry_this();
var anUint8Array = require_an_uint8_array();
var notDetached = require_array_buffer_not_detached();
var numberToString = uncurryThis$5(1.1.toString);
var Uint8Array$1 = globalThis$13.Uint8Array;
var INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS = !Uint8Array$1 || !Uint8Array$1.prototype.toHex || !(function() {
try {
return new Uint8Array$1([
255,
255,
255,
255,
255,
255,
255,
255
]).toHex() === "ffffffffffffffff";
} catch (error) {
return false;
}
})();
if (Uint8Array$1) $$7({
target: "Uint8Array",
proto: true,
forced: INCORRECT_BEHAVIOR_OR_DOESNT_EXISTS
}, { toHex: function toHex() {
anUint8Array(this);
notDetached(this.buffer);
var result = "";
for (var i = 0, length = this.length; i < length; i++) {
var hex = numberToString(this[i], 16);
result += hex.length === 1 ? "0" + hex : hex;
}
return result;
} });
})))();
var require_not_a_nan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var $RangeError$1 = RangeError;
module.exports = function(it) {
if (it === it) return it;
throw new $RangeError$1("NaN is not allowed");
};
}));
var require_to_positive_integer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toIntegerOrInfinity = require_to_integer_or_infinity();
var $RangeError = RangeError;
module.exports = function(it) {
var result = toIntegerOrInfinity(it);
if (result < 0) throw new $RangeError("The argument can't be less than 0");
return result;
};
}));
var $$6 = require_export();
var call$3 = require_function_call();
var anObject$3 = require_an_object();
var getIteratorDirect$1 = require_get_iterator_direct();
var notANaN = require_not_a_nan();
var toPositiveInteger = require_to_positive_integer();
var iteratorClose = require_iterator_close();
var createIteratorProxy = require_iterator_create_proxy();
var iteratorHelperThrowsOnInvalidIterator = require_iterator_helper_throws_on_invalid_iterator();
var iteratorHelperWithoutClosingOnEarlyError = require_iterator_helper_without_closing_on_early_error();
var IS_PURE$4 = require_is_pure();
var DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE$4 && !iteratorHelperThrowsOnInvalidIterator("drop", 0);
var dropWithoutClosingOnEarlyError = !IS_PURE$4 && !DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR && iteratorHelperWithoutClosingOnEarlyError("drop", RangeError);
var FORCED = IS_PURE$4 || DROP_WITHOUT_THROWING_ON_INVALID_ITERATOR || dropWithoutClosingOnEarlyError;
var IteratorProxy = createIteratorProxy(function() {
var iterator = this.iterator;
var next$1 = this.next;
var result, done;
while (this.remaining) {
this.remaining--;
result = anObject$3(call$3(next$1, iterator));
done = this.done = !!result.done;
if (done) return;
}
result = anObject$3(call$3(next$1, iterator));
done = this.done = !!result.done;
if (!done) return result.value;
});
$$6({
target: "Iterator",
proto: true,
real: true,
forced: FORCED
}, { drop: function drop(limit) {
anObject$3(this);
var remaining;
try {
remaining = toPositiveInteger(notANaN(+limit));
} catch (error) {
iteratorClose(this, "throw", error);
}
if (dropWithoutClosingOnEarlyError) return call$3(dropWithoutClosingOnEarlyError, this, remaining);
return new IteratorProxy(getIteratorDirect$1(this), { remaining });
} });
var require_inherit_if_required = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var isCallable$5 = require_is_callable();
var isObject$1 = require_is_object();
var setPrototypeOf$1 = require_object_set_prototype_of();
module.exports = function($this, dummy, Wrapper) {
var NewTarget, NewTargetPrototype;
if (setPrototypeOf$1 && isCallable$5(NewTarget = dummy.constructor) && NewTarget !== Wrapper && isObject$1(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype) setPrototypeOf$1($this, NewTargetPrototype);
return $this;
};
}));
var require_normalize_string_argument = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var toString = require_to_string();
module.exports = function(argument, $default) {
return argument === void 0 ? arguments.length < 2 ? "" : $default : toString(argument);
};
}));
var require_dom_exception_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = {
IndexSizeError: {
s: "INDEX_SIZE_ERR",
c: 1,
m: 1
},
DOMStringSizeError: {
s: "DOMSTRING_SIZE_ERR",
c: 2,
m: 0
},
HierarchyRequestError: {
s: "HIERARCHY_REQUEST_ERR",
c: 3,
m: 1
},
WrongDocumentError: {
s: "WRONG_DOCUMENT_ERR",
c: 4,
m: 1
},
InvalidCharacterError: {
s: "INVALID_CHARACTER_ERR",
c: 5,
m: 1
},
NoDataAllowedError: {
s: "NO_DATA_ALLOWED_ERR",
c: 6,
m: 0
},
NoModificationAllowedError: {
s: "NO_MODIFICATION_ALLOWED_ERR",
c: 7,
m: 1
},
NotFoundError: {
s: "NOT_FOUND_ERR",
c: 8,
m: 1
},
NotSupportedError: {
s: "NOT_SUPPORTED_ERR",
c: 9,
m: 1
},
InUseAttributeError: {
s: "INUSE_ATTRIBUTE_ERR",
c: 10,
m: 1
},
InvalidStateError: {
s: "INVALID_STATE_ERR",
c: 11,
m: 1
},
SyntaxError: {
s: "SYNTAX_ERR",
c: 12,
m: 1
},
InvalidModificationError: {
s: "INVALID_MODIFICATION_ERR",
c: 13,
m: 1
},
NamespaceError: {
s: "NAMESPACE_ERR",
c: 14,
m: 1
},
InvalidAccessError: {
s: "INVALID_ACCESS_ERR",
c: 15,
m: 1
},
ValidationError: {
s: "VALIDATION_ERR",
c: 16,
m: 0
},
TypeMismatchError: {
s: "TYPE_MISMATCH_ERR",
c: 17,
m: 1
},
SecurityError: {
s: "SECURITY_ERR",
c: 18,
m: 1
},
NetworkError: {
s: "NETWORK_ERR",
c: 19,
m: 1
},
AbortError: {
s: "ABORT_ERR",
c: 20,
m: 1
},
URLMismatchError: {
s: "URL_MISMATCH_ERR",
c: 21,
m: 1
},
QuotaExceededError: {
s: "QUOTA_EXCEEDED_ERR",
c: 22,
m: 1
},
TimeoutError: {
s: "TIMEOUT_ERR",
c: 23,
m: 1
},
InvalidNodeTypeError: {
s: "INVALID_NODE_TYPE_ERR",
c: 24,
m: 1
},
DataCloneError: {
s: "DATA_CLONE_ERR",
c: 25,
m: 1
}
};
}));
var require_error_stack_clear = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$4 = require_function_uncurry_this();
var $Error$1 = Error;
var replace = uncurryThis$4("".replace);
var TEST = (function(arg) {
return String(new $Error$1(arg).stack);
})("zxcasd");
var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
module.exports = function(stack, dropEntries) {
if (IS_V8_OR_CHAKRA_STACK && typeof stack == "string" && !$Error$1.prepareStackTrace) while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, "");
return stack;
};
}));
var $$5 = require_export();
var globalThis$12 = require_global_this();
var getBuiltIn$3 = require_get_built_in();
var createPropertyDescriptor$2 = require_create_property_descriptor();
var defineProperty$3 = require_object_define_property().f;
var hasOwn$6 = require_has_own_property();
var anInstance = require_an_instance();
var inheritIfRequired = require_inherit_if_required();
var normalizeStringArgument$1 = require_normalize_string_argument();
var DOMExceptionConstants = require_dom_exception_constants();
var clearErrorStack$1 = require_error_stack_clear();
var DESCRIPTORS = require_descriptors();
var IS_PURE$3 = require_is_pure();
var DOM_EXCEPTION = "DOMException";
var Error$2 = getBuiltIn$3("Error");
var NativeDOMException = getBuiltIn$3(DOM_EXCEPTION);
var $DOMException = function DOMException$1() {
anInstance(this, DOMExceptionPrototype);
var argumentsLength = arguments.length;
var message = normalizeStringArgument$1(argumentsLength < 1 ? void 0 : arguments[0]);
var that = new NativeDOMException(message, normalizeStringArgument$1(argumentsLength < 2 ? void 0 : arguments[1], "Error"));
var error = new Error$2(message);
error.name = DOM_EXCEPTION;
defineProperty$3(that, "stack", createPropertyDescriptor$2(1, clearErrorStack$1(error.stack, 1)));
inheritIfRequired(that, this, $DOMException);
return that;
};
var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype;
var ERROR_HAS_STACK = "stack" in new Error$2(DOM_EXCEPTION);
var DOM_EXCEPTION_HAS_STACK = "stack" in new NativeDOMException(1, 2);
var descriptor$2 = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(globalThis$12, DOM_EXCEPTION);
var BUGGY_DESCRIPTOR = !!descriptor$2 && !(descriptor$2.writable && descriptor$2.configurable);
var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK;
$$5({
global: true,
constructor: true,
forced: IS_PURE$3 || FORCED_CONSTRUCTOR
}, { DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException });
var PolyfilledDOMException = getBuiltIn$3(DOM_EXCEPTION);
var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;
if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) {
if (!IS_PURE$3) defineProperty$3(PolyfilledDOMExceptionPrototype, "constructor", createPropertyDescriptor$2(1, PolyfilledDOMException));
for (var key in DOMExceptionConstants) if (hasOwn$6(DOMExceptionConstants, key)) {
var constant = DOMExceptionConstants[key];
var constantName = constant.s;
if (!hasOwn$6(PolyfilledDOMException, constantName)) defineProperty$3(PolyfilledDOMException, constantName, createPropertyDescriptor$2(6, constant.c));
}
}
var require_is_constructor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$3 = require_function_uncurry_this();
var fails$5 = require_fails();
var isCallable$4 = require_is_callable();
var classof$1 = require_classof();
var getBuiltIn$2 = require_get_built_in();
var inspectSource = require_inspect_source();
var noop = function() {};
var construct = getBuiltIn$2("Reflect", "construct");
var constructorRegExp = /^\s*(?:class|function)\b/;
var exec = uncurryThis$3(constructorRegExp.exec);
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
var isConstructorModern = function isConstructor$1(argument) {
if (!isCallable$4(argument)) return false;
try {
construct(noop, [], argument);
return true;
} catch (error) {
return false;
}
};
var isConstructorLegacy = function isConstructor$1(argument) {
if (!isCallable$4(argument)) return false;
switch (classof$1(argument)) {
case "AsyncFunction":
case "GeneratorFunction":
case "AsyncGeneratorFunction": return false;
}
try {
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
} catch (error) {
return true;
}
};
isConstructorLegacy.sham = true;
module.exports = !construct || fails$5(function() {
var called;
return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function() {
called = true;
}) || called;
}) ? isConstructorLegacy : isConstructorModern;
}));
var require_regexp_flags_detection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$11 = require_global_this();
var fails$4 = require_fails();
var RegExp$1 = globalThis$11.RegExp;
module.exports = { correct: !fails$4(function() {
var INDICES_SUPPORT = true;
try {
RegExp$1(".", "d");
} catch (error) {
INDICES_SUPPORT = false;
}
var O = {};
var calls = "";
var expected = INDICES_SUPPORT ? "dgimsy" : "gimsy";
var addGetter = function(key$2, chr) {
Object.defineProperty(O, key$2, { get: function() {
calls += chr;
return true;
} });
};
var pairs = {
dotAll: "s",
global: "g",
ignoreCase: "i",
multiline: "m",
sticky: "y"
};
if (INDICES_SUPPORT) pairs.hasIndices = "d";
for (var key$1 in pairs) addGetter(key$1, pairs[key$1]);
return Object.getOwnPropertyDescriptor(RegExp$1.prototype, "flags").get.call(O) !== expected || calls !== expected;
}) };
}));
var require_regexp_flags = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var anObject$2 = require_an_object();
module.exports = function() {
var that = anObject$2(this);
var result = "";
if (that.hasIndices) result += "d";
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.unicodeSets) result += "v";
if (that.sticky) result += "y";
return result;
};
}));
var require_regexp_get_flags = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var call$2 = require_function_call();
var hasOwn$5 = require_has_own_property();
var isPrototypeOf$1 = require_object_is_prototype_of();
var regExpFlagsDetection = require_regexp_flags_detection();
var regExpFlagsGetterImplementation = require_regexp_flags();
var RegExpPrototype = RegExp.prototype;
module.exports = regExpFlagsDetection.correct ? function(it) {
return it.flags;
} : function(it) {
return !regExpFlagsDetection.correct && isPrototypeOf$1(RegExpPrototype, it) && !hasOwn$5(it, "flags") ? call$2(regExpFlagsGetterImplementation, it) : it.flags;
};
}));
var require_map_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var uncurryThis$2 = require_function_uncurry_this();
var MapPrototype = Map.prototype;
module.exports = {
Map,
set: uncurryThis$2(MapPrototype.set),
get: uncurryThis$2(MapPrototype.get),
has: uncurryThis$2(MapPrototype.has),
remove: uncurryThis$2(MapPrototype["delete"]),
proto: MapPrototype
};
}));
var require_error_stack_installable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var fails$3 = require_fails();
var createPropertyDescriptor$1 = require_create_property_descriptor();
module.exports = !fails$3(function() {
var error = /* @__PURE__ */ new Error("a");
if (!("stack" in error)) return true;
Object.defineProperty(error, "stack", createPropertyDescriptor$1(1, 7));
return error.stack !== 7;
});
}));
var IS_PURE$2 = require_is_pure();
var $$4 = require_export();
var globalThis$10 = require_global_this();
var getBuiltIn$1 = require_get_built_in();
var uncurryThis$1 = require_function_uncurry_this();
var fails$2 = require_fails();
var uid = require_uid();
var isCallable$3 = require_is_callable();
var isConstructor = require_is_constructor();
var isNullOrUndefined = require_is_null_or_undefined();
var isObject = require_is_object();
var isSymbol = require_is_symbol();
var iterate$1 = require_iterate();
var anObject$1 = require_an_object();
var classof = require_classof();
var hasOwn$4 = require_has_own_property();
var createProperty = require_create_property();
var createNonEnumerableProperty$2 = require_create_non_enumerable_property();
var lengthOfArrayLike = require_length_of_array_like();
var validateArgumentsLength$2 = require_validate_arguments_length();
var getRegExpFlags = require_regexp_get_flags();
var MapHelpers = require_map_helpers();
var SetHelpers = require_set_helpers();
var setIterate = require_set_iterate();
var detachTransferable = require_detach_transferable();
var ERROR_STACK_INSTALLABLE$1 = require_error_stack_installable();
var PROPER_STRUCTURED_CLONE_TRANSFER = require_structured_clone_proper_transfer();
var Object$1 = globalThis$10.Object;
var Array$1 = globalThis$10.Array;
var Date = globalThis$10.Date;
var Error$1 = globalThis$10.Error;
var TypeError$1 = globalThis$10.TypeError;
var PerformanceMark = globalThis$10.PerformanceMark;
var DOMException = getBuiltIn$1("DOMException");
var Map$1 = MapHelpers.Map;
var mapHas = MapHelpers.has;
var mapGet = MapHelpers.get;
var mapSet = MapHelpers.set;
var Set$1 = SetHelpers.Set;
var setAdd = SetHelpers.add;
var setHas = SetHelpers.has;
var objectKeys = getBuiltIn$1("Object", "keys");
var push$1 = uncurryThis$1([].push);
var thisBooleanValue = uncurryThis$1(true.valueOf);
var thisNumberValue = uncurryThis$1(1.1.valueOf);
var thisStringValue = uncurryThis$1("".valueOf);
var thisTimeValue = uncurryThis$1(Date.prototype.getTime);
var PERFORMANCE_MARK = uid("structuredClone");
var DATA_CLONE_ERROR = "DataCloneError";
var TRANSFERRING = "Transferring";
var checkBasicSemantic = function(structuredCloneImplementation) {
return !fails$2(function() {
var set1 = new globalThis$10.Set([7]);
var set2 = structuredCloneImplementation(set1);
var number = structuredCloneImplementation(Object$1(7));
return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7;
}) && structuredCloneImplementation;
};
var checkErrorsCloning = function(structuredCloneImplementation, $Error$2) {
return !fails$2(function() {
var error = new $Error$2();
var test$1 = structuredCloneImplementation({
a: error,
b: error
});
return !(test$1 && test$1.a === test$1.b && test$1.a instanceof $Error$2 && test$1.a.stack === error.stack);
});
};
var checkNewErrorsCloningSemantic = function(structuredCloneImplementation) {
return !fails$2(function() {
var test$1 = structuredCloneImplementation(new globalThis$10.AggregateError([1], PERFORMANCE_MARK, { cause: 3 }));
return test$1.name !== "AggregateError" || test$1.errors[0] !== 1 || test$1.message !== PERFORMANCE_MARK || test$1.cause !== 3;
});
};
var nativeStructuredClone = globalThis$10.structuredClone;
var FORCED_REPLACEMENT = IS_PURE$2 || !checkErrorsCloning(nativeStructuredClone, Error$1) || !checkErrorsCloning(nativeStructuredClone, DOMException) || !checkNewErrorsCloningSemantic(nativeStructuredClone);
var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function(value) {
return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail;
});
var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark;
var throwUncloneable = function(type) {
throw new DOMException("Uncloneable type: " + type, DATA_CLONE_ERROR);
};
var throwUnpolyfillable = function(type, action) {
throw new DOMException((action || "Cloning") + " of " + type + " cannot be properly polyfilled in this engine", DATA_CLONE_ERROR);
};
var tryNativeRestrictedStructuredClone = function(value, type) {
if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type);
return nativeRestrictedStructuredClone(value);
};
var createDataTransfer = function() {
var dataTransfer;
try {
dataTransfer = new globalThis$10.DataTransfer();
} catch (error) {
try {
dataTransfer = new globalThis$10.ClipboardEvent("").clipboardData;
} catch (error2) {}
}
return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null;
};
var cloneBuffer = function(value, map, $type) {
if (mapHas(map, value)) return mapGet(map, value);
var type = $type || classof(value);
var clone$3, length, options, source, target, i;
if (type === "SharedArrayBuffer") if (nativeRestrictedStructuredClone) clone$3 = nativeRestrictedStructuredClone(value);
else clone$3 = value;
else {
var DataView$3 = globalThis$10.DataView;
if (!DataView$3 && !isCallable$3(value.slice)) throwUnpolyfillable("ArrayBuffer");
try {
if (isCallable$3(value.slice) && !value.resizable) clone$3 = value.slice(0);
else {
length = value.byteLength;
options = "maxByteLength" in value ? { maxByteLength: value.maxByteLength } : void 0;
clone$3 = new ArrayBuffer(length, options);
source = new DataView$3(value);
target = new DataView$3(clone$3);
for (i = 0; i < length; i++) target.setUint8(i, source.getUint8(i));
}
} catch (error) {
throw new DOMException("ArrayBuffer is detached", DATA_CLONE_ERROR);
}
}
mapSet(map, value, clone$3);
return clone$3;
};
var cloneView = function(value, type, offset, length, map) {
var C = globalThis$10[type];
if (!isObject(C)) throwUnpolyfillable(type);
return new C(cloneBuffer(value.buffer, map), offset, length);
};
var structuredCloneInternal = function(value, map) {
if (isSymbol(value)) throwUncloneable("Symbol");
if (!isObject(value)) return value;
if (map) {
if (mapHas(map, value)) return mapGet(map, value);
} else map = new Map$1();
var type = classof(value);
var C, name, cloned, dataTransfer, i, length, keys$2, key$1;
switch (type) {
case "Array":
cloned = Array$1(lengthOfArrayLike(value));
break;
case "Object":
cloned = {};
break;
case "Map":
cloned = new Map$1();
break;
case "Set":
cloned = new Set$1();
break;
case "RegExp":
cloned = new RegExp(value.source, getRegExpFlags(value));
break;
case "Error":
name = value.name;
switch (name) {
case "AggregateError":
cloned = new (getBuiltIn$1(name))([]);
break;
case "EvalError":
case "RangeError":
case "ReferenceError":
case "SuppressedError":
case "SyntaxError":
case "TypeError":
case "URIError":
cloned = new (getBuiltIn$1(name))();
break;
case "CompileError":
case "LinkError":
case "RuntimeError":
cloned = new (getBuiltIn$1("WebAssembly", name))();
break;
default: cloned = new Error$1();
}
break;
case "DOMException":
cloned = new DOMException(value.message, value.name);
break;
case "ArrayBuffer":
case "SharedArrayBuffer":
cloned = cloneBuffer(value, map, type);
break;
case "DataView":
case "Int8Array":
case "Uint8Array":
case "Uint8ClampedArray":
case "Int16Array":
case "Uint16Array":
case "Int32Array":
case "Uint32Array":
case "Float16Array":
case "Float32Array":
case "Float64Array":
case "BigInt64Array":
case "BigUint64Array":
length = type === "DataView" ? value.byteLength : value.length;
cloned = cloneView(value, type, value.byteOffset, length, map);
break;
case "DOMQuad":
try {
cloned = new DOMQuad(structuredCloneInternal(value.p1, map), structuredCloneInternal(value.p2, map), structuredCloneInternal(value.p3, map), structuredCloneInternal(value.p4, map));
} catch (error) {
cloned = tryNativeRestrictedStructuredClone(value, type);
}
break;
case "File":
if (nativeRestrictedStructuredClone) try {
cloned = nativeRestrictedStructuredClone(value);
if (classof(cloned) !== type) cloned = void 0;
} catch (error) {}
if (!cloned) try {
cloned = new File([value], value.name, value);
} catch (error) {}
if (!cloned) throwUnpolyfillable(type);
break;
case "FileList":
dataTransfer = createDataTransfer();
if (dataTransfer) {
for (i = 0, length = lengthOfArrayLike(value); i < length; i++) dataTransfer.items.add(structuredCloneInternal(value[i], map));
cloned = dataTransfer.files;
} else cloned = tryNativeRestrictedStructuredClone(value, type);
break;
case "ImageData":
try {
cloned = new ImageData(structuredCloneInternal(value.data, map), value.width, value.height, { colorSpace: value.colorSpace });
} catch (error) {
cloned = tryNativeRestrictedStructuredClone(value, type);
}
break;
default: if (nativeRestrictedStructuredClone) cloned = nativeRestrictedStructuredClone(value);
else switch (type) {
case "BigInt":
cloned = Object$1(value.valueOf());
break;
case "Boolean":
cloned = Object$1(thisBooleanValue(value));
break;
case "Number":
cloned = Object$1(thisNumberValue(value));
break;
case "String":
cloned = Object$1(thisStringValue(value));
break;
case "Date":
cloned = new Date(thisTimeValue(value));
break;
case "Blob":
try {
cloned = value.slice(0, value.size, value.type);
} catch (error) {
throwUnpolyfillable(type);
}
break;
case "DOMPoint":
case "DOMPointReadOnly":
C = globalThis$10[type];
try {
cloned = C.fromPoint ? C.fromPoint(value) : new C(value.x, value.y, value.z, value.w);
} catch (error) {
throwUnpolyfillable(type);
}
break;
case "DOMRect":
case "DOMRectReadOnly":
C = globalThis$10[type];
try {
cloned = C.fromRect ? C.fromRect(value) : new C(value.x, value.y, value.width, value.height);
} catch (error) {
throwUnpolyfillable(type);
}
break;
case "DOMMatrix":
case "DOMMatrixReadOnly":
C = globalThis$10[type];
try {
cloned = C.fromMatrix ? C.fromMatrix(value) : new C(value);
} catch (error) {
throwUnpolyfillable(type);
}
break;
case "AudioData":
case "VideoFrame":
if (!isCallable$3(value.clone)) throwUnpolyfillable(type);
try {
cloned = value.clone();
} catch (error) {
throwUncloneable(type);
}
break;
case "CropTarget":
case "CryptoKey":
case "FileSystemDirectoryHandle":
case "FileSystemFileHandle":
case "FileSystemHandle":
case "GPUCompilationInfo":
case "GPUCompilationMessage":
case "ImageBitmap":
case "RTCCertificate":
case "WebAssembly.Module": throwUnpolyfillable(type);
default: throwUncloneable(type);
}
}
mapSet(map, value, cloned);
switch (type) {
case "Array":
case "Object":
keys$2 = objectKeys(value);
for (i = 0, length = lengthOfArrayLike(keys$2); i < length; i++) {
key$1 = keys$2[i];
createProperty(cloned, key$1, structuredCloneInternal(value[key$1], map));
}
break;
case "Map":
value.forEach(function(v, k) {
mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map));
});
break;
case "Set":
value.forEach(function(v) {
setAdd(cloned, structuredCloneInternal(v, map));
});
break;
case "Error":
createNonEnumerableProperty$2(cloned, "message", structuredCloneInternal(value.message, map));
if (hasOwn$4(value, "cause")) createNonEnumerableProperty$2(cloned, "cause", structuredCloneInternal(value.cause, map));
if (name === "AggregateError") cloned.errors = structuredCloneInternal(value.errors, map);
else if (name === "SuppressedError") {
cloned.error = structuredCloneInternal(value.error, map);
cloned.suppressed = structuredCloneInternal(value.suppressed, map);
}
case "DOMException": if (ERROR_STACK_INSTALLABLE$1) createNonEnumerableProperty$2(cloned, "stack", structuredCloneInternal(value.stack, map));
}
return cloned;
};
var tryToTransfer = function(rawTransfer, map) {
if (!isObject(rawTransfer)) throw new TypeError$1("Transfer option cannot be converted to a sequence");
var transfer = [];
iterate$1(rawTransfer, function(value$1) {
push$1(transfer, anObject$1(value$1));
});
var i = 0;
var length = lengthOfArrayLike(transfer);
var buffers = new Set$1();
var value, type, C, transferred, canvas, context;
while (i < length) {
value = transfer[i++];
type = classof(value);
if (type === "ArrayBuffer" ? setHas(buffers, value) : mapHas(map, value)) throw new DOMException("Duplicate transferable", DATA_CLONE_ERROR);
if (type === "ArrayBuffer") {
setAdd(buffers, value);
continue;
}
if (PROPER_STRUCTURED_CLONE_TRANSFER) transferred = nativeStructuredClone(value, { transfer: [value] });
else switch (type) {
case "ImageBitmap":
C = globalThis$10.OffscreenCanvas;
if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING);
try {
canvas = new C(value.width, value.height);
context = canvas.getContext("bitmaprenderer");
context.transferFromImageBitmap(value);
transferred = canvas.transferToImageBitmap();
} catch (error) {}
break;
case "AudioData":
case "VideoFrame":
if (!isCallable$3(value.clone) || !isCallable$3(value.close)) throwUnpolyfillable(type, TRANSFERRING);
try {
transferred = value.clone();
value.close();
} catch (error) {}
break;
case "MediaSourceHandle":
case "MessagePort":
case "MIDIAccess":
case "OffscreenCanvas":
case "ReadableStream":
case "RTCDataChannel":
case "TransformStream":
case "WebTransportReceiveStream":
case "WebTransportSendStream":
case "WritableStream": throwUnpolyfillable(type, TRANSFERRING);
}
if (transferred === void 0) throw new DOMException("This object cannot be transferred: " + type, DATA_CLONE_ERROR);
mapSet(map, value, transferred);
}
return buffers;
};
var detachBuffers = function(buffers) {
setIterate(buffers, function(buffer$1) {
if (PROPER_STRUCTURED_CLONE_TRANSFER) nativeRestrictedStructuredClone(buffer$1, { transfer: [buffer$1] });
else if (isCallable$3(buffer$1.transfer)) buffer$1.transfer();
else if (detachTransferable) detachTransferable(buffer$1);
else throwUnpolyfillable("ArrayBuffer", TRANSFERRING);
});
};
$$4({
global: true,
enumerable: true,
sham: !PROPER_STRUCTURED_CLONE_TRANSFER,
forced: FORCED_REPLACEMENT
}, { structuredClone: function structuredClone$3(value) {
var options = validateArgumentsLength$2(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject$1(arguments[1]) : void 0;
var transfer = options ? options.transfer : void 0;
var map, buffers;
if (transfer !== void 0) {
map = new Map$1();
buffers = tryToTransfer(transfer, map);
}
var clone$3 = structuredCloneInternal(value, map);
if (buffers) detachBuffers(buffers);
return clone$3;
} });
var require_path = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_global_this();
}));
var require_well_known_symbol_wrapped = /* @__PURE__ */ __commonJSMin(((exports) => {
exports.f = require_well_known_symbol();
}));
var require_well_known_symbol_define = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var path = require_path();
var hasOwn$3 = require_has_own_property();
var wrappedWellKnownSymbolModule = require_well_known_symbol_wrapped();
var defineProperty$2 = require_object_define_property().f;
module.exports = function(NAME$1) {
var Symbol$4 = path.Symbol || (path.Symbol = {});
if (!hasOwn$3(Symbol$4, NAME$1)) defineProperty$2(Symbol$4, NAME$1, { value: wrappedWellKnownSymbolModule.f(NAME$1) });
};
}));
var globalThis$8 = require_global_this();
var defineWellKnownSymbol$1 = require_well_known_symbol_define();
var defineProperty$1 = require_object_define_property().f;
var getOwnPropertyDescriptor$1 = require_object_get_own_property_descriptor().f;
var Symbol$2 = globalThis$8.Symbol;
defineWellKnownSymbol$1("asyncDispose");
if (Symbol$2) {
var descriptor$1 = getOwnPropertyDescriptor$1(Symbol$2, "asyncDispose");
if (descriptor$1.enumerable && descriptor$1.configurable && descriptor$1.writable) defineProperty$1(Symbol$2, "asyncDispose", {
value: descriptor$1.value,
enumerable: false,
configurable: false,
writable: false
});
}
var globalThis$7 = require_global_this();
var defineWellKnownSymbol = require_well_known_symbol_define();
var defineProperty = require_object_define_property().f;
var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f;
var Symbol$1 = globalThis$7.Symbol;
defineWellKnownSymbol("dispose");
if (Symbol$1) {
var descriptor = getOwnPropertyDescriptor(Symbol$1, "dispose");
if (descriptor.enumerable && descriptor.configurable && descriptor.writable) defineProperty(Symbol$1, "dispose", {
value: descriptor.value,
enumerable: false,
configurable: false,
writable: false
});
}
var require_error_stack_install = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var createNonEnumerableProperty$1 = require_create_non_enumerable_property();
var clearErrorStack = require_error_stack_clear();
var ERROR_STACK_INSTALLABLE = require_error_stack_installable();
var captureStackTrace = Error.captureStackTrace;
module.exports = function(error, C, stack, dropEntries) {
if (ERROR_STACK_INSTALLABLE) if (captureStackTrace) captureStackTrace(error, C);
else createNonEnumerableProperty$1(error, "stack", clearErrorStack(stack, dropEntries));
};
}));
var $$3 = require_export();
var globalThis$6 = require_global_this();
var isPrototypeOf = require_object_is_prototype_of();
var getPrototypeOf$1 = require_object_get_prototype_of();
var setPrototypeOf = require_object_set_prototype_of();
var copyConstructorProperties = require_copy_constructor_properties();
var create$1 = require_object_create();
var createNonEnumerableProperty = require_create_non_enumerable_property();
var createPropertyDescriptor = require_create_property_descriptor();
var installErrorStack = require_error_stack_install();
var normalizeStringArgument = require_normalize_string_argument();
var wellKnownSymbol$3 = require_well_known_symbol();
var fails$1 = require_fails();
var IS_PURE$1 = require_is_pure();
var NativeSuppressedError = globalThis$6.SuppressedError;
var TO_STRING_TAG = wellKnownSymbol$3("toStringTag");
var $Error = Error;
var WRONG_ARITY = !!NativeSuppressedError && NativeSuppressedError.length !== 3;
var EXTRA_ARGS_SUPPORT = !!NativeSuppressedError && fails$1(function() {
return new NativeSuppressedError(1, 2, 3, { cause: 4 }).cause === 4;
});
var PATCH = WRONG_ARITY || EXTRA_ARGS_SUPPORT;
var $SuppressedError = function SuppressedError(error, suppressed, message) {
var isInstance = isPrototypeOf(SuppressedErrorPrototype, this);
var that;
if (setPrototypeOf) that = PATCH && (!isInstance || getPrototypeOf$1(this) === SuppressedErrorPrototype) ? new NativeSuppressedError() : setPrototypeOf(new $Error(), isInstance ? getPrototypeOf$1(this) : SuppressedErrorPrototype);
else {
that = isInstance ? this : create$1(SuppressedErrorPrototype);
createNonEnumerableProperty(that, TO_STRING_TAG, "Error");
}
if (message !== void 0) createNonEnumerableProperty(that, "message", normalizeStringArgument(message));
installErrorStack(that, $SuppressedError, that.stack, 1);
createNonEnumerableProperty(that, "error", error);
createNonEnumerableProperty(that, "suppressed", suppressed);
return that;
};
if (setPrototypeOf) setPrototypeOf($SuppressedError, $Error);
else copyConstructorProperties($SuppressedError, $Error, { name: true });
var SuppressedErrorPrototype = $SuppressedError.prototype = PATCH ? NativeSuppressedError.prototype : create$1($Error.prototype, {
constructor: createPropertyDescriptor(1, $SuppressedError),
message: createPropertyDescriptor(1, ""),
name: createPropertyDescriptor(1, "SuppressedError")
});
if (PATCH && !IS_PURE$1) SuppressedErrorPrototype.constructor = $SuppressedError;
$$3({
global: true,
constructor: true,
arity: 3,
forced: PATCH
}, { SuppressedError: $SuppressedError });
var call$1 = require_function_call();
var defineBuiltIn$2 = require_define_built_in();
var getMethod$1 = require_get_method();
var hasOwn$2 = require_has_own_property();
var wellKnownSymbol$2 = require_well_known_symbol();
var IteratorPrototype = require_iterators_core().IteratorPrototype;
var DISPOSE = wellKnownSymbol$2("dispose");
if (!hasOwn$2(IteratorPrototype, DISPOSE)) defineBuiltIn$2(IteratorPrototype, DISPOSE, function() {
var $return = getMethod$1(this, "return");
if ($return) call$1($return, this);
});
var $$2 = require_export();
var anObject = require_an_object();
var iterate = require_iterate();
var getIteratorDirect = require_get_iterator_direct();
var push = [].push;
$$2({
target: "Iterator",
proto: true,
real: true
}, { toArray: function toArray() {
var result = [];
iterate(getIteratorDirect(anObject(this)), push, {
that: result,
IS_RECORD: true
});
return result;
} });
var require_async_iterator_prototype = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$5 = require_global_this();
var shared = require_shared_store();
var isCallable$2 = require_is_callable();
var create = require_object_create();
var getPrototypeOf = require_object_get_prototype_of();
var defineBuiltIn$1 = require_define_built_in();
var wellKnownSymbol$1 = require_well_known_symbol();
var IS_PURE = require_is_pure();
var USE_FUNCTION_CONSTRUCTOR = "USE_FUNCTION_CONSTRUCTOR";
var ASYNC_ITERATOR = wellKnownSymbol$1("asyncIterator");
var AsyncIterator = globalThis$5.AsyncIterator;
var PassedAsyncIteratorPrototype = shared.AsyncIteratorPrototype;
var AsyncIteratorPrototype$1, prototype;
if (PassedAsyncIteratorPrototype) AsyncIteratorPrototype$1 = PassedAsyncIteratorPrototype;
else if (isCallable$2(AsyncIterator)) AsyncIteratorPrototype$1 = AsyncIterator.prototype;
else if (shared[USE_FUNCTION_CONSTRUCTOR] || globalThis$5[USE_FUNCTION_CONSTRUCTOR]) try {
prototype = getPrototypeOf(getPrototypeOf(getPrototypeOf(Function("return async function*(){}()")())));
if (getPrototypeOf(prototype) === Object.prototype) AsyncIteratorPrototype$1 = prototype;
} catch (error) {}
if (!AsyncIteratorPrototype$1) AsyncIteratorPrototype$1 = {};
else if (IS_PURE) AsyncIteratorPrototype$1 = create(AsyncIteratorPrototype$1);
if (!isCallable$2(AsyncIteratorPrototype$1[ASYNC_ITERATOR])) defineBuiltIn$1(AsyncIteratorPrototype$1, ASYNC_ITERATOR, function() {
return this;
});
module.exports = AsyncIteratorPrototype$1;
}));
var call = require_function_call();
var defineBuiltIn = require_define_built_in();
var getBuiltIn = require_get_built_in();
var getMethod = require_get_method();
var hasOwn$1 = require_has_own_property();
var wellKnownSymbol = require_well_known_symbol();
var AsyncIteratorPrototype = require_async_iterator_prototype();
var ASYNC_DISPOSE = wellKnownSymbol("asyncDispose");
var Promise$1 = getBuiltIn("Promise");
if (!hasOwn$1(AsyncIteratorPrototype, ASYNC_DISPOSE)) defineBuiltIn(AsyncIteratorPrototype, ASYNC_DISPOSE, function() {
var O = this;
return new Promise$1(function(resolve, reject) {
var $return = getMethod(O, "return");
if ($return) Promise$1.resolve(call($return, O)).then(function() {
resolve(void 0);
}, reject);
else resolve(void 0);
});
});
var require_array_slice = /* @__PURE__ */ __commonJSMin(((exports, module) => {
module.exports = require_function_uncurry_this()([].slice);
}));
var require_environment_is_ios = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var userAgent = require_environment_user_agent();
module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
}));
var require_task = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$4 = require_global_this();
var apply$1 = require_function_apply();
var bind = require_function_bind_context();
var isCallable$1 = require_is_callable();
var hasOwn = require_has_own_property();
var fails = require_fails();
var html = require_html();
var arraySlice$1 = require_array_slice();
var createElement = require_document_create_element();
var validateArgumentsLength$1 = require_validate_arguments_length();
var IS_IOS = require_environment_is_ios();
var IS_NODE = require_environment_is_node();
var set = globalThis$4.setImmediate;
var clear = globalThis$4.clearImmediate;
var process = globalThis$4.process;
var Dispatch = globalThis$4.Dispatch;
var Function$2 = globalThis$4.Function;
var MessageChannel = globalThis$4.MessageChannel;
var String$1 = globalThis$4.String;
var counter = 0;
var queue = {};
var ONREADYSTATECHANGE = "onreadystatechange";
var $location, defer, channel, port;
fails(function() {
$location = globalThis$4.location;
});
var run = function(id$1) {
if (hasOwn(queue, id$1)) {
var fn = queue[id$1];
delete queue[id$1];
fn();
}
};
var runner = function(id$1) {
return function() {
run(id$1);
};
};
var eventListener = function(event) {
run(event.data);
};
var globalPostMessageDefer = function(id$1) {
globalThis$4.postMessage(String$1(id$1), $location.protocol + "//" + $location.host);
};
if (!set || !clear) {
set = function setImmediate$1(handler) {
validateArgumentsLength$1(arguments.length, 1);
var fn = isCallable$1(handler) ? handler : Function$2(handler);
var args = arraySlice$1(arguments, 1);
queue[++counter] = function() {
apply$1(fn, void 0, args);
};
defer(counter);
return counter;
};
clear = function clearImmediate$1(id$1) {
delete queue[id$1];
};
if (IS_NODE) defer = function(id$1) {
process.nextTick(runner(id$1));
};
else if (Dispatch && Dispatch.now) defer = function(id$1) {
Dispatch.now(runner(id$1));
};
else if (MessageChannel && !IS_IOS) {
channel = new MessageChannel();
port = channel.port2;
channel.port1.onmessage = eventListener;
defer = bind(port.postMessage, port);
} else if (globalThis$4.addEventListener && isCallable$1(globalThis$4.postMessage) && !globalThis$4.importScripts && $location && $location.protocol !== "file:" && !fails(globalPostMessageDefer)) {
defer = globalPostMessageDefer;
globalThis$4.addEventListener("message", eventListener, false);
} else if (ONREADYSTATECHANGE in createElement("script")) defer = function(id$1) {
html.appendChild(createElement("script"))[ONREADYSTATECHANGE] = function() {
html.removeChild(this);
run(id$1);
};
};
else defer = function(id$1) {
setTimeout(runner(id$1), 0);
};
}
module.exports = {
set,
clear
};
}));
var require_web_clear_immediate = /* @__PURE__ */ __commonJSMin((() => {
var $$1 = require_export();
var globalThis$3 = require_global_this();
var clearImmediate = require_task().clear;
$$1({
global: true,
bind: true,
enumerable: true,
forced: globalThis$3.clearImmediate !== clearImmediate
}, { clearImmediate });
}));
var require_schedulers_fix = /* @__PURE__ */ __commonJSMin(((exports, module) => {
var globalThis$2 = require_global_this();
var apply = require_function_apply();
var isCallable = require_is_callable();
var ENVIRONMENT = require_environment();
var USER_AGENT = require_environment_user_agent();
var arraySlice = require_array_slice();
var validateArgumentsLength = require_validate_arguments_length();
var Function$1 = globalThis$2.Function;
var WRAP = /MSIE .\./.test(USER_AGENT) || ENVIRONMENT === "BUN" && (function() {
var version$1 = globalThis$2.Bun.version.split(".");
return version$1.length < 3 || version$1[0] === "0" && (version$1[1] < 3 || version$1[1] === "3" && version$1[2] === "0");
})();
module.exports = function(scheduler, hasTimeArg) {
var firstParamIndex = hasTimeArg ? 2 : 1;
return WRAP ? function(handler, timeout) {
var boundArgs = validateArgumentsLength(arguments.length, 1) > firstParamIndex;
var fn = isCallable(handler) ? handler : Function$1(handler);
var params$2 = boundArgs ? arraySlice(arguments, firstParamIndex) : [];
var callback = boundArgs ? function() {
apply(fn, this, params$2);
} : fn;
return hasTimeArg ? scheduler(callback, timeout) : scheduler(callback);
} : scheduler;
};
}));
var require_web_set_immediate = /* @__PURE__ */ __commonJSMin((() => {
var $ = require_export();
var globalThis$1 = require_global_this();
var setTask = require_task().set;
var schedulersFix = require_schedulers_fix();
var setImmediate = globalThis$1.setImmediate ? schedulersFix(setTask, false) : setTask;
$({
global: true,
bind: true,
enumerable: true,
forced: globalThis$1.setImmediate !== setImmediate
}, { setImmediate });
}));
require_web_clear_immediate();
require_web_set_immediate();
/*!
* SJS 6.15.1
*/
(function() {
function e(e$1, t$1) {
return (t$1 || "") + " (SystemJS https://github.com/systemjs/systemjs/blob/main/docs/errors.md#" + e$1 + ")";
}
function t(e$1, t$1) {
if (-1 !== e$1.indexOf("\\") && (e$1 = e$1.replace(S, "/")), "/" === e$1[0] && "/" === e$1[1]) return t$1.slice(0, t$1.indexOf(":") + 1) + e$1;
if ("." === e$1[0] && ("/" === e$1[1] || "." === e$1[1] && ("/" === e$1[2] || 2 === e$1.length && (e$1 += "/")) || 1 === e$1.length && (e$1 += "/")) || "/" === e$1[0]) {
var r$1, n$1 = t$1.slice(0, t$1.indexOf(":") + 1);
if (r$1 = "/" === t$1[n$1.length + 1] ? "file:" !== n$1 ? (r$1 = t$1.slice(n$1.length + 2)).slice(r$1.indexOf("/") + 1) : t$1.slice(8) : t$1.slice(n$1.length + ("/" === t$1[n$1.length])), "/" === e$1[0]) return t$1.slice(0, t$1.length - r$1.length - 1) + e$1;
for (var i$1 = r$1.slice(0, r$1.lastIndexOf("/") + 1) + e$1, o$1 = [], s$1 = -1, c$1 = 0; c$1 < i$1.length; c$1++) -1 !== s$1 ? "/" === i$1[c$1] && (o$1.push(i$1.slice(s$1, c$1 + 1)), s$1 = -1) : "." === i$1[c$1] ? "." !== i$1[c$1 + 1] || "/" !== i$1[c$1 + 2] && c$1 + 2 !== i$1.length ? "/" === i$1[c$1 + 1] || c$1 + 1 === i$1.length ? c$1 += 1 : s$1 = c$1 : (o$1.pop(), c$1 += 2) : s$1 = c$1;
return -1 !== s$1 && o$1.push(i$1.slice(s$1)), t$1.slice(0, t$1.length - r$1.length) + o$1.join("");
}
}
function r(e$1, r$1) {
return t(e$1, r$1) || (-1 !== e$1.indexOf(":") ? e$1 : t("./" + e$1, r$1));
}
function n(e$1, r$1, n$1, i$1, o$1) {
for (var s$1 in e$1) {
var f$1 = t(s$1, n$1) || s$1, a$1 = e$1[s$1];
if ("string" == typeof a$1) {
var l$1 = u(i$1, t(a$1, n$1) || a$1, o$1);
l$1 ? r$1[f$1] = l$1 : c("W1", s$1, a$1);
}
}
}
function i(e$1, t$1, i$1) {
var o$1;
for (o$1 in e$1.imports && n(e$1.imports, i$1.imports, t$1, i$1, null), e$1.scopes || {}) {
var s$1 = r(o$1, t$1);
n(e$1.scopes[o$1], i$1.scopes[s$1] || (i$1.scopes[s$1] = {}), t$1, i$1, s$1);
}
for (o$1 in e$1.depcache || {}) i$1.depcache[r(o$1, t$1)] = e$1.depcache[o$1];
for (o$1 in e$1.integrity || {}) i$1.integrity[r(o$1, t$1)] = e$1.integrity[o$1];
}
function o(e$1, t$1) {
if (t$1[e$1]) return e$1;
var r$1 = e$1.length;
do {
var n$1 = e$1.slice(0, r$1 + 1);
if (n$1 in t$1) return n$1;
} while (-1 !== (r$1 = e$1.lastIndexOf("/", r$1 - 1)));
}
function s(e$1, t$1) {
var r$1 = o(e$1, t$1);
if (r$1) {
var n$1 = t$1[r$1];
if (null === n$1) return;
if (!(e$1.length > r$1.length && "/" !== n$1[n$1.length - 1])) return n$1 + e$1.slice(r$1.length);
c("W2", r$1, n$1);
}
}
function c(t$1, r$1, n$1) {
console.warn(e(t$1, [n$1, r$1].join(", ")));
}
function u(e$1, t$1, r$1) {
for (var n$1 = e$1.scopes, i$1 = r$1 && o(r$1, n$1); i$1;) {
var c$1 = s(t$1, n$1[i$1]);
if (c$1) return c$1;
i$1 = o(i$1.slice(0, i$1.lastIndexOf("/")), n$1);
}
return s(t$1, e$1.imports) || -1 !== t$1.indexOf(":") && t$1;
}
function f() {
this[b] = {};
}
function a(t$1, r$1, n$1, i$1) {
var o$1 = t$1[b][r$1];
if (o$1) return o$1;
var s$1 = [], c$1 = Object.create(null);
j && Object.defineProperty(c$1, j, { value: "Module" });
var u$1 = Promise.resolve().then((function() {
return t$1.instantiate(r$1, n$1, i$1);
})).then((function(n$2) {
if (!n$2) throw Error(e(2, r$1));
var i$2 = n$2[1]((function(e$1, t$2) {
o$1.h = !0;
var r$2 = !1;
if ("string" == typeof e$1) e$1 in c$1 && c$1[e$1] === t$2 || (c$1[e$1] = t$2, r$2 = !0);
else {
for (var n$3 in e$1) t$2 = e$1[n$3], n$3 in c$1 && c$1[n$3] === t$2 || (c$1[n$3] = t$2, r$2 = !0);
e$1 && e$1.__esModule && (c$1.__esModule = e$1.__esModule);
}
if (r$2) for (var i$3 = 0; i$3 < s$1.length; i$3++) {
var u$2 = s$1[i$3];
u$2 && u$2(c$1);
}
return t$2;
}), 2 === n$2[1].length ? {
import: function(e$1, n$3) {
return t$1.import(e$1, r$1, n$3);
},
meta: t$1.createContext(r$1)
} : void 0);
return o$1.e = i$2.execute || function() {}, [
n$2[0],
i$2.setters || [],
n$2[2] || []
];
}), (function(e$1) {
throw o$1.e = null, o$1.er = e$1, e$1;
})), f$1 = u$1.then((function(e$1) {
return Promise.all(e$1[0].map((function(n$2, i$2) {
var o$2 = e$1[1][i$2], s$2 = e$1[2][i$2];
return Promise.resolve(t$1.resolve(n$2, r$1)).then((function(e$2) {
var n$3 = a(t$1, e$2, r$1, s$2);
return Promise.resolve(n$3.I).then((function() {
return o$2 && (n$3.i.push(o$2), !n$3.h && n$3.I || o$2(n$3.n)), n$3;
}));
}));
}))).then((function(e$2) {
o$1.d = e$2;
}));
}));
return o$1 = t$1[b][r$1] = {
id: r$1,
i: s$1,
n: c$1,
m: i$1,
I: u$1,
L: f$1,
h: !1,
d: void 0,
e: void 0,
er: void 0,
E: void 0,
C: void 0,
p: void 0
};
}
function l(e$1, t$1, r$1, n$1) {
if (!n$1[t$1.id]) return n$1[t$1.id] = !0, Promise.resolve(t$1.L).then((function() {
return t$1.p && null !== t$1.p.e || (t$1.p = r$1), Promise.all(t$1.d.map((function(t$2) {
return l(e$1, t$2, r$1, n$1);
})));
})).catch((function(e$2) {
if (t$1.er) throw e$2;
throw t$1.e = null, e$2;
}));
}
function h(e$1, t$1) {
return t$1.C = l(e$1, t$1, t$1, {}).then((function() {
return d(e$1, t$1, {});
})).then((function() {
return t$1.n;
}));
}
function d(e$1, t$1, r$1) {
function n$1() {
try {
var e$2 = o$1.call(I);
if (e$2) return e$2 = e$2.then((function() {
t$1.C = t$1.n, t$1.E = null;
}), (function(e$3) {
throw t$1.er = e$3, t$1.E = null, e$3;
})), t$1.E = e$2;
t$1.C = t$1.n, t$1.L = t$1.I = void 0;
} catch (r$2) {
throw t$1.er = r$2, r$2;
}
}
if (!r$1[t$1.id]) {
if (r$1[t$1.id] = !0, !t$1.e) {
if (t$1.er) throw t$1.er;
return t$1.E ? t$1.E : void 0;
}
var i$1, o$1 = t$1.e;
return t$1.e = null, t$1.d.forEach((function(n$2) {
try {
var o$2 = d(e$1, n$2, r$1);
o$2 && (i$1 = i$1 || []).push(o$2);
} catch (s$1) {
throw t$1.er = s$1, s$1;
}
})), i$1 ? Promise.all(i$1).then(n$1) : n$1();
}
}
function v() {
[].forEach.call(document.querySelectorAll("script"), (function(t$1) {
if (!t$1.sp) {
if ("systemjs-module" === t$1.type) {
if (t$1.sp = !0, !t$1.src) return;
System.import("import:" === t$1.src.slice(0, 7) ? t$1.src.slice(7) : r(t$1.src, p)).catch((function(e$1) {
if (e$1.message.indexOf("https://github.com/systemjs/systemjs/blob/main/docs/errors.md#3") > -1) {
var r$1 = document.createEvent("Event");
r$1.initEvent("error", !1, !1), t$1.dispatchEvent(r$1);
}
return Promise.reject(e$1);
}));
} else if ("systemjs-importmap" === t$1.type) {
t$1.sp = !0;
var n$1 = t$1.src ? (System.fetch || fetch)(t$1.src, {
integrity: t$1.integrity,
priority: t$1.fetchPriority,
passThrough: !0
}).then((function(e$1) {
if (!e$1.ok) throw Error(e$1.status);
return e$1.text();
})).catch((function(r$1) {
return r$1.message = e("W4", t$1.src) + "\n" + r$1.message, console.warn(r$1), "function" == typeof t$1.onerror && t$1.onerror(), "{}";
})) : t$1.innerHTML;
M = M.then((function() {
return n$1;
})).then((function(r$1) {
(function(t$2, r$2, n$2) {
var o$1 = {};
try {
o$1 = JSON.parse(r$2);
} catch (s$1) {
console.warn(Error(e("W5")));
}
i(o$1, n$2, t$2);
})(R, r$1, t$1.src || p);
}));
}
}
}));
}
var p, m = "undefined" != typeof Symbol, g = "undefined" != typeof self, y = "undefined" != typeof document, E = g ? self : global;
if (y) {
var w = document.querySelector("base[href]");
w && (p = w.href);
}
if (!p && "undefined" != typeof location) {
var O = (p = location.href.split("#")[0].split("?")[0]).lastIndexOf("/");
-1 !== O && (p = p.slice(0, O + 1));
}
var x, S = /\\/g, j = m && Symbol.toStringTag, b = m ? Symbol() : "@", P = f.prototype;
P.import = function(e$1, t$1, r$1) {
var n$1 = this;
return t$1 && "object" == typeof t$1 && (r$1 = t$1, t$1 = void 0), Promise.resolve(n$1.prepareImport()).then((function() {
return n$1.resolve(e$1, t$1, r$1);
})).then((function(e$2) {
var t$2 = a(n$1, e$2, void 0, r$1);
return t$2.C || h(n$1, t$2);
}));
}, P.createContext = function(e$1) {
var t$1 = this;
return {
url: e$1,
resolve: function(r$1, n$1) {
return Promise.resolve(t$1.resolve(r$1, n$1 || e$1));
}
};
}, P.register = function(e$1, t$1, r$1) {
x = [
e$1,
t$1,
r$1
];
}, P.getRegister = function() {
var e$1 = x;
return x = void 0, e$1;
};
var I = Object.freeze(Object.create(null));
E.System = new f();
var L, C, M = Promise.resolve(), R = {
imports: {},
scopes: {},
depcache: {},
integrity: {}
}, T = y;
if (P.prepareImport = function(e$1) {
return (T || e$1) && (v(), T = !1), M;
}, P.getImportMap = function() {
return JSON.parse(JSON.stringify(R));
}, y && (v(), window.addEventListener("DOMContentLoaded", v)), P.addImportMap = function(e$1, t$1) {
i(e$1, t$1 || p, R);
}, y) {
window.addEventListener("error", (function(e$1) {
J = e$1.filename, W = e$1.error;
}));
var _ = location.origin;
}
P.createScript = function(e$1) {
var t$1 = document.createElement("script");
t$1.async = !0, e$1.indexOf(_ + "/") && (t$1.crossOrigin = "anonymous");
var r$1 = R.integrity[e$1];
return r$1 && (t$1.integrity = r$1), t$1.src = e$1, t$1;
};
var J, W, q = {}, N = P.register;
P.register = function(e$1, t$1) {
if (y && "loading" === document.readyState && "string" != typeof e$1) {
var r$1 = document.querySelectorAll("script[src]"), n$1 = r$1[r$1.length - 1];
if (n$1) {
L = e$1;
var i$1 = this;
C = setTimeout((function() {
q[n$1.src] = [e$1, t$1], i$1.import(n$1.src);
}));
}
} else L = void 0;
return N.call(this, e$1, t$1);
}, P.instantiate = function(t$1, r$1) {
var n$1 = q[t$1];
if (n$1) return delete q[t$1], n$1;
var i$1 = this;
return Promise.resolve(P.createScript(t$1)).then((function(n$2) {
return new Promise((function(o$1, s$1) {
n$2.addEventListener("error", (function() {
s$1(Error(e(3, [t$1, r$1].join(", "))));
})), n$2.addEventListener("load", (function() {
if (document.head.removeChild(n$2), J === t$1) s$1(W);
else {
var e$1 = i$1.getRegister(t$1);
e$1 && e$1[0] === L && clearTimeout(C), o$1(e$1);
}
})), document.head.appendChild(n$2);
}));
}));
}, P.shouldFetch = function() {
return !1;
}, "undefined" != typeof fetch && (P.fetch = fetch);
var k = P.instantiate, A = /^(text|application)\/(x-)?javascript(;|$)/;
P.instantiate = function(t$1, r$1, n$1) {
var i$1 = this;
return this.shouldFetch(t$1, r$1, n$1) ? this.fetch(t$1, {
credentials: "same-origin",
integrity: R.integrity[t$1],
meta: n$1
}).then((function(n$2) {
if (!n$2.ok) throw Error(e(7, [
n$2.status,
n$2.statusText,
t$1,
r$1
].join(", ")));
var o$1 = n$2.headers.get("content-type");
if (!o$1 || !A.test(o$1)) throw Error(e(4, o$1));
return n$2.text().then((function(e$1) {
return e$1.indexOf("//# sourceURL=") < 0 && (e$1 += "\n//# sourceURL=" + t$1), (0, eval)(e$1), i$1.getRegister(t$1);
}));
})) : k.apply(this, arguments);
}, P.resolve = function(r$1, n$1) {
return u(R, t(r$1, n$1 = n$1 || p) || r$1, n$1) || function(t$1, r$2) {
throw Error(e(8, [t$1, r$2].join(", ")));
}(r$1, n$1);
};
var F = P.instantiate;
P.instantiate = function(e$1, t$1, r$1) {
var n$1 = R.depcache[e$1];
if (n$1) for (var i$1 = 0; i$1 < n$1.length; i$1++) a(this, this.resolve(n$1[i$1], e$1), e$1);
return F.call(this, e$1, t$1, r$1);
}, g && "function" == typeof importScripts && (P.instantiate = function(e$1) {
var t$1 = this;
return Promise.resolve().then((function() {
return importScripts(e$1), t$1.getRegister(e$1);
}));
});
})();
})();