@polyester/sdk 0.0.0

package/dist/smart-account/smart-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-account.d.ts","names":[],"sources":["../../src/smart-account/smart-account.ts"],"mappings":"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"}

package/dist/smart-account/smart-account.js

@@ -0,0 +1,94 @@
+import { predictSafeAddress } from "../account-signer/predict-safe-address.js";
+import { createPublicClient, http } from "viem";
+import { createSmartAccountClient } from "permissionless";
+import { toSafeSmartAccount } from "permissionless/accounts";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+//#region src/smart-account/smart-account.ts
+const smartAccountEnvironmentFingerprints = /* @__PURE__ */ new WeakMap();
+const USER_OPERATION_GAS_BUFFER_BPS = 2000n;
+const USER_OPERATION_MIN_GAS_BUFFER = 50000n;
+function predictPolyesterSmartAccountAddress({ environment, ownerAddress, saltNonce = 0n }) {
+	const { safeProxyFactoryAddress, safeSingletonAddress, safeModuleSetupAddress, safe4337ModuleAddress, multiSendAddress } = environment.accountAbstraction.safe;
+	return predictSafeAddress({
+		owners: [ownerAddress],
+		saltNonce,
+		safeProxyFactoryAddress,
+		safeSingletonAddress,
+		safeModuleSetupAddress,
+		safe4337ModuleAddress,
+		multiSendAddress
+	});
+}
+/**
+* Creates a Polyester smart account instance.
+*/
+async function createPolyesterSmartAccount({ environment, owner, saltNonce, publicClient }) {
+	const client = publicClient ?? createPublicClient({
+		chain: environment.chain,
+		transport: http(environment.rpcUrl)
+	});
+	if (client.chain?.id && client.chain.id !== environment.chain.id) throw new Error("Smart account public client chain does not match environment.");
+	const account = await toSafeSmartAccount({
+		client,
+		owners: [owner],
+		saltNonce,
+		entryPoint: environment.accountAbstraction.entryPoint,
+		...environment.accountAbstraction.safe
+	});
+	smartAccountEnvironmentFingerprints.set(account, environment.fingerprint);
+	return account;
+}
+/**
+* Creates a viem client bound to a Polyester smart account.
+*/
+function createPolyesterSmartAccountClient(account, params) {
+	const { environment } = params;
+	const accountEnvironmentFingerprint = smartAccountEnvironmentFingerprints.get(account);
+	if (accountEnvironmentFingerprint && accountEnvironmentFingerprint !== environment.fingerprint) throw new Error("Smart account environment does not match client environment.");
+	const paymaster = createPimlicoClient({
+		chain: environment.chain,
+		transport: http(environment.accountAbstraction.paymasterUrl),
+		entryPoint: environment.accountAbstraction.entryPoint
+	});
+	return createSmartAccountClient({
+		account,
+		chain: environment.chain,
+		paymaster,
+		bundlerTransport: http(environment.accountAbstraction.bundlerUrl),
+		userOperation: { estimateFeesPerGas: async () => (await paymaster.getUserOperationGasPrice()).fast }
+	});
+}
+function addUserOperationGasBuffer(gas) {
+	const percentBuffer = gas * USER_OPERATION_GAS_BUFFER_BPS / 10000n;
+	return gas + (percentBuffer > USER_OPERATION_MIN_GAS_BUFFER ? percentBuffer : USER_OPERATION_MIN_GAS_BUFFER);
+}
+function bufferPolyesterUserOperationGas(gas) {
+	return {
+		...gas,
+		...typeof gas.callGasLimit === "bigint" ? { callGasLimit: addUserOperationGasBuffer(gas.callGasLimit) } : {},
+		...typeof gas.preVerificationGas === "bigint" ? { preVerificationGas: addUserOperationGasBuffer(gas.preVerificationGas) } : {},
+		...typeof gas.verificationGasLimit === "bigint" ? { verificationGasLimit: addUserOperationGasBuffer(gas.verificationGasLimit) } : {},
+		...typeof gas.paymasterPostOpGasLimit === "bigint" ? { paymasterPostOpGasLimit: addUserOperationGasBuffer(gas.paymasterPostOpGasLimit) } : {},
+		...typeof gas.paymasterVerificationGasLimit === "bigint" ? { paymasterVerificationGasLimit: addUserOperationGasBuffer(gas.paymasterVerificationGasLimit) } : {}
+	};
+}
+async function sendPolyesterUserOperation(client, parameters) {
+	try {
+		const gas = await client.estimateUserOperationGas({
+			callGasLimit: 0n,
+			preVerificationGas: 0n,
+			verificationGasLimit: 0n,
+			...parameters
+		});
+		return client.sendUserOperation({
+			...parameters,
+			...bufferPolyesterUserOperationGas(gas)
+		});
+	} catch {
+		return client.sendUserOperation(parameters);
+	}
+}
+//#endregion
+export { createPolyesterSmartAccount, createPolyesterSmartAccountClient, predictPolyesterSmartAccountAddress, sendPolyesterUserOperation };
+
+//# sourceMappingURL=smart-account.js.map

