@happyvertical/smrt-core 0.56.0 → 0.56.2

package/dist/node_modules/.pnpm/@noble_hashes@2.4.0/node_modules/@noble/hashes/utils.js

@@ -1,243 +0,0 @@
-//#region ../../node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/utils.js
-/**
-* Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.
-* @param a - value to test
-* @returns `true` when the value is a Uint8Array-compatible view.
-* @example
-* Check whether a value is a Uint8Array-compatible view.
-* ```ts
-* isBytes(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function isBytes(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-var atitle = (title) => title ? `"${title}" ` : "";
-/**
-* Asserts something is a non-negative integer.
-* @param n - number to validate
-* @param title - label included in thrown errors
-* @returns The validated number.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a non-negative integer option.
-* ```ts
-* anumber(32, 'length');
-* ```
-*/
-function anumber(n, title = "") {
-	if (typeof n !== "number") throw new TypeError(atitle(title) + "expected number, got " + typeof n);
-	if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
-	return n;
-}
-/**
-* Asserts something is Uint8Array.
-* @param value - value to validate
-* @param length - optional exact length constraint
-* @param title - label included in thrown errors
-* @returns The validated byte array.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate that a value is a byte array.
-* ```ts
-* abytes(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function abytes(value, length, title = "") {
-	if (isBytes(value) && (length === void 0 || value.length === length)) return value;
-	if (length !== void 0) anumber(length, "length");
-	const bytes = isBytes(value);
-	const ofLen = length !== void 0 ? ` of length ${length}` : "";
-	const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
-	const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
-	if (!bytes) throw new TypeError(message);
-	throw new RangeError(message);
-}
-var aobject = (value, label) => {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
-};
-var aopts = (value, label) => {
-	aobject(value, label);
-	const proto = Object.getPrototypeOf(value);
-	if (proto !== Object.prototype && proto !== null) throw new TypeError(`"${label}" expected plain object`);
-	if (Object.hasOwn(value, "__proto__")) throw new TypeError(`"${label}.__proto__" is not allowed`);
-};
-/**
-* Asserts a hash instance has not been destroyed or finished.
-* @param instance - hash instance to validate
-* @param checkFinished - whether to reject finalized instances
-* @throws If the hash instance has already been destroyed or finalized. {@link Error}
-* @example
-* Validate that a hash instance is still usable.
-* ```ts
-* import { aexists } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aexists(hash);
-* ```
-*/
-function aexists(instance, checkFinished = true) {
-	if (instance.destroyed) throw new Error("hash was destroyed");
-	if (checkFinished && instance.finished) throw new Error("digest() was already called");
-}
-/**
-* Asserts output is a sufficiently-sized byte array.
-* @param out - destination buffer
-* @param instance - hash instance providing output length
-* Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a caller-provided digest buffer.
-* ```ts
-* import { aoutput } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aoutput(new Uint8Array(hash.outputLen), hash);
-* ```
-*/
-function aoutput(out, instance) {
-	abytes(out, void 0, "output");
-	const min = instance.outputLen;
-	if (!(out.length >= min)) throw new RangeError("\"output\" expected length >= " + min);
-}
-/**
-* Zeroizes typed arrays in place. Warning: JS provides no guarantees.
-* @param arrays - arrays to overwrite with zeros
-* @example
-* Zeroize sensitive buffers in place.
-* ```ts
-* clean(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function clean(...arrays) {
-	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
-}
-/**
-* Creates a DataView for byte-level manipulation.
-* @param arr - source typed array
-* @returns DataView over the same buffer region.
-* @example
-* Create a DataView over an existing buffer.
-* ```ts
-* createView(new Uint8Array(4));
-* ```
-*/
-function createView(arr) {
-	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-/**
-* Rotate-right operation for uint32 values.
-* @param word - source word
-* @param shift - shift amount in bits
-* @returns Rotated word.
-* @example
-* Rotate a 32-bit word to the right.
-* ```ts
-* rotr(0x12345678, 8);
-* ```
-*/
-function rotr(word, shift) {
-	return word << 32 - shift | word >>> shift;
-}
-var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
-var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-/**
-* Convert byte array to hex string.
-* Uses the built-in function when available and assumes it matches the tested
-* fallback semantics.
-* @param bytes - bytes to encode
-* @returns Lowercase hexadecimal string.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Convert bytes to lowercase hexadecimal.
-* ```ts
-* bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'
-* ```
-*/
-function bytesToHex(bytes) {
-	abytes(bytes);
-	if (hasHexBuiltin) return bytes.toHex();
-	let hex = "";
-	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
-	return hex;
-}
-/**
-* Merges default options and passed options.
-* @param defaults - base option object
-* @param opts - user overrides
-* @param title - label included in thrown override errors
-* @returns Fresh merged option object with a null prototype.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Merge user overrides onto default options.
-* ```ts
-* checkOpts({ dkLen: 32 }, { asyncTick: 10 });
-* ```
-*/
-function checkOpts(defaults, opts, title = "opts") {
-	aopts(defaults, "defaults");
-	if (opts !== void 0) aopts(opts, title);
-	return Object.assign(Object.create(null), defaults, opts);
-}
-/**
-* Creates a callable hash function from a stateful class constructor.
-* @param hashCons - hash constructor or factory
-* @param info - optional metadata such as DER OID
-* @returns Frozen callable hash wrapper with `.create()`.
-*   Wrapper construction eagerly calls `hashCons(undefined)` once to read
-*   `outputLen` / `blockLen`, so constructor side effects happen at module
-*   init time.
-* @throws On wrong argument types. {@link TypeError}
-* @example
-* Wrap a stateful hash constructor into a callable helper.
-* ```ts
-* import { createHasher } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const wrapped = createHasher(sha256.create, { oid: sha256.oid });
-* wrapped(new Uint8Array([1]));
-* ```
-*/
-function createHasher(hashCons, info = {}) {
-	if (typeof hashCons !== "function") throw new TypeError("\"hashCons\" expected function, got type=" + typeof hashCons);
-	info = checkOpts({}, info, "info");
-	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-	const tmp = hashCons(void 0);
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.canXOF = tmp.canXOF;
-	hashC.create = (opts) => hashCons(opts);
-	Object.assign(hashC, info);
-	return Object.freeze(hashC);
-}
-/**
-* Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.
-* @param suffix - final OID byte for the selected hash.
-*   The helper accepts any byte even though only the documented NIST hash
-*   suffixes are meaningful downstream.
-* @returns Object containing the DER-encoded OID.
-* @example
-* Build OID metadata for a NIST hash.
-* ```ts
-* oidNist(0x01);
-* ```
-*/
-var oidNist = (suffix) => ({ oid: Uint8Array.from([
-	6,
-	9,
-	96,
-	134,
-	72,
-	1,
-	101,
-	3,
-	4,
-	2,
-	suffix
-]) });
-//#endregion
-export { abytes, aexists, anumber, aoutput, bytesToHex, checkOpts, clean, createHasher, createView, isBytes, oidNist, rotr };
-
-//# sourceMappingURL=utils.js.map

package/dist/node_modules/.pnpm/@noble_hashes@2.4.0/node_modules/@noble/hashes/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/utils.js"],"sourcesContent":["/**\n * Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.\n * @param a - value to test\n * @returns `true` when the value is a Uint8Array-compatible view.\n * @example\n * Check whether a value is a Uint8Array-compatible view.\n * ```ts\n * isBytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function isBytes(a) {\n    // Plain `instanceof Uint8Array` is too strict for some Buffer / proxy / cross-realm cases.\n    // The fallback still requires a real ArrayBuffer view, so plain\n    // JSON-deserialized `{ constructor: ... }` spoofing is rejected, and\n    // `BYTES_PER_ELEMENT === 1` keeps the fallback on byte-oriented views.\n    return (a instanceof Uint8Array ||\n        (ArrayBuffer.isView(a) &&\n            a.constructor.name === 'Uint8Array' &&\n            'BYTES_PER_ELEMENT' in a &&\n            a.BYTES_PER_ELEMENT === 1));\n}\n// Shared error-message prefix builder. Only called on throw paths, so assert\n// success paths never pay for the string concatenation.\nconst atitle = (title) => (title ? `\"${title}\" ` : '');\n/**\n * Asserts something is a non-negative integer.\n * @param n - number to validate\n * @param title - label included in thrown errors\n * @returns The validated number.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate a non-negative integer option.\n * ```ts\n * anumber(32, 'length');\n * ```\n */\nexport function anumber(n, title = '') {\n    if (typeof n !== 'number')\n        throw new TypeError(atitle(title) + 'expected number, got ' + typeof n);\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new RangeError(atitle(title) + 'expected integer >= 0, got ' + n);\n    return n;\n}\n/**\n * Asserts something is a boolean.\n * @param value - value to validate\n * @param title - label included in thrown errors\n * @returns The validated boolean.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Validate a boolean option.\n * ```ts\n * abool(true, 'enableXOF');\n * ```\n */\nexport function abool(value, title = '') {\n    if (typeof value !== 'boolean')\n        throw new TypeError(atitle(title) + 'expected boolean, got type=' + typeof value);\n    return value;\n}\n/**\n * Asserts something is Uint8Array.\n * @param value - value to validate\n * @param length - optional exact length constraint\n * @param title - label included in thrown errors\n * @returns The validated byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate that a value is a byte array.\n * ```ts\n * abytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function abytes(value, length, title = '') {\n    // Success path first: this runs at the start of every update() / digestInto(), and the\n    // common `abytes(data)` form must not pay for length handling it does not use.\n    if (isBytes(value) && (length === undefined || value.length === length))\n        return value;\n    // Error path: recompute freely to build the exact message.\n    if (length !== undefined)\n        anumber(length, 'length');\n    const bytes = isBytes(value);\n    const ofLen = length !== undefined ? ` of length ${length}` : '';\n    const got = bytes ? `length=${value.length}` : `type=${typeof value}`;\n    const message = atitle(title) + 'expected Uint8Array' + ofLen + ', got ' + got;\n    if (!bytes)\n        throw new TypeError(message);\n    throw new RangeError(message);\n}\n/**\n * Copies bytes into a fresh Uint8Array.\n * Buffer-style slices can alias the same backing store, so callers that need ownership should copy.\n * @param bytes - source bytes to clone\n * @returns Freshly allocated copy of `bytes`.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Clone a byte array before mutating it.\n * ```ts\n * const copy = copyBytes(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function copyBytes(bytes) {\n    // `Uint8Array.from(...)` would also accept arrays / other typed arrays. Keep this helper strict\n    // because callers use it at byte-validation boundaries before mutating the detached copy.\n    return Uint8Array.from(abytes(bytes));\n}\n/**\n * Asserts something is a wrapped hash constructor.\n * @param h - hash constructor to validate\n * @throws On wrong argument types or invalid hash wrapper shape. {@link TypeError}\n * @throws On invalid hash metadata ranges or values. {@link RangeError}\n * @throws If the hash metadata allows empty outputs or block sizes. {@link Error}\n * @example\n * Validate a callable hash wrapper.\n * ```ts\n * import { ahash } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * ahash(sha256);\n * ```\n */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new TypeError('expected hash wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n    // HMAC and KDF callers treat these as real byte lengths; allowing zero lets fake wrappers pass\n    // validation and can produce empty outputs instead of failing fast.\n    if (h.outputLen < 1 || h.blockLen < 1)\n        throw new Error('hash blockLen / outputLen must be >= 1');\n}\nconst aobject = (value, label) => {\n    if (value === null || typeof value !== 'object' || Array.isArray(value))\n        throw new TypeError((label === 'object' ? '' : `\"${label}\" `) + 'expected object, got type=' + typeof value);\n};\nconst aopts = (value, label) => {\n    aobject(value, label);\n    const proto = Object.getPrototypeOf(value);\n    if (proto !== Object.prototype && proto !== null)\n        throw new TypeError(`\"${label}\" expected plain object`);\n    // Object.assign() treats an own \"__proto__\" source key as a write to the target's legacy\n    // prototype setter. Reject it before merging so inherited option values cannot be injected.\n    if (Object.hasOwn(value, '__proto__'))\n        throw new TypeError(`\"${label}.__proto__\" is not allowed`);\n};\n/**\n * Asserts a hash instance has not been destroyed or finished.\n * @param instance - hash instance to validate\n * @param checkFinished - whether to reject finalized instances\n * @throws If the hash instance has already been destroyed or finalized. {@link Error}\n * @example\n * Validate that a hash instance is still usable.\n * ```ts\n * import { aexists } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const hash = sha256.create();\n * aexists(hash);\n * ```\n */\nexport function aexists(instance, checkFinished = true) {\n    // Runs on every update()/digestInto(); the flags are library-owned booleans, so only their\n    // truthiness is checked - re-validating their type per call was pure hot-path overhead.\n    if (instance.destroyed)\n        throw new Error('hash was destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('digest() was already called');\n}\n/**\n * Asserts output is a sufficiently-sized byte array.\n * @param out - destination buffer\n * @param instance - hash instance providing output length\n * Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validate a caller-provided digest buffer.\n * ```ts\n * import { aoutput } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const hash = sha256.create();\n * aoutput(new Uint8Array(hash.outputLen), hash);\n * ```\n */\nexport function aoutput(out, instance) {\n    abytes(out, undefined, 'output');\n    // `outputLen` is a library-owned readonly number; the negated comparison keeps failing fast\n    // when it is missing/NaN (comparisons with undefined/NaN are false) without an anumber() call.\n    const min = instance.outputLen;\n    if (!(out.length >= min)) {\n        throw new RangeError('\"output\" expected length >= ' + min);\n    }\n}\n/**\n * Casts a typed array view to Uint8Array.\n * @param arr - source typed array\n * @returns Uint8Array view over the same buffer.\n * @example\n * Reinterpret a typed array as bytes.\n * ```ts\n * u8(new Uint32Array([1, 2]));\n * ```\n */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Casts a typed array view to Uint32Array.\n * `arr.byteOffset` must already be 4-byte aligned or the platform\n * Uint32Array constructor will throw.\n * @param arr - source typed array\n * @returns Uint32Array view over the same buffer.\n * @example\n * Reinterpret a byte array as 32-bit words.\n * ```ts\n * u32(new Uint8Array(8));\n * ```\n */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/**\n * Zeroizes typed arrays in place. Warning: JS provides no guarantees.\n * @param arrays - arrays to overwrite with zeros\n * @example\n * Zeroize sensitive buffers in place.\n * ```ts\n * clean(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/**\n * Creates a DataView for byte-level manipulation.\n * @param arr - source typed array\n * @returns DataView over the same buffer region.\n * @example\n * Create a DataView over an existing buffer.\n * ```ts\n * createView(new Uint8Array(4));\n * ```\n */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Rotate-right operation for uint32 values.\n * @param word - source word\n * @param shift - shift amount in bits\n * @returns Rotated word.\n * @example\n * Rotate a 32-bit word to the right.\n * ```ts\n * rotr(0x12345678, 8);\n * ```\n */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/**\n * Rotate-left operation for uint32 values.\n * @param word - source word\n * @param shift - shift amount in bits\n * @returns Rotated word.\n * @example\n * Rotate a 32-bit word to the left.\n * ```ts\n * rotl(0x12345678, 8);\n * ```\n */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Whether the current platform is little-endian. */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/**\n * Byte-swap operation for uint32 values.\n * @param word - source word\n * @returns Word with reversed byte order.\n * @example\n * Reverse the byte order of a 32-bit word.\n * ```ts\n * byteSwap(0x11223344);\n * ```\n */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/**\n * Conditionally byte-swaps one 32-bit word on big-endian platforms.\n * @param n - source word\n * @returns Original or byte-swapped word depending on platform endianness.\n * @example\n * Normalize a 32-bit word for host endianness.\n * ```ts\n * swap8IfBE(0x11223344);\n * ```\n */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n) >>> 0;\n/**\n * Byte-swaps every word of a Uint32Array in place.\n * @param arr - array to mutate\n * @returns The same array after mutation; callers pass live state arrays here.\n * @example\n * Reverse the byte order of every word in place.\n * ```ts\n * byteSwap32(new Uint32Array([0x11223344]));\n * ```\n */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\n}\n/**\n * Conditionally byte-swaps a Uint32Array on big-endian platforms.\n * @param u - array to normalize for host endianness\n * @returns Original or byte-swapped array depending on platform endianness.\n *   On big-endian runtimes this mutates `u` in place via `byteSwap32(...)`.\n * @example\n * Normalize a word array for host endianness.\n * ```ts\n * swap32IfBE(new Uint32Array([0x11223344]));\n * ```\n */\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin = /* @__PURE__ */ (() => \n// @ts-ignore\ntypeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * Convert byte array to hex string.\n * Uses the built-in function when available and assumes it matches the tested\n * fallback semantics.\n * @param bytes - bytes to encode\n * @returns Lowercase hexadecimal string.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Convert bytes to lowercase hexadecimal.\n * ```ts\n * bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'\n * ```\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// Strict ASCII nibble parser: non-ASCII hex lookalikes are rejected as undefined.\n// ASCII codes: '0'..'9' = 48..57, 'A'..'F' = 65..70, 'a'..'f' = 97..102.\n// prettier-ignore\nfunction asciiToBase16(ch) {\n    return ch >= 48 && ch <= 57 ? ch - 48 // '2' => 50-48\n        : ch >= 65 && ch <= 70 ? ch - (65 - 10) // 'B' => 66-(65-10)\n            : ch >= 97 && ch <= 102 ? ch - (97 - 10) // 'b' => 98-(97-10)\n                : undefined;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @param hex - hexadecimal string to decode\n * @returns Decoded bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Decode lowercase hexadecimal into bytes.\n * ```ts\n * hexToBytes('cafe0123'); // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n * ```\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new TypeError('hex string expected, got ' + typeof hex);\n    if (hasHexBuiltin) {\n        try {\n            return Uint8Array.fromHex(hex);\n        }\n        catch (error) {\n            if (error instanceof SyntaxError)\n                throw new RangeError(error.message);\n            throw error;\n        }\n    }\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new RangeError('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi)); // parse first char, multiply it by 16\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1)); // parse second char\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new RangeError('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2; // example: 'A9' => 10*16 + 9\n    }\n    return array;\n}\n/**\n * Yields to the host task scheduler so timers, I/O, and rendering can make progress.\n * Uses the Web Scheduling API when available or `setTimeout` as a cross-platform fallback.\n * Host-task yields are much slower than microtasks (roughly 1ms with the timer fallback), so\n * async loops should use `asyncTick >= 10` to amortize scheduling overhead to about 10% while\n * still allowing other event-loop work to proceed.\n * @param onReject - optional cleanup invoked only if the host yield fails\n * @example\n * Yield to the next scheduler tick.\n * ```ts\n * await nextTick();\n * ```\n */\nexport function nextTick(onReject) {\n    const host = globalThis;\n    if (typeof host.scheduler?.yield === 'function') {\n        const promise = host.scheduler.yield();\n        // Keep the original scheduler rejection; this handler exists only for cleanup.\n        if (onReject)\n            promise.catch(onReject);\n        return promise;\n    }\n    return new Promise((resolve) => host.setTimeout(resolve, 0));\n}\n/**\n * Returns control to the host event loop every `tick` milliseconds to avoid blocking long loops.\n * @param iters - number of loop iterations to run\n * @param tick - maximum time slice in milliseconds\n * @param cb - callback executed on each iteration\n * @param onReject - optional cleanup invoked only if a host yield fails\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Run a loop that periodically yields back to the event loop.\n * ```ts\n * await asyncLoop(2, 0, () => {});\n * ```\n */\nexport async function asyncLoop(iters, tick, cb, onReject) {\n    anumber(iters, 'iters');\n    anumber(tick, 'tick');\n    if (typeof cb !== 'function')\n        throw new TypeError('callback must be a function');\n    // Callback is synchronous by contract; asyncLoop only yields between sync work windows.\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick(onReject);\n        // Track only synchronous work time; scheduler delay after yielding is outside our budget.\n        ts = Date.now();\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * Built-in doesn't validate input to be string: we do the check.\n * Non-ASCII details are delegated to the platform `TextEncoder`.\n * @param str - string to encode\n * @returns UTF-8 encoded bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Encode a string as UTF-8 bytes.\n * ```ts\n * utf8ToBytes('abc'); // Uint8Array.from([97, 98, 99])\n * ```\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new TypeError('string expected');\n    const encoded = new TextEncoder().encode(str);\n    try {\n        // Copy into the current realm for Firefox extension contexts. Callers that own the returned\n        // buffer can then wipe it independently of TextEncoder's temporary result.\n        return new Uint8Array(encoded); // https://bugzil.la/1681809\n    }\n    finally {\n        clean(encoded);\n    }\n}\n/**\n * Helper for KDFs: consumes Uint8Array or string.\n * String inputs are UTF-8 encoded; byte-array inputs stay aliased to the caller buffer.\n * @param data - user-provided KDF input\n * @param errorTitle - label included in thrown errors\n * @returns Byte representation of the input.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Normalize KDF input to bytes.\n * ```ts\n * kdfInputToBytes('password');\n * ```\n */\nexport function kdfInputToBytes(data, errorTitle = '') {\n    if (typeof data === 'string')\n        return utf8ToBytes(data);\n    return abytes(data, undefined, errorTitle);\n}\n/**\n * Copies several Uint8Arrays into one.\n * @param arrays - arrays to concatenate\n * @returns Concatenated byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Concatenate multiple byte arrays.\n * ```ts\n * concatBytes(new Uint8Array([1]), new Uint8Array([2]));\n * ```\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n/**\n * Validates declared required and optional field types on a plain object.\n * This walks field schemas and formats detailed errors, so avoid it on hot paths; use direct\n * one-line guards such as `abytes()`, `abool()`, or `anumber()` instead.\n * @param object - object to validate\n * @param fields - map of required field names to expected types\n * @param optFields - map of optional field names to expected types\n * @param title - label included in thrown errors\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Validate required and optional option fields.\n * ```ts\n * validateObject({ N: 1024, dkLen: 32 }, { N: 'number' }, { dkLen: 'number' });\n * ```\n */\nexport const validateObject = (object, fields = {}, optFields = {}, title = 'object') => {\n    aobject(object, title);\n    aobject(fields, 'fields');\n    aobject(optFields, 'optFields');\n    function checkField(fieldName, expectedType, isOpt) {\n        const label = title === 'object' ? `param \"${String(fieldName)}\"` : `\"${title}.${String(fieldName)}\"`;\n        // Config fields must be explicit own properties. Optional inherited values are rejected too\n        // because callers keep reading the same options object after validation.\n        const val = object[fieldName];\n        // Runtime objects such as Field instances intentionally satisfy required method slots\n        // via their shared prototype.\n        if (!Object.hasOwn(object, fieldName) &&\n            (isOpt ? val !== undefined : expectedType !== 'function')) {\n            throw new TypeError(`${label} is invalid: expected own property`);\n        }\n        if (isOpt && val === undefined)\n            return;\n        const current = typeof val;\n        if (current !== expectedType || val === null)\n            throw new TypeError(`${label} is invalid: expected ${expectedType}, got ${current}`);\n    }\n    const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));\n    iter(fields, false);\n    iter(optFields, true);\n};\n/**\n * Merges default options and passed options.\n * @param defaults - base option object\n * @param opts - user overrides\n * @param title - label included in thrown override errors\n * @returns Fresh merged option object with a null prototype.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Merge user overrides onto default options.\n * ```ts\n * checkOpts({ dkLen: 32 }, { asyncTick: 10 });\n * ```\n */\nexport function checkOpts(defaults, opts, title = 'opts') {\n    aopts(defaults, 'defaults');\n    if (opts !== undefined)\n        aopts(opts, title);\n    // Callers read optional fields directly, so omitted values must not fall through to ambient\n    // Object.prototype pollution (for example a forged `dkLen` changing SHAKE's default output).\n    const merged = Object.assign(Object.create(null), defaults, opts);\n    return merged;\n}\n/**\n * Creates a callable hash function from a stateful class constructor.\n * @param hashCons - hash constructor or factory\n * @param info - optional metadata such as DER OID\n * @returns Frozen callable hash wrapper with `.create()`.\n *   Wrapper construction eagerly calls `hashCons(undefined)` once to read\n *   `outputLen` / `blockLen`, so constructor side effects happen at module\n *   init time.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Wrap a stateful hash constructor into a callable helper.\n * ```ts\n * import { createHasher } from '@noble/hashes/utils.js';\n * import { sha256 } from '@noble/hashes/sha2.js';\n * const wrapped = createHasher(sha256.create, { oid: sha256.oid });\n * wrapped(new Uint8Array([1]));\n * ```\n */\nexport function createHasher(hashCons, info = {}) {\n    if (typeof hashCons !== 'function')\n        throw new TypeError('\"hashCons\" expected function, got type=' + typeof hashCons);\n    info = checkOpts({}, info, 'info');\n    const hashC = (msg, opts) => hashCons(opts)\n        .update(msg)\n        .digest();\n    const tmp = hashCons(undefined);\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.canXOF = tmp.canXOF;\n    hashC.create = (opts) => hashCons(opts);\n    Object.assign(hashC, info);\n    return Object.freeze(hashC);\n}\n/**\n * Cryptographically secure PRNG backed by `crypto.getRandomValues`.\n * @param bytesLength - number of random bytes to generate\n * @returns Random bytes.\n * The platform `getRandomValues()` implementation still defines any\n * single-call length cap, and this helper rejects oversize requests\n * with a stable library `RangeError` instead of host-specific errors.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @throws If the current runtime does not provide `crypto.getRandomValues`. {@link Error}\n * @example\n * Generate a fresh random key or nonce.\n * ```ts\n * const key = randomBytes(16);\n * ```\n */\nexport function randomBytes(bytesLength = 32) {\n    // Match the repo's other length-taking helpers instead of relying on Uint8Array coercion.\n    anumber(bytesLength, 'bytesLength');\n    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n    if (typeof cr?.getRandomValues !== 'function')\n        throw new Error('crypto.getRandomValues must be defined');\n    // Web Cryptography API Level 2 §10.1.1:\n    // if `byteLength > 65536`, throw `QuotaExceededError`.\n    // Keep the guard explicit so callers can see the quota in code\n    // instead of discovering it by reading the spec or host errors.\n    // This wrapper surfaces the same quota as a stable library RangeError.\n    if (bytesLength > 65536)\n        throw new RangeError(`\"bytesLength\" expected <= 65536, got ${bytesLength}`);\n    return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/**\n * Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.\n * @param suffix - final OID byte for the selected hash.\n *   The helper accepts any byte even though only the documented NIST hash\n *   suffixes are meaningful downstream.\n * @returns Object containing the DER-encoded OID.\n * @example\n * Build OID metadata for a NIST hash.\n * ```ts\n * oidNist(0x01);\n * ```\n */\nexport const oidNist = (suffix) => ({\n    // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.\n    // Larger suffix values would need base-128 OID encoding and a different length byte.\n    oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),\n});\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js

@@ -1,51 +0,0 @@
-//#region ../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
-var balanced = (a, b, str) => {
-	const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
-	const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-	const r = ma !== null && mb != null && range(ma, mb, str);
-	return r && {
-		start: r[0],
-		end: r[1],
-		pre: str.slice(0, r[0]),
-		body: str.slice(r[0] + ma.length, r[1]),
-		post: str.slice(r[1] + mb.length)
-	};
-};
-var maybeMatch = (reg, str) => {
-	const m = str.match(reg);
-	return m ? m[0] : null;
-};
-var range = (a, b, str) => {
-	let begs, beg, left, right = void 0, result;
-	let ai = str.indexOf(a);
-	let bi = str.indexOf(b, ai + 1);
-	let i = ai;
-	if (ai >= 0 && bi > 0) {
-		if (a === b) return [ai, bi];
-		begs = [];
-		left = str.length;
-		while (i >= 0 && !result) {
-			if (i === ai) {
-				begs.push(i);
-				ai = str.indexOf(a, i + 1);
-			} else if (begs.length === 1) {
-				const r = begs.pop();
-				if (r !== void 0) result = [r, bi];
-			} else {
-				beg = begs.pop();
-				if (beg !== void 0 && beg < left) {
-					left = beg;
-					right = bi;
-				}
-				bi = str.indexOf(b, i + 1);
-			}
-			i = ai < bi && ai >= 0 ? ai : bi;
-		}
-		if (begs.length && right !== void 0) result = [left, right];
-	}
-	return result;
-};
-//#endregion
-export { balanced, range };
-
-//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js"],"sourcesContent":["export const balanced = (a, b, str) => {\n    const ma = a instanceof RegExp ? maybeMatch(a, str) : a;\n    const mb = b instanceof RegExp ? maybeMatch(b, str) : b;\n    const r = ma !== null && mb != null && range(ma, mb, str);\n    return (r && {\n        start: r[0],\n        end: r[1],\n        pre: str.slice(0, r[0]),\n        body: str.slice(r[0] + ma.length, r[1]),\n        post: str.slice(r[1] + mb.length),\n    });\n};\nconst maybeMatch = (reg, str) => {\n    const m = str.match(reg);\n    return m ? m[0] : null;\n};\nexport const range = (a, b, str) => {\n    let begs, beg, left, right = undefined, result;\n    let ai = str.indexOf(a);\n    let bi = str.indexOf(b, ai + 1);\n    let i = ai;\n    if (ai >= 0 && bi > 0) {\n        if (a === b) {\n            return [ai, bi];\n        }\n        begs = [];\n        left = str.length;\n        while (i >= 0 && !result) {\n            if (i === ai) {\n                begs.push(i);\n                ai = str.indexOf(a, i + 1);\n            }\n            else if (begs.length === 1) {\n                const r = begs.pop();\n                if (r !== undefined)\n                    result = [r, bi];\n            }\n            else {\n                beg = begs.pop();\n                if (beg !== undefined && beg < left) {\n                    left = beg;\n                    right = bi;\n                }\n                bi = str.indexOf(b, i + 1);\n            }\n            i = ai < bi && ai >= 0 ? ai : bi;\n        }\n        if (begs.length && right !== undefined) {\n            result = [left, right];\n        }\n    }\n    return result;\n};\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,IAAa,YAAY,GAAG,GAAG,QAAQ;CACnC,MAAM,KAAK,aAAa,SAAS,WAAW,GAAG,GAAG,IAAI;CACtD,MAAM,KAAK,aAAa,SAAS,WAAW,GAAG,GAAG,IAAI;CACtD,MAAM,IAAI,OAAO,QAAQ,MAAM,QAAQ,MAAM,IAAI,IAAI,GAAG;CACxD,OAAQ,KAAK;EACT,OAAO,EAAE;EACT,KAAK,EAAE;EACP,KAAK,IAAI,MAAM,GAAG,EAAE,EAAE;EACtB,MAAM,IAAI,MAAM,EAAE,KAAK,GAAG,QAAQ,EAAE,EAAE;EACtC,MAAM,IAAI,MAAM,EAAE,KAAK,GAAG,MAAM;CACpC;AACJ;AACA,IAAM,cAAc,KAAK,QAAQ;CAC7B,MAAM,IAAI,IAAI,MAAM,GAAG;CACvB,OAAO,IAAI,EAAE,KAAK;AACtB;AACA,IAAa,SAAS,GAAG,GAAG,QAAQ;CAChC,IAAI,MAAM,KAAK,MAAM,QAAQ,KAAA,GAAW;CACxC,IAAI,KAAK,IAAI,QAAQ,CAAC;CACtB,IAAI,KAAK,IAAI,QAAQ,GAAG,KAAK,CAAC;CAC9B,IAAI,IAAI;CACR,IAAI,MAAM,KAAK,KAAK,GAAG;EACnB,IAAI,MAAM,GACN,OAAO,CAAC,IAAI,EAAE;EAElB,OAAO,CAAC;EACR,OAAO,IAAI;EACX,OAAO,KAAK,KAAK,CAAC,QAAQ;GACtB,IAAI,MAAM,IAAI;IACV,KAAK,KAAK,CAAC;IACX,KAAK,IAAI,QAAQ,GAAG,IAAI,CAAC;GAC7B,OACK,IAAI,KAAK,WAAW,GAAG;IACxB,MAAM,IAAI,KAAK,IAAI;IACnB,IAAI,MAAM,KAAA,GACN,SAAS,CAAC,GAAG,EAAE;GACvB,OACK;IACD,MAAM,KAAK,IAAI;IACf,IAAI,QAAQ,KAAA,KAAa,MAAM,MAAM;KACjC,OAAO;KACP,QAAQ;IACZ;IACA,KAAK,IAAI,QAAQ,GAAG,IAAI,CAAC;GAC7B;GACA,IAAI,KAAK,MAAM,MAAM,IAAI,KAAK;EAClC;EACA,IAAI,KAAK,UAAU,UAAU,KAAA,GACzB,SAAS,CAAC,MAAM,KAAK;CAE7B;CACA,OAAO;AACX"}

package/dist/node_modules/.pnpm/brace-expansion@5.0.11/node_modules/brace-expansion/dist/esm/index.js

@@ -1,202 +0,0 @@
-import { balanced } from "../../../../../balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js";
-//#region ../../node_modules/.pnpm/brace-expansion@5.0.11/node_modules/brace-expansion/dist/esm/index.js
-var escSlash = "\0SLASH" + Math.random() + "\0";
-var escOpen = "\0OPEN" + Math.random() + "\0";
-var escClose = "\0CLOSE" + Math.random() + "\0";
-var escComma = "\0COMMA" + Math.random() + "\0";
-var escPeriod = "\0PERIOD" + Math.random() + "\0";
-var escSlashPattern = new RegExp(escSlash, "g");
-var escOpenPattern = new RegExp(escOpen, "g");
-var escClosePattern = new RegExp(escClose, "g");
-var escCommaPattern = new RegExp(escComma, "g");
-var escPeriodPattern = new RegExp(escPeriod, "g");
-var slashPattern = /\\\\/g;
-var openPattern = /\\{/g;
-var closePattern = /\\}/g;
-var commaPattern = /\\,/g;
-var periodPattern = /\\\./g;
-var EXPANSION_MAX = 1e5;
-var EXPANSION_MAX_LENGTH = 4e6;
-var EXPANSION_MAX_DEPTH = 1e3;
-function numeric(str) {
-	return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-}
-function escapeBraces(str) {
-	return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str) {
-	return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-function pushAll(target, items) {
-	for (let i = 0; i < items.length; i++) target.push(items[i]);
-}
-/**
-* Basically just str.split(","), but handling cases
-* where we have nested braced sections, which should be
-* treated as individual members, like {a,{b,c},d}
-*/
-function parseCommaParts(str) {
-	const parts = [];
-	let carry = "";
-	for (;;) {
-		const m = balanced("{", "}", str);
-		if (!m) {
-			const tail = str.split(",");
-			tail[0] = carry + tail[0];
-			pushAll(parts, tail);
-			return parts;
-		}
-		const { pre, body, post } = m;
-		const p = pre.split(",");
-		p[0] = carry + p[0];
-		p[p.length - 1] += "{" + body + "}";
-		if (!post.length) {
-			pushAll(parts, p);
-			return parts;
-		}
-		carry = p.pop();
-		pushAll(parts, p);
-		str = post;
-	}
-}
-function expand(str, options = {}) {
-	if (!str) return [];
-	const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH, maxDepth = EXPANSION_MAX_DEPTH } = options;
-	if (str.slice(0, 2) === "{}") str = "\\{\\}" + str.slice(2);
-	return expand_(escapeBraces(str), max, maxLength, maxDepth, 0, true).map(unescapeBraces);
-}
-function embrace(str) {
-	return "{" + str + "}";
-}
-function isPadded(el) {
-	return /^-?0\d/.test(el);
-}
-function lte(i, y) {
-	return i <= y;
-}
-function gte(i, y) {
-	return i >= y;
-}
-function combine(acc, pre, values, max, maxLength, dropEmpties) {
-	const out = [];
-	let length = 0;
-	for (let a = 0; a < acc.length; a++) for (let v = 0; v < values.length; v++) {
-		if (out.length >= max) return out;
-		const expansion = acc[a] + pre + values[v];
-		if (dropEmpties && !expansion) continue;
-		if (length + expansion.length > maxLength) return out;
-		out.push(expansion);
-		length += expansion.length;
-	}
-	return out;
-}
-function expandSequence(body, isAlphaSequence, max, maxLength) {
-	const n = body.split(/\.\./);
-	const N = [];
-	/* c8 ignore start */
-	if (n[0] === void 0 || n[1] === void 0) return N;
-	/* c8 ignore stop */
-	const x = numeric(n[0]);
-	const y = numeric(n[1]);
-	const width = Math.max(n[0].length, n[1].length);
-	let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
-	let test = lte;
-	if (y < x) {
-		incr *= -1;
-		test = gte;
-	}
-	const pad = n.some(isPadded);
-	let length = 0;
-	for (let i = x; test(i, y) && N.length < max; i += incr) {
-		let c;
-		if (isAlphaSequence) {
-			c = String.fromCharCode(i);
-			if (c === "\\") c = "";
-		} else {
-			c = String(i);
-			if (pad) {
-				const need = width - c.length;
-				if (need > 0) {
-					const z = new Array(need + 1).join("0");
-					if (i < 0) c = "-" + z + c.slice(1);
-					else c = z + c;
-				}
-			}
-		}
-		if (length + c.length > maxLength) break;
-		N.push(c);
-		length += c.length;
-	}
-	return N;
-}
-function expand_(str, max, maxLength, maxDepth, depth, isTop) {
-	if (depth > maxDepth) return [str];
-	let acc = [""];
-	let dropEmpties = false;
-	let firstGroup = true;
-	for (;;) {
-		const m = balanced("{", "}", str);
-		if (!m) return combine(acc, str, [""], max, maxLength, dropEmpties);
-		const pre = m.pre;
-		if (/\$$/.test(pre)) {
-			acc = combine(acc, pre + "{" + m.body + "}", [""], max, maxLength, dropEmpties && !m.post.length);
-			firstGroup = false;
-			if (!m.post.length) break;
-			str = m.post;
-			continue;
-		}
-		const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-		const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-		const isSequence = isNumericSequence || isAlphaSequence;
-		const isOptions = m.body.indexOf(",") >= 0;
-		if (!isSequence && !isOptions) {
-			if (m.post.match(/,(?!,).*\}/)) {
-				str = m.pre + "{" + m.body + escClose + m.post;
-				isTop = true;
-				continue;
-			}
-			return combine(acc, pre + "{" + m.body + "}" + m.post, [""], max, maxLength, dropEmpties);
-		}
-		if (firstGroup) {
-			dropEmpties = isTop && !isSequence;
-			firstGroup = false;
-		}
-		let values;
-		if (isSequence) values = expandSequence(m.body, isAlphaSequence, max, maxLength);
-		else {
-			let n = parseCommaParts(m.body);
-			if (n.length === 1 && n[0] !== void 0) {
-				n = expand_(n[0], max, maxLength, maxDepth, depth + 1, false).map(embrace);
-				/* c8 ignore start */
-				if (n.length === 1) {
-					acc = combine(acc, pre + n[0], [""], max, maxLength, dropEmpties && !m.post.length);
-					if (!m.post.length) break;
-					str = m.post;
-					continue;
-				}
-			}
-			let dropsEmpties = dropEmpties && !m.post.length && !pre;
-			for (let d = 0; dropsEmpties && d < acc.length; d++) if (acc[d]) dropsEmpties = false;
-			values = [];
-			let valuesLength = 0;
-			outer: for (let j = 0; j < n.length; j++) {
-				const expanded = expand_(n[j], max, maxLength, maxDepth, depth + 1, false);
-				for (let k = 0; k < expanded.length; k++) {
-					const v = expanded[k];
-					if (dropsEmpties && !v) continue;
-					if (values.length >= max || valuesLength + v.length > maxLength) break outer;
-					values.push(v);
-					valuesLength += v.length;
-				}
-			}
-		}
-		acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
-		if (!m.post.length) break;
-		str = m.post;
-	}
-	return acc;
-}
-//#endregion
-export { EXPANSION_MAX, EXPANSION_MAX_DEPTH, EXPANSION_MAX_LENGTH, expand };
-
-//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/brace-expansion@5.0.11/node_modules/brace-expansion/dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/brace-expansion@5.0.11/node_modules/brace-expansion/dist/esm/index.js"],"sourcesContent":["import { balanced } from 'balanced-match';\nconst escSlash = '\\0SLASH' + Math.random() + '\\0';\nconst escOpen = '\\0OPEN' + Math.random() + '\\0';\nconst escClose = '\\0CLOSE' + Math.random() + '\\0';\nconst escComma = '\\0COMMA' + Math.random() + '\\0';\nconst escPeriod = '\\0PERIOD' + Math.random() + '\\0';\nconst escSlashPattern = new RegExp(escSlash, 'g');\nconst escOpenPattern = new RegExp(escOpen, 'g');\nconst escClosePattern = new RegExp(escClose, 'g');\nconst escCommaPattern = new RegExp(escComma, 'g');\nconst escPeriodPattern = new RegExp(escPeriod, 'g');\nconst slashPattern = /\\\\\\\\/g;\nconst openPattern = /\\\\{/g;\nconst closePattern = /\\\\}/g;\nconst commaPattern = /\\\\,/g;\nconst periodPattern = /\\\\\\./g;\nexport const EXPANSION_MAX = 100_000;\n// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An\n// input like `'{a,b}'.repeat(1500)` stays under that count - its output is\n// truncated to 100k results - while making every result ~1500 characters\n// long. The result set, and the intermediate arrays built while combining\n// brace sets, then grow large enough to exhaust memory and crash the process\n// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of\n// characters the accumulator may hold at any point, so memory stays flat no\n// matter how many brace groups are chained. The limit sits well above any\n// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M\n// characters) so legitimate input is unaffected.\nexport const EXPANSION_MAX_LENGTH = 4_000_000;\n// `expand_` recurses once per level of brace *nesting* - both when expanding a\n// set's comma members and when re-wrapping a set whose body is a single part.\n// The CVE-2026-14257 fix made the *tail* iterative (recursion on `m.post`, one\n// level per chained group), which left nesting depth unbounded: about 3,100\n// levels of `{{{...a,b...}}}` - only ~6KB of input - exhausted the native stack\n// and crashed the process. `EXPANSION_MAX_DEPTH` bounds how deep the parser\n// will follow nesting. It sits far above any realistic pattern and well below\n// the depth at which the stack runs out.\nexport const EXPANSION_MAX_DEPTH = 1_000;\nfunction numeric(str) {\n    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);\n}\nfunction escapeBraces(str) {\n    return str\n        .replace(slashPattern, escSlash)\n        .replace(openPattern, escOpen)\n        .replace(closePattern, escClose)\n        .replace(commaPattern, escComma)\n        .replace(periodPattern, escPeriod);\n}\nfunction unescapeBraces(str) {\n    return str\n        .replace(escSlashPattern, '\\\\')\n        .replace(escOpenPattern, '{')\n        .replace(escClosePattern, '}')\n        .replace(escCommaPattern, ',')\n        .replace(escPeriodPattern, '.');\n}\n// Like `target.push(...items)` but doesn't overflow the stack\nfunction pushAll(target, items) {\n    for (let i = 0; i < items.length; i++) {\n        target.push(items[i]);\n    }\n}\n/**\n * Basically just str.split(\",\"), but handling cases\n * where we have nested braced sections, which should be\n * treated as individual members, like {a,{b,c},d}\n */\nfunction parseCommaParts(str) {\n    const parts = [];\n    // Walk the brace groups iteratively. Recursing on `post` once per group let a\n    // chain of them exhaust the stack - the parsing-side counterpart to\n    // the `expand_` overflow fixed for CVE-2026-14257, and not something `max` or\n    // `maxLength` can bound, since it happens before expansion.\n    //\n    // The part the next chunk continues\n    let carry = '';\n    for (;;) {\n        const m = balanced('{', '}', str);\n        if (!m) {\n            const tail = str.split(',');\n            tail[0] = carry + tail[0];\n            pushAll(parts, tail);\n            return parts;\n        }\n        const { pre, body, post } = m;\n        const p = pre.split(',');\n        p[0] = carry + p[0];\n        p[p.length - 1] += '{' + body + '}';\n        if (!post.length) {\n            pushAll(parts, p);\n            return parts;\n        }\n        carry = p.pop();\n        pushAll(parts, p);\n        str = post;\n    }\n}\nexport function expand(str, options = {}) {\n    if (!str) {\n        return [];\n    }\n    const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH, maxDepth = EXPANSION_MAX_DEPTH, } = options;\n    // I don't know why Bash 4.3 does this, but it does.\n    // Anything starting with {} will have the first two bytes preserved\n    // but *only* at the top level, so {},a}b will not expand to anything,\n    // but a{},b}c will be expanded to [a}c,abc].\n    // One could argue that this is a bug in Bash, but since the goal of\n    // this module is to match Bash's rules, we escape a leading {}\n    if (str.slice(0, 2) === '{}') {\n        str = '\\\\{\\\\}' + str.slice(2);\n    }\n    return expand_(escapeBraces(str), max, maxLength, maxDepth, 0, true).map(unescapeBraces);\n}\nfunction embrace(str) {\n    return '{' + str + '}';\n}\nfunction isPadded(el) {\n    return /^-?0\\d/.test(el);\n}\nfunction lte(i, y) {\n    return i <= y;\n}\nfunction gte(i, y) {\n    return i >= y;\n}\n// Build `{ acc[a] + pre + values[v] }` for every combination, capping the\n// number of results at `max` and the total number of characters at `maxLength`.\n// This is the one place output grows, so bounding it here keeps the single\n// accumulator - and therefore memory - flat regardless of how many brace groups\n// are combined (CVE-2026-14257).\nfunction combine(acc, pre, values, max, maxLength, dropEmpties) {\n    const out = [];\n    let length = 0;\n    for (let a = 0; a < acc.length; a++) {\n        for (let v = 0; v < values.length; v++) {\n            if (out.length >= max)\n                return out;\n            const expansion = acc[a] + pre + values[v];\n            // Bash drops empty results at the top level. Skip them before they count\n            // against `max`, so `max` bounds the number of *kept* results.\n            if (dropEmpties && !expansion)\n                continue;\n            if (length + expansion.length > maxLength)\n                return out;\n            out.push(expansion);\n            length += expansion.length;\n        }\n    }\n    return out;\n}\n// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)\n// sequence body.\nfunction expandSequence(body, isAlphaSequence, max, maxLength) {\n    const n = body.split(/\\.\\./);\n    const N = [];\n    // A sequence body always splits into two or three parts, but the compiler\n    // can't know that.\n    /* c8 ignore start */\n    if (n[0] === undefined || n[1] === undefined) {\n        return N;\n    }\n    /* c8 ignore stop */\n    const x = numeric(n[0]);\n    const y = numeric(n[1]);\n    const width = Math.max(n[0].length, n[1].length);\n    let incr = n.length === 3 && n[2] !== undefined ?\n        Math.max(Math.abs(numeric(n[2])), 1)\n        : 1;\n    let test = lte;\n    const reverse = y < x;\n    if (reverse) {\n        incr *= -1;\n        test = gte;\n    }\n    const pad = n.some(isPadded);\n    let length = 0;\n    for (let i = x; test(i, y) && N.length < max; i += incr) {\n        let c;\n        if (isAlphaSequence) {\n            c = String.fromCharCode(i);\n            if (c === '\\\\') {\n                c = '';\n            }\n        }\n        else {\n            c = String(i);\n            if (pad) {\n                const need = width - c.length;\n                if (need > 0) {\n                    const z = new Array(need + 1).join('0');\n                    if (i < 0) {\n                        c = '-' + z + c.slice(1);\n                    }\n                    else {\n                        c = z + c;\n                    }\n                }\n            }\n        }\n        if (length + c.length > maxLength)\n            break;\n        N.push(c);\n        length += c.length;\n    }\n    return N;\n}\nfunction expand_(str, max, maxLength, maxDepth, depth, isTop) {\n    // Too deeply nested to keep following: treat the rest as literal, the same\n    // way a group that cannot expand is already handled. Truncating rather than\n    // throwing keeps `expand` total, matching `max` and `maxLength`.\n    if (depth > maxDepth) {\n        return [str];\n    }\n    // Consume the string's top-level brace groups left to right, threading a\n    // running set of combined prefixes (`acc`). Expanding the tail iteratively -\n    // rather than recursing on `m.post` once per group - keeps the native stack\n    // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no\n    // longer overflow the stack, and leaves a single accumulator whose size\n    // `maxLength` bounds directly (CVE-2026-14257).\n    let acc = [''];\n    // Bash drops empty results, but only when the *first* top-level group is a\n    // comma set - a sequence like `{a..\\}` may legitimately yield ''. The drop\n    // is on the final strings, so it is applied to whichever `combine` produces\n    // them (the one with no brace set left in the tail).\n    let dropEmpties = false;\n    let firstGroup = true;\n    for (;;) {\n        const m = balanced('{', '}', str);\n        // No brace set left: the rest of the string is literal.\n        if (!m) {\n            return combine(acc, str, [''], max, maxLength, dropEmpties);\n        }\n        // no need to expand pre, since it is guaranteed to be free of brace-sets\n        const pre = m.pre;\n        if (/\\$$/.test(pre)) {\n            acc = combine(acc, pre + '{' + m.body + '}', [''], max, maxLength, dropEmpties && !m.post.length);\n            firstGroup = false;\n            if (!m.post.length)\n                break;\n            str = m.post;\n            continue;\n        }\n        const isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n        const isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n        const isSequence = isNumericSequence || isAlphaSequence;\n        const isOptions = m.body.indexOf(',') >= 0;\n        if (!isSequence && !isOptions) {\n            // {a},b}\n            if (m.post.match(/,(?!,).*\\}/)) {\n                str = m.pre + '{' + m.body + escClose + m.post;\n                isTop = true;\n                continue;\n            }\n            // Nothing here expands, so the whole remaining string is literal.\n            return combine(acc, pre + '{' + m.body + '}' + m.post, [''], max, maxLength, dropEmpties);\n        }\n        if (firstGroup) {\n            dropEmpties = isTop && !isSequence;\n            firstGroup = false;\n        }\n        let values;\n        if (isSequence) {\n            values = expandSequence(m.body, isAlphaSequence, max, maxLength);\n        }\n        else {\n            let n = parseCommaParts(m.body);\n            if (n.length === 1 && n[0] !== undefined) {\n                // x{{a,b}}y ==> x{a}y x{b}y\n                n = expand_(n[0], max, maxLength, maxDepth, depth + 1, false).map(embrace);\n                //XXX is this necessary? Can't seem to hit it in tests.\n                /* c8 ignore start */\n                if (n.length === 1) {\n                    acc = combine(acc, pre + n[0], [''], max, maxLength, dropEmpties && !m.post.length);\n                    if (!m.post.length)\n                        break;\n                    str = m.post;\n                    continue;\n                }\n                /* c8 ignore stop */\n            }\n            // Values that `combine` is going to drop as empty produce no result, so\n            // they must not count against `max` - otherwise `{a,,b}` with `max: 2`\n            // would stop at `['a', '']` and yield one result instead of two. Skipping\n            // them outright keeps `values` bounded while leaving `max` a bound on\n            // *kept* results.\n            let dropsEmpties = dropEmpties && !m.post.length && !pre;\n            for (let d = 0; dropsEmpties && d < acc.length; d++) {\n                if (acc[d]) {\n                    dropsEmpties = false;\n                }\n            }\n            values = [];\n            let valuesLength = 0;\n            outer: for (let j = 0; j < n.length; j++) {\n                const expanded = expand_(n[j], max, maxLength, maxDepth, depth + 1, false);\n                for (let k = 0; k < expanded.length; k++) {\n                    const v = expanded[k];\n                    if (dropsEmpties && !v)\n                        continue;\n                    if (values.length >= max ||\n                        valuesLength + v.length > maxLength) {\n                        break outer;\n                    }\n                    values.push(v);\n                    valuesLength += v.length;\n                }\n            }\n        }\n        acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);\n        if (!m.post.length)\n            break;\n        str = m.post;\n    }\n    return acc;\n}\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/.pnpm/minimatch@10.2.6/node_modules/minimatch/dist/esm/assert-valid-pattern.js

@@ -1,10 +0,0 @@
-//#region ../../node_modules/.pnpm/minimatch@10.2.6/node_modules/minimatch/dist/esm/assert-valid-pattern.js
-var MAX_PATTERN_LENGTH = 1024 * 64;
-var assertValidPattern = (pattern) => {
-	if (typeof pattern !== "string") throw new TypeError("invalid pattern");
-	if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
-};
-//#endregion
-export { assertValidPattern };
-
-//# sourceMappingURL=assert-valid-pattern.js.map

package/dist/node_modules/.pnpm/minimatch@10.2.6/node_modules/minimatch/dist/esm/assert-valid-pattern.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert-valid-pattern.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/minimatch@10.2.6/node_modules/minimatch/dist/esm/assert-valid-pattern.js"],"sourcesContent":["const MAX_PATTERN_LENGTH = 1024 * 64;\nexport const assertValidPattern = (pattern) => {\n    if (typeof pattern !== 'string') {\n        throw new TypeError('invalid pattern');\n    }\n    if (pattern.length > MAX_PATTERN_LENGTH) {\n        throw new TypeError('pattern is too long');\n    }\n};\n//# sourceMappingURL=assert-valid-pattern.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,IAAM,qBAAqB,OAAO;AAClC,IAAa,sBAAsB,YAAY;CAC3C,IAAI,OAAO,YAAY,UACnB,MAAM,IAAI,UAAU,iBAAiB;CAEzC,IAAI,QAAQ,SAAS,oBACjB,MAAM,IAAI,UAAU,qBAAqB;AAEjD"}