@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/pbkdf2-CIW-oWrm.cjs

@@ -0,0 +1,1337 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require__polyfill_node_process = require("./_polyfill-node.process-rf9LjCyG.cjs");
+const require_safe_buffer$1 = require("./safe-buffer-DYOwEfHB.cjs");
+//#region ../../node_modules/create-hash/index.js
+var require_create_hash = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	module.exports = require("node:crypto").createHash;
+}));
+//#endregion
+//#region ../../node_modules/pbkdf2/lib/precondition.js
+var require_precondition = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var $isFinite = isFinite;
+	var MAX_ALLOC = Math.pow(2, 30) - 1;
+	module.exports = function(iterations, keylen) {
+		if (typeof iterations !== "number") throw new TypeError("Iterations not a number");
+		if (iterations < 0 || !$isFinite(iterations)) throw new TypeError("Bad iterations");
+		if (typeof keylen !== "number") throw new TypeError("Key length not a number");
+		if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) throw new TypeError("Bad key length");
+		return keylen + 0;
+	};
+}));
+//#endregion
+//#region ../../node_modules/pbkdf2/lib/default-encoding.js
+var require_default_encoding = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	require__polyfill_node_process.init__polyfill_node_process();
+	require__polyfill_node_process.init__polyfill_global_this();
+	var defaultEncoding;
+	/* istanbul ignore next */
+	if (require__polyfill_node_process._polyfill_global_this_default.process && require__polyfill_node_process._polyfill_global_this_default.process.browser) defaultEncoding = "utf-8";
+	else if (require__polyfill_node_process._polyfill_global_this_default.process && require__polyfill_node_process._polyfill_global_this_default.process.version) defaultEncoding = parseInt(require__polyfill_node_process.browser$1.version.split(".")[0].slice(1), 10) >= 6 ? "utf-8" : "binary";
+	else defaultEncoding = "utf-8";
+	module.exports = defaultEncoding;
+}));
+//#endregion
+//#region ../../node_modules/isarray/index.js
+var require_isarray = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var toString = {}.toString;
+	module.exports = Array.isArray || function(arr) {
+		return toString.call(arr) == "[object Array]";
+	};
+}));
+//#endregion
+//#region ../../node_modules/es-errors/type.js
+var require_type = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./type')} */
+	module.exports = TypeError;
+}));
+//#endregion
+//#region ../../node_modules/es-object-atoms/index.js
+var require_es_object_atoms = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	module.exports = Object;
+}));
+//#endregion
+//#region ../../node_modules/es-errors/index.js
+var require_es_errors = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	module.exports = Error;
+}));
+//#endregion
+//#region ../../node_modules/es-errors/eval.js
+var require_eval = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./eval')} */
+	module.exports = EvalError;
+}));
+//#endregion
+//#region ../../node_modules/es-errors/range.js
+var require_range = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./range')} */
+	module.exports = RangeError;
+}));
+//#endregion
+//#region ../../node_modules/es-errors/ref.js
+var require_ref = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./ref')} */
+	module.exports = ReferenceError;
+}));
+//#endregion
+//#region ../../node_modules/es-errors/syntax.js
+var require_syntax = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./syntax')} */
+	module.exports = SyntaxError;
+}));
+//#endregion
+//#region ../../node_modules/es-errors/uri.js
+var require_uri = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./uri')} */
+	module.exports = URIError;
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/abs.js
+var require_abs = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./abs')} */
+	module.exports = Math.abs;
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/floor.js
+var require_floor = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./floor')} */
+	module.exports = Math.floor;
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/max.js
+var require_max = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./max')} */
+	module.exports = Math.max;
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/min.js
+var require_min = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./min')} */
+	module.exports = Math.min;
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/pow.js
+var require_pow = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./pow')} */
+	module.exports = Math.pow;
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/round.js
+var require_round = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./round')} */
+	module.exports = Math.round;
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/isNaN.js
+var require_isNaN = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./isNaN')} */
+	module.exports = Number.isNaN || function isNaN(a) {
+		return a !== a;
+	};
+}));
+//#endregion
+//#region ../../node_modules/math-intrinsics/sign.js
+var require_sign = /* @__PURE__ */ require_rolldown_runtime.__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/gopd/gOPD.js
+var require_gOPD = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./gOPD')} */
+	module.exports = Object.getOwnPropertyDescriptor;
+}));
+//#endregion
+//#region ../../node_modules/gopd/index.js
+var require_gopd = /* @__PURE__ */ require_rolldown_runtime.__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/es-define-property/index.js
+var require_es_define_property = /* @__PURE__ */ require_rolldown_runtime.__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/has-symbols/shams.js
+var require_shams$1 = /* @__PURE__ */ require_rolldown_runtime.__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/has-symbols/index.js
+var require_has_symbols = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var origSymbol = typeof Symbol !== "undefined" && Symbol;
+	var hasSymbolSham = require_shams$1();
+	/** @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/get-proto/Reflect.getPrototypeOf.js
+var require_Reflect_getPrototypeOf = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./Reflect.getPrototypeOf')} */
+	module.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+}));
+//#endregion
+//#region ../../node_modules/get-proto/Object.getPrototypeOf.js
+var require_Object_getPrototypeOf = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./Object.getPrototypeOf')} */
+	module.exports = require_es_object_atoms().getPrototypeOf || null;
+}));
+//#endregion
+//#region ../../node_modules/function-bind/implementation.js
+var require_implementation = /* @__PURE__ */ require_rolldown_runtime.__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/function-bind/index.js
+var require_function_bind = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var implementation = require_implementation();
+	module.exports = Function.prototype.bind || implementation;
+}));
+//#endregion
+//#region ../../node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./functionCall')} */
+	module.exports = Function.prototype.call;
+}));
+//#endregion
+//#region ../../node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./functionApply')} */
+	module.exports = Function.prototype.apply;
+}));
+//#endregion
+//#region ../../node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('./reflectApply')} */
+	module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+}));
+//#endregion
+//#region ../../node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = /* @__PURE__ */ require_rolldown_runtime.__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/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = /* @__PURE__ */ require_rolldown_runtime.__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/dunder-proto/get.js
+var require_get = /* @__PURE__ */ require_rolldown_runtime.__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/get-proto/index.js
+var require_get_proto = /* @__PURE__ */ require_rolldown_runtime.__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/hasown/index.js
+var require_hasown = /* @__PURE__ */ require_rolldown_runtime.__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/get-intrinsic/index.js
+var require_get_intrinsic = /* @__PURE__ */ require_rolldown_runtime.__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/call-bound/index.js
+var require_call_bound = /* @__PURE__ */ require_rolldown_runtime.__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/is-callable/index.js
+var require_is_callable = /* @__PURE__ */ require_rolldown_runtime.__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/for-each/index.js
+var require_for_each = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var isCallable = require_is_callable();
+	var toStr = Object.prototype.toString;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/** @type {<This, A extends readonly unknown[]>(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */
+	var forEachArray = function forEachArray(array, iterator, receiver) {
+		for (var i = 0, len = array.length; i < len; i++) if (hasOwnProperty.call(array, i)) if (receiver == null) iterator(array[i], i, array);
+		else iterator.call(receiver, array[i], i, array);
+	};
+	/** @type {<This, S extends string>(string: S, iterator: (this: This | void, value: S[number], index: number, string: S) => void, receiver: This | undefined) => void} */
+	var forEachString = function forEachString(string, iterator, receiver) {
+		for (var i = 0, len = string.length; i < len; i++) if (receiver == null) iterator(string.charAt(i), i, string);
+		else iterator.call(receiver, string.charAt(i), i, string);
+	};
+	/** @type {<This, O>(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */
+	var forEachObject = function forEachObject(object, iterator, receiver) {
+		for (var k in object) if (hasOwnProperty.call(object, k)) if (receiver == null) iterator(object[k], k, object);
+		else iterator.call(receiver, object[k], k, object);
+	};
+	/** @type {(x: unknown) => x is readonly unknown[]} */
+	function isArray(x) {
+		return toStr.call(x) === "[object Array]";
+	}
+	/** @type {import('.')._internal} */
+	module.exports = function forEach(list, iterator, thisArg) {
+		if (!isCallable(iterator)) throw new TypeError("iterator must be a function");
+		var receiver;
+		if (arguments.length >= 3) receiver = thisArg;
+		if (isArray(list)) forEachArray(list, iterator, receiver);
+		else if (typeof list === "string") forEachString(list, iterator, receiver);
+		else forEachObject(list, iterator, receiver);
+	};
+}));
+//#endregion
+//#region ../../node_modules/possible-typed-array-names/index.js
+var require_possible_typed_array_names = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	/** @type {import('.')} */
+	module.exports = [
+		"Float16Array",
+		"Float32Array",
+		"Float64Array",
+		"Int8Array",
+		"Int16Array",
+		"Int32Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Uint16Array",
+		"Uint32Array",
+		"BigInt64Array",
+		"BigUint64Array"
+	];
+}));
+//#endregion
+//#region ../../node_modules/available-typed-arrays/index.js
+var require_available_typed_arrays = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	require__polyfill_node_process.init__polyfill_global_this();
+	var possibleNames = require_possible_typed_array_names();
+	var g = typeof globalThis === "undefined" ? require__polyfill_node_process._polyfill_global_this_default : globalThis;
+	/** @type {import('.')} */
+	module.exports = function availableTypedArrays() {
+		var out = [];
+		for (var i = 0; i < possibleNames.length; i++) if (typeof g[possibleNames[i]] === "function") out[out.length] = possibleNames[i];
+		return out;
+	};
+}));
+//#endregion
+//#region ../../node_modules/define-data-property/index.js
+var require_define_data_property = /* @__PURE__ */ require_rolldown_runtime.__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/has-property-descriptors/index.js
+var require_has_property_descriptors = /* @__PURE__ */ require_rolldown_runtime.__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/set-function-length/index.js
+var require_set_function_length = /* @__PURE__ */ require_rolldown_runtime.__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/call-bind-apply-helpers/applyBind.js
+var require_applyBind = /* @__PURE__ */ require_rolldown_runtime.__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/call-bind/index.js
+var require_call_bind = /* @__PURE__ */ require_rolldown_runtime.__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 = originalFunction.length - (arguments.length - 1);
+		return setFunctionLength(func, 1 + (adjustedLength > 0 ? adjustedLength : 0), true);
+	};
+	if ($defineProperty) $defineProperty(module.exports, "apply", { value: applyBind });
+	else module.exports.apply = applyBind;
+}));
+//#endregion
+//#region ../../node_modules/has-tostringtag/shams.js
+var require_shams = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var hasSymbols = require_shams$1();
+	/** @type {import('.')} */
+	module.exports = function hasToStringTagShams() {
+		return hasSymbols() && !!Symbol.toStringTag;
+	};
+}));
+//#endregion
+//#region ../../node_modules/which-typed-array/index.js
+var require_which_typed_array = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	require__polyfill_node_process.init__polyfill_global_this();
+	var forEach = require_for_each();
+	var availableTypedArrays = require_available_typed_arrays();
+	var callBind = require_call_bind();
+	var callBound = require_call_bound();
+	var gOPD = require_gopd();
+	var getProto = require_get_proto();
+	var $toString = callBound("Object.prototype.toString");
+	var hasToStringTag = require_shams()();
+	var g = typeof globalThis === "undefined" ? require__polyfill_node_process._polyfill_global_this_default : globalThis;
+	var typedArrays = availableTypedArrays();
+	var $slice = callBound("String.prototype.slice");
+	/** @type {<T = unknown>(array: readonly T[], value: unknown) => number} */
+	var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
+		for (var i = 0; i < array.length; i += 1) if (array[i] === value) return i;
+		return -1;
+	};
+	/** @typedef {import('./types').Getter} Getter */
+	/** @type {import('./types').Cache} */
+	var cache = { __proto__: null };
+	if (hasToStringTag && gOPD && getProto) forEach(typedArrays, function(typedArray) {
+		var arr = new g[typedArray]();
+		if (Symbol.toStringTag in arr && getProto) {
+			var proto = getProto(arr);
+			var descriptor = gOPD(proto, Symbol.toStringTag);
+			if (!descriptor && proto) descriptor = gOPD(getProto(proto), Symbol.toStringTag);
+			if (descriptor && descriptor.get) {
+				var bound = callBind(descriptor.get);
+				cache["$" + typedArray] = bound;
+			}
+		}
+	});
+	else forEach(typedArrays, function(typedArray) {
+		var arr = new g[typedArray]();
+		var fn = arr.slice || arr.set;
+		if (fn) {
+			var bound = callBind(fn);
+			cache["$" + typedArray] = bound;
+		}
+	});
+	/** @type {(value: object) => false | import('.').TypedArrayName} */
+	var tryTypedArrays = function tryAllTypedArrays(value) {
+		/** @type {ReturnType<typeof tryAllTypedArrays>} */ var found = false;
+		forEach(
+			cache,
+			/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+			function(getter, typedArray) {
+				if (!found) try {
+					if ("$" + getter(value) === typedArray) found = $slice(typedArray, 1);
+				} catch (e) {}
+			}
+		);
+		return found;
+	};
+	/** @type {(value: object) => false | import('.').TypedArrayName} */
+	var trySlices = function tryAllSlices(value) {
+		/** @type {ReturnType<typeof tryAllSlices>} */ var found = false;
+		forEach(
+			cache,
+			/** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+			function(getter, name) {
+				if (!found) try {
+					getter(value);
+					found = $slice(name, 1);
+				} catch (e) {}
+			}
+		);
+		return found;
+	};
+	/** @type {import('.')} */
+	module.exports = function whichTypedArray(value) {
+		if (!value || typeof value !== "object") return false;
+		if (!hasToStringTag) {
+			/** @type {string} */
+			var tag = $slice($toString(value), 8, -1);
+			if ($indexOf(typedArrays, tag) > -1) return tag;
+			if (tag !== "Object") return false;
+			return trySlices(value);
+		}
+		if (!gOPD) return null;
+		return tryTypedArrays(value);
+	};
+}));
+//#endregion
+//#region ../../node_modules/is-typed-array/index.js
+var require_is_typed_array = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var whichTypedArray = require_which_typed_array();
+	/** @type {import('.')} */
+	module.exports = function isTypedArray(value) {
+		return !!whichTypedArray(value);
+	};
+}));
+//#endregion
+//#region ../../node_modules/typed-array-buffer/index.js
+var require_typed_array_buffer = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var $TypeError = require_type();
+	/** @type {undefined | ((thisArg: import('.').TypedArray) => Buffer<ArrayBufferLike>)} */
+	var $typedArrayBuffer = require_call_bound()("TypedArray.prototype.buffer", true);
+	var isTypedArray = require_is_typed_array();
+	/** @type {import('.')} */
+	module.exports = $typedArrayBuffer || function typedArrayBuffer(x) {
+		if (!isTypedArray(x)) throw new $TypeError("Not a Typed Array");
+		return x.buffer;
+	};
+}));
+//#endregion
+//#region ../../node_modules/to-buffer/index.js
+var require_to_buffer$1 = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var Buffer = require_safe_buffer$1.require_safe_buffer().Buffer;
+	var isArray = require_isarray();
+	var typedArrayBuffer = require_typed_array_buffer();
+	var isView = ArrayBuffer.isView || function isView(obj) {
+		try {
+			typedArrayBuffer(obj);
+			return true;
+		} catch (e) {
+			return false;
+		}
+	};
+	var useUint8Array = typeof Uint8Array !== "undefined";
+	var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
+	var useFromArrayBuffer = useArrayBuffer && (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
+	module.exports = function toBuffer(data, encoding) {
+		if (Buffer.isBuffer(data)) {
+			if (data.constructor && !("isBuffer" in data)) return Buffer.from(data);
+			return data;
+		}
+		if (typeof data === "string") return Buffer.from(data, encoding);
+		if (useArrayBuffer && isView(data)) {
+			if (data.byteLength === 0) return Buffer.alloc(0);
+			if (useFromArrayBuffer) {
+				var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+				if (res.byteLength === data.byteLength) return res;
+			}
+			var uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+			var result = Buffer.from(uint8);
+			if (result.length === data.byteLength) return result;
+		}
+		if (useUint8Array && data instanceof Uint8Array) return Buffer.from(data);
+		var isArr = isArray(data);
+		if (isArr) for (var i = 0; i < data.length; i += 1) {
+			var x = data[i];
+			if (typeof x !== "number" || x < 0 || x > 255 || ~~x !== x) throw new RangeError("Array items must be numbers in the range 0-255.");
+		}
+		if (isArr || Buffer.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data)) return Buffer.from(data);
+		throw new TypeError("The \"data\" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.");
+	};
+}));
+//#endregion
+//#region ../../node_modules/pbkdf2/lib/to-buffer.js
+var require_to_buffer = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var Buffer = require_safe_buffer$1.require_safe_buffer().Buffer;
+	var toBuffer = require_to_buffer$1();
+	var useUint8Array = typeof Uint8Array !== "undefined";
+	var isView = useUint8Array && typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView;
+	module.exports = function(thing, encoding, name) {
+		if (typeof thing === "string" || Buffer.isBuffer(thing) || useUint8Array && thing instanceof Uint8Array || isView && isView(thing)) return toBuffer(thing, encoding);
+		throw new TypeError(name + " must be a string, a Buffer, a Uint8Array, or a DataView");
+	};
+}));
+//#endregion
+//#region ../../node_modules/create-hmac/index.js
+var require_create_hmac = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	module.exports = require("node:crypto").createHmac;
+}));
+//#endregion
+//#region ../../node_modules/pbkdf2/lib/sync.js
+var require_sync = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	var sizes = {
+		__proto__: null,
+		md5: 16,
+		sha1: 20,
+		sha224: 28,
+		sha256: 32,
+		sha384: 48,
+		sha512: 64,
+		"sha512-256": 32,
+		rmd160: 20,
+		ripemd160: 20
+	};
+	var mapping = {
+		__proto__: null,
+		"sha-1": "sha1",
+		"sha-224": "sha224",
+		"sha-256": "sha256",
+		"sha-384": "sha384",
+		"sha-512": "sha512",
+		"ripemd-160": "ripemd160"
+	};
+	var createHash = require_create_hash();
+	var createHmac = require_create_hmac();
+	var Buffer = require_safe_buffer$1.require_safe_buffer().Buffer;
+	var checkParameters = require_precondition();
+	var defaultEncoding = require_default_encoding();
+	var toBuffer = require_to_buffer();
+	function pbkdf2(password, salt, iterations, keylen, digest) {
+		keylen = checkParameters(iterations, keylen);
+		password = toBuffer(password, defaultEncoding, "Password");
+		salt = toBuffer(salt, defaultEncoding, "Salt");
+		var lowerDigest = (digest || "sha1").toLowerCase();
+		var mappedDigest = mapping[lowerDigest] || lowerDigest;
+		var size = sizes[mappedDigest];
+		if (typeof size !== "number" || !size) throw new TypeError("Digest algorithm not supported: " + digest);
+		var blocksize = mappedDigest === "sha384" || mappedDigest === "sha512" || mappedDigest === "sha512-256" ? 128 : 64;
+		if (password.length > blocksize) password = createHash(mappedDigest).update(password).digest();
+		var DK = Buffer.allocUnsafe(keylen);
+		var block1 = Buffer.allocUnsafe(salt.length + 4);
+		salt.copy(block1, 0, 0, salt.length);
+		var destPos = 0;
+		var hLen = size;
+		var l = Math.ceil(keylen / hLen);
+		for (var i = 1; i <= l; i++) {
+			block1.writeUInt32BE(i, salt.length);
+			var T = createHmac(mappedDigest, password).update(block1).digest();
+			var U = T;
+			for (var j = 1; j < iterations; j++) {
+				U = createHmac(mappedDigest, password).update(U).digest();
+				for (var k = 0; k < hLen; k++) T[k] ^= U[k];
+			}
+			T.copy(DK, destPos);
+			destPos += hLen;
+		}
+		return DK;
+	}
+	module.exports = pbkdf2;
+}));
+//#endregion
+//#region ../../node_modules/pbkdf2/lib/async.js
+var require_async = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports, module) => {
+	require__polyfill_node_process.init__polyfill_global_this();
+	var Buffer = require_safe_buffer$1.require_safe_buffer().Buffer;
+	var checkParameters = require_precondition();
+	var defaultEncoding = require_default_encoding();
+	var sync = require_sync();
+	var toBuffer = require_to_buffer();
+	var ZERO_BUF;
+	var subtle = require__polyfill_node_process._polyfill_global_this_default.crypto && require__polyfill_node_process._polyfill_global_this_default.crypto.subtle;
+	var toBrowser = {
+		sha: "SHA-1",
+		"sha-1": "SHA-1",
+		sha1: "SHA-1",
+		sha256: "SHA-256",
+		"sha-256": "SHA-256",
+		sha384: "SHA-384",
+		"sha-384": "SHA-384",
+		"sha-512": "SHA-512",
+		sha512: "SHA-512"
+	};
+	var checks = [];
+	var nextTick;
+	function getNextTick() {
+		if (nextTick) return nextTick;
+		if (require__polyfill_node_process._polyfill_global_this_default.process && require__polyfill_node_process._polyfill_global_this_default.process.nextTick) nextTick = require__polyfill_node_process._polyfill_global_this_default.process.nextTick;
+		else if (require__polyfill_node_process._polyfill_global_this_default.queueMicrotask) nextTick = require__polyfill_node_process._polyfill_global_this_default.queueMicrotask;
+		else if (require__polyfill_node_process._polyfill_global_this_default.setImmediate) nextTick = require__polyfill_node_process._polyfill_global_this_default.setImmediate;
+		else nextTick = require__polyfill_node_process._polyfill_global_this_default.setTimeout;
+		return nextTick;
+	}
+	function browserPbkdf2(password, salt, iterations, length, algo) {
+		return subtle.importKey("raw", password, { name: "PBKDF2" }, false, ["deriveBits"]).then(function(key) {
+			return subtle.deriveBits({
+				name: "PBKDF2",
+				salt,
+				iterations,
+				hash: { name: algo }
+			}, key, length << 3);
+		}).then(function(res) {
+			return Buffer.from(res);
+		});
+	}
+	function checkNative(algo) {
+		if (require__polyfill_node_process._polyfill_global_this_default.process && !require__polyfill_node_process._polyfill_global_this_default.process.browser) return Promise.resolve(false);
+		if (!subtle || !subtle.importKey || !subtle.deriveBits) return Promise.resolve(false);
+		if (checks[algo] !== void 0) return checks[algo];
+		ZERO_BUF = ZERO_BUF || Buffer.alloc(8);
+		var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function() {
+			return true;
+		}, function() {
+			return false;
+		});
+		checks[algo] = prom;
+		return prom;
+	}
+	function resolvePromise(promise, callback) {
+		promise.then(function(out) {
+			getNextTick()(function() {
+				callback(null, out);
+			});
+		}, function(e) {
+			getNextTick()(function() {
+				callback(e);
+			});
+		});
+	}
+	module.exports = function(password, salt, iterations, keylen, digest, callback) {
+		if (typeof digest === "function") {
+			callback = digest;
+			digest = void 0;
+		}
+		keylen = checkParameters(iterations, keylen);
+		password = toBuffer(password, defaultEncoding, "Password");
+		salt = toBuffer(salt, defaultEncoding, "Salt");
+		if (typeof callback !== "function") throw new Error("No callback provided to pbkdf2");
+		digest = digest || "sha1";
+		var algo = toBrowser[digest.toLowerCase()];
+		if (!algo || typeof require__polyfill_node_process._polyfill_global_this_default.Promise !== "function") {
+			getNextTick()(function() {
+				var out;
+				try {
+					out = sync(password, salt, iterations, keylen, digest);
+				} catch (e) {
+					callback(e);
+					return;
+				}
+				callback(null, out);
+			});
+			return;
+		}
+		resolvePromise(checkNative(algo).then(function(resp) {
+			if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo);
+			return sync(password, salt, iterations, keylen, digest);
+		}), callback);
+	};
+}));
+//#endregion
+//#region ../../node_modules/pbkdf2/index.js
+var require_pbkdf2 = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports) => {
+	var nativeImpl = require("node:crypto");
+	var checkParameters = require_precondition();
+	var defaultEncoding = require_default_encoding();
+	var toBuffer = require_to_buffer();
+	function nativePBKDF2(password, salt, iterations, keylen, digest, callback) {
+		keylen = checkParameters(iterations, keylen);
+		password = toBuffer(password, defaultEncoding, "Password");
+		salt = toBuffer(salt, defaultEncoding, "Salt");
+		if (typeof digest === "function") {
+			callback = digest;
+			digest = "sha1";
+		}
+		if (typeof callback !== "function") throw new Error("No callback provided to pbkdf2");
+		return nativeImpl.pbkdf2(password, salt, iterations, keylen, digest, callback);
+	}
+	function nativePBKDF2Sync(password, salt, iterations, keylen, digest) {
+		keylen = checkParameters(iterations, keylen);
+		password = toBuffer(password, defaultEncoding, "Password");
+		salt = toBuffer(salt, defaultEncoding, "Salt");
+		digest = digest || "sha1";
+		return nativeImpl.pbkdf2Sync(password, salt, iterations, keylen, digest);
+	}
+	/* istanbul ignore next */
+	if (!nativeImpl.pbkdf2Sync || nativeImpl.pbkdf2Sync.toString().indexOf("keylen, digest") === -1) {
+		exports.pbkdf2Sync = require_sync();
+		exports.pbkdf2 = require_async();
+	} else {
+		exports.pbkdf2Sync = nativePBKDF2Sync;
+		exports.pbkdf2 = nativePBKDF2;
+	}
+}));
+//#endregion
+Object.defineProperty(exports, "require_create_hash", {
+	enumerable: true,
+	get: function() {
+		return require_create_hash;
+	}
+});
+Object.defineProperty(exports, "require_pbkdf2", {
+	enumerable: true,
+	get: function() {
+		return require_pbkdf2;
+	}
+});