package/dist/smart-account/smart-account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-account.js","names":[],"sources":["../../src/smart-account/smart-account.ts"],"sourcesContent":["import type { Address, LocalAccount, PublicClient } from \"viem\";\nimport { createPublicClient, http } from \"viem\";\nimport { createSmartAccountClient } from \"permissionless\";\nimport { toSafeSmartAccount } from \"permissionless/accounts\";\nimport { createPimlicoClient } from \"permissionless/clients/pimlico\";\nimport type { PolyesterEnvironment } from \"../environment.js\";\nimport { predictSafeAddress } from \"../account-signer/predict-safe-address.js\";\n\nexport type SafeSmartAccountInstance = Awaited<ReturnType<typeof toSafeSmartAccount>>;\nexport type PolyesterSmartAccountClient = ReturnType<typeof createPolyesterSmartAccountClient>;\n\nconst smartAccountEnvironmentFingerprints = new WeakMap<SafeSmartAccountInstance, string>();\nconst USER_OPERATION_GAS_BUFFER_BPS = 2_000n;\nconst USER_OPERATION_MIN_GAS_BUFFER = 50_000n;\n\ntype PolyesterUserOperationGas = {\n    callGasLimit?: bigint;\n    preVerificationGas?: bigint;\n    verificationGasLimit?: bigint;\n    paymasterPostOpGasLimit?: bigint;\n    paymasterVerificationGasLimit?: bigint;\n};\n\nexport interface CreateSmartAccountParams {\n    environment: PolyesterEnvironment;\n    owner: LocalAccount;\n    saltNonce?: bigint;\n    publicClient?: PublicClient;\n}\n\nexport interface PredictPolyesterSmartAccountAddressParams {\n    environment: PolyesterEnvironment;\n    ownerAddress: Address;\n    saltNonce?: bigint;\n}\n\nexport function predictPolyesterSmartAccountAddress({\n    environment,\n    ownerAddress,\n    saltNonce = 0n,\n}: PredictPolyesterSmartAccountAddressParams): Address {\n    const {\n        safeProxyFactoryAddress,\n        safeSingletonAddress,\n        safeModuleSetupAddress,\n        safe4337ModuleAddress,\n        multiSendAddress,\n    } = environment.accountAbstraction.safe;\n\n    return predictSafeAddress({\n        owners: [ownerAddress],\n        saltNonce,\n        safeProxyFactoryAddress,\n        safeSingletonAddress,\n        safeModuleSetupAddress,\n        safe4337ModuleAddress,\n        multiSendAddress,\n    });\n}\n\n/**\n * Creates a Polyester smart account instance.\n */\nexport async function createPolyesterSmartAccount({\n    environment,\n    owner,\n    saltNonce,\n    publicClient,\n}: CreateSmartAccountParams): Promise<SafeSmartAccountInstance> {\n    const client =\n        publicClient ??\n        createPublicClient({\n            chain: environment.chain,\n            transport: http(environment.rpcUrl),\n        });\n\n    if (client.chain?.id && client.chain.id !== environment.chain.id) {\n        throw new Error(\"Smart account public client chain does not match environment.\");\n    }\n\n    const account = await toSafeSmartAccount({\n        client,\n        owners: [owner],\n        saltNonce,\n        entryPoint: environment.accountAbstraction.entryPoint,\n        ...environment.accountAbstraction.safe,\n    });\n    smartAccountEnvironmentFingerprints.set(account, environment.fingerprint);\n    return account;\n}\n\n/**\n * Creates a viem client bound to a Polyester smart account.\n */\nexport function createPolyesterSmartAccountClient(\n    account: SafeSmartAccountInstance,\n    params: { environment: PolyesterEnvironment },\n) {\n    const { environment } = params;\n    const accountEnvironmentFingerprint = smartAccountEnvironmentFingerprints.get(account);\n    if (\n        accountEnvironmentFingerprint &&\n        accountEnvironmentFingerprint !== environment.fingerprint\n    ) {\n        throw new Error(\"Smart account environment does not match client environment.\");\n    }\n\n    const paymaster = createPimlicoClient({\n        chain: environment.chain,\n        transport: http(environment.accountAbstraction.paymasterUrl),\n        entryPoint: environment.accountAbstraction.entryPoint,\n    });\n\n    return createSmartAccountClient({\n        account,\n        chain: environment.chain,\n        paymaster,\n        bundlerTransport: http(environment.accountAbstraction.bundlerUrl),\n        userOperation: {\n            estimateFeesPerGas: async () => (await paymaster.getUserOperationGasPrice()).fast,\n        },\n    });\n}\n\nfunction addUserOperationGasBuffer(gas: bigint): bigint {\n    const percentBuffer = (gas * USER_OPERATION_GAS_BUFFER_BPS) / 10_000n;\n    return (\n        gas +\n        (percentBuffer > USER_OPERATION_MIN_GAS_BUFFER\n            ? percentBuffer\n            : USER_OPERATION_MIN_GAS_BUFFER)\n    );\n}\n\nfunction bufferPolyesterUserOperationGas<T extends PolyesterUserOperationGas>(gas: T): T {\n    return {\n        ...gas,\n        ...(typeof gas.callGasLimit === \"bigint\"\n            ? { callGasLimit: addUserOperationGasBuffer(gas.callGasLimit) }\n            : {}),\n        ...(typeof gas.preVerificationGas === \"bigint\"\n            ? { preVerificationGas: addUserOperationGasBuffer(gas.preVerificationGas) }\n            : {}),\n        ...(typeof gas.verificationGasLimit === \"bigint\"\n            ? { verificationGasLimit: addUserOperationGasBuffer(gas.verificationGasLimit) }\n            : {}),\n        ...(typeof gas.paymasterPostOpGasLimit === \"bigint\"\n            ? { paymasterPostOpGasLimit: addUserOperationGasBuffer(gas.paymasterPostOpGasLimit) }\n            : {}),\n        ...(typeof gas.paymasterVerificationGasLimit === \"bigint\"\n            ? {\n                  paymasterVerificationGasLimit: addUserOperationGasBuffer(\n                      gas.paymasterVerificationGasLimit,\n                  ),\n              }\n            : {}),\n    };\n}\n\nexport async function sendPolyesterUserOperation(\n    client: PolyesterSmartAccountClient,\n    parameters: Parameters<PolyesterSmartAccountClient[\"sendUserOperation\"]>[0],\n): Promise<Awaited<ReturnType<PolyesterSmartAccountClient[\"sendUserOperation\"]>>> {\n    try {\n        const gas = await client.estimateUserOperationGas({\n            callGasLimit: 0n,\n            preVerificationGas: 0n,\n            verificationGasLimit: 0n,\n            ...parameters,\n        } as Parameters<PolyesterSmartAccountClient[\"estimateUserOperationGas\"]>[0]);\n        return client.sendUserOperation({\n            ...parameters,\n            ...bufferPolyesterUserOperationGas(gas),\n        } as Parameters<PolyesterSmartAccountClient[\"sendUserOperation\"]>[0]);\n    } catch {\n        return client.sendUserOperation(parameters);\n    }\n}\n"],"mappings":";;;;;;AAWA,MAAM,sDAAsC,IAAI,QAA0C;AAC1F,MAAM,gCAAgC;AACtC,MAAM,gCAAgC;AAuBtC,SAAgB,oCAAoC,EAChD,aACA,cACA,YAAY,MACuC;CACnD,MAAM,EACF,yBACA,sBACA,wBACA,uBACA,qBACA,YAAY,mBAAmB;CAEnC,OAAO,mBAAmB;EACtB,QAAQ,CAAC,YAAY;EACrB;EACA;EACA;EACA;EACA;EACA;CACJ,CAAC;AACL;;;;AAKA,eAAsB,4BAA4B,EAC9C,aACA,OACA,WACA,gBAC4D;CAC5D,MAAM,SACF,gBACA,mBAAmB;EACf,OAAO,YAAY;EACnB,WAAW,KAAK,YAAY,MAAM;CACtC,CAAC;CAEL,IAAI,OAAO,OAAO,MAAM,OAAO,MAAM,OAAO,YAAY,MAAM,IAC1D,MAAM,IAAI,MAAM,+DAA+D;CAGnF,MAAM,UAAU,MAAM,mBAAmB;EACrC;EACA,QAAQ,CAAC,KAAK;EACd;EACA,YAAY,YAAY,mBAAmB;EAC3C,GAAG,YAAY,mBAAmB;CACtC,CAAC;CACD,oCAAoC,IAAI,SAAS,YAAY,WAAW;CACxE,OAAO;AACX;;;;AAKA,SAAgB,kCACZ,SACA,QACF;CACE,MAAM,EAAE,gBAAgB;CACxB,MAAM,gCAAgC,oCAAoC,IAAI,OAAO;CACrF,IACI,iCACA,kCAAkC,YAAY,aAE9C,MAAM,IAAI,MAAM,8DAA8D;CAGlF,MAAM,YAAY,oBAAoB;EAClC,OAAO,YAAY;EACnB,WAAW,KAAK,YAAY,mBAAmB,YAAY;EAC3D,YAAY,YAAY,mBAAmB;CAC/C,CAAC;CAED,OAAO,yBAAyB;EAC5B;EACA,OAAO,YAAY;EACnB;EACA,kBAAkB,KAAK,YAAY,mBAAmB,UAAU;EAChE,eAAe,EACX,oBAAoB,aAAa,MAAM,UAAU,yBAAyB,EAAA,CAAG,KACjF;CACJ,CAAC;AACL;AAEA,SAAS,0BAA0B,KAAqB;CACpD,MAAM,gBAAiB,MAAM,gCAAiC;CAC9D,OACI,OACC,gBAAgB,gCACX,gBACA;AAEd;AAEA,SAAS,gCAAqE,KAAW;CACrF,OAAO;EACH,GAAG;EACH,GAAI,OAAO,IAAI,iBAAiB,WAC1B,EAAE,cAAc,0BAA0B,IAAI,YAAY,EAAE,IAC5D,CAAC;EACP,GAAI,OAAO,IAAI,uBAAuB,WAChC,EAAE,oBAAoB,0BAA0B,IAAI,kBAAkB,EAAE,IACxE,CAAC;EACP,GAAI,OAAO,IAAI,yBAAyB,WAClC,EAAE,sBAAsB,0BAA0B,IAAI,oBAAoB,EAAE,IAC5E,CAAC;EACP,GAAI,OAAO,IAAI,4BAA4B,WACrC,EAAE,yBAAyB,0BAA0B,IAAI,uBAAuB,EAAE,IAClF,CAAC;EACP,GAAI,OAAO,IAAI,kCAAkC,WAC3C,EACI,+BAA+B,0BAC3B,IAAI,6BACR,EACJ,IACA,CAAC;CACX;AACJ;AAEA,eAAsB,2BAClB,QACA,YAC8E;CAC9E,IAAI;EACA,MAAM,MAAM,MAAM,OAAO,yBAAyB;GAC9C,cAAc;GACd,oBAAoB;GACpB,sBAAsB;GACtB,GAAG;EACP,CAA2E;EAC3E,OAAO,OAAO,kBAAkB;GAC5B,GAAG;GACH,GAAG,gCAAgC,GAAG;EAC1C,CAAoE;CACxE,QAAQ;EACJ,OAAO,OAAO,kBAAkB,UAAU;CAC9C;AACJ"}

