@pablopunk/tau 0.0.0-stage → 0.1.1

package/dist/promise.try-CAAOYvMP.js

@@ -0,0 +1,1426 @@
+import { t as __commonJSMin } from "./rolldown-runtime-1p2KPIdQ.js";
+//#region ../../node_modules/.pnpm/es-object-atoms@1.1.2/node_modules/es-object-atoms/index.js
+var require_es_object_atoms = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	module.exports = Object;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/index.js
+var require_es_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	module.exports = Error;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/eval.js
+var require_eval = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./eval')} */
+	module.exports = EvalError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/range.js
+var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./range')} */
+	module.exports = RangeError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/ref.js
+var require_ref = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./ref')} */
+	module.exports = ReferenceError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/syntax.js
+var require_syntax = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./syntax')} */
+	module.exports = SyntaxError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/type.js
+var require_type = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./type')} */
+	module.exports = TypeError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-errors@1.3.0/node_modules/es-errors/uri.js
+var require_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./uri')} */
+	module.exports = URIError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/abs.js
+var require_abs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./abs')} */
+	module.exports = Math.abs;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/floor.js
+var require_floor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./floor')} */
+	module.exports = Math.floor;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/max.js
+var require_max = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./max')} */
+	module.exports = Math.max;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/min.js
+var require_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./min')} */
+	module.exports = Math.min;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/pow.js
+var require_pow = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./pow')} */
+	module.exports = Math.pow;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/round.js
+var require_round = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./round')} */
+	module.exports = Math.round;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/isNaN.js
+var require_isNaN = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./isNaN')} */
+	module.exports = Number.isNaN || function isNaN(a) {
+		return a !== a;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/math-intrinsics@1.1.0/node_modules/math-intrinsics/sign.js
+var require_sign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $isNaN = require_isNaN();
+	/** @type {import('./sign')} */
+	module.exports = function sign(number) {
+		if ($isNaN(number) || number === 0) return number;
+		return number < 0 ? -1 : 1;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/gOPD.js
+var require_gOPD = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./gOPD')} */
+	module.exports = Object.getOwnPropertyDescriptor;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/gopd@1.2.0/node_modules/gopd/index.js
+var require_gopd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	var $gOPD = require_gOPD();
+	if ($gOPD) try {
+		$gOPD([], "length");
+	} catch (e) {
+		$gOPD = null;
+	}
+	module.exports = $gOPD;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-define-property@1.0.1/node_modules/es-define-property/index.js
+var require_es_define_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	var $defineProperty = Object.defineProperty || false;
+	if ($defineProperty) try {
+		$defineProperty({}, "a", { value: 1 });
+	} catch (e) {
+		$defineProperty = false;
+	}
+	module.exports = $defineProperty;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/shams.js
+var require_shams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./shams')} */
+	module.exports = function hasSymbols() {
+		if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") return false;
+		if (typeof Symbol.iterator === "symbol") return true;
+		/** @type {{ [k in symbol]?: unknown }} */
+		var obj = {};
+		var sym = Symbol("test");
+		var symObj = Object(sym);
+		if (typeof sym === "string") return false;
+		if (Object.prototype.toString.call(sym) !== "[object Symbol]") return false;
+		if (Object.prototype.toString.call(symObj) !== "[object Symbol]") return false;
+		var symVal = 42;
+		obj[sym] = symVal;
+		for (var _ in obj) return false;
+		if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) return false;
+		if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) return false;
+		var syms = Object.getOwnPropertySymbols(obj);
+		if (syms.length !== 1 || syms[0] !== sym) return false;
+		if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) return false;
+		if (typeof Object.getOwnPropertyDescriptor === "function") {
+			var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+			if (descriptor.value !== symVal || descriptor.enumerable !== true) return false;
+		}
+		return true;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js
+var require_has_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var origSymbol = typeof Symbol !== "undefined" && Symbol;
+	var hasSymbolSham = require_shams();
+	/** @type {import('.')} */
+	module.exports = function hasNativeSymbols() {
+		if (typeof origSymbol !== "function") return false;
+		if (typeof Symbol !== "function") return false;
+		if (typeof origSymbol("foo") !== "symbol") return false;
+		if (typeof Symbol("bar") !== "symbol") return false;
+		return hasSymbolSham();
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Reflect.getPrototypeOf.js
+var require_Reflect_getPrototypeOf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./Reflect.getPrototypeOf')} */
+	module.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/Object.getPrototypeOf.js
+var require_Object_getPrototypeOf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./Object.getPrototypeOf')} */
+	module.exports = require_es_object_atoms().getPrototypeOf || null;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/implementation.js
+var require_implementation$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+	var toStr = Object.prototype.toString;
+	var max = Math.max;
+	var funcType = "[object Function]";
+	var concatty = function concatty(a, b) {
+		var arr = [];
+		for (var i = 0; i < a.length; i += 1) arr[i] = a[i];
+		for (var j = 0; j < b.length; j += 1) arr[j + a.length] = b[j];
+		return arr;
+	};
+	var slicy = function slicy(arrLike, offset) {
+		var arr = [];
+		for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) arr[j] = arrLike[i];
+		return arr;
+	};
+	var joiny = function(arr, joiner) {
+		var str = "";
+		for (var i = 0; i < arr.length; i += 1) {
+			str += arr[i];
+			if (i + 1 < arr.length) str += joiner;
+		}
+		return str;
+	};
+	module.exports = function bind(that) {
+		var target = this;
+		if (typeof target !== "function" || toStr.apply(target) !== funcType) throw new TypeError(ERROR_MESSAGE + target);
+		var args = slicy(arguments, 1);
+		var bound;
+		var binder = function() {
+			if (this instanceof bound) {
+				var result = target.apply(this, concatty(args, arguments));
+				if (Object(result) === result) return result;
+				return this;
+			}
+			return target.apply(that, concatty(args, arguments));
+		};
+		var boundLength = max(0, target.length - args.length);
+		var boundArgs = [];
+		for (var i = 0; i < boundLength; i++) boundArgs[i] = "$" + i;
+		bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+		if (target.prototype) {
+			var Empty = function Empty() {};
+			Empty.prototype = target.prototype;
+			bound.prototype = new Empty();
+			Empty.prototype = null;
+		}
+		return bound;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/function-bind@1.1.2/node_modules/function-bind/index.js
+var require_function_bind = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var implementation = require_implementation$2();
+	module.exports = Function.prototype.bind || implementation;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./functionCall')} */
+	module.exports = Function.prototype.call;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./functionApply')} */
+	module.exports = Function.prototype.apply;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./reflectApply')} */
+	module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var bind = require_function_bind();
+	var $apply = require_functionApply();
+	var $call = require_functionCall();
+	/** @type {import('./actualApply')} */
+	module.exports = require_reflectApply() || bind.call($call, $apply);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var bind = require_function_bind();
+	var $TypeError = require_type();
+	var $call = require_functionCall();
+	var $actualApply = require_actualApply();
+	/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
+	module.exports = function callBindBasic(args) {
+		if (args.length < 1 || typeof args[0] !== "function") throw new $TypeError("a function is required");
+		return $actualApply(bind, $call, args);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/dunder-proto@1.0.1/node_modules/dunder-proto/get.js
+var require_get = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var callBind = require_call_bind_apply_helpers();
+	var gOPD = require_gopd();
+	var hasProtoAccessor;
+	try {
+		hasProtoAccessor = [].__proto__ === Array.prototype;
+	} catch (e) {
+		if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") throw e;
+	}
+	var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, "__proto__");
+	var $Object = Object;
+	var $getPrototypeOf = $Object.getPrototypeOf;
+	/** @type {import('./get')} */
+	module.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? function getDunder(value) {
+		return $getPrototypeOf(value == null ? value : $Object(value));
+	} : false;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/get-proto@1.0.1/node_modules/get-proto/index.js
+var require_get_proto = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var reflectGetProto = require_Reflect_getPrototypeOf();
+	var originalGetProto = require_Object_getPrototypeOf();
+	var getDunderProto = require_get();
+	/** @type {import('.')} */
+	module.exports = reflectGetProto ? function getProto(O) {
+		return reflectGetProto(O);
+	} : originalGetProto ? function getProto(O) {
+		if (!O || typeof O !== "object" && typeof O !== "function") throw new TypeError("getProto: not an object");
+		return originalGetProto(O);
+	} : getDunderProto ? function getProto(O) {
+		return getDunderProto(O);
+	} : null;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/hasown@2.0.4/node_modules/hasown/index.js
+var require_hasown = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var call = Function.prototype.call;
+	var $hasOwn = Object.prototype.hasOwnProperty;
+	/** @type {import('.')} */
+	module.exports = require_function_bind().call(call, $hasOwn);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/get-intrinsic@1.3.0/node_modules/get-intrinsic/index.js
+var require_get_intrinsic = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var undefined;
+	var $Object = require_es_object_atoms();
+	var $Error = require_es_errors();
+	var $EvalError = require_eval();
+	var $RangeError = require_range();
+	var $ReferenceError = require_ref();
+	var $SyntaxError = require_syntax();
+	var $TypeError = require_type();
+	var $URIError = require_uri();
+	var abs = require_abs();
+	var floor = require_floor();
+	var max = require_max();
+	var min = require_min();
+	var pow = require_pow();
+	var round = require_round();
+	var sign = require_sign();
+	var $Function = Function;
+	var getEvalledConstructor = function(expressionSyntax) {
+		try {
+			return $Function("\"use strict\"; return (" + expressionSyntax + ").constructor;")();
+		} catch (e) {}
+	};
+	var $gOPD = require_gopd();
+	var $defineProperty = require_es_define_property();
+	var throwTypeError = function() {
+		throw new $TypeError();
+	};
+	var ThrowTypeError = $gOPD ? function() {
+		try {
+			arguments.callee;
+			return throwTypeError;
+		} catch (calleeThrows) {
+			try {
+				return $gOPD(arguments, "callee").get;
+			} catch (gOPDthrows) {
+				return throwTypeError;
+			}
+		}
+	}() : throwTypeError;
+	var hasSymbols = require_has_symbols()();
+	var getProto = require_get_proto();
+	var $ObjectGPO = require_Object_getPrototypeOf();
+	var $ReflectGPO = require_Reflect_getPrototypeOf();
+	var $apply = require_functionApply();
+	var $call = require_functionCall();
+	var needsEval = {};
+	var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined : getProto(Uint8Array);
+	var INTRINSICS = {
+		__proto__: null,
+		"%AggregateError%": typeof AggregateError === "undefined" ? undefined : AggregateError,
+		"%Array%": Array,
+		"%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined : ArrayBuffer,
+		"%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,
+		"%AsyncFromSyncIteratorPrototype%": undefined,
+		"%AsyncFunction%": needsEval,
+		"%AsyncGenerator%": needsEval,
+		"%AsyncGeneratorFunction%": needsEval,
+		"%AsyncIteratorPrototype%": needsEval,
+		"%Atomics%": typeof Atomics === "undefined" ? undefined : Atomics,
+		"%BigInt%": typeof BigInt === "undefined" ? undefined : BigInt,
+		"%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined : BigInt64Array,
+		"%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined : BigUint64Array,
+		"%Boolean%": Boolean,
+		"%DataView%": typeof DataView === "undefined" ? undefined : DataView,
+		"%Date%": Date,
+		"%decodeURI%": decodeURI,
+		"%decodeURIComponent%": decodeURIComponent,
+		"%encodeURI%": encodeURI,
+		"%encodeURIComponent%": encodeURIComponent,
+		"%Error%": $Error,
+		"%eval%": eval,
+		"%EvalError%": $EvalError,
+		"%Float16Array%": typeof Float16Array === "undefined" ? undefined : Float16Array,
+		"%Float32Array%": typeof Float32Array === "undefined" ? undefined : Float32Array,
+		"%Float64Array%": typeof Float64Array === "undefined" ? undefined : Float64Array,
+		"%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined : FinalizationRegistry,
+		"%Function%": $Function,
+		"%GeneratorFunction%": needsEval,
+		"%Int8Array%": typeof Int8Array === "undefined" ? undefined : Int8Array,
+		"%Int16Array%": typeof Int16Array === "undefined" ? undefined : Int16Array,
+		"%Int32Array%": typeof Int32Array === "undefined" ? undefined : Int32Array,
+		"%isFinite%": isFinite,
+		"%isNaN%": isNaN,
+		"%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,
+		"%JSON%": typeof JSON === "object" ? JSON : undefined,
+		"%Map%": typeof Map === "undefined" ? undefined : Map,
+		"%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+		"%Math%": Math,
+		"%Number%": Number,
+		"%Object%": $Object,
+		"%Object.getOwnPropertyDescriptor%": $gOPD,
+		"%parseFloat%": parseFloat,
+		"%parseInt%": parseInt,
+		"%Promise%": typeof Promise === "undefined" ? undefined : Promise,
+		"%Proxy%": typeof Proxy === "undefined" ? undefined : Proxy,
+		"%RangeError%": $RangeError,
+		"%ReferenceError%": $ReferenceError,
+		"%Reflect%": typeof Reflect === "undefined" ? undefined : Reflect,
+		"%RegExp%": RegExp,
+		"%Set%": typeof Set === "undefined" ? undefined : Set,
+		"%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+		"%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined : SharedArrayBuffer,
+		"%String%": String,
+		"%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined,
+		"%Symbol%": hasSymbols ? Symbol : undefined,
+		"%SyntaxError%": $SyntaxError,
+		"%ThrowTypeError%": ThrowTypeError,
+		"%TypedArray%": TypedArray,
+		"%TypeError%": $TypeError,
+		"%Uint8Array%": typeof Uint8Array === "undefined" ? undefined : Uint8Array,
+		"%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined : Uint8ClampedArray,
+		"%Uint16Array%": typeof Uint16Array === "undefined" ? undefined : Uint16Array,
+		"%Uint32Array%": typeof Uint32Array === "undefined" ? undefined : Uint32Array,
+		"%URIError%": $URIError,
+		"%WeakMap%": typeof WeakMap === "undefined" ? undefined : WeakMap,
+		"%WeakRef%": typeof WeakRef === "undefined" ? undefined : WeakRef,
+		"%WeakSet%": typeof WeakSet === "undefined" ? undefined : WeakSet,
+		"%Function.prototype.call%": $call,
+		"%Function.prototype.apply%": $apply,
+		"%Object.defineProperty%": $defineProperty,
+		"%Object.getPrototypeOf%": $ObjectGPO,
+		"%Math.abs%": abs,
+		"%Math.floor%": floor,
+		"%Math.max%": max,
+		"%Math.min%": min,
+		"%Math.pow%": pow,
+		"%Math.round%": round,
+		"%Math.sign%": sign,
+		"%Reflect.getPrototypeOf%": $ReflectGPO
+	};
+	if (getProto) try {
+		null.error;
+	} catch (e) {
+		INTRINSICS["%Error.prototype%"] = getProto(getProto(e));
+	}
+	var doEval = function doEval(name) {
+		var value;
+		if (name === "%AsyncFunction%") value = getEvalledConstructor("async function () {}");
+		else if (name === "%GeneratorFunction%") value = getEvalledConstructor("function* () {}");
+		else if (name === "%AsyncGeneratorFunction%") value = getEvalledConstructor("async function* () {}");
+		else if (name === "%AsyncGenerator%") {
+			var fn = doEval("%AsyncGeneratorFunction%");
+			if (fn) value = fn.prototype;
+		} else if (name === "%AsyncIteratorPrototype%") {
+			var gen = doEval("%AsyncGenerator%");
+			if (gen && getProto) value = getProto(gen.prototype);
+		}
+		INTRINSICS[name] = value;
+		return value;
+	};
+	var LEGACY_ALIASES = {
+		__proto__: null,
+		"%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+		"%ArrayPrototype%": ["Array", "prototype"],
+		"%ArrayProto_entries%": [
+			"Array",
+			"prototype",
+			"entries"
+		],
+		"%ArrayProto_forEach%": [
+			"Array",
+			"prototype",
+			"forEach"
+		],
+		"%ArrayProto_keys%": [
+			"Array",
+			"prototype",
+			"keys"
+		],
+		"%ArrayProto_values%": [
+			"Array",
+			"prototype",
+			"values"
+		],
+		"%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+		"%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+		"%AsyncGeneratorPrototype%": [
+			"AsyncGeneratorFunction",
+			"prototype",
+			"prototype"
+		],
+		"%BooleanPrototype%": ["Boolean", "prototype"],
+		"%DataViewPrototype%": ["DataView", "prototype"],
+		"%DatePrototype%": ["Date", "prototype"],
+		"%ErrorPrototype%": ["Error", "prototype"],
+		"%EvalErrorPrototype%": ["EvalError", "prototype"],
+		"%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+		"%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+		"%FunctionPrototype%": ["Function", "prototype"],
+		"%Generator%": ["GeneratorFunction", "prototype"],
+		"%GeneratorPrototype%": [
+			"GeneratorFunction",
+			"prototype",
+			"prototype"
+		],
+		"%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+		"%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+		"%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+		"%JSONParse%": ["JSON", "parse"],
+		"%JSONStringify%": ["JSON", "stringify"],
+		"%MapPrototype%": ["Map", "prototype"],
+		"%NumberPrototype%": ["Number", "prototype"],
+		"%ObjectPrototype%": ["Object", "prototype"],
+		"%ObjProto_toString%": [
+			"Object",
+			"prototype",
+			"toString"
+		],
+		"%ObjProto_valueOf%": [
+			"Object",
+			"prototype",
+			"valueOf"
+		],
+		"%PromisePrototype%": ["Promise", "prototype"],
+		"%PromiseProto_then%": [
+			"Promise",
+			"prototype",
+			"then"
+		],
+		"%Promise_all%": ["Promise", "all"],
+		"%Promise_reject%": ["Promise", "reject"],
+		"%Promise_resolve%": ["Promise", "resolve"],
+		"%RangeErrorPrototype%": ["RangeError", "prototype"],
+		"%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+		"%RegExpPrototype%": ["RegExp", "prototype"],
+		"%SetPrototype%": ["Set", "prototype"],
+		"%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+		"%StringPrototype%": ["String", "prototype"],
+		"%SymbolPrototype%": ["Symbol", "prototype"],
+		"%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+		"%TypedArrayPrototype%": ["TypedArray", "prototype"],
+		"%TypeErrorPrototype%": ["TypeError", "prototype"],
+		"%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+		"%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+		"%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+		"%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+		"%URIErrorPrototype%": ["URIError", "prototype"],
+		"%WeakMapPrototype%": ["WeakMap", "prototype"],
+		"%WeakSetPrototype%": ["WeakSet", "prototype"]
+	};
+	var bind = require_function_bind();
+	var hasOwn = require_hasown();
+	var $concat = bind.call($call, Array.prototype.concat);
+	var $spliceApply = bind.call($apply, Array.prototype.splice);
+	var $replace = bind.call($call, String.prototype.replace);
+	var $strSlice = bind.call($call, String.prototype.slice);
+	var $exec = bind.call($call, RegExp.prototype.exec);
+	var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+	var reEscapeChar = /\\(\\)?/g;
+	var stringToPath = function stringToPath(string) {
+		var first = $strSlice(string, 0, 1);
+		var last = $strSlice(string, -1);
+		if (first === "%" && last !== "%") throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+		else if (last === "%" && first !== "%") throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+		var result = [];
+		$replace(string, rePropName, function(match, number, quote, subString) {
+			result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+		});
+		return result;
+	};
+	var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
+		var intrinsicName = name;
+		var alias;
+		if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+			alias = LEGACY_ALIASES[intrinsicName];
+			intrinsicName = "%" + alias[0] + "%";
+		}
+		if (hasOwn(INTRINSICS, intrinsicName)) {
+			var value = INTRINSICS[intrinsicName];
+			if (value === needsEval) value = doEval(intrinsicName);
+			if (typeof value === "undefined" && !allowMissing) throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+			return {
+				alias,
+				name: intrinsicName,
+				value
+			};
+		}
+		throw new $SyntaxError("intrinsic " + name + " does not exist!");
+	};
+	module.exports = function GetIntrinsic(name, allowMissing) {
+		if (typeof name !== "string" || name.length === 0) throw new $TypeError("intrinsic name must be a non-empty string");
+		if (arguments.length > 1 && typeof allowMissing !== "boolean") throw new $TypeError("\"allowMissing\" argument must be a boolean");
+		if ($exec(/^%?[^%]*%?$/, name) === null) throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+		var parts = stringToPath(name);
+		var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+		var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+		var intrinsicRealName = intrinsic.name;
+		var value = intrinsic.value;
+		var skipFurtherCaching = false;
+		var alias = intrinsic.alias;
+		if (alias) {
+			intrinsicBaseName = alias[0];
+			$spliceApply(parts, $concat([0, 1], alias));
+		}
+		for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+			var part = parts[i];
+			var first = $strSlice(part, 0, 1);
+			var last = $strSlice(part, -1);
+			if ((first === "\"" || first === "'" || first === "`" || last === "\"" || last === "'" || last === "`") && first !== last) throw new $SyntaxError("property names with quotes must have matching quotes");
+			if (part === "constructor" || !isOwn) skipFurtherCaching = true;
+			intrinsicBaseName += "." + part;
+			intrinsicRealName = "%" + intrinsicBaseName + "%";
+			if (hasOwn(INTRINSICS, intrinsicRealName)) value = INTRINSICS[intrinsicRealName];
+			else if (value != null) {
+				if (!(part in value)) {
+					if (!allowMissing) throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+					return;
+				}
+				if ($gOPD && i + 1 >= parts.length) {
+					var desc = $gOPD(value, part);
+					isOwn = !!desc;
+					if (isOwn && "get" in desc && !("originalValue" in desc.get)) value = desc.get;
+					else value = value[part];
+				} else {
+					isOwn = hasOwn(value, part);
+					value = value[part];
+				}
+				if (isOwn && !skipFurtherCaching) INTRINSICS[intrinsicRealName] = value;
+			}
+		}
+		return value;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/define-data-property@1.1.4/node_modules/define-data-property/index.js
+var require_define_data_property = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $defineProperty = require_es_define_property();
+	var $SyntaxError = require_syntax();
+	var $TypeError = require_type();
+	var gopd = require_gopd();
+	/** @type {import('.')} */
+	module.exports = function defineDataProperty(obj, property, value) {
+		if (!obj || typeof obj !== "object" && typeof obj !== "function") throw new $TypeError("`obj` must be an object or a function`");
+		if (typeof property !== "string" && typeof property !== "symbol") throw new $TypeError("`property` must be a string or a symbol`");
+		if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
+		if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
+		if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
+		if (arguments.length > 6 && typeof arguments[6] !== "boolean") throw new $TypeError("`loose`, if provided, must be a boolean");
+		var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+		var nonWritable = arguments.length > 4 ? arguments[4] : null;
+		var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+		var loose = arguments.length > 6 ? arguments[6] : false;
+		var desc = !!gopd && gopd(obj, property);
+		if ($defineProperty) $defineProperty(obj, property, {
+			configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+			enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+			value,
+			writable: nonWritable === null && desc ? desc.writable : !nonWritable
+		});
+		else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) obj[property] = value;
+		else throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/has-property-descriptors@1.0.2/node_modules/has-property-descriptors/index.js
+var require_has_property_descriptors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $defineProperty = require_es_define_property();
+	var hasPropertyDescriptors = function hasPropertyDescriptors() {
+		return !!$defineProperty;
+	};
+	hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+		if (!$defineProperty) return null;
+		try {
+			return $defineProperty([], "length", { value: 1 }).length !== 1;
+		} catch (e) {
+			return true;
+		}
+	};
+	module.exports = hasPropertyDescriptors;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/set-function-length@1.2.2/node_modules/set-function-length/index.js
+var require_set_function_length = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var define = require_define_data_property();
+	var hasDescriptors = require_has_property_descriptors()();
+	var gOPD = require_gopd();
+	var $TypeError = require_type();
+	var $floor = GetIntrinsic("%Math.floor%");
+	/** @type {import('.')} */
+	module.exports = function setFunctionLength(fn, length) {
+		if (typeof fn !== "function") throw new $TypeError("`fn` is not a function");
+		if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) throw new $TypeError("`length` must be a positive 32-bit integer");
+		var loose = arguments.length > 2 && !!arguments[2];
+		var functionLengthIsConfigurable = true;
+		var functionLengthIsWritable = true;
+		if ("length" in fn && gOPD) {
+			var desc = gOPD(fn, "length");
+			if (desc && !desc.configurable) functionLengthIsConfigurable = false;
+			if (desc && !desc.writable) functionLengthIsWritable = false;
+		}
+		if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+			if (hasDescriptors) define(fn, "length", length, true, true);
+			else define(fn, "length", length);
+		}
+		return fn;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind-apply-helpers@1.0.2/node_modules/call-bind-apply-helpers/applyBind.js
+var require_applyBind = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var bind = require_function_bind();
+	var $apply = require_functionApply();
+	var actualApply = require_actualApply();
+	/** @type {import('./applyBind')} */
+	module.exports = function applyBind() {
+		return actualApply(bind, $apply, arguments);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/index.js
+var require_call_bind = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var setFunctionLength = require_set_function_length();
+	var $defineProperty = require_es_define_property();
+	var callBindBasic = require_call_bind_apply_helpers();
+	var applyBind = require_applyBind();
+	module.exports = function callBind(originalFunction) {
+		var func = callBindBasic(arguments);
+		var adjustedLength = 1 + originalFunction.length - (arguments.length - 1);
+		return setFunctionLength(func, adjustedLength > 0 ? adjustedLength : 0, true);
+	};
+	if ($defineProperty) $defineProperty(module.exports, "apply", { value: applyBind });
+	else module.exports.apply = applyBind;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
+var require_isArguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var toStr = Object.prototype.toString;
+	module.exports = function isArguments(value) {
+		var str = toStr.call(value);
+		var isArgs = str === "[object Arguments]";
+		if (!isArgs) isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+		return isArgs;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
+var require_implementation$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var keysShim;
+	if (!Object.keys) {
+		var has = Object.prototype.hasOwnProperty;
+		var toStr = Object.prototype.toString;
+		var isArgs = require_isArguments();
+		var isEnumerable = Object.prototype.propertyIsEnumerable;
+		var hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+		var hasProtoEnumBug = isEnumerable.call(function() {}, "prototype");
+		var dontEnums = [
+			"toString",
+			"toLocaleString",
+			"valueOf",
+			"hasOwnProperty",
+			"isPrototypeOf",
+			"propertyIsEnumerable",
+			"constructor"
+		];
+		var equalsConstructorPrototype = function(o) {
+			var ctor = o.constructor;
+			return ctor && ctor.prototype === o;
+		};
+		var excludedKeys = {
+			$applicationCache: true,
+			$console: true,
+			$external: true,
+			$frame: true,
+			$frameElement: true,
+			$frames: true,
+			$innerHeight: true,
+			$innerWidth: true,
+			$onmozfullscreenchange: true,
+			$onmozfullscreenerror: true,
+			$outerHeight: true,
+			$outerWidth: true,
+			$pageXOffset: true,
+			$pageYOffset: true,
+			$parent: true,
+			$scrollLeft: true,
+			$scrollTop: true,
+			$scrollX: true,
+			$scrollY: true,
+			$self: true,
+			$webkitIndexedDB: true,
+			$webkitStorageInfo: true,
+			$window: true
+		};
+		var hasAutomationEqualityBug = function() {
+			if (typeof window === "undefined") return false;
+			for (var k in window) try {
+				if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") try {
+					equalsConstructorPrototype(window[k]);
+				} catch (e) {
+					return true;
+				}
+			} catch (e) {
+				return true;
+			}
+			return false;
+		}();
+		var equalsConstructorPrototypeIfNotBuggy = function(o) {
+			if (typeof window === "undefined" || !hasAutomationEqualityBug) return equalsConstructorPrototype(o);
+			try {
+				return equalsConstructorPrototype(o);
+			} catch (e) {
+				return false;
+			}
+		};
+		keysShim = function keys(object) {
+			var isObject = object !== null && typeof object === "object";
+			var isFunction = toStr.call(object) === "[object Function]";
+			var isArguments = isArgs(object);
+			var isString = isObject && toStr.call(object) === "[object String]";
+			var theKeys = [];
+			if (!isObject && !isFunction && !isArguments) throw new TypeError("Object.keys called on a non-object");
+			var skipProto = hasProtoEnumBug && isFunction;
+			if (isString && object.length > 0 && !has.call(object, 0)) for (var i = 0; i < object.length; ++i) theKeys.push(String(i));
+			if (isArguments && object.length > 0) for (var j = 0; j < object.length; ++j) theKeys.push(String(j));
+			else for (var name in object) if (!(skipProto && name === "prototype") && has.call(object, name)) theKeys.push(String(name));
+			if (hasDontEnumBug) {
+				var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+				for (var k = 0; k < dontEnums.length; ++k) if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) theKeys.push(dontEnums[k]);
+			}
+			return theKeys;
+		};
+	}
+	module.exports = keysShim;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js
+var require_object_keys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var slice = Array.prototype.slice;
+	var isArgs = require_isArguments();
+	var origKeys = Object.keys;
+	var keysShim = origKeys ? function keys(o) {
+		return origKeys(o);
+	} : require_implementation$1();
+	var originalKeys = Object.keys;
+	keysShim.shim = function shimObjectKeys() {
+		if (Object.keys) {
+			if (!function() {
+				var args = Object.keys(arguments);
+				return args && args.length === arguments.length;
+			}(1, 2)) Object.keys = function keys(object) {
+				if (isArgs(object)) return originalKeys(slice.call(object));
+				return originalKeys(object);
+			};
+		} else Object.keys = keysShim;
+		return Object.keys || keysShim;
+	};
+	module.exports = keysShim;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js
+var require_define_properties = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var keys = require_object_keys();
+	var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+	var toStr = Object.prototype.toString;
+	var concat = Array.prototype.concat;
+	var defineDataProperty = require_define_data_property();
+	var isFunction = function(fn) {
+		return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+	};
+	var supportsDescriptors = require_has_property_descriptors()();
+	var defineProperty = function(object, name, value, predicate) {
+		if (name in object) {
+			if (predicate === true) {
+				if (object[name] === value) return;
+			} else if (!isFunction(predicate) || !predicate()) return;
+		}
+		if (supportsDescriptors) defineDataProperty(object, name, value, true);
+		else defineDataProperty(object, name, value);
+	};
+	var defineProperties = function(object, map) {
+		var predicates = arguments.length > 2 ? arguments[2] : {};
+		var props = keys(map);
+		if (hasSymbols) props = concat.call(props, Object.getOwnPropertySymbols(map));
+		for (var i = 0; i < props.length; i += 1) defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+	};
+	defineProperties.supportsDescriptors = !!supportsDescriptors;
+	module.exports = defineProperties;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bound@1.0.4/node_modules/call-bound/index.js
+var require_call_bound = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var callBindBasic = require_call_bind_apply_helpers();
+	/** @type {(thisArg: string, searchString: string, position?: number) => number} */
+	var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
+	/** @type {import('.')} */
+	module.exports = function callBoundIntrinsic(name, allowMissing) {
+		var intrinsic = GetIntrinsic(name, !!allowMissing);
+		if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) return callBindBasic([intrinsic]);
+		return intrinsic;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/helpers/IsArray.js
+var require_IsArray$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $Array = require_get_intrinsic()("%Array%");
+	var toStr = !$Array.isArray && require_call_bound()("Object.prototype.toString");
+	module.exports = $Array.isArray || function IsArray(argument) {
+		return toStr(argument) === "[object Array]";
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/IsArray.js
+var require_IsArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_IsArray$1();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/Call.js
+var require_Call = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var callBound = require_call_bound();
+	var $TypeError = require_type();
+	var IsArray = require_IsArray();
+	var $apply = GetIntrinsic("%Reflect.apply%", true) || callBound("Function.prototype.apply");
+	module.exports = function Call(F, V) {
+		var argumentsList = arguments.length > 2 ? arguments[2] : [];
+		if (!IsArray(argumentsList)) throw new $TypeError("Assertion failed: optional `argumentsList`, if provided, must be a List");
+		return $apply(F, V, argumentsList);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/is-callable@1.2.7/node_modules/is-callable/index.js
+var require_is_callable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fnToStr = Function.prototype.toString;
+	var reflectApply = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
+	var badArrayLike;
+	var isCallableMarker;
+	if (typeof reflectApply === "function" && typeof Object.defineProperty === "function") try {
+		badArrayLike = Object.defineProperty({}, "length", { get: function() {
+			throw isCallableMarker;
+		} });
+		isCallableMarker = {};
+		reflectApply(function() {
+			throw 42;
+		}, null, badArrayLike);
+	} catch (_) {
+		if (_ !== isCallableMarker) reflectApply = null;
+	}
+	else reflectApply = null;
+	var constructorRegex = /^\s*class\b/;
+	var isES6ClassFn = function isES6ClassFunction(value) {
+		try {
+			var fnStr = fnToStr.call(value);
+			return constructorRegex.test(fnStr);
+		} catch (e) {
+			return false;
+		}
+	};
+	var tryFunctionObject = function tryFunctionToStr(value) {
+		try {
+			if (isES6ClassFn(value)) return false;
+			fnToStr.call(value);
+			return true;
+		} catch (e) {
+			return false;
+		}
+	};
+	var toStr = Object.prototype.toString;
+	var objectClass = "[object Object]";
+	var fnClass = "[object Function]";
+	var genClass = "[object GeneratorFunction]";
+	var ddaClass = "[object HTMLAllCollection]";
+	var ddaClass2 = "[object HTML document.all class]";
+	var ddaClass3 = "[object HTMLCollection]";
+	var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
+	var isIE68 = !(0 in [,]);
+	var isDDA = function isDocumentDotAll() {
+		return false;
+	};
+	if (typeof document === "object") {
+		var all = document.all;
+		if (toStr.call(all) === toStr.call(document.all)) isDDA = function isDocumentDotAll(value) {
+			if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) try {
+				var str = toStr.call(value);
+				return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
+			} catch (e) {}
+			return false;
+		};
+	}
+	module.exports = reflectApply ? function isCallable(value) {
+		if (isDDA(value)) return true;
+		if (!value) return false;
+		if (typeof value !== "function" && typeof value !== "object") return false;
+		try {
+			reflectApply(value, null, badArrayLike);
+		} catch (e) {
+			if (e !== isCallableMarker) return false;
+		}
+		return !isES6ClassFn(value) && tryFunctionObject(value);
+	} : function isCallable(value) {
+		if (isDDA(value)) return true;
+		if (!value) return false;
+		if (typeof value !== "function" && typeof value !== "object") return false;
+		if (hasToStringTag) return tryFunctionObject(value);
+		if (isES6ClassFn(value)) return false;
+		var strClass = toStr.call(value);
+		if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) return false;
+		return tryFunctionObject(value);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/IsCallable.js
+var require_IsCallable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_is_callable();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/GetIntrinsic.js
+var require_GetIntrinsic = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_get_intrinsic();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-object-atoms@1.1.2/node_modules/es-object-atoms/isObject.js
+var require_isObject$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {import('./isObject')} */
+	module.exports = function isObject(x) {
+		return !!x && (typeof x === "function" || typeof x === "object");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/helpers/records/property-descriptor.js
+var require_property_descriptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	var hasOwn = require_hasown();
+	var allowed = {
+		__proto__: null,
+		"[[Configurable]]": true,
+		"[[Enumerable]]": true,
+		"[[Get]]": true,
+		"[[Set]]": true,
+		"[[Value]]": true,
+		"[[Writable]]": true
+	};
+	module.exports = function isPropertyDescriptor(Desc) {
+		if (!Desc || typeof Desc !== "object") return false;
+		for (var key in Desc) if (hasOwn(Desc, key) && !allowed[key]) return false;
+		var isData = hasOwn(Desc, "[[Value]]") || hasOwn(Desc, "[[Writable]]");
+		var IsAccessor = hasOwn(Desc, "[[Get]]") || hasOwn(Desc, "[[Set]]");
+		if (isData && IsAccessor) throw new $TypeError("Property Descriptors may not be both accessor and data descriptors");
+		return true;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/helpers/DefineOwnProperty.js
+var require_DefineOwnProperty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasPropertyDescriptors = require_has_property_descriptors();
+	var $defineProperty = require_es_define_property();
+	var hasArrayLengthDefineBug = hasPropertyDescriptors.hasArrayLengthDefineBug();
+	var isArray = hasArrayLengthDefineBug && require_IsArray$1();
+	var $isEnumerable = require_call_bound()("Object.prototype.propertyIsEnumerable");
+	module.exports = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {
+		if (!$defineProperty) {
+			if (!IsDataDescriptor(desc)) return false;
+			if (!desc["[[Configurable]]"] || !desc["[[Writable]]"]) return false;
+			if (P in O && $isEnumerable(O, P) !== !!desc["[[Enumerable]]"]) return false;
+			var V = desc["[[Value]]"];
+			O[P] = V;
+			return SameValue(O[P], V);
+		}
+		if (hasArrayLengthDefineBug && P === "length" && "[[Value]]" in desc && isArray(O) && O.length !== desc["[[Value]]"]) {
+			O.length = desc["[[Value]]"];
+			return O.length === desc["[[Value]]"];
+		}
+		$defineProperty(O, P, FromPropertyDescriptor(desc));
+		return true;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/helpers/fromPropertyDescriptor.js
+var require_fromPropertyDescriptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function fromPropertyDescriptor(Desc) {
+		if (typeof Desc === "undefined") return Desc;
+		var obj = {};
+		if ("[[Value]]" in Desc) obj.value = Desc["[[Value]]"];
+		if ("[[Writable]]" in Desc) obj.writable = !!Desc["[[Writable]]"];
+		if ("[[Get]]" in Desc) obj.get = Desc["[[Get]]"];
+		if ("[[Set]]" in Desc) obj.set = Desc["[[Set]]"];
+		if ("[[Enumerable]]" in Desc) obj.enumerable = !!Desc["[[Enumerable]]"];
+		if ("[[Configurable]]" in Desc) obj.configurable = !!Desc["[[Configurable]]"];
+		return obj;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/FromPropertyDescriptor.js
+var require_FromPropertyDescriptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	var isPropertyDescriptor = require_property_descriptor();
+	var fromPropertyDescriptor = require_fromPropertyDescriptor();
+	module.exports = function FromPropertyDescriptor(Desc) {
+		if (typeof Desc !== "undefined" && !isPropertyDescriptor(Desc)) throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+		return fromPropertyDescriptor(Desc);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/IsDataDescriptor.js
+var require_IsDataDescriptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	var hasOwn = require_hasown();
+	var isPropertyDescriptor = require_property_descriptor();
+	module.exports = function IsDataDescriptor(Desc) {
+		if (typeof Desc === "undefined") return false;
+		if (!isPropertyDescriptor(Desc)) throw new $TypeError("Assertion failed: `Desc` must be a Property Descriptor");
+		if (!hasOwn(Desc, "[[Value]]") && !hasOwn(Desc, "[[Writable]]")) return false;
+		return true;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/helpers/isPropertyKey.js
+var require_isPropertyKey = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function isPropertyKey(argument) {
+		return typeof argument === "string" || typeof argument === "symbol";
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/SameValue.js
+var require_SameValue = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $isNaN = require_isNaN();
+	module.exports = function SameValue(x, y) {
+		if (x === y) {
+			if (x === 0) return 1 / x === 1 / y;
+			return true;
+		}
+		return $isNaN(x) && $isNaN(y);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/ToBoolean.js
+var require_ToBoolean = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function ToBoolean(value) {
+		return !!value;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/ToPropertyDescriptor.js
+var require_ToPropertyDescriptor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var hasOwn = require_hasown();
+	var $TypeError = require_type();
+	var isObject = require_isObject$1();
+	var IsCallable = require_IsCallable();
+	var ToBoolean = require_ToBoolean();
+	module.exports = function ToPropertyDescriptor(Obj) {
+		if (!isObject(Obj)) throw new $TypeError("ToPropertyDescriptor requires an object");
+		var desc = {};
+		if (hasOwn(Obj, "enumerable")) desc["[[Enumerable]]"] = ToBoolean(Obj.enumerable);
+		if (hasOwn(Obj, "configurable")) desc["[[Configurable]]"] = ToBoolean(Obj.configurable);
+		if (hasOwn(Obj, "value")) desc["[[Value]]"] = Obj.value;
+		if (hasOwn(Obj, "writable")) desc["[[Writable]]"] = ToBoolean(Obj.writable);
+		if (hasOwn(Obj, "get")) {
+			var getter = Obj.get;
+			if (typeof getter !== "undefined" && !IsCallable(getter)) throw new $TypeError("getter must be a function");
+			desc["[[Get]]"] = getter;
+		}
+		if (hasOwn(Obj, "set")) {
+			var setter = Obj.set;
+			if (typeof setter !== "undefined" && !IsCallable(setter)) throw new $TypeError("setter must be a function");
+			desc["[[Set]]"] = setter;
+		}
+		if ((hasOwn(desc, "[[Get]]") || hasOwn(desc, "[[Set]]")) && (hasOwn(desc, "[[Value]]") || hasOwn(desc, "[[Writable]]"))) throw new $TypeError("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute");
+		return desc;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/DefinePropertyOrThrow.js
+var require_DefinePropertyOrThrow = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	var isObject = require_isObject$1();
+	var isPropertyDescriptor = require_property_descriptor();
+	var DefineOwnProperty = require_DefineOwnProperty();
+	var FromPropertyDescriptor = require_FromPropertyDescriptor();
+	var IsDataDescriptor = require_IsDataDescriptor();
+	var isPropertyKey = require_isPropertyKey();
+	var SameValue = require_SameValue();
+	var ToPropertyDescriptor = require_ToPropertyDescriptor();
+	module.exports = function DefinePropertyOrThrow(O, P, desc) {
+		if (!isObject(O)) throw new $TypeError("Assertion failed: Type(O) is not Object");
+		if (!isPropertyKey(P)) throw new $TypeError("Assertion failed: P is not a Property Key");
+		var Desc = isPropertyDescriptor(desc) ? desc : ToPropertyDescriptor(desc);
+		if (!isPropertyDescriptor(Desc)) throw new $TypeError("Assertion failed: Desc is not a valid Property Descriptor");
+		return DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, Desc);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/IsConstructor.js
+var require_IsConstructor = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $construct = require_GetIntrinsic()("%Reflect.construct%", true);
+	var DefinePropertyOrThrow = require_DefinePropertyOrThrow();
+	try {
+		DefinePropertyOrThrow({}, "", { "[[Get]]": function() {} });
+	} catch (e) {
+		DefinePropertyOrThrow = null;
+	}
+	if (DefinePropertyOrThrow && $construct) {
+		var isConstructorMarker = {};
+		var badArrayLike = {};
+		DefinePropertyOrThrow(badArrayLike, "length", {
+			"[[Get]]": function() {
+				throw isConstructorMarker;
+			},
+			"[[Enumerable]]": true
+		});
+		module.exports = function IsConstructor(argument) {
+			try {
+				$construct(argument, badArrayLike);
+			} catch (err) {
+				return err === isConstructorMarker;
+			}
+		};
+	} else module.exports = function IsConstructor(argument) {
+		return typeof argument === "function" && !!argument.prototype;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/NewPromiseCapability.js
+var require_NewPromiseCapability = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	var IsCallable = require_IsCallable();
+	var IsConstructor = require_IsConstructor();
+	module.exports = function NewPromiseCapability(C) {
+		if (!IsConstructor(C)) throw new $TypeError("C must be a constructor");
+		var resolvingFunctions = {
+			"[[Resolve]]": void 0,
+			"[[Reject]]": void 0
+		};
+		var promise = new C(function(resolve, reject) {
+			if (typeof resolvingFunctions["[[Resolve]]"] !== "undefined" || typeof resolvingFunctions["[[Reject]]"] !== "undefined") throw new $TypeError("executor has already been called");
+			resolvingFunctions["[[Resolve]]"] = resolve;
+			resolvingFunctions["[[Reject]]"] = reject;
+		});
+		if (!IsCallable(resolvingFunctions["[[Resolve]]"]) || !IsCallable(resolvingFunctions["[[Reject]]"])) throw new $TypeError("executor must provide valid resolve and reject functions");
+		return {
+			"[[Promise]]": promise,
+			"[[Resolve]]": resolvingFunctions["[[Resolve]]"],
+			"[[Reject]]": resolvingFunctions["[[Reject]]"]
+		};
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/2025/PromiseResolve.js
+var require_PromiseResolve = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var callBind = require_call_bind();
+	var $SyntaxError = require_syntax();
+	var $resolve = GetIntrinsic("%Promise.resolve%", true);
+	var $PromiseResolve = $resolve && callBind($resolve);
+	module.exports = function PromiseResolve(C, x) {
+		if (!$PromiseResolve) throw new $SyntaxError("This environment does not support Promises.");
+		return $PromiseResolve(C, x);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/es-abstract@1.24.2/node_modules/es-abstract/helpers/isObject.js
+var require_isObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_isObject$1();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/functions-have-names@1.2.3/node_modules/functions-have-names/index.js
+var require_functions_have_names = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var functionsHaveNames = function functionsHaveNames() {
+		return typeof function f() {}.name === "string";
+	};
+	var gOPD = Object.getOwnPropertyDescriptor;
+	if (gOPD) try {
+		gOPD([], "length");
+	} catch (e) {
+		gOPD = null;
+	}
+	functionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() {
+		if (!functionsHaveNames() || !gOPD) return false;
+		var desc = gOPD(function() {}, "name");
+		return !!desc && !!desc.configurable;
+	};
+	var $bind = Function.prototype.bind;
+	functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() {
+		return functionsHaveNames() && typeof $bind === "function" && function f() {}.bind().name !== "";
+	};
+	module.exports = functionsHaveNames;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/set-function-name@2.0.2/node_modules/set-function-name/index.js
+var require_set_function_name = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var define = require_define_data_property();
+	var hasDescriptors = require_has_property_descriptors()();
+	var functionsHaveConfigurableNames = require_functions_have_names().functionsHaveConfigurableNames();
+	var $TypeError = require_type();
+	/** @type {import('.')} */
+	module.exports = function setFunctionName(fn, name) {
+		if (typeof fn !== "function") throw new $TypeError("`fn` is not a function");
+		if (!(arguments.length > 2 && !!arguments[2]) || functionsHaveConfigurableNames) {
+			if (hasDescriptors) define(fn, "name", name, true, true);
+			else define(fn, "name", name);
+		}
+		return fn;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/callBound.js
+var require_callBound = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var GetIntrinsic = require_get_intrinsic();
+	var callBind = require_call_bind();
+	var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+	module.exports = function callBoundIntrinsic(name, allowMissing) {
+		var intrinsic = GetIntrinsic(name, !!allowMissing);
+		if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) return callBind(intrinsic);
+		return intrinsic;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/promise.try@2.0.2/node_modules/promise.try/implementation.js
+var require_implementation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Call = require_Call();
+	var NewPromiseCapability = require_NewPromiseCapability();
+	var PromiseResolve = require_PromiseResolve();
+	var isObject = require_isObject();
+	var setFunctionName = require_set_function_name();
+	var $TypeError = require_type();
+	var $slice = require_callBound()("Array.prototype.slice");
+	module.exports = setFunctionName(function try_(callbackfn) {
+		var C = this;
+		if (!isObject(C)) throw new $TypeError("receiver must be an object");
+		var args = arguments.length > 1 ? $slice(arguments, 1) : [];
+		var status;
+		try {
+			status = Call(callbackfn, void 0, args);
+		} catch (e) {
+			var promiseCapability = NewPromiseCapability(C);
+			Call(promiseCapability["[[Reject]]"], void 0, [e]);
+			return promiseCapability["[[Promise]]"];
+		}
+		return PromiseResolve(C, status);
+	}, "try", true);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/promise.try@2.0.2/node_modules/promise.try/requirePromise.js
+var require_requirePromise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	module.exports = function requirePromise() {
+		if (typeof Promise !== "function") throw new $TypeError("`Promise.try` requires a global `Promise` be available.");
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/promise.try@2.0.2/node_modules/promise.try/polyfill.js
+var require_polyfill = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var requirePromise = require_requirePromise();
+	var implementation = require_implementation();
+	function wrapsReturnedPromise() {
+		var sentinel = Promise.resolve();
+		return Promise["try"](function() {
+			return sentinel;
+		}) !== sentinel;
+	}
+	module.exports = function getPolyfill() {
+		requirePromise();
+		if (typeof Promise["try"] === "function" && !wrapsReturnedPromise()) return Promise["try"];
+		return implementation;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/promise.try@2.0.2/node_modules/promise.try/shim.js
+var require_shim = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var requirePromise = require_requirePromise();
+	var getPolyfill = require_polyfill();
+	var define = require_define_properties();
+	module.exports = function shimPromiseTry() {
+		requirePromise();
+		var polyfill = getPolyfill();
+		define(Promise, { "try": polyfill }, { "try": function testTry() {
+			return Promise["try"] !== polyfill;
+		} });
+		return polyfill;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/promise.try@2.0.2/node_modules/promise.try/index.js
+var require_promise_try = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var callBind = require_call_bind();
+	var define = require_define_properties();
+	var implementation = require_implementation();
+	var getPolyfill = require_polyfill();
+	var shim = require_shim();
+	var requirePromise = require_requirePromise();
+	var bound = callBind.apply(getPolyfill());
+	function promiseTry(fn) {
+		requirePromise();
+		return bound(typeof this === "undefined" ? Promise : this, arguments);
+	}
+	define(promiseTry, {
+		getPolyfill,
+		implementation,
+		shim
+	});
+	module.exports = promiseTry;
+}));
+//#endregion
+export default require_promise_try();
+export {};