{"version":3,"file":"index-BoAXwWJx.js","sources":["../../../../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/_assert.js","../../../../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/_u64.js","../../../../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/crypto.js","../../../../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/utils.js","../../../../../node_modules/.pnpm/@noble+hashes@1.3.3/node_modules/@noble/hashes/sha3.js","../../../../../node_modules/.pnpm/@paralleldrive+cuid2@2.2.2/node_modules/@paralleldrive/cuid2/src/index.js","../../../../../node_modules/.pnpm/@paralleldrive+cuid2@2.2.2/node_modules/@paralleldrive/cuid2/index.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;\nfunction number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nexports.number = number;\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nexports.bool = bool;\n// copied from utils\nfunction isBytes(a) {\n    return (a instanceof Uint8Array ||\n        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));\n}\nfunction bytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nexports.bytes = bytes;\nfunction hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nexports.hash = hash;\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nexports.exists = exists;\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexports.output = output;\nconst assert = { number, bool, bytes, hash, exists, output };\nexports.default = assert;\n//# sourceMappingURL=_assert.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.add5L = exports.add5H = exports.add4H = exports.add4L = exports.add3H = exports.add3L = exports.add = exports.rotlBL = exports.rotlBH = exports.rotlSL = exports.rotlSH = exports.rotr32L = exports.rotr32H = exports.rotrBL = exports.rotrBH = exports.rotrSL = exports.rotrSH = exports.shrSL = exports.shrSH = exports.toBig = exports.split = exports.fromBig = void 0;\nconst U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\n// We are not using BigUint64Array, because they are extremely slow as per 2022\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\nexports.fromBig = fromBig;\nfunction split(lst, le = false) {\n    let Ah = new Uint32Array(lst.length);\n    let Al = new Uint32Array(lst.length);\n    for (let i = 0; i < lst.length; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nexports.split = split;\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\nexports.toBig = toBig;\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nexports.shrSH = shrSH;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\nexports.shrSL = shrSL;\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nexports.rotrSH = rotrSH;\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\nexports.rotrSL = rotrSL;\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nexports.rotrBH = rotrBH;\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\nexports.rotrBL = rotrBL;\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nexports.rotr32H = rotr32H;\nconst rotr32L = (h, _l) => h;\nexports.rotr32L = rotr32L;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nexports.rotlSH = rotlSH;\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\nexports.rotlSL = rotlSL;\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nexports.rotlBH = rotlBH;\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\nexports.rotlBL = rotlBL;\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\nexports.add = add;\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nexports.add3L = add3L;\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nexports.add3H = add3H;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nexports.add4L = add4L;\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nexports.add4H = add4H;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nexports.add5L = add5L;\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\nexports.add5H = add5H;\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexports.default = u64;\n//# sourceMappingURL=_u64.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.crypto = void 0;\nexports.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n//# sourceMappingURL=crypto.js.map","\"use strict\";\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.randomBytes = exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nconst crypto_1 = require(\"@noble/hashes/crypto\");\n// Cast array to different type\nconst u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.u8 = u8;\nconst u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\nexports.u32 = u32;\nfunction isBytes(a) {\n    return (a instanceof Uint8Array ||\n        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));\n}\n// Cast array to view\nconst createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\nexports.createView = createView;\n// The rotate right (circular right shift) operation for uint32\nconst rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\nexports.rotr = rotr;\n// big-endian hardware is rare. Just in case someone still decides to run hashes:\n// early-throw an error because we don't support BE yet.\n// Other libraries would silently corrupt the data instead of throwing an error,\n// when they don't support it.\nexports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\nif (!exports.isLE)\n    throw new Error('Non little-endian hardware is not supported');\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 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nfunction bytesToHex(bytes) {\n    if (!isBytes(bytes))\n        throw new Error('Uint8Array expected');\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}\nexports.bytesToHex = bytesToHex;\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };\nfunction asciiToBase16(char) {\n    if (char >= asciis._0 && char <= asciis._9)\n        return char - asciis._0;\n    if (char >= asciis._A && char <= asciis._F)\n        return char - (asciis._A - 10);\n    if (char >= asciis._a && char <= asciis._f)\n        return char - (asciis._a - 10);\n    return;\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nfunction hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('padded 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));\n        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n        if (n1 === undefined || n2 === undefined) {\n            const char = hex[hi] + hex[hi + 1];\n            throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n        }\n        array[ai] = n1 * 16 + n2;\n    }\n    return array;\n}\nexports.hexToBytes = hexToBytes;\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nconst nextTick = async () => { };\nexports.nextTick = nextTick;\n// Returns control to thread each 'tick' ms to avoid blocking\nasync function asyncLoop(iters, tick, cb) {\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 (0, exports.nextTick)();\n        ts += diff;\n    }\n}\nexports.asyncLoop = asyncLoop;\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nfunction utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\nexports.utf8ToBytes = utf8ToBytes;\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nfunction toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!isBytes(data))\n        throw new Error(`expected Uint8Array, got ${typeof data}`);\n    return data;\n}\nexports.toBytes = toBytes;\n/**\n * Copies several Uint8Arrays into one.\n */\nfunction concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        if (!isBytes(a))\n            throw new Error('Uint8Array expected');\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}\nexports.concatBytes = concatBytes;\n// For runtime check if class implements interface\nclass Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nexports.Hash = Hash;\nconst toStr = {}.toString;\nfunction checkOpts(defaults, opts) {\n    if (opts !== undefined && toStr.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexports.checkOpts = checkOpts;\nfunction wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexports.wrapConstructor = wrapConstructor;\nfunction wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexports.wrapConstructorWithOpts = wrapConstructorWithOpts;\nfunction wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nfunction randomBytes(bytesLength = 32) {\n    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {\n        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\nexports.randomBytes = randomBytes;\n//# sourceMappingURL=utils.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.shake256 = exports.shake128 = exports.keccak_512 = exports.keccak_384 = exports.keccak_256 = exports.keccak_224 = exports.sha3_512 = exports.sha3_384 = exports.sha3_256 = exports.sha3_224 = exports.Keccak = exports.keccakP = void 0;\nconst _assert_js_1 = require(\"./_assert.js\");\nconst _u64_js_1 = require(\"./_u64.js\");\nconst utils_js_1 = require(\"./utils.js\");\n// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.\n// It's called a sponge function.\n// Various per round constants calculations\nconst [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nconst _7n = /* @__PURE__ */ BigInt(7);\nconst _256n = /* @__PURE__ */ BigInt(256);\nconst _0x71n = /* @__PURE__ */ BigInt(0x71);\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\n    // Pi\n    [x, y] = [y, (2 * x + 3 * y) % 5];\n    SHA3_PI.push(2 * (5 * y + x));\n    // Rotational\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\n    // Iota\n    let t = _0n;\n    for (let j = 0; j < 7; j++) {\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\n        if (R & _2n)\n            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);\n    }\n    _SHA3_IOTA.push(t);\n}\nconst [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ (0, _u64_js_1.split)(_SHA3_IOTA, true);\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? (0, _u64_js_1.rotlBH)(h, l, s) : (0, _u64_js_1.rotlSH)(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? (0, _u64_js_1.rotlBL)(h, l, s) : (0, _u64_js_1.rotlSL)(h, l, s));\n// Same as keccakf1600, but allows to skip some rounds\nfunction keccakP(s, rounds = 24) {\n    const B = new Uint32Array(5 * 2);\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\n    for (let round = 24 - rounds; round < 24; round++) {\n        // Theta θ\n        for (let x = 0; x < 10; x++)\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\n        for (let x = 0; x < 10; x += 2) {\n            const idx1 = (x + 8) % 10;\n            const idx0 = (x + 2) % 10;\n            const B0 = B[idx0];\n            const B1 = B[idx0 + 1];\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\n            for (let y = 0; y < 50; y += 10) {\n                s[x + y] ^= Th;\n                s[x + y + 1] ^= Tl;\n            }\n        }\n        // Rho (ρ) and Pi (π)\n        let curH = s[2];\n        let curL = s[3];\n        for (let t = 0; t < 24; t++) {\n            const shift = SHA3_ROTL[t];\n            const Th = rotlH(curH, curL, shift);\n            const Tl = rotlL(curH, curL, shift);\n            const PI = SHA3_PI[t];\n            curH = s[PI];\n            curL = s[PI + 1];\n            s[PI] = Th;\n            s[PI + 1] = Tl;\n        }\n        // Chi (χ)\n        for (let y = 0; y < 50; y += 10) {\n            for (let x = 0; x < 10; x++)\n                B[x] = s[y + x];\n            for (let x = 0; x < 10; x++)\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\n        }\n        // Iota (ι)\n        s[0] ^= SHA3_IOTA_H[round];\n        s[1] ^= SHA3_IOTA_L[round];\n    }\n    B.fill(0);\n}\nexports.keccakP = keccakP;\nclass Keccak extends utils_js_1.Hash {\n    // NOTE: we accept arguments in bytes instead of bits here.\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\n        super();\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        // Can be passed from user as dkLen\n        (0, _assert_js_1.number)(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        if (0 >= this.blockLen || this.blockLen >= 200)\n            throw new Error('Sha3 supports only keccak-f1600 function');\n        this.state = new Uint8Array(200);\n        this.state32 = (0, utils_js_1.u32)(this.state);\n    }\n    keccak() {\n        keccakP(this.state32, this.rounds);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        (0, _assert_js_1.exists)(this);\n        const { blockLen, state } = this;\n        data = (0, utils_js_1.toBytes)(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            for (let i = 0; i < take; i++)\n                state[this.pos++] ^= data[pos++];\n            if (this.pos === blockLen)\n                this.keccak();\n        }\n        return this;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        const { state, suffix, pos, blockLen } = this;\n        // Do the padding\n        state[pos] ^= suffix;\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\n            this.keccak();\n        state[blockLen - 1] ^= 0x80;\n        this.keccak();\n    }\n    writeInto(out) {\n        (0, _assert_js_1.exists)(this, false);\n        (0, _assert_js_1.bytes)(out);\n        this.finish();\n        const bufferOut = this.state;\n        const { blockLen } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.keccak();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible for this instance');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        (0, _assert_js_1.number)(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        (0, _assert_js_1.output)(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.writeInto(out);\n        this.destroy();\n        return out;\n    }\n    digest() {\n        return this.digestInto(new Uint8Array(this.outputLen));\n    }\n    destroy() {\n        this.destroyed = true;\n        this.state.fill(0);\n    }\n    _cloneInto(to) {\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\n        to.state32.set(this.state32);\n        to.pos = this.pos;\n        to.posOut = this.posOut;\n        to.finished = this.finished;\n        to.rounds = rounds;\n        // Suffix can change in cSHAKE\n        to.suffix = suffix;\n        to.outputLen = outputLen;\n        to.enableXOF = enableXOF;\n        to.destroyed = this.destroyed;\n        return to;\n    }\n}\nexports.Keccak = Keccak;\nconst gen = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapConstructor)(() => new Keccak(blockLen, suffix, outputLen));\nexports.sha3_224 = gen(0x06, 144, 224 / 8);\n/**\n * SHA3-256 hash function\n * @param message - that would be hashed\n */\nexports.sha3_256 = gen(0x06, 136, 256 / 8);\nexports.sha3_384 = gen(0x06, 104, 384 / 8);\nexports.sha3_512 = gen(0x06, 72, 512 / 8);\nexports.keccak_224 = gen(0x01, 144, 224 / 8);\n/**\n * keccak-256 hash function. Different from SHA3-256.\n * @param message - that would be hashed\n */\nexports.keccak_256 = gen(0x01, 136, 256 / 8);\nexports.keccak_384 = gen(0x01, 104, 384 / 8);\nexports.keccak_512 = gen(0x01, 72, 512 / 8);\nconst genShake = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapXOFConstructorWithOpts)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\nexports.shake128 = genShake(0x1f, 168, 128 / 8);\nexports.shake256 = genShake(0x1f, 136, 256 / 8);\n//# sourceMappingURL=sha3.js.map","/* global global, window, module */\nconst { sha3_512: sha3 } = require(\"@noble/hashes/sha3\");\n\nconst defaultLength = 24;\nconst bigLength = 32;\n\nconst createEntropy = (length = 4, random = Math.random) => {\n  let entropy = \"\";\n\n  while (entropy.length < length) {\n    entropy = entropy + Math.floor(random() * 36).toString(36);\n  }\n  return entropy;\n};\n\n/*\n * Adapted from https://github.com/juanelas/bigint-conversion\n * MIT License Copyright (c) 2018 Juan Hernández Serrano\n */\nfunction bufToBigInt(buf) {\n  let bits = 8n;\n\n  let value = 0n;\n  for (const i of buf.values()) {\n    const bi = BigInt(i);\n    value = (value << bits) + bi;\n  }\n  return value;\n}\n\nconst hash = (input = \"\") => {\n  // Drop the first character because it will bias the histogram\n  // to the left.\n  return bufToBigInt(sha3(input)).toString(36).slice(1);\n};\n\nconst alphabet = Array.from({ length: 26 }, (x, i) =>\n  String.fromCharCode(i + 97)\n);\n\nconst randomLetter = (random) =>\n  alphabet[Math.floor(random() * alphabet.length)];\n\n/*\nThis is a fingerprint of the host environment. It is used to help\nprevent collisions when generating ids in a distributed system.\nIf no global object is available, you can pass in your own, or fall back\non a random string.\n*/\nconst createFingerprint = ({\n  globalObj = typeof global !== \"undefined\"\n    ? global\n    : typeof window !== \"undefined\"\n    ? window\n    : {},\n  random = Math.random,\n} = {}) => {\n  const globals = Object.keys(globalObj).toString();\n  const sourceString = globals.length\n    ? globals + createEntropy(bigLength, random)\n    : createEntropy(bigLength, random);\n\n  return hash(sourceString).substring(0, bigLength);\n};\n\nconst createCounter = (count) => () => {\n  return count++;\n};\n\n// ~22k hosts before 50% chance of initial counter collision\n// with a remaining counter range of 9.0e+15 in JavaScript.\nconst initialCountMax = 476782367;\n\nconst init = ({\n  // Fallback if the user does not pass in a CSPRNG. This should be OK\n  // because we don't rely solely on the random number generator for entropy.\n  // We also use the host fingerprint, current time, and a session counter.\n  random = Math.random,\n  counter = createCounter(Math.floor(random() * initialCountMax)),\n  length = defaultLength,\n  fingerprint = createFingerprint({ random }),\n} = {}) => {\n  return function cuid2() {\n    const firstLetter = randomLetter(random);\n\n    // If we're lucky, the `.toString(36)` calls may reduce hashing rounds\n    // by shortening the input to the hash function a little.\n    const time = Date.now().toString(36);\n    const count = counter().toString(36);\n\n    // The salt should be long enough to be globally unique across the full\n    // length of the hash. For simplicity, we use the same length as the\n    // intended id output.\n    const salt = createEntropy(length, random);\n    const hashInput = `${time + salt + count + fingerprint}`;\n\n    return `${firstLetter + hash(hashInput).substring(1, length)}`;\n  };\n};\n\nconst createId = init();\n\nconst isCuid = (id, { minLength = 2, maxLength = bigLength } = {}) => {\n  const length = id.length;\n  const regex = /^[0-9a-z]+$/;\n\n  try {\n    if (\n      typeof id === \"string\" &&\n      length >= minLength &&\n      length <= maxLength &&\n      regex.test(id)\n    )\n      return true;\n  } finally {\n  }\n\n  return false;\n};\n\nmodule.exports.getConstants = () => ({ defaultLength, bigLength });\nmodule.exports.init = init;\nmodule.exports.createId = createId;\nmodule.exports.bufToBigInt = bufToBigInt;\nmodule.exports.createCounter = createCounter;\nmodule.exports.createFingerprint = createFingerprint;\nmodule.exports.isCuid = isCuid;\n","const { createId, init, getConstants, isCuid } = require(\"./src/index\");\n\nmodule.exports.createId = createId;\nmodule.exports.init = init;\nmodule.exports.getConstants = getConstants;\nmodule.exports.isCuid = isCuid;\n"],"names":["number","n","Number","isSafeInteger","Error","_assert","bool","b","isBytes","a","Uint8Array","constructor","name","bytes","lengths","length","includes","hash","create","outputLen","blockLen","exists","instance","checkFinished","destroyed","finished","output","out","min","assert","exports","U32_MASK64","BigInt","_32n","fromBig","le","h","l","_u64","split","lst","Ah","Uint32Array","Al","i","toBig","shrSH","_l","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","rotr32H","_h","rotr32L","rotlSH","rotlSL","rotlBH","rotlBL","add","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5L","El","add5H","Eh","u64","globalThis","crypto","undefined","crypto_1","require","u8","arr","buffer","byteOffset","byteLength","u32","Math","floor","createView","DataView","rotr","word","shift","isLE","hexes","Array","from","_","toString","padStart","bytesToHex","hex","asciis","_0","_9","_A","_F","_a","_f","asciiToBase16","char","hexToBytes","hl","al","array","ai","hi","n1","charCodeAt","n2","nextTick","asyncLoop","iters","tick","cb","ts","Date","now","diff","utf8ToBytes","str","TextEncoder","encode","toBytes","data","concatBytes","arrays","sum","res","pad","set","Hash","clone","_cloneInto","toStr","checkOpts","defaults","opts","call","Object","assign","wrapConstructor","hashCons","hashC","msg","update","digest","tmp","wrapConstructorWithOpts","wrapXOFConstructorWithOpts","randomBytes","bytesLength","getRandomValues","_assert_js_1","_u64_js_1","utils_js_1","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","_0n","_1n","_2n","_7n","_256n","_0x71n","round","R","x","y","push","t","j","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","rotlL","keccakP","rounds","B","idx1","idx0","B0","B1","Th","Tl","curH","curL","PI","fill","sha3","Keccak","suffix","enableXOF","pos","posOut","state","state32","keccak","len","take","finish","writeInto","bufferOut","subarray","xofInto","xof","digestInto","destroy","to","gen","genShake","dkLen","sha3_512","defaultLength","bigLength","createEntropy","random","entropy","bufToBigInt","buf","bits","value","values","bi","input","slice","alphabet","String","fromCharCode","randomLetter","createFingerprint","globalObj","global","window","globals","keys","sourceString","substring","createCounter","count","initialCountMax","init","counter","fingerprint","firstLetter","time","salt","hashInput","createId","isCuid","id","minLength","maxLength","regex","test","module","src","getConstants","createId_1"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6]}