package/dist/utils/base58-id.js

@@ -0,0 +1,110 @@
+import { ValidationError } from "../shared/errors.js";
+//#region src/utils/base58-id.ts
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const BASE58_MAP = (() => {
+	const m = {};
+	for (let i = 0; i < 58; i++) m[BASE58_ALPHABET[i]] = i;
+	return m;
+})();
+const U64_MAX = (1n << 64n) - 1n;
+function assertU64(x, label) {
+	if (x < 0n) throw new ValidationError(`${label}: must be >= 0`);
+	if (x > U64_MAX) throw new ValidationError(`${label}: must be <= 2^64-1`);
+	return x;
+}
+/**
+* Convert a base58 encoded ID to a bigint.
+* @param input - The base58 encoded ID.
+* @param label - The label for the input.
+* @returns The bigint ID.
+*/
+function idToBigInt(input, label = "id") {
+	if (typeof input === "bigint") return assertU64(input, label);
+	if (typeof input === "number") {
+		if (!Number.isFinite(input) || input < 0 || !Number.isInteger(input)) throw new ValidationError(`${label}: invalid number`);
+		return assertU64(BigInt(input), label);
+	}
+	const raw = input.trim();
+	if (!raw) throw new ValidationError(`${label}: empty`);
+	if (/^\d+$/.test(raw)) return assertU64(BigInt(raw), label);
+	return idParse(raw);
+}
+function idToFixed64Bytes(input) {
+	const out = /* @__PURE__ */ new Uint8Array(8);
+	new DataView(out.buffer).setBigUint64(0, idToBigInt(input));
+	return out;
+}
+function bytesToBigintBE(bytes) {
+	return new DataView(bytes.buffer, bytes.byteOffset).getBigUint64(0);
+}
+function base58Encode(bytes) {
+	if (bytes.length === 0) return "";
+	let zeros = 0;
+	while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+	const digits = [];
+	for (let i = zeros; i < bytes.length; i++) {
+		let carry = bytes[i];
+		for (let j = 0; j < digits.length; j++) {
+			const x = digits[j] * 256 + carry;
+			digits[j] = x % 58;
+			carry = Math.floor(x / 58);
+		}
+		while (carry > 0) {
+			digits.push(carry % 58);
+			carry = Math.floor(carry / 58);
+		}
+	}
+	let out = "1".repeat(zeros);
+	for (let i = digits.length - 1; i >= 0; i--) out += BASE58_ALPHABET[digits[i]];
+	return out ?? "1";
+}
+function base58Decode(s) {
+	const raw = s.trim();
+	if (!raw) return /* @__PURE__ */ new Uint8Array();
+	let zeros = 0;
+	while (zeros < raw.length && raw[zeros] === "1") zeros++;
+	const bytes = [];
+	for (let i = zeros; i < raw.length; i++) {
+		const ch = raw[i];
+		const val = BASE58_MAP[ch];
+		if (val === void 0) throw new ValidationError(`idParse: invalid base58 character "${ch}"`);
+		let carry = val;
+		for (let j = 0; j < bytes.length; j++) {
+			const x = bytes[j] * 58 + carry;
+			bytes[j] = x & 255;
+			carry = x >> 8;
+		}
+		while (carry > 0) {
+			bytes.push(carry & 255);
+			carry >>= 8;
+		}
+	}
+	const out = new Uint8Array(zeros + bytes.length);
+	for (let i = 0; i < zeros; i++) out[i] = 0;
+	for (let i = 0; i < bytes.length; i++) out[out.length - 1 - i] = bytes[i];
+	return out;
+}
+/**
+* Given a fixed64 ID, format it as a base58 encoded string.
+* @param input - The base58 encoded ID.
+* @returns The base58 encoded ID.
+*/
+function formatId(input) {
+	const fixed = idToFixed64Bytes(input);
+	let firstNonZero = 0;
+	while (firstNonZero < fixed.length && fixed[firstNonZero] === 0) firstNonZero++;
+	return base58Encode(firstNonZero >= fixed.length ? new Uint8Array([0]) : fixed.slice(firstNonZero));
+}
+function idParse(s) {
+	const raw = s.trim();
+	if (!raw) throw new ValidationError("idParse: empty");
+	const bytes = base58Decode(raw);
+	if (bytes.length > 8) throw new ValidationError("idParse: too large");
+	const padded = /* @__PURE__ */ new Uint8Array(8);
+	padded.set(bytes, 8 - bytes.length);
+	return assertU64(bytesToBigintBE(padded), "idParse");
+}
+//#endregion
+export { formatId, idToBigInt };
+
+//# sourceMappingURL=base58-id.js.map

package/dist/utils/base58-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58-id.js","names":[],"sources":["../../src/utils/base58-id.ts"],"sourcesContent":["import { ValidationError } from \"../shared/errors.js\";\n\nconst BASE58_ALPHABET = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\" as const;\nconst BASE58_MAP: Record<string, number> = (() => {\n    const m: Record<string, number> = {};\n    for (let i = 0; i < BASE58_ALPHABET.length; i++) {\n        m[BASE58_ALPHABET[i]!] = i;\n    }\n    return m;\n})();\n\nconst U64_MAX = (1n << 64n) - 1n;\n\nexport type IdInput = bigint | number | string;\n\nfunction assertU64(x: bigint, label: string): bigint {\n    if (x < 0n) throw new ValidationError(`${label}: must be >= 0`);\n    if (x > U64_MAX) throw new ValidationError(`${label}: must be <= 2^64-1`);\n    return x;\n}\n\n/**\n * Convert a base58 encoded ID to a bigint.\n * @param input - The base58 encoded ID.\n * @param label - The label for the input.\n * @returns The bigint ID.\n */\nexport function idToBigInt(input: IdInput, label = \"id\"): bigint {\n    if (typeof input === \"bigint\") return assertU64(input, label);\n    if (typeof input === \"number\") {\n        if (!Number.isFinite(input) || input < 0 || !Number.isInteger(input)) {\n            throw new ValidationError(`${label}: invalid number`);\n        }\n        return assertU64(BigInt(input), label);\n    }\n\n    const raw = input.trim();\n    if (!raw) throw new ValidationError(`${label}: empty`);\n\n    // Heuristic: base58 strings are non-numeric and/or contain letters.\n    // If it's purely digits, treat as decimal uint64 (useful for debugging/tools).\n    if (/^\\d+$/.test(raw)) return assertU64(BigInt(raw), label);\n\n    return idParse(raw);\n}\n\nfunction idToFixed64Bytes(input: IdInput): Uint8Array {\n    const out = new Uint8Array(8);\n    new DataView(out.buffer).setBigUint64(0, idToBigInt(input));\n    return out;\n}\n\nfunction bytesToBigintBE(bytes: Uint8Array): bigint {\n    return new DataView(bytes.buffer, bytes.byteOffset).getBigUint64(0);\n}\n\nfunction base58Encode(bytes: Uint8Array): string {\n    if (bytes.length === 0) return \"\";\n\n    let zeros = 0;\n    while (zeros < bytes.length && bytes[zeros] === 0) zeros++;\n\n    // Convert base256 -> base58 (classic Bitcoin algorithm)\n    const digits: number[] = [];\n    for (let i = zeros; i < bytes.length; i++) {\n        let carry = bytes[i]!;\n        for (let j = 0; j < digits.length; j++) {\n            const x = digits[j]! * 256 + carry;\n            digits[j] = x % 58;\n            carry = Math.floor(x / 58);\n        }\n        while (carry > 0) {\n            digits.push(carry % 58);\n            carry = Math.floor(carry / 58);\n        }\n    }\n\n    let out = \"1\".repeat(zeros);\n    for (let i = digits.length - 1; i >= 0; i--) {\n        out += BASE58_ALPHABET[digits[i]!]!;\n    }\n    return out ?? \"1\";\n}\n\nfunction base58Decode(s: string): Uint8Array {\n    const raw = s.trim();\n    if (!raw) return new Uint8Array();\n\n    let zeros = 0;\n    while (zeros < raw.length && raw[zeros] === \"1\") zeros++;\n\n    const bytes: number[] = [];\n    for (let i = zeros; i < raw.length; i++) {\n        const ch = raw[i]!;\n        const val = BASE58_MAP[ch];\n        if (val === undefined) {\n            throw new ValidationError(`idParse: invalid base58 character \"${ch}\"`);\n        }\n        let carry = val;\n        for (let j = 0; j < bytes.length; j++) {\n            const x = bytes[j]! * 58 + carry;\n            bytes[j] = x & 0xff;\n            carry = x >> 8;\n        }\n        while (carry > 0) {\n            bytes.push(carry & 0xff);\n            carry >>= 8;\n        }\n    }\n\n    // bytes currently little-endian base256; reverse and add leading zeros\n    const out = new Uint8Array(zeros + bytes.length);\n    for (let i = 0; i < zeros; i++) out[i] = 0;\n    for (let i = 0; i < bytes.length; i++) out[out.length - 1 - i] = bytes[i]!;\n    return out;\n}\n\n/**\n * Given a fixed64 ID, format it as a base58 encoded string.\n * @param input - The base58 encoded ID.\n * @returns The base58 encoded ID.\n */\nexport function formatId(input: IdInput): string {\n    // Encode fixed64 ID as base58 (big-endian, no left-padding).\n    // This avoids confusing leading \"1\"s for small values.\n    const fixed = idToFixed64Bytes(input);\n    let firstNonZero = 0;\n    while (firstNonZero < fixed.length && fixed[firstNonZero] === 0) firstNonZero++;\n    const bytes = firstNonZero >= fixed.length ? new Uint8Array([0]) : fixed.slice(firstNonZero);\n    return base58Encode(bytes);\n}\n\nfunction idParse(s: string): bigint {\n    const raw = s.trim();\n    if (!raw) throw new ValidationError(\"idParse: empty\");\n    const bytes = base58Decode(raw);\n    if (bytes.length > 8) throw new ValidationError(\"idParse: too large\");\n    const padded = new Uint8Array(8);\n    padded.set(bytes, 8 - bytes.length);\n    return assertU64(bytesToBigintBE(padded), \"idParse\");\n}\n"],"mappings":"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"}

package/dist/utils/columnar-time.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/columnar-time.d.ts
+type ColumnarTimeWindow = {
+  startTsSec: number;
+  endTsSec: number;
+  points: number;
+};
+declare function columnarTimestampSecAt(window: ColumnarTimeWindow, index: number): number | null;
+declare function expandColumnarTimestampsSec(window: ColumnarTimeWindow, count?: number): number[];
+//#endregion
+export { ColumnarTimeWindow, columnarTimestampSecAt, expandColumnarTimestampsSec };
+//# sourceMappingURL=columnar-time.d.ts.map

package/dist/utils/columnar-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnar-time.d.ts","names":[],"sources":["../../src/utils/columnar-time.ts"],"mappings":";KAAY;EACR;EACA;EACA;;iBAQY,uBAAuB,QAAQ,oBAAoB;iBAanD,4BACZ,QAAQ,oBACR"}

package/dist/utils/columnar-time.js

@@ -0,0 +1,30 @@
+//#region src/utils/columnar-time.ts
+function pointCount(points) {
+	if (!Number.isFinite(points)) return 0;
+	return Math.max(0, Math.trunc(points));
+}
+function columnarTimestampSecAt(window, index) {
+	const points = pointCount(window.points);
+	if (points === 0) return null;
+	if (!Number.isInteger(index) || index < 0 || index >= points) return null;
+	const startTsSec = Number(window.startTsSec);
+	const endTsSec = Number(window.endTsSec);
+	if (!Number.isFinite(startTsSec) || !Number.isFinite(endTsSec)) return null;
+	if (endTsSec < startTsSec) return null;
+	return startTsSec + index * ((endTsSec - startTsSec) / points);
+}
+function expandColumnarTimestampsSec(window, count = window.points) {
+	const points = pointCount(window.points);
+	const length = Math.min(points, pointCount(count));
+	const timestamps = [];
+	for (let index = 0; index < length; index++) {
+		const tsSec = columnarTimestampSecAt(window, index);
+		if (tsSec == null) return [];
+		timestamps.push(tsSec);
+	}
+	return timestamps;
+}
+//#endregion
+export { columnarTimestampSecAt, expandColumnarTimestampsSec };
+
+//# sourceMappingURL=columnar-time.js.map

package/dist/utils/columnar-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnar-time.js","names":[],"sources":["../../src/utils/columnar-time.ts"],"sourcesContent":["export type ColumnarTimeWindow = {\n    startTsSec: number;\n    endTsSec: number;\n    points: number;\n};\n\nfunction pointCount(points: number): number {\n    if (!Number.isFinite(points)) return 0;\n    return Math.max(0, Math.trunc(points));\n}\n\nexport function columnarTimestampSecAt(window: ColumnarTimeWindow, index: number): number | null {\n    const points = pointCount(window.points);\n    if (points === 0) return null;\n    if (!Number.isInteger(index) || index < 0 || index >= points) return null;\n\n    const startTsSec = Number(window.startTsSec);\n    const endTsSec = Number(window.endTsSec);\n    if (!Number.isFinite(startTsSec) || !Number.isFinite(endTsSec)) return null;\n    if (endTsSec < startTsSec) return null;\n\n    return startTsSec + index * ((endTsSec - startTsSec) / points);\n}\n\nexport function expandColumnarTimestampsSec(\n    window: ColumnarTimeWindow,\n    count = window.points,\n): number[] {\n    const points = pointCount(window.points);\n    const length = Math.min(points, pointCount(count));\n    const timestamps: number[] = [];\n\n    for (let index = 0; index < length; index++) {\n        const tsSec = columnarTimestampSecAt(window, index);\n        if (tsSec == null) return [];\n        timestamps.push(tsSec);\n    }\n\n    return timestamps;\n}\n"],"mappings":";AAMA,SAAS,WAAW,QAAwB;CACxC,IAAI,CAAC,OAAO,SAAS,MAAM,GAAG,OAAO;CACrC,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,MAAM,CAAC;AACzC;AAEA,SAAgB,uBAAuB,QAA4B,OAA8B;CAC7F,MAAM,SAAS,WAAW,OAAO,MAAM;CACvC,IAAI,WAAW,GAAG,OAAO;CACzB,IAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,SAAS,QAAQ,OAAO;CAErE,MAAM,aAAa,OAAO,OAAO,UAAU;CAC3C,MAAM,WAAW,OAAO,OAAO,QAAQ;CACvC,IAAI,CAAC,OAAO,SAAS,UAAU,KAAK,CAAC,OAAO,SAAS,QAAQ,GAAG,OAAO;CACvE,IAAI,WAAW,YAAY,OAAO;CAElC,OAAO,aAAa,UAAU,WAAW,cAAc;AAC3D;AAEA,SAAgB,4BACZ,QACA,QAAQ,OAAO,QACP;CACR,MAAM,SAAS,WAAW,OAAO,MAAM;CACvC,MAAM,SAAS,KAAK,IAAI,QAAQ,WAAW,KAAK,CAAC;CACjD,MAAM,aAAuB,CAAC;CAE9B,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,SAAS;EACzC,MAAM,QAAQ,uBAAuB,QAAQ,KAAK;EAClD,IAAI,SAAS,MAAM,OAAO,CAAC;EAC3B,WAAW,KAAK,KAAK;CACzB;CAEA,OAAO;AACX"}

package/dist/utils/connect-mfa-errors.d.ts

@@ -0,0 +1,23 @@
+//#region src/utils/connect-mfa-errors.d.ts
+/**
+ * True when the server indicates the user must complete MFA enrollment first.
+ * Covers typed SDK errors and raw `ConnectError`s carrying the stable auth detail code.
+ */
+declare function isMfaEnrollmentRequiredError(err: unknown): boolean;
+/**
+ * True when the server requires a fresh MFA step-up (retry with `X-Auth-Step-Up`).
+ * Covers typed SDK errors and raw `ConnectError`s carrying the stable auth detail code.
+ */
+declare function isFreshStepUpRequiredError(err: unknown): boolean;
+/**
+ * True when the server requires a recent MFA-elevated session, not a one-use
+ * fresh step-up proof. Prefer `err instanceof SessionElevationRequiredError`.
+ */
+declare function isSessionElevationRequiredError(err: unknown): boolean;
+/**
+ * True when deleting the requested factor would leave no active MFA factors.
+ */
+declare function isMfaLastFactorRequiredError(err: unknown): boolean;
+//#endregion
+export { isFreshStepUpRequiredError, isMfaEnrollmentRequiredError, isMfaLastFactorRequiredError, isSessionElevationRequiredError };
+//# sourceMappingURL=connect-mfa-errors.d.ts.map

package/dist/utils/connect-mfa-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-mfa-errors.d.ts","names":[],"sources":["../../src/utils/connect-mfa-errors.ts"],"mappings":";;;;;iBAYgB,6BAA6B;;;;;iBAQ7B,2BAA2B;;;;;iBAQ3B,gCAAgC;;;;iBAOhC,6BAA6B"}

package/dist/utils/connect-mfa-errors.js

@@ -0,0 +1,34 @@
+import { MfaEnrollmentRequiredError, MfaLastFactorRequiredError, SessionElevationRequiredError, StepUpRequiredError } from "../shared/errors.js";
+import { toPolyesterError } from "../shared/connect-error-mapping.js";
+//#region src/utils/connect-mfa-errors.ts
+/**
+* True when the server indicates the user must complete MFA enrollment first.
+* Covers typed SDK errors and raw `ConnectError`s carrying the stable auth detail code.
+*/
+function isMfaEnrollmentRequiredError(err) {
+	return toPolyesterError(err) instanceof MfaEnrollmentRequiredError;
+}
+/**
+* True when the server requires a fresh MFA step-up (retry with `X-Auth-Step-Up`).
+* Covers typed SDK errors and raw `ConnectError`s carrying the stable auth detail code.
+*/
+function isFreshStepUpRequiredError(err) {
+	return toPolyesterError(err) instanceof StepUpRequiredError;
+}
+/**
+* True when the server requires a recent MFA-elevated session, not a one-use
+* fresh step-up proof. Prefer `err instanceof SessionElevationRequiredError`.
+*/
+function isSessionElevationRequiredError(err) {
+	return toPolyesterError(err) instanceof SessionElevationRequiredError;
+}
+/**
+* True when deleting the requested factor would leave no active MFA factors.
+*/
+function isMfaLastFactorRequiredError(err) {
+	return toPolyesterError(err) instanceof MfaLastFactorRequiredError;
+}
+//#endregion
+export { isFreshStepUpRequiredError, isMfaEnrollmentRequiredError, isMfaLastFactorRequiredError, isSessionElevationRequiredError };
+
+//# sourceMappingURL=connect-mfa-errors.js.map

package/dist/utils/connect-mfa-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-mfa-errors.js","names":[],"sources":["../../src/utils/connect-mfa-errors.ts"],"sourcesContent":["import { toPolyesterError } from \"../shared/connect-error-mapping.js\";\nimport {\n    MfaEnrollmentRequiredError,\n    MfaLastFactorRequiredError,\n    SessionElevationRequiredError,\n    StepUpRequiredError,\n} from \"../shared/errors.js\";\n\n/**\n * True when the server indicates the user must complete MFA enrollment first.\n * Covers typed SDK errors and raw `ConnectError`s carrying the stable auth detail code.\n */\nexport function isMfaEnrollmentRequiredError(err: unknown): boolean {\n    return toPolyesterError(err) instanceof MfaEnrollmentRequiredError;\n}\n\n/**\n * True when the server requires a fresh MFA step-up (retry with `X-Auth-Step-Up`).\n * Covers typed SDK errors and raw `ConnectError`s carrying the stable auth detail code.\n */\nexport function isFreshStepUpRequiredError(err: unknown): boolean {\n    return toPolyesterError(err) instanceof StepUpRequiredError;\n}\n\n/**\n * True when the server requires a recent MFA-elevated session, not a one-use\n * fresh step-up proof. Prefer `err instanceof SessionElevationRequiredError`.\n */\nexport function isSessionElevationRequiredError(err: unknown): boolean {\n    return toPolyesterError(err) instanceof SessionElevationRequiredError;\n}\n\n/**\n * True when deleting the requested factor would leave no active MFA factors.\n */\nexport function isMfaLastFactorRequiredError(err: unknown): boolean {\n    return toPolyesterError(err) instanceof MfaLastFactorRequiredError;\n}\n"],"mappings":";;;;;;;AAYA,SAAgB,6BAA6B,KAAuB;CAChE,OAAO,iBAAiB,GAAG,aAAa;AAC5C;;;;;AAMA,SAAgB,2BAA2B,KAAuB;CAC9D,OAAO,iBAAiB,GAAG,aAAa;AAC5C;;;;;AAMA,SAAgB,gCAAgC,KAAuB;CACnE,OAAO,iBAAiB,GAAG,aAAa;AAC5C;;;;AAKA,SAAgB,6BAA6B,KAAuB;CAChE,OAAO,iBAAiB,GAAG,aAAa;AAC5C"}

package/dist/utils/connect-order-errors.d.ts

@@ -0,0 +1,9 @@
+//#region src/utils/connect-order-errors.d.ts
+/**
+ * True when an order mutation was rejected because its client reference quote
+ * exceeded the backend's configured drift limit.
+ */
+declare function isStaleQuoteError(error: unknown): boolean;
+//#endregion
+export { isStaleQuoteError };
+//# sourceMappingURL=connect-order-errors.d.ts.map

package/dist/utils/connect-order-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-order-errors.d.ts","names":[],"sources":["../../src/utils/connect-order-errors.ts"],"mappings":";;;;;iBAOgB,kBAAkB"}

package/dist/utils/connect-order-errors.js

@@ -0,0 +1,20 @@
+import { StaleQuoteError } from "../shared/errors.js";
+import { toPolyesterError } from "../shared/connect-error-mapping.js";
+//#region src/utils/connect-order-errors.ts
+/**
+* True when an order mutation was rejected because its client reference quote
+* exceeded the backend's configured drift limit.
+*/
+function isStaleQuoteError(error) {
+	let current = error;
+	for (let depth = 0; depth < 5; depth += 1) {
+		if (toPolyesterError(current) instanceof StaleQuoteError) return true;
+		if (!(current instanceof Error) || current.cause === void 0) return false;
+		current = current.cause;
+	}
+	return false;
+}
+//#endregion
+export { isStaleQuoteError };
+
+//# sourceMappingURL=connect-order-errors.js.map

package/dist/utils/connect-order-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-order-errors.js","names":[],"sources":["../../src/utils/connect-order-errors.ts"],"sourcesContent":["import { toPolyesterError } from \"../shared/connect-error-mapping.js\";\nimport { StaleQuoteError } from \"../shared/errors.js\";\n\n/**\n * True when an order mutation was rejected because its client reference quote\n * exceeded the backend's configured drift limit.\n */\nexport function isStaleQuoteError(error: unknown): boolean {\n    let current = error;\n\n    for (let depth = 0; depth < 5; depth += 1) {\n        if (toPolyesterError(current) instanceof StaleQuoteError) return true;\n        if (!(current instanceof Error) || current.cause === undefined) return false;\n        current = current.cause;\n    }\n\n    return false;\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,kBAAkB,OAAyB;CACvD,IAAI,UAAU;CAEd,KAAK,IAAI,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG;EACvC,IAAI,iBAAiB,OAAO,aAAa,iBAAiB,OAAO;EACjE,IAAI,EAAE,mBAAmB,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO;EACvE,UAAU,QAAQ;CACtB;CAEA,OAAO;AACX"}

package/dist/utils/cookie-es/_utils.js

@@ -0,0 +1,41 @@
+//#region src/utils/cookie-es/_utils.ts
+/**
+* RFC 6265bis cookie-age-limit: 400 days in seconds.
+*/
+const COOKIE_MAX_AGE_LIMIT = 3456e4;
+/**
+* Find the `;` character between `min` and `len` in str.
+*/
+function endIndex(str, min, len) {
+	const index = str.indexOf(";", min);
+	return index === -1 ? len : index;
+}
+/**
+* Find the `=` character between `min` and `max` in str.
+*/
+function eqIndex(str, min, max) {
+	const index = str.indexOf("=", min);
+	return index < max ? index : -1;
+}
+/**
+* Slice out a value between start to max.
+*/
+function valueSlice(str, min, max) {
+	if (min === max) return "";
+	let start = min;
+	let end = max;
+	do {
+		const code = str.charCodeAt(start);
+		if (code !== 32 && code !== 9) break;
+	} while (++start < end);
+	while (end > start) {
+		const code = str.charCodeAt(end - 1);
+		if (code !== 32 && code !== 9) break;
+		end--;
+	}
+	return str.slice(start, end);
+}
+//#endregion
+export { COOKIE_MAX_AGE_LIMIT, endIndex, eqIndex, valueSlice };
+
+//# sourceMappingURL=_utils.js.map

package/dist/utils/cookie-es/_utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_utils.js","names":[],"sources":["../../../src/utils/cookie-es/_utils.ts"],"sourcesContent":["/**\n * RFC 6265bis cookie-age-limit: 400 days in seconds.\n */\nexport const COOKIE_MAX_AGE_LIMIT = 34560000; // 400 * 24 * 60 * 60\n\n/**\n * Find the `;` character between `min` and `len` in str.\n */\nexport function endIndex(str: string, min: number, len: number) {\n    const index = str.indexOf(\";\", min);\n    return index === -1 ? len : index;\n}\n\n/**\n * Find the `=` character between `min` and `max` in str.\n */\nexport function eqIndex(str: string, min: number, max: number) {\n    const index = str.indexOf(\"=\", min);\n    return index < max ? index : -1;\n}\n\n/**\n * Slice out a value between start to max.\n */\nexport function valueSlice(str: string, min: number, max: number) {\n    if (min === max) return \"\";\n    let start = min;\n    let end = max;\n\n    do {\n        // eslint-disable-next-line unicorn/prefer-code-point\n        const code = str.charCodeAt(start);\n        if (code !== 32 /*   */ && code !== 9 /* \\t */) break;\n    } while (++start < end);\n\n    while (end > start) {\n        // eslint-disable-next-line unicorn/prefer-code-point\n        const code = str.charCodeAt(end - 1);\n        if (code !== 32 /*   */ && code !== 9 /* \\t */) break;\n        end--;\n    }\n\n    return str.slice(start, end);\n}\n"],"mappings":";;;;AAGA,MAAa,uBAAuB;;;;AAKpC,SAAgB,SAAS,KAAa,KAAa,KAAa;CAC5D,MAAM,QAAQ,IAAI,QAAQ,KAAK,GAAG;CAClC,OAAO,UAAU,KAAK,MAAM;AAChC;;;;AAKA,SAAgB,QAAQ,KAAa,KAAa,KAAa;CAC3D,MAAM,QAAQ,IAAI,QAAQ,KAAK,GAAG;CAClC,OAAO,QAAQ,MAAM,QAAQ;AACjC;;;;AAKA,SAAgB,WAAW,KAAa,KAAa,KAAa;CAC9D,IAAI,QAAQ,KAAK,OAAO;CACxB,IAAI,QAAQ;CACZ,IAAI,MAAM;CAEV,GAAG;EAEC,MAAM,OAAO,IAAI,WAAW,KAAK;EACjC,IAAI,SAAS,MAAc,SAAS,GAAY;CACpD,SAAS,EAAE,QAAQ;CAEnB,OAAO,MAAM,OAAO;EAEhB,MAAM,OAAO,IAAI,WAAW,MAAM,CAAC;EACnC,IAAI,SAAS,MAAc,SAAS,GAAY;EAChD;CACJ;CAEA,OAAO,IAAI,MAAM,OAAO,GAAG;AAC/B"}

package/dist/utils/cookie-es/cookie/parse.js

@@ -0,0 +1,53 @@
+import { endIndex, eqIndex, valueSlice } from "../_utils.js";
+//#region src/utils/cookie-es/cookie/parse.ts
+const NullObject = /* @__PURE__ */ (() => {
+	const C = function() {};
+	C.prototype = Object.create(null);
+	return C;
+})();
+function parse(str, options) {
+	const obj = new NullObject();
+	const len = str.length;
+	if (len < 2) return obj;
+	const dec = options?.decode || decode;
+	const allowMultiple = options?.allowMultiple || false;
+	let index = 0;
+	do {
+		const eqIdx = eqIndex(str, index, len);
+		if (eqIdx === -1) break;
+		const endIdx = endIndex(str, index, len);
+		if (eqIdx > endIdx) {
+			index = str.lastIndexOf(";", eqIdx - 1) + 1;
+			continue;
+		}
+		const key = valueSlice(str, index, eqIdx);
+		if (options?.filter && !options.filter(key)) {
+			index = endIdx + 1;
+			continue;
+		}
+		const val = dec(valueSlice(str, eqIdx + 1, endIdx));
+		if (allowMultiple) {
+			const existing = obj[key];
+			if (existing === void 0) obj[key] = val;
+			else if (Array.isArray(existing)) existing.push(val);
+			else obj[key] = [existing, val];
+		} else if (obj[key] === void 0) obj[key] = val;
+		index = endIdx + 1;
+	} while (index < len);
+	return obj;
+}
+/**
+* URL-decode string value. Optimized to skip native call when no %.
+*/
+function decode(str) {
+	if (!str.includes("%")) return str;
+	try {
+		return decodeURIComponent(str);
+	} catch {
+		return str;
+	}
+}
+//#endregion
+export { parse };
+
+//# sourceMappingURL=parse.js.map

package/dist/utils/cookie-es/cookie/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","names":[],"sources":["../../../../src/utils/cookie-es/cookie/parse.ts"],"sourcesContent":["// Based on https://github.com/jshttp/cookie (MIT)\n// Copyright (c) 2012-2014 Roman Shtylman <shtylman@gmail.com>\n// Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>\n// Last sync: v1.1.1 (e264dfa)\n\nimport type { CookieParseOptions, Cookies, MultiCookies } from \"./types.js\";\nimport { endIndex, eqIndex, valueSlice } from \"../_utils.js\";\n\nconst NullObject = /* @__PURE__ */ (() => {\n    const C = function () {};\n    C.prototype = Object.create(null);\n    return C;\n})() as unknown as { new (): any };\n\n/**\n * Parse a `Cookie` header string into an object.\n *\n * The object has cookie names as keys and decoded values as values.\n * First occurrence wins for duplicate names unless `allowMultiple` is set.\n *\n * @param str - The `Cookie` header string to parse.\n * @param options - Parsing options (`decode`, `filter`, `allowMultiple`).\n * @returns A prototype-less object of cookie name-value pairs.\n */\nexport function parse(\n    str: string,\n    options: CookieParseOptions & { allowMultiple: true },\n): MultiCookies;\nexport function parse(str: string, options?: CookieParseOptions): Cookies;\nexport function parse(str: string, options?: CookieParseOptions): Cookies | MultiCookies {\n    const obj: MultiCookies = new NullObject();\n    const len = str.length;\n    // RFC 6265bis sec 4.1.1, RFC 2616 2.2 defines a cookie name consists of one char minimum, plus '='.\n    if (len < 2) return obj;\n\n    const dec = options?.decode || decode;\n    const allowMultiple = options?.allowMultiple || false;\n    let index = 0;\n\n    do {\n        const eqIdx = eqIndex(str, index, len);\n        if (eqIdx === -1) break; // No more cookie pairs.\n\n        const endIdx = endIndex(str, index, len);\n\n        if (eqIdx > endIdx) {\n            // backtrack on prior semicolon\n            index = str.lastIndexOf(\";\", eqIdx - 1) + 1;\n            continue;\n        }\n\n        const key = valueSlice(str, index, eqIdx);\n\n        if (options?.filter && !options.filter(key)) {\n            index = endIdx + 1;\n            continue;\n        }\n\n        const val = dec(valueSlice(str, eqIdx + 1, endIdx));\n\n        if (allowMultiple) {\n            const existing = obj[key];\n            if (existing === undefined) {\n                obj[key] = val;\n            } else if (Array.isArray(existing)) {\n                existing.push(val!);\n            } else {\n                obj[key] = [existing!, val!];\n            }\n        } else if (obj[key] === undefined) {\n            obj[key] = val;\n        }\n\n        index = endIdx + 1;\n    } while (index < len);\n\n    return obj;\n}\n\n// --- Internal Utils ---\n\n/**\n * URL-decode string value. Optimized to skip native call when no %.\n */\nfunction decode(str: string): string {\n    if (!str.includes(\"%\")) return str;\n\n    try {\n        return decodeURIComponent(str);\n    } catch {\n        return str;\n    }\n}\n"],"mappings":";;AAQA,MAAM,aAA6B,uBAAO;CACtC,MAAM,IAAI,WAAY,CAAC;CACvB,EAAE,YAAY,OAAO,OAAO,IAAI;CAChC,OAAO;AACX,EAAA,CAAG;AAiBH,SAAgB,MAAM,KAAa,SAAsD;CACrF,MAAM,MAAoB,IAAI,WAAW;CACzC,MAAM,MAAM,IAAI;CAEhB,IAAI,MAAM,GAAG,OAAO;CAEpB,MAAM,MAAM,SAAS,UAAU;CAC/B,MAAM,gBAAgB,SAAS,iBAAiB;CAChD,IAAI,QAAQ;CAEZ,GAAG;EACC,MAAM,QAAQ,QAAQ,KAAK,OAAO,GAAG;EACrC,IAAI,UAAU,IAAI;EAElB,MAAM,SAAS,SAAS,KAAK,OAAO,GAAG;EAEvC,IAAI,QAAQ,QAAQ;GAEhB,QAAQ,IAAI,YAAY,KAAK,QAAQ,CAAC,IAAI;GAC1C;EACJ;EAEA,MAAM,MAAM,WAAW,KAAK,OAAO,KAAK;EAExC,IAAI,SAAS,UAAU,CAAC,QAAQ,OAAO,GAAG,GAAG;GACzC,QAAQ,SAAS;GACjB;EACJ;EAEA,MAAM,MAAM,IAAI,WAAW,KAAK,QAAQ,GAAG,MAAM,CAAC;EAElD,IAAI,eAAe;GACf,MAAM,WAAW,IAAI;GACrB,IAAI,aAAa,KAAA,GACb,IAAI,OAAO;QACR,IAAI,MAAM,QAAQ,QAAQ,GAC7B,SAAS,KAAK,GAAI;QAElB,IAAI,OAAO,CAAC,UAAW,GAAI;EAEnC,OAAO,IAAI,IAAI,SAAS,KAAA,GACpB,IAAI,OAAO;EAGf,QAAQ,SAAS;CACrB,SAAS,QAAQ;CAEjB,OAAO;AACX;;;;AAOA,SAAS,OAAO,KAAqB;CACjC,IAAI,CAAC,IAAI,SAAS,GAAG,GAAG,OAAO;CAE/B,IAAI;EACA,OAAO,mBAAmB,GAAG;CACjC,QAAQ;EACJ,OAAO;CACX;AACJ"}