3x-ui/web/public/assets/otpauth/otpauth.umd.min.js.147b92d3.map

{"version":3,"file":"otpauth.umd.min.js","sources":["../node_modules/@noble/hashes/esm/utils.js","../node_modules/@noble/hashes/esm/hmac.js","../node_modules/@noble/hashes/esm/_md.js","../node_modules/@noble/hashes/esm/legacy.js","../node_modules/@noble/hashes/esm/_u64.js","../node_modules/@noble/hashes/esm/sha2.js","../node_modules/@noble/hashes/esm/sha3.js","../src/internal/global-scope.js","../src/internal/crypto/hmac-digest.js","../src/internal/encoding/base32.js","../src/internal/encoding/hex.js","../src/internal/encoding/latin1.js","../src/internal/encoding/utf8.js","../src/secret.js","../src/internal/crypto/random-bytes.js","../src/hotp.js","../src/internal/encoding/uint.js","../src/internal/crypto/timing-safe-equal.js","../src/totp.js","../src/uri.js","../src/version.js"],"sourcesContent":["/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\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.\nimport { crypto } from '@noble/hashes/crypto';\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a) {\n    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is positive integer. */\nexport function anumber(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error('positive integer expected, got ' + n);\n}\n/** Asserts something is Uint8Array. */\nexport function abytes(b, ...lengths) {\n    if (!isBytes(b))\n        throw new Error('Uint8Array expected');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n/** Asserts something is hash */\nexport function ahash(h) {\n    if (typeof h !== 'function' || typeof h.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.createHasher');\n    anumber(h.outputLen);\n    anumber(h.blockLen);\n}\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(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}\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out, instance) {\n    abytes(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}\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word, shift) {\n    return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word, shift) {\n    return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/** The byte swap operation for uint32 */\nexport function byteSwap(word) {\n    return (((word << 24) & 0xff000000) |\n        ((word << 8) & 0xff0000) |\n        ((word >>> 8) & 0xff00) |\n        ((word >>> 24) & 0xff));\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n);\n/** @deprecated */\nexport const byteSwapIfBE = swap8IfBE;\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr) {\n    for (let i = 0; i < arr.length; i++) {\n        arr[i] = byteSwap(arr[i]);\n    }\n    return arr;\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. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\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// 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(ch) {\n    if (ch >= asciis._0 && ch <= asciis._9)\n        return ch - asciis._0; // '2' => 50-48\n    if (ch >= asciis.A && ch <= asciis.F)\n        return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n    if (ch >= asciis.a && ch <= asciis.f)\n        return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n    return;\n}\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return Uint8Array.fromHex(hex);\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new Error('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; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n    }\n    return array;\n}\n/**\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.\n */\nexport const nextTick = async () => { };\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async 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 nextTick();\n        ts += diff;\n    }\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\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 */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    abytes(data);\n    return data;\n}\n/** Copies several Uint8Arrays into one. */\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}\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && {}.toString.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}\n/** For runtime check if class implements interface */\nexport class Hash {\n}\n/** Wraps hash function, creating an interface on top of it */\nexport function createHasher(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}\nexport function createOptHasher(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}\nexport function createXOFer(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}\nexport const wrapConstructor = createHasher;\nexport const wrapConstructorWithOpts = createOptHasher;\nexport const wrapXOFConstructorWithOpts = createXOFer;\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    // Legacy Node.js compatibility\n    if (crypto && typeof crypto.randomBytes === 'function') {\n        return Uint8Array.from(crypto.randomBytes(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map","/**\n * HMAC: RFC2104 message authentication code.\n * @module\n */\nimport { abytes, aexists, ahash, clean, Hash, toBytes } from \"./utils.js\";\nexport class HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        ahash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        clean(pad);\n    }\n    update(buf) {\n        aexists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        abytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n * @example\n * import { hmac } from '@noble/hashes/hmac';\n * import { sha256 } from '@noble/hashes/sha2';\n * const mac1 = hmac(sha256, 'key', 'message');\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { Hash, abytes, aexists, aoutput, clean, createView, toBytes } from \"./utils.js\";\n/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */\nexport function setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n/** Choice: a ? b : c */\nexport function Chi(a, b, c) {\n    return (a & b) ^ (~a & c);\n}\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a, b, c) {\n    return (a & b) ^ (a & c) ^ (b & c);\n}\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport class HashMD extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        aexists(this);\n        data = toBytes(data);\n        abytes(data);\n        const { view, buffer, blockLen } = this;\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        clean(this.buffer.subarray(pos));\n        // we have less than padOffset left in buffer, so we cannot put length in\n        // current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.destroyed = destroyed;\n        to.finished = finished;\n        to.length = length;\n        to.pos = pos;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n    clone() {\n        return this._cloneInto();\n    }\n}\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV = /* @__PURE__ */ Uint32Array.from([\n    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\nexport const SHA384_IV = /* @__PURE__ */ Uint32Array.from([\n    0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n    0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */\nexport const SHA512_IV = /* @__PURE__ */ Uint32Array.from([\n    0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n    0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n//# sourceMappingURL=_md.js.map","/**\n\nSHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.\nDon't use them in a new protocol. What \"weak\" means:\n\n- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.\n- No practical pre-image attacks (only theoretical, 2^123.4)\n- HMAC seems kinda ok: https://datatracker.ietf.org/doc/html/rfc6151\n * @module\n */\nimport { Chi, HashMD, Maj } from \"./_md.js\";\nimport { clean, createHasher, rotl } from \"./utils.js\";\n/** Initial SHA1 state */\nconst SHA1_IV = /* @__PURE__ */ Uint32Array.from([\n    0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0,\n]);\n// Reusable temporary buffer\nconst SHA1_W = /* @__PURE__ */ new Uint32Array(80);\n/** SHA1 legacy hash class. */\nexport class SHA1 extends HashMD {\n    constructor() {\n        super(64, 20, 8, false);\n        this.A = SHA1_IV[0] | 0;\n        this.B = SHA1_IV[1] | 0;\n        this.C = SHA1_IV[2] | 0;\n        this.D = SHA1_IV[3] | 0;\n        this.E = SHA1_IV[4] | 0;\n    }\n    get() {\n        const { A, B, C, D, E } = this;\n        return [A, B, C, D, E];\n    }\n    set(A, B, C, D, E) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA1_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 80; i++)\n            SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);\n        // Compression function main loop, 80 rounds\n        let { A, B, C, D, E } = this;\n        for (let i = 0; i < 80; i++) {\n            let F, K;\n            if (i < 20) {\n                F = Chi(B, C, D);\n                K = 0x5a827999;\n            }\n            else if (i < 40) {\n                F = B ^ C ^ D;\n                K = 0x6ed9eba1;\n            }\n            else if (i < 60) {\n                F = Maj(B, C, D);\n                K = 0x8f1bbcdc;\n            }\n            else {\n                F = B ^ C ^ D;\n                K = 0xca62c1d6;\n            }\n            const T = (rotl(A, 5) + F + E + K + SHA1_W[i]) | 0;\n            E = D;\n            D = C;\n            C = rotl(B, 30);\n            B = A;\n            A = T;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        this.set(A, B, C, D, E);\n    }\n    roundClean() {\n        clean(SHA1_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\n/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */\nexport const sha1 = /* @__PURE__ */ createHasher(() => new SHA1());\n/** Per-round constants */\nconst p32 = /* @__PURE__ */ Math.pow(2, 32);\nconst K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));\n/** md5 initial state: same as sha1, but 4 u32 instead of 5. */\nconst MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);\n// Reusable temporary buffer\nconst MD5_W = /* @__PURE__ */ new Uint32Array(16);\n/** MD5 legacy hash class. */\nexport class MD5 extends HashMD {\n    constructor() {\n        super(64, 16, 8, true);\n        this.A = MD5_IV[0] | 0;\n        this.B = MD5_IV[1] | 0;\n        this.C = MD5_IV[2] | 0;\n        this.D = MD5_IV[3] | 0;\n    }\n    get() {\n        const { A, B, C, D } = this;\n        return [A, B, C, D];\n    }\n    set(A, B, C, D) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            MD5_W[i] = view.getUint32(offset, true);\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D } = this;\n        for (let i = 0; i < 64; i++) {\n            let F, g, s;\n            if (i < 16) {\n                F = Chi(B, C, D);\n                g = i;\n                s = [7, 12, 17, 22];\n            }\n            else if (i < 32) {\n                F = Chi(D, B, C);\n                g = (5 * i + 1) % 16;\n                s = [5, 9, 14, 20];\n            }\n            else if (i < 48) {\n                F = B ^ C ^ D;\n                g = (3 * i + 5) % 16;\n                s = [4, 11, 16, 23];\n            }\n            else {\n                F = C ^ (B | ~D);\n                g = (7 * i) % 16;\n                s = [6, 10, 15, 21];\n            }\n            F = F + A + K[i] + MD5_W[g];\n            A = D;\n            D = C;\n            C = B;\n            B = B + rotl(F, s[i % 4]);\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        this.set(A, B, C, D);\n    }\n    roundClean() {\n        clean(MD5_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\n/**\n * MD5 (RFC 1321) legacy hash function. It was cryptographically broken.\n * MD5 architecture is similar to SHA1, with some differences:\n * - Reduced output length: 16 bytes (128 bit) instead of 20\n * - 64 rounds, instead of 80\n * - Little-endian: could be faster, but will require more code\n * - Non-linear index selection: huge speed-up for unroll\n * - Per round constants: more memory accesses, additional speed-up for unroll\n */\nexport const md5 = /* @__PURE__ */ createHasher(() => new MD5());\n// RIPEMD-160\nconst Rho160 = /* @__PURE__ */ Uint8Array.from([\n    7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n]);\nconst Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();\nconst Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();\nconst idxLR = /* @__PURE__ */ (() => {\n    const L = [Id160];\n    const R = [Pi160];\n    const res = [L, R];\n    for (let i = 0; i < 4; i++)\n        for (let j of res)\n            j.push(j[i].map((k) => Rho160[k]));\n    return res;\n})();\nconst idxL = /* @__PURE__ */ (() => idxLR[0])();\nconst idxR = /* @__PURE__ */ (() => idxLR[1])();\n// const [idxL, idxR] = idxLR;\nconst shifts160 = /* @__PURE__ */ [\n    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],\n    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],\n    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],\n    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],\n    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],\n].map((i) => Uint8Array.from(i));\nconst shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));\nconst shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));\nconst Kl160 = /* @__PURE__ */ Uint32Array.from([\n    0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,\n]);\nconst Kr160 = /* @__PURE__ */ Uint32Array.from([\n    0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,\n]);\n// It's called f() in spec.\nfunction ripemd_f(group, x, y, z) {\n    if (group === 0)\n        return x ^ y ^ z;\n    if (group === 1)\n        return (x & y) | (~x & z);\n    if (group === 2)\n        return (x | ~y) ^ z;\n    if (group === 3)\n        return (x & z) | (y & ~z);\n    return x ^ (y | ~z);\n}\n// Reusable temporary buffer\nconst BUF_160 = /* @__PURE__ */ new Uint32Array(16);\nexport class RIPEMD160 extends HashMD {\n    constructor() {\n        super(64, 20, 8, true);\n        this.h0 = 0x67452301 | 0;\n        this.h1 = 0xefcdab89 | 0;\n        this.h2 = 0x98badcfe | 0;\n        this.h3 = 0x10325476 | 0;\n        this.h4 = 0xc3d2e1f0 | 0;\n    }\n    get() {\n        const { h0, h1, h2, h3, h4 } = this;\n        return [h0, h1, h2, h3, h4];\n    }\n    set(h0, h1, h2, h3, h4) {\n        this.h0 = h0 | 0;\n        this.h1 = h1 | 0;\n        this.h2 = h2 | 0;\n        this.h3 = h3 | 0;\n        this.h4 = h4 | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            BUF_160[i] = view.getUint32(offset, true);\n        // prettier-ignore\n        let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;\n        // Instead of iterating 0 to 80, we split it into 5 groups\n        // And use the groups in constants, functions, etc. Much simpler\n        for (let group = 0; group < 5; group++) {\n            const rGroup = 4 - group;\n            const hbl = Kl160[group], hbr = Kr160[group]; // prettier-ignore\n            const rl = idxL[group], rr = idxR[group]; // prettier-ignore\n            const sl = shiftsL160[group], sr = shiftsR160[group]; // prettier-ignore\n            for (let i = 0; i < 16; i++) {\n                const tl = (rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el) | 0;\n                al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore\n            }\n            // 2 loops are 10% faster\n            for (let i = 0; i < 16; i++) {\n                const tr = (rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er) | 0;\n                ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore\n            }\n        }\n        // Add the compressed chunk to the current hash value\n        this.set((this.h1 + cl + dr) | 0, (this.h2 + dl + er) | 0, (this.h3 + el + ar) | 0, (this.h4 + al + br) | 0, (this.h0 + bl + cr) | 0);\n    }\n    roundClean() {\n        clean(BUF_160);\n    }\n    destroy() {\n        this.destroyed = true;\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0);\n    }\n}\n/**\n * RIPEMD-160 - a legacy hash function from 1990s.\n * * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html\n * * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf\n */\nexport const ripemd160 = /* @__PURE__ */ createHasher(() => new RIPEMD160());\n//# sourceMappingURL=legacy.js.map","/**\n * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.\n * @todo re-check https://issues.chromium.org/issues/42212588\n * @module\n */\nconst U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\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}\nfunction split(lst, le = false) {\n    const len = lst.length;\n    let Ah = new Uint32Array(len);\n    let Al = new Uint32Array(len);\n    for (let i = 0; i < len; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nconst rotr32L = (h, _l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\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}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };\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};\nexport default u64;\n//# sourceMappingURL=_u64.js.map","/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from \"./_md.js\";\nimport * as u64 from \"./_u64.js\";\nimport { clean, createHasher, rotr } from \"./utils.js\";\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD {\n    constructor(outputLen = 32) {\n        super(64, outputLen, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = SHA256_IV[0] | 0;\n        this.B = SHA256_IV[1] | 0;\n        this.C = SHA256_IV[2] | 0;\n        this.D = SHA256_IV[3] | 0;\n        this.E = SHA256_IV[4] | 0;\n        this.F = SHA256_IV[5] | 0;\n        this.G = SHA256_IV[6] | 0;\n        this.H = SHA256_IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        clean(SHA256_W);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        clean(this.buffer);\n    }\n}\nexport class SHA224 extends SHA256 {\n    constructor() {\n        super(28);\n        this.A = SHA224_IV[0] | 0;\n        this.B = SHA224_IV[1] | 0;\n        this.C = SHA224_IV[2] | 0;\n        this.D = SHA224_IV[3] | 0;\n        this.E = SHA224_IV[4] | 0;\n        this.F = SHA224_IV[5] | 0;\n        this.G = SHA224_IV[6] | 0;\n        this.H = SHA224_IV[7] | 0;\n    }\n}\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD {\n    constructor(outputLen = 64) {\n        super(128, outputLen, 16, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = SHA512_IV[0] | 0;\n        this.Al = SHA512_IV[1] | 0;\n        this.Bh = SHA512_IV[2] | 0;\n        this.Bl = SHA512_IV[3] | 0;\n        this.Ch = SHA512_IV[4] | 0;\n        this.Cl = SHA512_IV[5] | 0;\n        this.Dh = SHA512_IV[6] | 0;\n        this.Dl = SHA512_IV[7] | 0;\n        this.Eh = SHA512_IV[8] | 0;\n        this.El = SHA512_IV[9] | 0;\n        this.Fh = SHA512_IV[10] | 0;\n        this.Fl = SHA512_IV[11] | 0;\n        this.Gh = SHA512_IV[12] | 0;\n        this.Gl = SHA512_IV[13] | 0;\n        this.Hh = SHA512_IV[14] | 0;\n        this.Hl = SHA512_IV[15] | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        clean(SHA512_W_H, SHA512_W_L);\n    }\n    destroy() {\n        clean(this.buffer);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nexport class SHA384 extends SHA512 {\n    constructor() {\n        super(48);\n        this.Ah = SHA384_IV[0] | 0;\n        this.Al = SHA384_IV[1] | 0;\n        this.Bh = SHA384_IV[2] | 0;\n        this.Bl = SHA384_IV[3] | 0;\n        this.Ch = SHA384_IV[4] | 0;\n        this.Cl = SHA384_IV[5] | 0;\n        this.Dh = SHA384_IV[6] | 0;\n        this.Dl = SHA384_IV[7] | 0;\n        this.Eh = SHA384_IV[8] | 0;\n        this.El = SHA384_IV[9] | 0;\n        this.Fh = SHA384_IV[10] | 0;\n        this.Fl = SHA384_IV[11] | 0;\n        this.Gh = SHA384_IV[12] | 0;\n        this.Gl = SHA384_IV[13] | 0;\n        this.Hh = SHA384_IV[14] | 0;\n        this.Hl = SHA384_IV[15] | 0;\n    }\n}\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n    0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n    0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n    0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n    0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\nexport class SHA512_224 extends SHA512 {\n    constructor() {\n        super(28);\n        this.Ah = T224_IV[0] | 0;\n        this.Al = T224_IV[1] | 0;\n        this.Bh = T224_IV[2] | 0;\n        this.Bl = T224_IV[3] | 0;\n        this.Ch = T224_IV[4] | 0;\n        this.Cl = T224_IV[5] | 0;\n        this.Dh = T224_IV[6] | 0;\n        this.Dl = T224_IV[7] | 0;\n        this.Eh = T224_IV[8] | 0;\n        this.El = T224_IV[9] | 0;\n        this.Fh = T224_IV[10] | 0;\n        this.Fl = T224_IV[11] | 0;\n        this.Gh = T224_IV[12] | 0;\n        this.Gl = T224_IV[13] | 0;\n        this.Hh = T224_IV[14] | 0;\n        this.Hl = T224_IV[15] | 0;\n    }\n}\nexport class SHA512_256 extends SHA512 {\n    constructor() {\n        super(32);\n        this.Ah = T256_IV[0] | 0;\n        this.Al = T256_IV[1] | 0;\n        this.Bh = T256_IV[2] | 0;\n        this.Bl = T256_IV[3] | 0;\n        this.Ch = T256_IV[4] | 0;\n        this.Cl = T256_IV[5] | 0;\n        this.Dh = T256_IV[6] | 0;\n        this.Dl = T256_IV[7] | 0;\n        this.Eh = T256_IV[8] | 0;\n        this.El = T256_IV[9] | 0;\n        this.Fh = T256_IV[10] | 0;\n        this.Fl = T256_IV[11] | 0;\n        this.Gh = T256_IV[12] | 0;\n        this.Gl = T256_IV[13] | 0;\n        this.Hh = T256_IV[14] | 0;\n        this.Hl = T256_IV[15] | 0;\n    }\n}\n/**\n * SHA2-256 hash function from RFC 4634.\n *\n * It is the fastest JS hash, even faster than Blake3.\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n */\nexport const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224 = /* @__PURE__ */ createHasher(() => new SHA224());\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512 = /* @__PURE__ */ createHasher(() => new SHA512());\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384 = /* @__PURE__ */ createHasher(() => new SHA384());\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256 = /* @__PURE__ */ createHasher(() => new SHA512_256());\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224 = /* @__PURE__ */ createHasher(() => new SHA512_224());\n//# sourceMappingURL=sha2.js.map","/**\n * SHA3 (keccak) hash function, based on a new \"Sponge function\" design.\n * Different from older hashes, the internal state is bigger than output size.\n *\n * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),\n * [Website](https://keccak.team/keccak.html),\n * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).\n *\n * Check out `sha3-addons` module for cSHAKE, k12, and others.\n * @module\n */\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from \"./_u64.js\";\n// prettier-ignore\nimport { abytes, aexists, anumber, aoutput, clean, createHasher, createXOFer, Hash, swap32IfBE, toBytes, u32 } from \"./utils.js\";\n// No __PURE__ annotations in sha3 header:\n// EVERYTHING is in fact used on every export.\n// Various per round constants calculations\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst _7n = BigInt(7);\nconst _256n = BigInt(256);\nconst _0x71n = BigInt(0x71);\nconst SHA3_PI = [];\nconst SHA3_ROTL = [];\nconst _SHA3_IOTA = [];\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 IOTAS = split(_SHA3_IOTA, true);\nconst SHA3_IOTA_H = IOTAS[0];\nconst SHA3_IOTA_L = IOTAS[1];\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));\n/** `keccakf1600` internal function, additionally allows to adjust round count. */\nexport function 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    clean(B);\n}\n/** Keccak sponge function. */\nexport class Keccak extends 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.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        this.enableXOF = false;\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        // Can be passed from user as dkLen\n        anumber(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        // 0 < blockLen < 200\n        if (!(0 < blockLen && blockLen < 200))\n            throw new Error('only keccak-f1600 function is supported');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    clone() {\n        return this._cloneInto();\n    }\n    keccak() {\n        swap32IfBE(this.state32);\n        keccakP(this.state32, this.rounds);\n        swap32IfBE(this.state32);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        aexists(this);\n        data = toBytes(data);\n        abytes(data);\n        const { blockLen, state } = this;\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        aexists(this, false);\n        abytes(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        anumber(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        aoutput(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        clean(this.state);\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}\nconst gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));\n/** SHA3-224 hash function. */\nexport const sha3_224 = /* @__PURE__ */ (() => gen(0x06, 144, 224 / 8))();\n/** SHA3-256 hash function. Different from keccak-256. */\nexport const sha3_256 = /* @__PURE__ */ (() => gen(0x06, 136, 256 / 8))();\n/** SHA3-384 hash function. */\nexport const sha3_384 = /* @__PURE__ */ (() => gen(0x06, 104, 384 / 8))();\n/** SHA3-512 hash function. */\nexport const sha3_512 = /* @__PURE__ */ (() => gen(0x06, 72, 512 / 8))();\n/** keccak-224 hash function. */\nexport const keccak_224 = /* @__PURE__ */ (() => gen(0x01, 144, 224 / 8))();\n/** keccak-256 hash function. Different from SHA3-256. */\nexport const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();\n/** keccak-384 hash function. */\nexport const keccak_384 = /* @__PURE__ */ (() => gen(0x01, 104, 384 / 8))();\n/** keccak-512 hash function. */\nexport const keccak_512 = /* @__PURE__ */ (() => gen(0x01, 72, 512 / 8))();\nconst genShake = (suffix, blockLen, outputLen) => createXOFer((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\n/** SHAKE128 XOF with 128-bit security. */\nexport const shake128 = /* @__PURE__ */ (() => genShake(0x1f, 168, 128 / 8))();\n/** SHAKE256 XOF with 256-bit security. */\nexport const shake256 = /* @__PURE__ */ (() => genShake(0x1f, 136, 256 / 8))();\n//# sourceMappingURL=sha3.js.map","/**\n * \"globalThis\" ponyfill.\n * @see [A horrifying globalThis polyfill in universal JavaScript](https://mathiasbynens.be/notes/globalthis)\n * @type {Object.<string, *>}\n */\nconst globalScope = (() => {\n  if (typeof globalThis === \"object\") return globalThis;\n  else {\n    Object.defineProperty(Object.prototype, \"__GLOBALTHIS__\", {\n      get() {\n        return this;\n      },\n      configurable: true,\n    });\n    try {\n      // @ts-expect-error\n      // eslint-disable-next-line no-undef\n      if (typeof __GLOBALTHIS__ !== \"undefined\") return __GLOBALTHIS__;\n    } finally {\n      // @ts-expect-error\n      delete Object.prototype.__GLOBALTHIS__;\n    }\n  }\n\n  // Still unable to determine \"globalThis\", fall back to a naive method.\n  if (typeof self !== \"undefined\") return self;\n  else if (typeof window !== \"undefined\") return window;\n  else if (typeof global !== \"undefined\") return global;\n\n  return undefined;\n})();\n\nexport { globalScope };\n","import * as crypto from \"node:crypto\";\nimport { hmac } from \"@noble/hashes/hmac.js\";\nimport { sha1 } from \"@noble/hashes/legacy.js\";\nimport { sha224, sha256, sha384, sha512 } from \"@noble/hashes/sha2.js\";\nimport { sha3_224, sha3_256, sha3_384, sha3_512 } from \"@noble/hashes/sha3.js\";\nimport { globalScope } from \"../global-scope.js\";\n\n/**\n * @noble/hashes hash functions.\n * @type {Object.<string, sha1|sha224|sha256|sha384|sha512|sha3_224|sha3_256|sha3_384|sha3_512>}\n */\nconst nobleHashes = {\n  SHA1: sha1,\n  SHA224: sha224,\n  SHA256: sha256,\n  SHA384: sha384,\n  SHA512: sha512,\n  \"SHA3-224\": sha3_224,\n  \"SHA3-256\": sha3_256,\n  \"SHA3-384\": sha3_384,\n  \"SHA3-512\": sha3_512,\n};\n\n/**\n * Canonicalizes a hash algorithm name.\n * @param {string} algorithm Hash algorithm name.\n * @returns {\"SHA1\"|\"SHA224\"|\"SHA256\"|\"SHA384\"|\"SHA512\"|\"SHA3-224\"|\"SHA3-256\"|\"SHA3-384\"|\"SHA3-512\"} Canonicalized hash algorithm name.\n */\nconst canonicalizeAlgorithm = (algorithm) => {\n  switch (true) {\n    case /^(?:SHA-?1|SSL3-SHA1)$/i.test(algorithm):\n      return \"SHA1\";\n    case /^SHA(?:2?-)?224$/i.test(algorithm):\n      return \"SHA224\";\n    case /^SHA(?:2?-)?256$/i.test(algorithm):\n      return \"SHA256\";\n    case /^SHA(?:2?-)?384$/i.test(algorithm):\n      return \"SHA384\";\n    case /^SHA(?:2?-)?512$/i.test(algorithm):\n      return \"SHA512\";\n    case /^SHA3-224$/i.test(algorithm):\n      return \"SHA3-224\";\n    case /^SHA3-256$/i.test(algorithm):\n      return \"SHA3-256\";\n    case /^SHA3-384$/i.test(algorithm):\n      return \"SHA3-384\";\n    case /^SHA3-512$/i.test(algorithm):\n      return \"SHA3-512\";\n    default:\n      throw new TypeError(`Unknown hash algorithm: ${algorithm}`);\n  }\n};\n\n/**\n * Calculates an HMAC digest.\n * @param {string} algorithm Algorithm.\n * @param {Uint8Array} key Key.\n * @param {Uint8Array} message Message.\n * @returns {Uint8Array} Digest.\n */\nconst hmacDigest = (algorithm, key, message) => {\n  if (crypto?.createHmac) {\n    const hmac = crypto.createHmac(algorithm, globalScope.Buffer.from(key));\n    hmac.update(globalScope.Buffer.from(message));\n    return hmac.digest();\n  } else if (hmac) {\n    const hash = nobleHashes[algorithm] ?? nobleHashes[canonicalizeAlgorithm(algorithm)];\n    return hmac(hash, key, message);\n  } else {\n    throw new Error(\"Missing HMAC function\");\n  }\n};\n\nexport { canonicalizeAlgorithm, hmacDigest };\n","/**\n * RFC 4648 base32 alphabet without pad.\n * @type {string}\n */\nconst ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567\";\n\n/**\n * Converts a base32 string to an Uint8Array (RFC 4648).\n * @see [LinusU/base32-decode](https://github.com/LinusU/base32-decode)\n * @param {string} str Base32 string.\n * @returns {Uint8Array} Uint8Array.\n */\nconst base32Decode = (str) => {\n  // Remove spaces (although they are not allowed by the spec, some issuers add them for readability).\n  str = str.replace(/ /g, \"\");\n\n  // Canonicalize to all upper case and remove padding if it exists.\n  let end = str.length;\n  while (str[end - 1] === \"=\") --end;\n  str = (end < str.length ? str.substring(0, end) : str).toUpperCase();\n\n  const buf = new ArrayBuffer(((str.length * 5) / 8) | 0);\n  const arr = new Uint8Array(buf);\n  let bits = 0;\n  let value = 0;\n  let index = 0;\n\n  for (let i = 0; i < str.length; i++) {\n    const idx = ALPHABET.indexOf(str[i]);\n    if (idx === -1) throw new TypeError(`Invalid character found: ${str[i]}`);\n\n    value = (value << 5) | idx;\n    bits += 5;\n\n    if (bits >= 8) {\n      bits -= 8;\n      arr[index++] = value >>> bits;\n    }\n  }\n\n  return arr;\n};\n\n/**\n * Converts an Uint8Array to a base32 string (RFC 4648).\n * @see [LinusU/base32-encode](https://github.com/LinusU/base32-encode)\n * @param {Uint8Array} arr Uint8Array.\n * @returns {string} Base32 string.\n */\nconst base32Encode = (arr) => {\n  let bits = 0;\n  let value = 0;\n  let str = \"\";\n\n  for (let i = 0; i < arr.length; i++) {\n    value = (value << 8) | arr[i];\n    bits += 8;\n\n    while (bits >= 5) {\n      str += ALPHABET[(value >>> (bits - 5)) & 31];\n      bits -= 5;\n    }\n  }\n\n  if (bits > 0) {\n    str += ALPHABET[(value << (5 - bits)) & 31];\n  }\n\n  return str;\n};\n\nexport { base32Decode, base32Encode };\n","/**\n * Converts a hexadecimal string to an Uint8Array.\n * @param {string} str Hexadecimal string.\n * @returns {Uint8Array} Uint8Array.\n */\nconst hexDecode = (str) => {\n  // Remove spaces (although they are not allowed by the spec, some issuers add them for readability).\n  str = str.replace(/ /g, \"\");\n\n  const buf = new ArrayBuffer(str.length / 2);\n  const arr = new Uint8Array(buf);\n\n  for (let i = 0; i < str.length; i += 2) {\n    arr[i / 2] = parseInt(str.substring(i, i + 2), 16);\n  }\n\n  return arr;\n};\n\n/**\n * Converts an Uint8Array to a hexadecimal string.\n * @param {Uint8Array} arr Uint8Array.\n * @returns {string} Hexadecimal string.\n */\nconst hexEncode = (arr) => {\n  let str = \"\";\n\n  for (let i = 0; i < arr.length; i++) {\n    const hex = arr[i].toString(16);\n    if (hex.length === 1) str += \"0\";\n    str += hex;\n  }\n\n  return str.toUpperCase();\n};\n\nexport { hexDecode, hexEncode };\n","/**\n * Converts a Latin-1 string to an Uint8Array.\n * @param {string} str Latin-1 string.\n * @returns {Uint8Array} Uint8Array.\n */\nconst latin1Decode = (str) => {\n  const buf = new ArrayBuffer(str.length);\n  const arr = new Uint8Array(buf);\n\n  for (let i = 0; i < str.length; i++) {\n    arr[i] = str.charCodeAt(i) & 0xff;\n  }\n\n  return arr;\n};\n\n/**\n * Converts an Uint8Array to a Latin-1 string.\n * @param {Uint8Array} arr Uint8Array.\n * @returns {string} Latin-1 string.\n */\nconst latin1Encode = (arr) => {\n  let str = \"\";\n\n  for (let i = 0; i < arr.length; i++) {\n    str += String.fromCharCode(arr[i]);\n  }\n\n  return str;\n};\n\nexport { latin1Decode, latin1Encode };\n","import { globalScope } from \"../global-scope.js\";\n\n/**\n * TextEncoder instance.\n * @type {TextEncoder|null}\n */\nconst ENCODER = globalScope.TextEncoder ? new globalScope.TextEncoder() : null;\n\n/**\n * TextDecoder instance.\n * @type {TextDecoder|null}\n */\nconst DECODER = globalScope.TextDecoder ? new globalScope.TextDecoder() : null;\n\n/**\n * Converts an UTF-8 string to an Uint8Array.\n * @param {string} str String.\n * @returns {Uint8Array} Uint8Array.\n */\nconst utf8Decode = (str) => {\n  if (!ENCODER) {\n    throw new Error(\"Encoding API not available\");\n  }\n\n  return ENCODER.encode(str);\n};\n\n/**\n * Converts an Uint8Array to an UTF-8 string.\n * @param {Uint8Array} arr Uint8Array.\n * @returns {string} String.\n */\nconst utf8Encode = (arr) => {\n  if (!DECODER) {\n    throw new Error(\"Encoding API not available\");\n  }\n\n  return DECODER.decode(arr);\n};\n\nexport { utf8Decode, utf8Encode };\n","import { base32Decode, base32Encode } from \"./internal/encoding/base32.js\";\nimport { hexDecode, hexEncode } from \"./internal/encoding/hex.js\";\nimport { latin1Decode, latin1Encode } from \"./internal/encoding/latin1.js\";\nimport { utf8Decode, utf8Encode } from \"./internal/encoding/utf8.js\";\nimport { randomBytes } from \"./internal/crypto/random-bytes.js\";\n\n/**\n * OTP secret key.\n */\nclass Secret {\n  /**\n   * Creates a secret key object.\n   * @param {Object} [config] Configuration options.\n   * @param {ArrayBufferLike} [config.buffer] Secret key buffer.\n   * @param {number} [config.size=20] Number of random bytes to generate, ignored if 'buffer' is provided.\n   */\n  constructor({ buffer, size = 20 } = {}) {\n    /**\n     * Secret key.\n     * @type {Uint8Array}\n     * @readonly\n     */\n    this.bytes = typeof buffer === \"undefined\" ? randomBytes(size) : new Uint8Array(buffer);\n\n    // Prevent the \"bytes\" property from being modified.\n    Object.defineProperty(this, \"bytes\", {\n      enumerable: true,\n      writable: false,\n      configurable: false,\n      value: this.bytes,\n    });\n  }\n\n  /**\n   * Converts a Latin-1 string to a Secret object.\n   * @param {string} str Latin-1 string.\n   * @returns {Secret} Secret object.\n   */\n  static fromLatin1(str) {\n    return new Secret({ buffer: latin1Decode(str).buffer });\n  }\n\n  /**\n   * Converts an UTF-8 string to a Secret object.\n   * @param {string} str UTF-8 string.\n   * @returns {Secret} Secret object.\n   */\n  static fromUTF8(str) {\n    return new Secret({ buffer: utf8Decode(str).buffer });\n  }\n\n  /**\n   * Converts a base32 string to a Secret object.\n   * @param {string} str Base32 string.\n   * @returns {Secret} Secret object.\n   */\n  static fromBase32(str) {\n    return new Secret({ buffer: base32Decode(str).buffer });\n  }\n\n  /**\n   * Converts a hexadecimal string to a Secret object.\n   * @param {string} str Hexadecimal string.\n   * @returns {Secret} Secret object.\n   */\n  static fromHex(str) {\n    return new Secret({ buffer: hexDecode(str).buffer });\n  }\n\n  /**\n   * Secret key buffer.\n   * @deprecated For backward compatibility, the \"bytes\" property should be used instead.\n   * @type {ArrayBufferLike}\n   */\n  get buffer() {\n    return this.bytes.buffer;\n  }\n\n  /**\n   * Latin-1 string representation of secret key.\n   * @type {string}\n   */\n  get latin1() {\n    Object.defineProperty(this, \"latin1\", {\n      enumerable: true,\n      writable: false,\n      configurable: false,\n      value: latin1Encode(this.bytes),\n    });\n\n    return this.latin1;\n  }\n\n  /**\n   * UTF-8 string representation of secret key.\n   * @type {string}\n   */\n  get utf8() {\n    Object.defineProperty(this, \"utf8\", {\n      enumerable: true,\n      writable: false,\n      configurable: false,\n      value: utf8Encode(this.bytes),\n    });\n\n    return this.utf8;\n  }\n\n  /**\n   * Base32 string representation of secret key.\n   * @type {string}\n   */\n  get base32() {\n    Object.defineProperty(this, \"base32\", {\n      enumerable: true,\n      writable: false,\n      configurable: false,\n      value: base32Encode(this.bytes),\n    });\n\n    return this.base32;\n  }\n\n  /**\n   * Hexadecimal string representation of secret key.\n   * @type {string}\n   */\n  get hex() {\n    Object.defineProperty(this, \"hex\", {\n      enumerable: true,\n      writable: false,\n      configurable: false,\n      value: hexEncode(this.bytes),\n    });\n\n    return this.hex;\n  }\n}\n\nexport { Secret };\n","import * as crypto from \"node:crypto\";\n\nimport { globalScope } from \"../global-scope.js\";\n\n/**\n * Returns random bytes.\n * @param {number} size Size.\n * @returns {Uint8Array} Random bytes.\n */\nconst randomBytes = (size) => {\n  if (crypto?.randomBytes) {\n    return crypto.randomBytes(size);\n  } else if (globalScope.crypto?.getRandomValues) {\n    return globalScope.crypto.getRandomValues(new Uint8Array(size));\n  } else {\n    throw new Error(\"Cryptography API not available\");\n  }\n};\n\nexport { randomBytes };\n","import { uintDecode } from \"./internal/encoding/uint.js\";\nimport { canonicalizeAlgorithm, hmacDigest } from \"./internal/crypto/hmac-digest.js\";\nimport { Secret } from \"./secret.js\";\nimport { timingSafeEqual } from \"./internal/crypto/timing-safe-equal.js\";\n\n/**\n * HOTP: An HMAC-based One-time Password Algorithm.\n * @see [RFC 4226](https://datatracker.ietf.org/doc/html/rfc4226)\n */\nclass HOTP {\n  /**\n   * Default configuration.\n   * @type {{\n   *   issuer: string,\n   *   label: string,\n   *   issuerInLabel: boolean,\n   *   algorithm: string,\n   *   digits: number,\n   *   counter: number\n   *   window: number\n   * }}\n   */\n  static get defaults() {\n    return {\n      issuer: \"\",\n      label: \"OTPAuth\",\n      issuerInLabel: true,\n      algorithm: \"SHA1\",\n      digits: 6,\n      counter: 0,\n      window: 1,\n    };\n  }\n\n  /**\n   * Creates an HOTP object.\n   * @param {Object} [config] Configuration options.\n   * @param {string} [config.issuer=''] Account provider.\n   * @param {string} [config.label='OTPAuth'] Account label.\n   * @param {boolean} [config.issuerInLabel=true] Include issuer prefix in label.\n   * @param {Secret|string} [config.secret=Secret] Secret key.\n   * @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.\n   * @param {number} [config.digits=6] Token length.\n   * @param {number} [config.counter=0] Initial counter value.\n   */\n  constructor({\n    issuer = HOTP.defaults.issuer,\n    label = HOTP.defaults.label,\n    issuerInLabel = HOTP.defaults.issuerInLabel,\n    secret = new Secret(),\n    algorithm = HOTP.defaults.algorithm,\n    digits = HOTP.defaults.digits,\n    counter = HOTP.defaults.counter,\n  } = {}) {\n    /**\n     * Account provider.\n     * @type {string}\n     */\n    this.issuer = issuer;\n    /**\n     * Account label.\n     * @type {string}\n     */\n    this.label = label;\n    /**\n     * Include issuer prefix in label.\n     * @type {boolean}\n     */\n    this.issuerInLabel = issuerInLabel;\n    /**\n     * Secret key.\n     * @type {Secret}\n     */\n    this.secret = typeof secret === \"string\" ? Secret.fromBase32(secret) : secret;\n    /**\n     * HMAC hashing algorithm.\n     * @type {string}\n     */\n    this.algorithm = canonicalizeAlgorithm(algorithm);\n    /**\n     * Token length.\n     * @type {number}\n     */\n    this.digits = digits;\n    /**\n     * Initial counter value.\n     * @type {number}\n     */\n    this.counter = counter;\n  }\n\n  /**\n   * Generates an HOTP token.\n   * @param {Object} config Configuration options.\n   * @param {Secret} config.secret Secret key.\n   * @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.\n   * @param {number} [config.digits=6] Token length.\n   * @param {number} [config.counter=0] Counter value.\n   * @returns {string} Token.\n   */\n  static generate({\n    secret,\n    algorithm = HOTP.defaults.algorithm,\n    digits = HOTP.defaults.digits,\n    counter = HOTP.defaults.counter,\n  }) {\n    const digest = hmacDigest(algorithm, secret.bytes, uintDecode(counter));\n    const offset = digest[digest.byteLength - 1] & 15;\n    const otp =\n      (((digest[offset] & 127) << 24) |\n        ((digest[offset + 1] & 255) << 16) |\n        ((digest[offset + 2] & 255) << 8) |\n        (digest[offset + 3] & 255)) %\n      10 ** digits;\n\n    return otp.toString().padStart(digits, \"0\");\n  }\n\n  /**\n   * Generates an HOTP token.\n   * @param {Object} [config] Configuration options.\n   * @param {number} [config.counter=this.counter++] Counter value.\n   * @returns {string} Token.\n   */\n  generate({ counter = this.counter++ } = {}) {\n    return HOTP.generate({\n      secret: this.secret,\n      algorithm: this.algorithm,\n      digits: this.digits,\n      counter,\n    });\n  }\n\n  /**\n   * Validates an HOTP token.\n   * @param {Object} config Configuration options.\n   * @param {string} config.token Token value.\n   * @param {Secret} config.secret Secret key.\n   * @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.\n   * @param {number} [config.digits=6] Token length.\n   * @param {number} [config.counter=0] Counter value.\n   * @param {number} [config.window=1] Window of counter values to test.\n   * @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.\n   */\n  static validate({\n    token,\n    secret,\n    algorithm,\n    digits = HOTP.defaults.digits,\n    counter = HOTP.defaults.counter,\n    window = HOTP.defaults.window,\n  }) {\n    // Return early if the token length does not match the digit number.\n    if (token.length !== digits) return null;\n\n    let delta = null;\n\n    const check = (/** @type {number} */ i) => {\n      const generatedToken = HOTP.generate({\n        secret,\n        algorithm,\n        digits,\n        counter: i,\n      });\n      if (timingSafeEqual(token, generatedToken)) {\n        delta = i - counter;\n      }\n    };\n\n    check(counter);\n    for (let i = 1; i <= window && delta === null; ++i) {\n      check(counter - i);\n      if (delta !== null) break;\n      check(counter + i);\n      if (delta !== null) break;\n    }\n\n    return delta;\n  }\n\n  /**\n   * Validates an HOTP token.\n   * @param {Object} config Configuration options.\n   * @param {string} config.token Token value.\n   * @param {number} [config.counter=this.counter] Counter value.\n   * @param {number} [config.window=1] Window of counter values to test.\n   * @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.\n   */\n  validate({ token, counter = this.counter, window }) {\n    return HOTP.validate({\n      token,\n      secret: this.secret,\n      algorithm: this.algorithm,\n      digits: this.digits,\n      counter,\n      window,\n    });\n  }\n\n  /**\n   * Returns a Google Authenticator key URI.\n   * @returns {string} URI.\n   */\n  toString() {\n    const e = encodeURIComponent;\n    return (\n      \"otpauth://hotp/\" +\n      `${\n        this.issuer.length > 0\n          ? this.issuerInLabel\n            ? `${e(this.issuer)}:${e(this.label)}?issuer=${e(this.issuer)}&`\n            : `${e(this.label)}?issuer=${e(this.issuer)}&`\n          : `${e(this.label)}?`\n      }` +\n      `secret=${e(this.secret.base32)}&` +\n      `algorithm=${e(this.algorithm)}&` +\n      `digits=${e(this.digits)}&` +\n      `counter=${e(this.counter)}`\n    );\n  }\n}\n\nexport { HOTP };\n","/**\n * Converts an integer to an Uint8Array.\n * @param {number} num Integer.\n * @returns {Uint8Array} Uint8Array.\n */\nconst uintDecode = (num) => {\n  const buf = new ArrayBuffer(8);\n  const arr = new Uint8Array(buf);\n  let acc = num;\n\n  for (let i = 7; i >= 0; i--) {\n    if (acc === 0) break;\n    arr[i] = acc & 255;\n    acc -= arr[i];\n    acc /= 256;\n  }\n\n  return arr;\n};\n\n/**\n * Converts an Uint8Array to an integer.\n * @param {Uint8Array} arr Uint8Array.\n * @returns {number} Integer.\n */\nconst uintEncode = (arr) => {\n  let num = 0;\n\n  for (let i = 0; i < arr.length; i++) {\n    num *= 256;\n    num += arr[i];\n  }\n\n  return num;\n};\n\nexport { uintDecode, uintEncode };\n","import * as crypto from \"node:crypto\";\n\nimport { globalScope } from \"../global-scope.js\";\n\n/**\n * Returns true if a is equal to b, without leaking timing information that would allow an attacker to guess one of the values.\n * @param {string} a String a.\n * @param {string} b String b.\n * @returns {boolean} Equality result.\n */\nconst timingSafeEqual = (a, b) => {\n  if (crypto?.timingSafeEqual) {\n    return crypto.timingSafeEqual(globalScope.Buffer.from(a), globalScope.Buffer.from(b));\n  } else {\n    if (a.length !== b.length) {\n      throw new TypeError(\"Input strings must have the same length\");\n    }\n    let i = -1;\n    let out = 0;\n    while (++i < a.length) {\n      out |= a.charCodeAt(i) ^ b.charCodeAt(i);\n    }\n    return out === 0;\n  }\n};\n\nexport { timingSafeEqual };\n","import { canonicalizeAlgorithm } from \"./internal/crypto/hmac-digest.js\";\nimport { HOTP } from \"./hotp.js\";\nimport { Secret } from \"./secret.js\";\n\n/**\n * TOTP: Time-Based One-Time Password Algorithm.\n * @see [RFC 6238](https://datatracker.ietf.org/doc/html/rfc6238)\n */\nclass TOTP {\n  /**\n   * Default configuration.\n   * @type {{\n   *   issuer: string,\n   *   label: string,\n   *   issuerInLabel: boolean,\n   *   algorithm: string,\n   *   digits: number,\n   *   period: number\n   *   window: number\n   * }}\n   */\n  static get defaults() {\n    return {\n      issuer: \"\",\n      label: \"OTPAuth\",\n      issuerInLabel: true,\n      algorithm: \"SHA1\",\n      digits: 6,\n      period: 30,\n      window: 1,\n    };\n  }\n\n  /**\n   * Creates a TOTP object.\n   * @param {Object} [config] Configuration options.\n   * @param {string} [config.issuer=''] Account provider.\n   * @param {string} [config.label='OTPAuth'] Account label.\n   * @param {boolean} [config.issuerInLabel=true] Include issuer prefix in label.\n   * @param {Secret|string} [config.secret=Secret] Secret key.\n   * @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.\n   * @param {number} [config.digits=6] Token length.\n   * @param {number} [config.period=30] Token time-step duration.\n   */\n  constructor({\n    issuer = TOTP.defaults.issuer,\n    label = TOTP.defaults.label,\n    issuerInLabel = TOTP.defaults.issuerInLabel,\n    secret = new Secret(),\n    algorithm = TOTP.defaults.algorithm,\n    digits = TOTP.defaults.digits,\n    period = TOTP.defaults.period,\n  } = {}) {\n    /**\n     * Account provider.\n     * @type {string}\n     */\n    this.issuer = issuer;\n    /**\n     * Account label.\n     * @type {string}\n     */\n    this.label = label;\n    /**\n     * Include issuer prefix in label.\n     * @type {boolean}\n     */\n    this.issuerInLabel = issuerInLabel;\n    /**\n     * Secret key.\n     * @type {Secret}\n     */\n    this.secret = typeof secret === \"string\" ? Secret.fromBase32(secret) : secret;\n    /**\n     * HMAC hashing algorithm.\n     * @type {string}\n     */\n    this.algorithm = canonicalizeAlgorithm(algorithm);\n    /**\n     * Token length.\n     * @type {number}\n     */\n    this.digits = digits;\n    /**\n     * Token time-step duration.\n     * @type {number}\n     */\n    this.period = period;\n  }\n\n  /**\n   * Calculates the counter. i.e. the number of periods since timestamp 0.\n   * @param {Object} [config] Configuration options.\n   * @param {number} [config.period=30] Token time-step duration.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @returns {number} Counter.\n   */\n  static counter({ period = TOTP.defaults.period, timestamp = Date.now() } = {}) {\n    return Math.floor(timestamp / 1000 / period);\n  }\n\n  /**\n   * Calculates the counter. i.e. the number of periods since timestamp 0.\n   * @param {Object} [config] Configuration options.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @returns {number} Counter.\n   */\n  counter({ timestamp = Date.now() } = {}) {\n    return TOTP.counter({\n      period: this.period,\n      timestamp,\n    });\n  }\n\n  /**\n   * Calculates the remaining time in milliseconds until the next token is generated.\n   * @param {Object} [config] Configuration options.\n   * @param {number} [config.period=30] Token time-step duration.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @returns {number} counter.\n   */\n  static remaining({ period = TOTP.defaults.period, timestamp = Date.now() } = {}) {\n    return period * 1000 - (timestamp % (period * 1000));\n  }\n\n  /**\n   * Calculates the remaining time in milliseconds until the next token is generated.\n   * @param {Object} [config] Configuration options.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @returns {number} counter.\n   */\n  remaining({ timestamp = Date.now() } = {}) {\n    return TOTP.remaining({\n      period: this.period,\n      timestamp,\n    });\n  }\n\n  /**\n   * Generates a TOTP token.\n   * @param {Object} config Configuration options.\n   * @param {Secret} config.secret Secret key.\n   * @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.\n   * @param {number} [config.digits=6] Token length.\n   * @param {number} [config.period=30] Token time-step duration.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @returns {string} Token.\n   */\n  static generate({ secret, algorithm, digits, period = TOTP.defaults.period, timestamp = Date.now() }) {\n    return HOTP.generate({\n      secret,\n      algorithm,\n      digits,\n      counter: TOTP.counter({ period, timestamp }),\n    });\n  }\n\n  /**\n   * Generates a TOTP token.\n   * @param {Object} [config] Configuration options.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @returns {string} Token.\n   */\n  generate({ timestamp = Date.now() } = {}) {\n    return TOTP.generate({\n      secret: this.secret,\n      algorithm: this.algorithm,\n      digits: this.digits,\n      period: this.period,\n      timestamp,\n    });\n  }\n\n  /**\n   * Validates a TOTP token.\n   * @param {Object} config Configuration options.\n   * @param {string} config.token Token value.\n   * @param {Secret} config.secret Secret key.\n   * @param {string} [config.algorithm='SHA1'] HMAC hashing algorithm.\n   * @param {number} [config.digits=6] Token length.\n   * @param {number} [config.period=30] Token time-step duration.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @param {number} [config.window=1] Window of counter values to test.\n   * @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.\n   */\n  static validate({ token, secret, algorithm, digits, period = TOTP.defaults.period, timestamp = Date.now(), window }) {\n    return HOTP.validate({\n      token,\n      secret,\n      algorithm,\n      digits,\n      counter: TOTP.counter({ period, timestamp }),\n      window,\n    });\n  }\n\n  /**\n   * Validates a TOTP token.\n   * @param {Object} config Configuration options.\n   * @param {string} config.token Token value.\n   * @param {number} [config.timestamp=Date.now] Timestamp value in milliseconds.\n   * @param {number} [config.window=1] Window of counter values to test.\n   * @returns {number|null} Token delta or null if it is not found in the search window, in which case it should be considered invalid.\n   */\n  validate({ token, timestamp, window }) {\n    return TOTP.validate({\n      token,\n      secret: this.secret,\n      algorithm: this.algorithm,\n      digits: this.digits,\n      period: this.period,\n      timestamp,\n      window,\n    });\n  }\n\n  /**\n   * Returns a Google Authenticator key URI.\n   * @returns {string} URI.\n   */\n  toString() {\n    const e = encodeURIComponent;\n    return (\n      \"otpauth://totp/\" +\n      `${\n        this.issuer.length > 0\n          ? this.issuerInLabel\n            ? `${e(this.issuer)}:${e(this.label)}?issuer=${e(this.issuer)}&`\n            : `${e(this.label)}?issuer=${e(this.issuer)}&`\n          : `${e(this.label)}?`\n      }` +\n      `secret=${e(this.secret.base32)}&` +\n      `algorithm=${e(this.algorithm)}&` +\n      `digits=${e(this.digits)}&` +\n      `period=${e(this.period)}`\n    );\n  }\n}\n\nexport { TOTP };\n","import { HOTP } from \"./hotp.js\";\nimport { TOTP } from \"./totp.js\";\n\n/**\n * Key URI regex (otpauth://TYPE/[ISSUER:]LABEL?PARAMETERS).\n * @type {RegExp}\n */\nconst OTPURI_REGEX = /^otpauth:\\/\\/([ht]otp)\\/(.+)\\?([A-Z0-9.~_-]+=[^?&]*(?:&[A-Z0-9.~_-]+=[^?&]*)*)$/i;\n\n/**\n * RFC 4648 base32 alphabet with pad.\n * @type {RegExp}\n */\nconst SECRET_REGEX = /^[2-7A-Z]+=*$/i;\n\n/**\n * Regex for supported algorithms.\n * @type {RegExp}\n */\nconst ALGORITHM_REGEX = /^SHA(?:1|224|256|384|512|3-224|3-256|3-384|3-512)$/i;\n\n/**\n * Integer regex.\n * @type {RegExp}\n */\nconst INTEGER_REGEX = /^[+-]?\\d+$/;\n\n/**\n * Positive integer regex.\n * @type {RegExp}\n */\nconst POSITIVE_INTEGER_REGEX = /^\\+?[1-9]\\d*$/;\n\n/**\n * HOTP/TOTP object/string conversion.\n * @see [Key URI Format](https://github.com/google/google-authenticator/wiki/Key-Uri-Format)\n */\nclass URI {\n  /**\n   * Parses a Google Authenticator key URI and returns an HOTP/TOTP object.\n   * @param {string} uri Google Authenticator Key URI.\n   * @returns {HOTP|TOTP} HOTP/TOTP object.\n   */\n  static parse(uri) {\n    let uriGroups;\n\n    try {\n      uriGroups = uri.match(OTPURI_REGEX);\n      // eslint-disable-next-line no-unused-vars\n    } catch (_) {\n      /* Handled below */\n    }\n\n    if (!Array.isArray(uriGroups)) {\n      throw new URIError(\"Invalid URI format\");\n    }\n\n    // Extract URI groups.\n    const uriType = uriGroups[1].toLowerCase();\n    const uriLabel = uriGroups[2].split(/(?::|%3A) *(.+)/i, 2).map(decodeURIComponent);\n    /** @type {Object.<string, string>} */\n    const uriParams = uriGroups[3].split(\"&\").reduce((acc, cur) => {\n      const pairArr = cur.split(/=(.*)/, 2).map(decodeURIComponent);\n      const pairKey = pairArr[0].toLowerCase();\n      const pairVal = pairArr[1];\n      /** @type {Object.<string, string>} */\n      const pairAcc = acc;\n\n      pairAcc[pairKey] = pairVal;\n      return pairAcc;\n    }, {});\n\n    // 'OTP' will be instantiated with 'config' argument.\n    let OTP;\n    const config = {};\n\n    if (uriType === \"hotp\") {\n      OTP = HOTP;\n\n      // Counter: required\n      if (typeof uriParams.counter !== \"undefined\" && INTEGER_REGEX.test(uriParams.counter)) {\n        config.counter = parseInt(uriParams.counter, 10);\n      } else {\n        throw new TypeError(\"Missing or invalid 'counter' parameter\");\n      }\n    } else if (uriType === \"totp\") {\n      OTP = TOTP;\n\n      // Period: optional\n      if (typeof uriParams.period !== \"undefined\") {\n        if (POSITIVE_INTEGER_REGEX.test(uriParams.period)) {\n          config.period = parseInt(uriParams.period, 10);\n        } else {\n          throw new TypeError(\"Invalid 'period' parameter\");\n        }\n      }\n    } else {\n      throw new TypeError(\"Unknown OTP type\");\n    }\n\n    // Label: required\n    // Issuer: optional\n    if (typeof uriParams.issuer !== \"undefined\") {\n      config.issuer = uriParams.issuer;\n    }\n    if (uriLabel.length === 2) {\n      config.label = uriLabel[1];\n      if (typeof config.issuer === \"undefined\" || config.issuer === \"\") {\n        config.issuer = uriLabel[0];\n      } else if (uriLabel[0] === \"\") {\n        config.issuerInLabel = false;\n      }\n    } else {\n      config.label = uriLabel[0];\n      if (typeof config.issuer !== \"undefined\" && config.issuer !== \"\") {\n        config.issuerInLabel = false;\n      }\n    }\n\n    // Secret: required\n    if (typeof uriParams.secret !== \"undefined\" && SECRET_REGEX.test(uriParams.secret)) {\n      config.secret = uriParams.secret;\n    } else {\n      throw new TypeError(\"Missing or invalid 'secret' parameter\");\n    }\n\n    // Algorithm: optional\n    if (typeof uriParams.algorithm !== \"undefined\") {\n      if (ALGORITHM_REGEX.test(uriParams.algorithm)) {\n        config.algorithm = uriParams.algorithm;\n      } else {\n        throw new TypeError(\"Invalid 'algorithm' parameter\");\n      }\n    }\n\n    // Digits: optional\n    if (typeof uriParams.digits !== \"undefined\") {\n      if (POSITIVE_INTEGER_REGEX.test(uriParams.digits)) {\n        config.digits = parseInt(uriParams.digits, 10);\n      } else {\n        throw new TypeError(\"Invalid 'digits' parameter\");\n      }\n    }\n\n    return new OTP(config);\n  }\n\n  /**\n   * Converts an HOTP/TOTP object to a Google Authenticator key URI.\n   * @param {HOTP|TOTP} otp HOTP/TOTP object.\n   * @returns {string} Google Authenticator Key URI.\n   */\n  static stringify(otp) {\n    if (otp instanceof HOTP || otp instanceof TOTP) {\n      return otp.toString();\n    }\n\n    throw new TypeError(\"Invalid 'HOTP/TOTP' object\");\n  }\n}\n\nexport { URI };\n","/**\n * Library version.\n * @type {string}\n */\nconst version = \"__OTPAUTH_VERSION__\";\n\nexport { version };\n"],"names":["anumber","n","Number","isSafeInteger","Error","abytes","b","lengths","a","Uint8Array","ArrayBuffer","isView","constructor","name","length","includes","aexists","instance","checkFinished","destroyed","finished","aoutput","out","min","outputLen","clean","arrays","i","fill","createView","arr","DataView","buffer","byteOffset","byteLength","rotr","word","shift","rotl","byteSwap","swap32IfBE","Uint32Array","u","toBytes","data","str","TextEncoder","encode","utf8ToBytes","Hash","createHasher","hashCons","hashC","msg","update","digest","tmp","blockLen","create","HMAC","buf","this","iHash","digestInto","oHash","destroy","_cloneInto","to","Object","getPrototypeOf","clone","hash","_key","super","h","ahash","key","pad","set","hmac","message","Chi","c","Maj","HashMD","view","len","pos","take","Math","dataView","process","subarray","roundClean","isLE","padOffset","value","setBigUint64","_32n","BigInt","_u32_max","wh","wl","l","setUint32","oview","outLen","state","get","res","slice","SHA256_IV","from","SHA224_IV","SHA384_IV","SHA512_IV","SHA1_IV","SHA1_W","SHA1","A","B","C","D","E","offset","getUint32","F","K","T","sha1","U32_MASK64","fromBig","le","split","lst","Ah","Al","shrSH","_l","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","add","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5L","El","add5H","Eh","SHA256_K","SHA256_W","SHA256","G","H","W15","W2","s0","s1","T1","T2","SHA224","K512","u64.split","map","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","u64.rotrSH","u64.shrSH","s0l","u64.rotrSL","u64.shrSL","W2h","W2l","s1h","u64.rotrBH","s1l","u64.rotrBL","SUMl","u64.add4L","SUMh","u64.add4H","sigma1h","sigma1l","CHIh","T1ll","u64.add5L","T1h","u64.add5H","T1l","sigma0h","sigma0l","MAJh","MAJl","u64.add","All","u64.add3L","u64.add3H","SHA384","sha256","sha224","sha512","sha384","_0n","_1n","_2n","_7n","_256n","_0x71n","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","round","R","x","y","push","t","j","IOTAS","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","rotlBH","rotlSH","rotlL","rotlBL","rotlSL","Keccak","keccak","state32","rounds","idx1","idx0","B0","B1","Th","Tl","curH","curL","PI","keccakP","posOut","finish","suffix","writeInto","bufferOut","xofInto","enableXOF","xof","bytes","floor","gen","sha3_224","sha3_256","sha3_384","sha3_512","globalScope","globalThis","defineProperty","prototype","configurable","__GLOBALTHIS__","self","window","global","nobleHashes","canonicalizeAlgorithm","algorithm","test","TypeError","ALPHABET","base32Decode","end","replace","substring","toUpperCase","bits","index","idx","indexOf","base32Encode","hexDecode","parseInt","hexEncode","hex","toString","latin1Decode","charCodeAt","latin1Encode","String","fromCharCode","ENCODER","DECODER","TextDecoder","utf8Decode","utf8Encode","decode","Secret","fromLatin1","fromUTF8","fromBase32","fromHex","latin1","enumerable","writable","utf8","base32","size","crypto","getRandomValues","randomBytes","HOTP","defaults","issuer","label","issuerInLabel","digits","counter","generate","secret","hmacDigest","num","acc","uintDecode","padStart","validate","token","delta","check","generatedToken","timingSafeEqual","e","encodeURIComponent","TOTP","period","timestamp","Date","now","remaining","OTPURI_REGEX","SECRET_REGEX","ALGORITHM_REGEX","INTEGER_REGEX","POSITIVE_INTEGER_REGEX","parse","uri","uriGroups","match","_","Array","isArray","URIError","uriType","toLowerCase","uriLabel","decodeURIComponent","uriParams","reduce","cur","pairArr","pairKey","pairVal","pairAcc","OTP","config","stringify","otp"],"mappings":";;;;8OAoBM,SAAUA,EAAQC,GACtB,IAAKC,OAAOC,cAAcF,IAAMA,EAAI,EAAG,MAAM,IAAIG,MAAM,kCAAoCH,EAC7F,CAGM,SAAUI,EAAOC,KAA8BC,GACnD,MAXsBC,EAWTF,aAVOG,YAAeC,YAAYC,OAAOH,IAA6B,eAAvBA,EAAEI,YAAYC,MAUzD,MAAM,IAAIT,MAAM,uBAX7B,IAAkBI,EAYtB,GAAID,EAAQO,OAAS,IAAMP,EAAQQ,SAAST,EAAEQ,QAC5C,MAAM,IAAIV,MAAM,iCAAmCG,EAAU,gBAAkBD,EAAEQ,OACrF,CAWM,SAAUE,EAAQC,EAAeC,GAAgB,GACrD,GAAID,EAASE,UAAW,MAAM,IAAIf,MAAM,oCACxC,GAAIc,GAAiBD,EAASG,SAAU,MAAM,IAAIhB,MAAM,wCAC1D,CAGM,SAAUiB,EAAQC,EAAUL,GAChCZ,EAAOiB,GACP,MAAMC,EAAMN,EAASO,UACrB,GAAIF,EAAIR,OAASS,EACf,MAAM,IAAInB,MAAM,yDAA2DmB,EAE/E,CAkBM,SAAUE,KAASC,GACvB,IAAK,IAAIC,EAAI,EAAGA,EAAID,EAAOZ,OAAQa,IACjCD,EAAOC,GAAGC,KAAK,EAEnB,CAGM,SAAUC,EAAWC,GACzB,OAAO,IAAIC,SAASD,EAAIE,OAAQF,EAAIG,WAAYH,EAAII,WACtD,CAGM,SAAUC,EAAKC,EAAcC,GACjC,OAAOD,GAAU,GAAKC,EAAWD,IAASC,CAC5C,CAGM,SAAUC,EAAKF,EAAcC,GACjC,OAAOD,GAASC,EAAUD,IAAU,GAAMC,IAAY,CACxD,CAOM,SAAUE,EAASH,GACvB,OAAOA,GACK,GAAM,WACfA,GAAS,EAAK,SACbA,IAAS,EAAK,MACfA,IAAU,GAAM,GAErB,CAgBO,MAAMI,EA3B+B,KACkB,KAA5D,IAAI/B,WAAW,IAAIgC,YAAY,CAAC,YAAaT,QAAQ,GADX,GA4BvCU,GAAmBA,EARlB,SAAqBZ,GACzB,IAAK,IAAIH,EAAI,EAAGA,EAAIG,EAAIhB,OAAQa,IAC9BG,EAAIH,GAAKY,EAAST,EAAIH,IAExB,OAAOG,CACT,EAqHM,SAAUa,EAAQC,GAGtB,MAFoB,iBAATA,IAAmBA,EArB1B,SAAsBC,GAC1B,GAAmB,iBAARA,EAAkB,MAAM,IAAIzC,MAAM,mBAC7C,OAAO,IAAIK,YAAW,IAAIqC,aAAcC,OAAOF,GACjD,CAkBuCG,CAAYJ,IACjDvC,EAAOuC,GACAA,CACT,CAmDM,MAAgBK,GA4ChB,SAAUC,EACdC,GAOA,MAAMC,EAASC,GAA2BF,IAAWG,OAAOX,EAAQU,IAAME,SACpEC,EAAML,IAIZ,OAHAC,EAAM5B,UAAYgC,EAAIhC,UACtB4B,EAAMK,SAAWD,EAAIC,SACrBL,EAAMM,OAAS,IAAMP,IACdC,CACT,CCrVM,MAAOO,UAAgCV,EA8B3C,MAAAK,CAAOM,GAGL,OAFA5C,EAAQ6C,MACRA,KAAKC,MAAMR,OAAOM,GACXC,IACT,CACA,UAAAE,CAAWzC,GACTN,EAAQ6C,MACRxD,EAAOiB,EAAKuC,KAAKrC,WACjBqC,KAAKzC,UAAW,EAChByC,KAAKC,MAAMC,WAAWzC,GACtBuC,KAAKG,MAAMV,OAAOhC,GAClBuC,KAAKG,MAAMD,WAAWzC,GACtBuC,KAAKI,SACP,CACA,MAAAV,GACE,MAAMjC,EAAM,IAAIb,WAAWoD,KAAKG,MAAMxC,WAEtC,OADAqC,KAAKE,WAAWzC,GACTA,CACT,CACA,UAAA4C,CAAWC,GAETA,IAAAA,EAAOC,OAAOV,OAAOU,OAAOC,eAAeR,MAAO,CAAA;CAClD,MAAMG,MAAEA,EAAKF,MAAEA,EAAK1C,SAAEA,EAAQD,UAAEA,EAASsC,SAAEA,EAAQjC,UAAEA,GAAcqC,KAQnE,OANAM,EAAG/C,SAAWA,EACd+C,EAAGhD,UAAYA,EACfgD,EAAGV,SAAWA,EACdU,EAAG3C,UAAYA,EACf2C,EAAGH,MAAQA,EAAME,WAAWC,EAAGH,OAC/BG,EAAGL,MAAQA,EAAMI,WAAWC,EAAGL,OACxBK,CACT,CACA,KAAAG,GACE,OAAOT,KAAKK,YACd,CACA,OAAAD,GACEJ,KAAK1C,WAAY,EACjB0C,KAAKG,MAAMC,UACXJ,KAAKC,MAAMG,SACb,CA7DA,WAAArD,CAAY2D,EAAaC,GACvBC,QAJMZ,KAAAzC,UAAW,EACXyC,KAAA1C,WAAY,EDoBhB,SAAgBuD,GACpB,GAAiB,mBAANA,GAAwC,mBAAbA,EAAEhB,OACtC,MAAM,IAAItD,MAAM,gDAClBJ,EAAQ0E,EAAElD,WACVxB,EAAQ0E,EAAEjB,SACZ,CCrBIkB,CAAMJ,GACN,MAAMK,EAAMjC,EAAQ6B,GAEpB,GADAX,KAAKC,MAAQS,EAAKb,SACe,mBAAtBG,KAAKC,MAAMR,OACpB,MAAM,IAAIlD,MAAM,uDAClByD,KAAKJ,SAAWI,KAAKC,MAAML,SAC3BI,KAAKrC,UAAYqC,KAAKC,MAAMtC,UAC5B,MAAMiC,EAAWI,KAAKJ,SAChBoB,EAAM,IAAIpE,WAAWgD,GAE3BoB,EAAIC,IAAIF,EAAI9D,OAAS2C,EAAWc,EAAKb,SAASJ,OAAOsB,GAAKrB,SAAWqB,GACrE,IAAK,IAAIjD,EAAI,EAAGA,EAAIkD,EAAI/D,OAAQa,IAAKkD,EAAIlD,IAAM,GAC/CkC,KAAKC,MAAMR,OAAOuB,GAElBhB,KAAKG,MAAQO,EAAKb,SAElB,IAAK,IAAI/B,EAAI,EAAGA,EAAIkD,EAAI/D,OAAQa,IAAKkD,EAAIlD,IAAM,IAC/CkC,KAAKG,MAAMV,OAAOuB,GAClBpD,EAAMoD,EACR,EAqDK,MAAME,EAGT,CAACR,EAAaK,EAAYI,IAC5B,IAAIrB,EAAUY,EAAMK,GAAKtB,OAAO0B,GAASzB,SCnErC,SAAU0B,EAAIzE,EAAWF,EAAW4E,GACxC,OAAO1E,EAAKF,GAAOE,EAAI0E,CACzB,CAGM,SAAUC,EAAI3E,EAAWF,EAAW4E,GACxC,OAAO1E,EAAKF,EAAME,EAAI0E,EAAM5E,EAAI4E,CAClC,CD6DAH,EAAKrB,OAAS,CAACa,EAAaK,IAAe,IAAIjB,EAAUY,EAAMK,GCvDzD,MAAgBQ,UAAoCnC,EA6BxD,MAAAK,CAAOV,GACL5B,EAAQ6C,MAERxD,EADAuC,EAAOD,EAAQC,IAEf,MAAMyC,KAAEA,EAAIrD,OAAEA,EAAMyB,SAAEA,GAAaI,KAC7ByB,EAAM1C,EAAK9B,OACjB,IAAK,IAAIyE,EAAM,EAAGA,EAAMD,GAAO,CAC7B,MAAME,EAAOC,KAAKlE,IAAIkC,EAAWI,KAAK0B,IAAKD,EAAMC,GAEjD,GAAIC,IAAS/B,EAAU,CACrB,MAAMiC,EAAW7D,EAAWe,GAC5B,KAAOa,GAAY6B,EAAMC,EAAKA,GAAO9B,EAAUI,KAAK8B,QAAQD,EAAUH,GACtE,QACF,CACAvD,EAAO8C,IAAIlC,EAAKgD,SAASL,EAAKA,EAAMC,GAAO3B,KAAK0B,KAChD1B,KAAK0B,KAAOC,EACZD,GAAOC,EACH3B,KAAK0B,MAAQ9B,IACfI,KAAK8B,QAAQN,EAAM,GACnBxB,KAAK0B,IAAM,EAEf,CAGA,OAFA1B,KAAK/C,QAAU8B,EAAK9B,OACpB+C,KAAKgC,aACEhC,IACT,CACA,UAAAE,CAAWzC,GACTN,EAAQ6C,MACRxC,EAAQC,EAAKuC,MACbA,KAAKzC,UAAW,EAIhB,MAAMY,OAAEA,EAAMqD,KAAEA,EAAI5B,SAAEA,EAAQqC,KAAEA,GAASjC,KACzC,IAAI0B,IAAEA,GAAQ1B,KAEd7B,EAAOuD,KAAS,IAChB9D,EAAMoC,KAAK7B,OAAO4D,SAASL,IAGvB1B,KAAKkC,UAAYtC,EAAW8B,IAC9B1B,KAAK8B,QAAQN,EAAM,GACnBE,EAAM,GAGR,IAAK,IAAI5D,EAAI4D,EAAK5D,EAAI8B,EAAU9B,IAAKK,EAAOL,GAAK,GAzG/C,SACJ0D,EACApD,EACA+D,EACAF,GAEA,GAAiC,mBAAtBT,EAAKY,aAA6B,OAAOZ,EAAKY,aAAahE,EAAY+D,EAAOF,GACzF,MAAMI,EAAOC,OAAO,IACdC,EAAWD,OAAO,YAClBE,EAAKnG,OAAO8F,GAAUE,EAAQE,GAC9BE,EAAKpG,OAAO8F,EAAQI,GACpB1B,EAAIoB,EAAO,EAAI,EACfS,EAAIT,EAAO,EAAI,EACrBT,EAAKmB,UAAUvE,EAAayC,EAAG2B,EAAIP,GACnCT,EAAKmB,UAAUvE,EAAasE,EAAGD,EAAIR,EACrC,CA8FIG,CAAaZ,EAAM5B,EAAW,EAAG0C,OAAqB,EAAdtC,KAAK/C,QAAagF,GAC1DjC,KAAK8B,QAAQN,EAAM,GACnB,MAAMoB,EAAQ5E,EAAWP,GACnBgE,EAAMzB,KAAKrC;CAEjB,GAAI8D,EAAM,EAAG,MAAM,IAAIlF,MAAM,+CAC7B,MAAMsG,EAASpB,EAAM,EACfqB,EAAQ9C,KAAK+C,MACnB,GAAIF,EAASC,EAAM7F,OAAQ,MAAM,IAAIV,MAAM,sCAC3C,IAAK,IAAIuB,EAAI,EAAGA,EAAI+E,EAAQ/E,IAAK8E,EAAMD,UAAU,EAAI7E,EAAGgF,EAAMhF,GAAImE,EACpE,CACA,MAAAvC,GACE,MAAMvB,OAAEA,EAAMR,UAAEA,GAAcqC,KAC9BA,KAAKE,WAAW/B,GAChB,MAAM6E,EAAM7E,EAAO8E,MAAM,EAAGtF,GAE5B,OADAqC,KAAKI,UACE4C,CACT,CACA,UAAA3C,CAAWC,GACTA,IAAAA,EAAO,IAAKN,KAAKjD,aACjBuD,EAAGW,OAAOjB,KAAK+C,OACf,MAAMnD,SAAEA,EAAQzB,OAAEA,EAAMlB,OAAEA,EAAMM,SAAEA,EAAQD,UAAEA,EAASoE,IAAEA,GAAQ1B,KAM/D,OALAM,EAAGhD,UAAYA,EACfgD,EAAG/C,SAAWA,EACd+C,EAAGrD,OAASA,EACZqD,EAAGoB,IAAMA,EACLzE,EAAS2C,GAAUU,EAAGnC,OAAO8C,IAAI9C,GAC9BmC,CACT,CACA,KAAAG,GACE,OAAOT,KAAKK,YACd,CAzFA,WAAAtD,CAAY6C,EAAkBjC,EAAmBuE,EAAmBD,GAClErB,QANQZ,KAAAzC,UAAW,EACXyC,KAAA/C,OAAS,EACT+C,KAAA0B,IAAM,EACN1B,KAAA1C,WAAY,EAIpB0C,KAAKJ,SAAWA,EAChBI,KAAKrC,UAAYA,EACjBqC,KAAKkC,UAAYA,EACjBlC,KAAKiC,KAAOA,EACZjC,KAAK7B,OAAS,IAAIvB,WAAWgD,GAC7BI,KAAKwB,KAAOxD,EAAWgC,KAAK7B,OAC9B,EA0FK,MAAM+E,EAAyCtE,YAAYuE,KAAK,CACrE,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,aAIzEC,EAAyCxE,YAAYuE,KAAK,CACrE,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,aAIzEE,EAAyCzE,YAAYuE,KAAK,CACrE,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,aAIzEG,EAAyC1E,YAAYuE,KAAK,CACrE,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,YChKhFI,EAA0B3E,YAAYuE,KAAK,CAC/C,WAAY,WAAY,WAAY,UAAY,aAI5CK,EAAyB,IAAI5E,YAAY,IAGzC,MAAO6E,UAAalC,EAUd,GAAAwB,GACR,MAAMW,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,GAAM9D,KAC1B,MAAO,CAAC0D,EAAGC,EAAGC,EAAGC,EAAGC,EACtB,CACU,GAAA7C,CAAIyC,EAAWC,EAAWC,EAAWC,EAAWC,GACxD9D,KAAK0D,EAAQ,EAAJA,EACT1D,KAAK2D,EAAQ,EAAJA,EACT3D,KAAK4D,EAAQ,EAAJA,EACT5D,KAAK6D,EAAQ,EAAJA,EACT7D,KAAK8D,EAAQ,EAAJA,CACX,CACU,OAAAhC,CAAQN,EAAgBuC,GAChC,IAAK,IAAIjG,EAAI,EAAGA,EAAI,GAAIA,IAAKiG,GAAU,EAAGP,EAAO1F,GAAK0D,EAAKwC,UAAUD,GAAQ,GAC7E,IAAK,IAAIjG,EAAI,GAAIA,EAAI,GAAIA,IACvB0F,EAAO1F,GAAKW,EAAK+E,EAAO1F,EAAI,GAAK0F,EAAO1F,EAAI,GAAK0F,EAAO1F,EAAI,IAAM0F,EAAO1F,EAAI,IAAK,GAEpF,IAAI4F,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,GAAM9D,KACxB,IAAK,IAAIlC,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAC3B,IAAImG,EAAGC,EACHpG,EAAI,IACNmG,EAAI7C,EAAIuC,EAAGC,EAAGC,GACdK,EAAI,YACKpG,EAAI,IACbmG,EAAIN,EAAIC,EAAIC,EACZK,EAAI,YACKpG,EAAI,IACbmG,EAAI3C,EAAIqC,EAAGC,EAAGC,GACdK,EAAI,aAEJD,EAAIN,EAAIC,EAAIC,EACZK,EAAI,YAEN,MAAMC,EAAI1F,EAAMiF,EAAG,GAAKO,EAAIH,EAAII,EAAIV,EAAO1F,GAAM,EACjDgG,EAAID,EACJA,EAAID,EACJA,EAAInF,EAAKkF,EAAG,IACZA,EAAID,EACJA,EAAIS,CACN,CAEAT,EAAIA,EAAK1D,KAAK0D,EAAK,EACnBC,EAAIA,EAAK3D,KAAK2D,EAAK,EACnBC,EAAIA,EAAK5D,KAAK4D,EAAK,EACnBC,EAAIA,EAAK7D,KAAK6D,EAAK,EACnBC,EAAIA,EAAK9D,KAAK8D,EAAK;AACnB9D,KAAKiB,IAAIyC,EAAGC,EAAGC,EAAGC,EAAGC,EACvB,CACU,UAAA9B,GACRpE,EAAM4F,EACR,CACA,OAAApD,GACEJ,KAAKiB,IAAI,EAAG,EAAG,EAAG,EAAG,GACrBrD,EAAMoC,KAAK7B,OACb,CAxDA,WAAApB,GACE6D,MAAM,GAAI,GAAI,GAAG,GAPXZ,KAAA0D,EAAiB,EAAbH,EAAQ,GACZvD,KAAA2D,EAAiB,EAAbJ,EAAQ,GACZvD,KAAA4D,EAAiB,EAAbL,EAAQ,GACZvD,KAAA6D,EAAiB,EAAbN,EAAQ,GACZvD,KAAA8D,EAAiB,EAAbP,EAAQ,EAIpB,EA0DK,MAAMa,EAA8B/E,EAAa,IAAM,IAAIoE,GCpF5DY,EAA6B/B,OAAO,GAAK,GAAK,GAC9CD,EAAuBC,OAAO,IAEpC,SAASgC,EACPlI,EACAmI,GAAK,GAKL,OAAIA,EAAW,CAAE1D,EAAGxE,OAAOD,EAAIiI,GAAa3B,EAAGrG,OAAQD,GAAKiG,EAAQgC,IAC7D,CAAExD,EAAsC,EAAnCxE,OAAQD,GAAKiG,EAAQgC,GAAiB3B,EAA4B,EAAzBrG,OAAOD,EAAIiI,GAClE,CAEA,SAASG,EAAMC,EAAeF,GAAK,GACjC,MAAM9C,EAAMgD,EAAIxH,OAChB,IAAIyH,EAAK,IAAI9F,YAAY6C,GACrBkD,EAAK,IAAI/F,YAAY6C,GACzB,IAAK,IAAI3D,EAAI,EAAGA,EAAI2D,EAAK3D,IAAK,CAC5B,MAAM+C,EAAEA,EAAC6B,EAAEA,GAAM4B,EAAQG,EAAI3G,GAAIyG,IAChCG,EAAG5G,GAAI6G,EAAG7G,IAAM,CAAC+C,EAAG6B,EACvB,CACA,MAAO,CAACgC,EAAIC,EACd,CAIA,MAAMC,EAAQ,CAAC/D,EAAWgE,EAAYC,IAAsBjE,IAAMiE,EAC5DC,EAAQ,CAAClE,EAAW6B,EAAWoC,IAAuBjE,GAAK,GAAMiE,EAAOpC,IAAMoC,EAE9EE,EAAS,CAACnE,EAAW6B,EAAWoC,IAAuBjE,IAAMiE,EAAMpC,GAAK,GAAMoC,EAC9EG,EAAS,CAACpE,EAAW6B,EAAWoC,IAAuBjE,GAAK,GAAMiE,EAAOpC,IAAMoC,EAE/EI,EAAS,CAACrE,EAAW6B,EAAWoC,IAAsBjE,GAAO,GAAKiE,EAAOpC,IAAOoC,EAAI,GACpFK,EAAS,CAACtE,EAAW6B,EAAWoC,IAAuBjE,IAAOiE,EAAI,GAAQpC,GAAM,GAAKoC,EAa3F,SAASM,EACPV,EACAC,EACAU,EACAC,GAKA,MAAM5C,GAAKiC,IAAE,IAAUW,IAAG,GAC1B,MAAO,CAAEzE,EAAI6D,EAAKW,GAAM3C,EAAK,GAAK,GAAG,GAAS,EAAGA,EAAO,EAAJA,EACtD,CAEA,MAAM6C,EAAQ,CAACZ,EAAYW,EAAYE,KAAwBb,IAAE,IAAWW,IAAE,IAAUE,IAAG,GACrFC,EAAQ,CAACC,EAAahB,EAAYW,EAAYM,IAClDjB,EAAMW,EAAKM,GAAOD,EAAM,GAAK,MAAY,EACrCE,EAAQ,CAACjB,EAAYW,EAAYE,EAAYK,KAAsBlB,QACzDW,IAAE,IAAUE,IAAG,IAAUK,IAAG,GACtCC,EAAQ,CAACJ,EAAahB,EAAYW,EAAYM,EAAYI,IAC9DrB,EAAMW,EAAKM,EAAKI,GAAML,EAAO,GAAK,GAAG,GAAS,EAC1CM,EAAQ,CAACrB,EAAYW,EAAYE,EAAYK,EAAYI,KAC5DtB,IAAE,IAAWW,IAAE,IAAWE,IAAE,IAAWK,IAAE,IAAWI,IAAE,GACnDC,EAAQ,CAACR,EAAahB,EAAYW,EAAYM,EAAYI,EAAYI,IACzEzB,EAAKW,EAAKM,EAAKI,EAAKI,GAAMT,EAAO,GAAK,GAAG,GAAS,EC3D/CU,EAA2BxH,YAAYuE,KAAK,CAChD,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WACpF,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UACpF,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UACpF,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WACpF,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,aAIhFkD,EAA2B,IAAIzH,YAAY,IAC3C,MAAO0H,UAAe/E,EAehB,GAAAwB,GACR,MAAMW,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACG,EAAEA,EAACsC,EAAEA,EAACC,EAAEA,GAAMxG,KACnC,MAAO,CAAC0D,EAAGC,EAAGC,EAAGC,EAAGC,EAAGG,EAAGsC,EAAGC,EAC/B,CAEU,GAAAvF,CACRyC,EAAWC,EAAWC,EAAWC,EAAWC,EAAWG,EAAWsC,EAAWC,GAE7ExG,KAAK0D,EAAQ,EAAJA,EACT1D,KAAK2D,EAAQ,EAAJA,EACT3D,KAAK4D,EAAQ,EAAJA,EACT5D,KAAK6D,EAAQ,EAAJA,EACT7D,KAAK8D,EAAQ,EAAJA,EACT9D,KAAKiE,EAAQ,EAAJA,EACTjE,KAAKuG,EAAQ,EAAJA,EACTvG,KAAKwG,EAAQ,EAAJA,CACX,CACU,OAAA1E,CAAQN,EAAgBuC,GAEhC,IAAK,IAAIjG,EAAI,EAAGA,EAAI,GAAIA,IAAKiG,GAAU,EAAGsC,EAASvI,GAAK0D,EAAKwC,UAAUD,GAAQ,GAC/E,IAAK,IAAIjG,EAAI,GAAIA,EAAI,GAAIA,IAAK;AAC5B,MAAM2I,EAAMJ,EAASvI,EAAI,IACnB4I,EAAKL,EAASvI,EAAI,GAClB6I,EAAKrI,EAAKmI,EAAK,GAAKnI,EAAKmI,EAAK,IAAOA,IAAQ,EAC7CG,EAAKtI,EAAKoI,EAAI,IAAMpI,EAAKoI,EAAI,IAAOA,IAAO,GACjDL,EAASvI,GAAM8I,EAAKP,EAASvI,EAAI,GAAK6I,EAAKN,EAASvI,EAAI,IAAO,CACjE,CAEA,IAAI4F,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACC,EAAEA,EAACG,EAAEA,EAACsC,EAAEA,EAACC,EAAEA,GAAMxG,KACjC,IAAK,IAAIlC,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAC3B,MACM+I,EAAKL,GADIlI,EAAKwF,EAAG,GAAKxF,EAAKwF,EAAG,IAAMxF,EAAKwF,EAAG,KACzB1C,EAAI0C,EAAGG,EAAGsC,GAAKH,EAAStI,GAAKuI,EAASvI,GAAM,EAE/DgJ,GADSxI,EAAKoF,EAAG,GAAKpF,EAAKoF,EAAG,IAAMpF,EAAKoF,EAAG,KAC7BpC,EAAIoC,EAAGC,EAAGC,GAAM,EACrC4C,EAAID,EACJA,EAAItC,EACJA,EAAIH,EACJA,EAAID,EAAKgD,EAAM,EACfhD,EAAID,EACJA,EAAID,EACJA,EAAID,EACJA,EAAImD,EAAMC,EAAM,CAClB,CAEApD,EAAIA,EAAK1D,KAAK0D,EAAK,EACnBC,EAAIA,EAAK3D,KAAK2D,EAAK,EACnBC,EAAIA,EAAK5D,KAAK4D,EAAK,EACnBC,EAAIA,EAAK7D,KAAK6D,EAAK,EACnBC,EAAIA,EAAK9D,KAAK8D,EAAK,EACnBG,EAAIA,EAAKjE,KAAKiE,EAAK,EACnBsC,EAAIA,EAAKvG,KAAKuG,EAAK,EACnBC,EAAIA,EAAKxG,KAAKwG,EAAK,EACnBxG,KAAKiB,IAAIyC,EAAGC,EAAGC,EAAGC,EAAGC,EAAGG,EAAGsC,EAAGC,EAChC,CACU,UAAAxE,GACRpE,EAAMyI,EACR,CACA,OAAAjG,GACEJ,KAAKiB,IAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAC9BrD,EAAMoC,KAAK7B,OACb,CA/DA,WAAApB,CAAYY,EAAoB,IAC9BiD,MAAM,GAAIjD,EAAW,GAAG,GAVhBqC,KAAA0D,EAA2B,EAAfR,EAAU,GACtBlD,KAAA2D,EAA2B,EAAfT,EAAU,GACtBlD,KAAA4D,EAA2B,EAAfV,EAAU,GACtBlD,KAAA6D,EAA2B,EAAfX,EAAU,GACtBlD,KAAA8D,EAA2B,EAAfZ,EAAU,GACtBlD,KAAAiE,EAA2B,EAAff,EAAU,GACtBlD,KAAAuG,EAA2B,EAAfrD,EAAU,GACtBlD,KAAAwG,EAA2B,EAAftD,EAAU,EAIhC,EAgEI,MAAO6D,UAAeT,EAS1B,WAAAvJ,GACE6D,MAAM,IATEZ,KAAA0D,EAA2B,EAAfN,EAAU,GACtBpD,KAAA2D,EAA2B,EAAfP,EAAU,GACtBpD,KAAA4D,EAA2B,EAAfR,EAAU,GACtBpD,KAAA6D,EAA2B,EAAfT,EAAU,GACtBpD,KAAA8D,EAA2B,EAAfV,EAAU,GACtBpD,KAAAiE,EAA2B,EAAfb,EAAU,GACtBpD,KAAAuG,EAA2B,EAAfnD,EAAU,GACtBpD,KAAAwG,EAA2B,EAAfpD,EAAU,EAGhC;AAQF,MAAM4D,EAAsB,KAAQC,EAAU,CAC5C,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,qBAClE,qBAAsB,qBAAsB,qBAAsB,sBAClEC,IAAI9K,GAAIkG,OAAQlG,KArBU,GAsBtB+K,EAA6B,KAAMH,EAAK,GAAX,GAC7BI,EAA2B,KAAQJ,EAAK,GAAb,GAG3BK,EAA6B,IAAIzI,YAAY,IAC7C0I,EAA6B,IAAI1I,YAAY,IAE7C,MAAO2I,UAAehG,EAyBhB,GAAAwB,GAIR,MAAM2B,GAAEA,EAAEC,GAAEA,EAAEU,GAAEA,EAAEC,GAAEA,EAAEK,GAAEA,EAAEH,GAAEA,EAAEO,GAAEA,EAAEF,GAAEA,EAAEM,GAAEA,EAAEF,GAAEA,EAAEuB,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,GAAO7H,KAC3E,MAAO,CAAC0E,EAAIC,EAAIU,EAAIC,EAAIK,EAAIH,EAAIO,EAAIF,EAAIM,EAAIF,EAAIuB,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EACtE,CAEU,GAAA5G,CACRyD,EAAYC,EAAYU,EAAYC,EAAYK,EAAYH,EAAYO,EAAYF,EACpFM,EAAYF,EAAYuB,EAAYC,EAAYC,EAAYC,EAAYC,EAAYC,GAEpF7H,KAAK0E,GAAU,EAALA,EACV1E,KAAK2E,GAAU,EAALA,EACV3E,KAAKqF,GAAU,EAALA,EACVrF,KAAKsF,GAAU,EAALA,EACVtF,KAAK2F,GAAU,EAALA;AACV3F,KAAKwF,GAAU,EAALA,EACVxF,KAAK+F,GAAU,EAALA,EACV/F,KAAK6F,GAAU,EAALA,EACV7F,KAAKmG,GAAU,EAALA,EACVnG,KAAKiG,GAAU,EAALA,EACVjG,KAAKwH,GAAU,EAALA,EACVxH,KAAKyH,GAAU,EAALA,EACVzH,KAAK0H,GAAU,EAALA,EACV1H,KAAK2H,GAAU,EAALA,EACV3H,KAAK4H,GAAU,EAALA,EACV5H,KAAK6H,GAAU,EAALA,CACZ,CACU,OAAA/F,CAAQN,EAAgBuC,GAEhC,IAAK,IAAIjG,EAAI,EAAGA,EAAI,GAAIA,IAAKiG,GAAU,EACrCsD,EAAWvJ,GAAK0D,EAAKwC,UAAUD,GAC/BuD,EAAWxJ,GAAK0D,EAAKwC,UAAWD,GAAU,GAE5C,IAAK,IAAIjG,EAAI,GAAIA,EAAI,GAAIA,IAAK,CAE5B,MAAMgK,EAA4B,EAArBT,EAAWvJ,EAAI,IACtBiK,EAA4B,EAArBT,EAAWxJ,EAAI,IACtBkK,EAAMC,EAAWH,EAAMC,EAAM,GAAKE,EAAWH,EAAMC,EAAM,GAAKG,EAAUJ,EAAMC,EAAM,GACpFI,EAAMC,EAAWN,EAAMC,EAAM,GAAKK,EAAWN,EAAMC,EAAM,GAAKM,EAAUP,EAAMC,EAAM,GAEpFO,EAA0B,EAApBjB,EAAWvJ,EAAI,GACrByK,EAA0B,EAApBjB,EAAWxJ,EAAI,GACrB0K,EAAMP,EAAWK,EAAKC,EAAK,IAAME,EAAWH,EAAKC,EAAK,IAAML,EAAUI,EAAKC,EAAK,GAChFG,EAAMN,EAAWE,EAAKC,EAAK,IAAMI,EAAWL,EAAKC,EAAK,IAAMF,EAAUC,EAAKC,EAAK,GAEhFK,EAAOC,EAAUV,EAAKO,EAAKpB,EAAWxJ,EAAI,GAAIwJ,EAAWxJ,EAAI,KAC7DgL,EAAOC,EAAUH,EAAMZ,EAAKQ,EAAKnB,EAAWvJ,EAAI,GAAIuJ,EAAWvJ,EAAI,KACzEuJ,EAAWvJ,GAAY,EAAPgL,EAChBxB,EAAWxJ,GAAY,EAAP8K,CAClB,CACA,IAAIlE,GAAEA,EAAEC,GAAEA,EAAEU,GAAEA,EAAEC,GAAEA,EAAEK,GAAEA,EAAEH,GAAEA,EAAEO,GAAEA,EAAEF,GAAEA,EAAEM,GAAEA,EAAEF,GAAEA,EAAEuB,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,EAAEC,GAAEA,GAAO7H,KAEzE,IAAK,IAAIlC,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAE3B,MAAMkL,EAAUf,EAAW9B,EAAIF,EAAI,IAAMgC,EAAW9B,EAAIF,EAAI,IAAMwC,EAAWtC,EAAIF,EAAI,IAC/EgD,EAAUb,EAAWjC,EAAIF,EAAI,IAAMmC,EAAWjC,EAAIF,EAAI,IAAM0C,EAAWxC,EAAIF,EAAI,IAE/EiD,EAAQ/C,EAAKqB,GAAMrB,EAAOuB,EAI1ByB,EAAOC,EAAUvB,EAAIoB,EAHdhD,EAAMwB,GAAMxB,EAAO0B,EAGUP,EAAUtJ,GAAIwJ,EAAWxJ,IAC7DuL,EAAMC,EAAUH,EAAMvB,EAAIoB,EAASE,EAAM/B,EAAUrJ,GAAIuJ,EAAWvJ,IAClEyL,EAAa,EAAPJ,EAENK,EAAUvB,EAAWvD,EAAIC,EAAI,IAAM8D,EAAW/D,EAAIC,EAAI,IAAM8D,EAAW/D,EAAIC,EAAI,IAC/E8E,EAAUrB,EAAW1D,EAAIC,EAAI,IAAMgE,EAAWjE,EAAIC,EAAI,IAAMgE,EAAWjE,EAAIC,EAAI,IAC/E+E,EAAOhF,EAAMW,EAAOX,EAAKiB,EAAON,EAAKM,EACrCgE,EAAQhF,EAAKW,EAAOX,EAAKa,EAAOF,EAAKE,EAC3CoC,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALF,EACLG,EAAU,EAALF,EACLD,EAAU,EAALrB,EACLsB,EAAU,EAALxB,IACFpF,EAAGsF,EAAIzD,EAAGuD,GAAO2D,EAAa,EAAL7D,EAAa,EAALF,EAAc,EAANwD,EAAe,EAANE,IACrDxD,EAAU,EAALJ,EACLE,EAAU,EAALL,EACLG,EAAU,EAALN,EACLG,EAAU,EAALF,EACLD,EAAU,EAALX,EACLY,EAAU,EAALX,EACL,MAAMkF,EAAMC,EAAUP,EAAKE,EAASE,GACpCjF,EAAKqF,EAAUF,EAAKR,EAAKG,EAASE,GAClC/E,EAAW,EAANkF,CACP,GAEGhJ,EAAG6D,EAAIhC,EAAGiC,GAAOiF,EAAkB,EAAV5J,KAAK0E,GAAkB,EAAV1E,KAAK2E,GAAa,EAALD,EAAa,EAALC,MAC3D9D,EAAGwE,EAAI3C,EAAG4C,GAAOsE,EAAkB,EAAV5J,KAAKqF,GAAkB,EAAVrF,KAAKsF,GAAa,EAALD,EAAa,EAALC,MAC3DzE,EAAG8E,EAAIjD,EAAG8C,GAAOoE,EAAkB,EAAV5J,KAAK2F,GAAkB,EAAV3F,KAAKwF,GAAa,EAALG,EAAa,EAALH,MAC3D3E,EAAGkF,EAAIrD,EAAGmD,GAAO+D,EAAkB,EAAV5J,KAAK+F,GAAkB,EAAV/F,KAAK6F,GAAa,EAALE,EAAa,EAALF,MAC3DhF,EAAGsF,EAAIzD,EAAGuD,GAAO2D,EAAkB,EAAV5J,KAAKmG,GAAkB,EAAVnG,KAAKiG,GAAa,EAALE,EAAa,EAALF,MAC3DpF,EAAG2G,EAAI9E,EAAG+E,GAAOmC,EAAkB,EAAV5J,KAAKwH,GAAkB,EAAVxH,KAAKyH,GAAa,EAALD,EAAa,EAALC,MAC3D5G,EAAG6G,EAAIhF,EAAGiF,GAAOiC,EAAkB,EAAV5J,KAAK0H,GAAkB,EAAV1H,KAAK2H,GAAa,EAALD,EAAa,EAALC,MAC3D9G,EAAG+G,EAAIlF,EAAGmF,GAAO+B,EAAkB,EAAV5J,KAAK4H,GAAkB,EAAV5H,KAAK6H,GAAa,EAALD,EAAa,EAALC,IAC9D7H,KAAKiB,IAAIyD,EAAIC,EAAIU,EAAIC,EAAIK,EAAIH,EAAIO,EAAIF,EAAIM,EAAIF,EAAIuB,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EACvE,CACU,UAAA7F,GACRpE,EAAMyJ,EAAYC,EACpB,CACA,OAAAlH,GACExC,EAAMoC,KAAK7B,QACX6B,KAAKiB,IAAI,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EACxD,CA7GA,WAAAlE,CAAYY,EAAoB,IAC9BiD,MAAM,IAAKjD,EAAW,IAAI,GAlBlBqC,KAAA0E,GAA4B,EAAfpB,EAAU,GACvBtD,KAAA2E,GAA4B,EAAfrB,EAAU,GACvBtD,KAAAqF,GAA4B,EAAf/B,EAAU,GACvBtD,KAAAsF,GAA4B,EAAfhC,EAAU,GACvBtD,KAAA2F,GAA4B,EAAfrC,EAAU,GACvBtD,KAAAwF,GAA4B,EAAflC,EAAU,GACvBtD,KAAA+F,GAA4B,EAAfzC,EAAU,GACvBtD,KAAA6F,GAA4B,EAAfvC,EAAU,GACvBtD,KAAAmG,GAA4B,EAAf7C,EAAU,GACvBtD,KAAAiG,GAA4B,EAAf3C,EAAU,GACvBtD,KAAAwH,GAA6B,EAAhBlE,EAAU,IACvBtD,KAAAyH,GAA6B,EAAhBnE,EAAU,IACvBtD,KAAA0H,GAA6B,EAAhBpE,EAAU,IACvBtD,KAAA2H,GAA6B,EAAhBrE,EAAU,IACvBtD,KAAA4H,GAA6B,EAAhBtE,EAAU,IACvBtD,KAAA6H,GAA6B,EAAhBvE,EAAU,GAIjC,EA8GI,MAAO0G,WAAezC,EAkB1B,WAAAxK,GACE6D,MAAM,IAlBEZ,KAAA0E,GAA4B,EAAfrB,EAAU,GACvBrD,KAAA2E,GAA4B,EAAftB,EAAU,GACvBrD,KAAAqF,GAA4B,EAAfhC,EAAU,GACvBrD,KAAAsF,GAA4B,EAAfjC,EAAU,GACvBrD,KAAA2F,GAA4B,EAAftC,EAAU,GACvBrD,KAAAwF,GAA4B,EAAfnC,EAAU,GACvBrD,KAAA+F,GAA4B,EAAf1C,EAAU,GACvBrD,KAAA6F,GAA4B,EAAfxC,EAAU,GACvBrD,KAAAmG,GAA4B,EAAf9C,EAAU,GACvBrD,KAAAiG,GAA4B,EAAf5C,EAAU,GACvBrD,KAAAwH,GAA6B,EAAhBnE,EAAU,IACvBrD,KAAAyH,GAA6B,EAAhBpE,EAAU,IACvBrD,KAAA0H,GAA6B,EAAhBrE,EAAU,IACvBrD,KAAA2H,GAA6B,EAAhBtE,EAAU,IACvBrD,KAAA4H,GAA6B,EAAhBvE,EAAU,IACvBrD,KAAA6H,GAA6B,EAAhBxE,EAAU,GAIjC;AA2EK,MAAM4G,GAAgC5K,EAAa,IAAM,IAAIiH,GAEvD4D,GAAgC7K,EAAa,IAAM,IAAI0H,GAGvDoD,GAAgC9K,EAAa,IAAM,IAAIkI,GAEvD6C,GAAgC/K,EAAa,IAAM,IAAI2K,IC9W9DK,GAAM/H,OAAO,GACbgI,GAAMhI,OAAO,GACbiI,GAAMjI,OAAO,GACbkI,GAAMlI,OAAO,GACbmI,GAAQnI,OAAO,KACfoI,GAASpI,OAAO,KAChBqI,GAAoB,GACpBC,GAAsB,GACtBC,GAAuB,GAC7B,IAAK,IAAIC,EAAQ,EAAGC,EAAIT,GAAKU,EAAI,EAAGC,EAAI,EAAGH,EAAQ,GAAIA,IAAS,EAE7DE,EAAGC,GAAK,CAACA,GAAI,EAAID,EAAI,KAAS,GAC/BL,GAAQO,KAAK,GAAK,EAAID,EAACD,IAEvBJ,GAAUM,MAAMJ,EAAO,IAAQA,EAAM,GAAS,EAAK,IAEnD,IAAIK,EAAId,GACR,IAAK,IAAIe,EAAI,EAAGA,EAAI,EAAGA,IACrBL,GAAMA,GAAKT,IAASS,GAAKP,IAAOE,IAAWD,GACvCM,EAAIR,KAAKY,GAAKb,KAASA,IAAuBhI,OAAO8I,IAAMd,IAEjEO,GAAWK,KAAKC,EAClB,CACA,MAAME,GAAQ7G,EAAMqG,IAAY,GAC1BS,GAAcD,GAAM,GACpBE,GAAcF,GAAM,GAGpBG,GAAQ,CAAC3K,EAAW6B,EAAWoC,IAAeA,EAAI,GFLzC,EAACjE,EAAW6B,EAAWoC,IAAsBpC,GAAOoC,EAAI,GAAQjE,IAAO,GAAKiE,EEK9B2G,CAAO5K,EAAG6B,EAAGoC,GFR3D,EAACjE,EAAW6B,EAAWoC,IAAuBjE,GAAKiE,EAAMpC,IAAM,GAAMoC,EEQL4G,CAAO7K,EAAG6B,EAAGoC,GACtF6G,GAAQ,CAAC9K,EAAW6B,EAAWoC,IAAeA,EAAI,GFLzC,EAACjE,EAAW6B,EAAWoC,IAAsBjE,GAAOiE,EAAI,GAAQpC,IAAM,GAAMoC,EEK9B8G,CAAO/K,EAAG6B,EAAGoC,GFR3D,EAACjE,EAAW6B,EAAWoC,IAAuBpC,GAAKoC,EAAMjE,IAAM,GAAMiE,EEQL+G,CAAOhL,EAAG6B,EAAGoC,GA+CtF,MAAOgH,WAAe1M,EAqC1B,KAAAqB,GACE,OAAOT,KAAKK,YACd,CACU,MAAA0L,GACRpN,EAAWqB,KAAKgM,SArFd,SAAkBlH,EAAgBmH,EAAiB,IACvD,MAAMtI,EAAI,IAAI/E,YAAY,IAE1B,IAAK,IAAIkM,EAAQ,GAAKmB,EAAQnB,EAAQ,GAAIA,IAAS,CAEjD,IAAK,IAAIE,EAAI,EAAGA,EAAI,GAAIA,IAAKrH,EAAEqH,GAAKlG,EAAEkG,GAAKlG,EAAEkG,EAAI,IAAMlG,EAAEkG,EAAI,IAAMlG,EAAEkG,EAAI,IAAMlG,EAAEkG,EAAI,IACrF,IAAK,IAAIA,EAAI,EAAGA,EAAI,GAAIA,GAAK,EAAG,CAC9B,MAAMkB,GAAQlB,KAAS,GACjBmB,GAAQnB,KAAS,GACjBoB,EAAKzI,EAAEwI,GACPE,EAAK1I,EAAEwI,EAAO,GACdG,EAAKd,GAAMY,EAAIC,EAAI,GAAK1I,EAAEuI,GAC1BK,EAAKZ,GAAMS,EAAIC,EAAI,GAAK1I,EAAEuI,EAAO,GACvC,IAAK,IAAIjB,EAAI,EAAGA,EAAI,GAAIA,GAAK,GAC3BnG,EAAEkG,EAAIC,IAAMqB,EACZxH,EAAEkG,EAAIC,EAAI,IAAMsB,CAEpB,CAEA,IAAIC,EAAO1H,EAAE,GACT2H,EAAO3H,EAAE,GACb,IAAK,IAAIqG,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAC3B,MAAM3M,EAAQoM,GAAUO,GAClBmB,EAAKd,GAAMgB,EAAMC,EAAMjO,GACvB+N,EAAKZ,GAAMa,EAAMC,EAAMjO,GACvBkO,EAAK/B,GAAQQ,GACnBqB,EAAO1H,EAAE4H,GACTD,EAAO3H,EAAE4H,EAAK,GACd5H,EAAE4H,GAAMJ,EACRxH,EAAE4H,EAAK,GAAKH,CACd,CAEA,IAAK,IAAItB,EAAI,EAAGA,EAAI,GAAIA,GAAK,GAAI,CAC/B,IAAK,IAAID,EAAI,EAAGA,EAAI,GAAIA,IAAKrH,EAAEqH,GAAKlG,EAAEmG,EAAID,GAC1C,IAAK,IAAIA,EAAI,EAAGA,EAAI,GAAIA,IAAKlG,EAAEmG,EAAID,KAAOrH,GAAGqH,EAAC,GAAQ,IAAMrH,GAAGqH,EAAC,GAAQ,GAC1E,CAEAlG,EAAE,IAAMwG,GAAYR,GACpBhG,EAAE,IAAMyG,GAAYT,EACtB,CACAlN,EAAM+F,EACR,CA6CIgJ,CAAQ3M,KAAKgM,QAAShM,KAAKiM,QAC3BtN,EAAWqB,KAAKgM,SAChBhM,KAAK4M,OAAS,EACd5M,KAAK0B,IAAM,CACb,CACA,MAAAjC,CAAOV,GACL5B,EAAQ6C,MAERxD,EADAuC,EAAOD,EAAQC,IAEf,MAAMa,SAAEA,EAAQkD,MAAEA,GAAU9C,KACtByB,EAAM1C,EAAK9B,OACjB,IAAK,IAAIyE,EAAM,EAAGA,EAAMD,GAAO,CAC7B,MAAME,EAAOC,KAAKlE,IAAIkC,EAAWI,KAAK0B,IAAKD,EAAMC,GACjD,IAAK,IAAI5D,EAAI,EAAGA,EAAI6D,EAAM7D,IAAKgF,EAAM9C,KAAK0B,QAAU3C,EAAK2C,KACrD1B,KAAK0B,MAAQ9B,GAAUI,KAAK+L,QAClC,CACA,OAAO/L,IACT,CACU,MAAA6M,GACR,GAAI7M,KAAKzC,SAAU,OACnByC,KAAKzC,UAAW,EAChB,MAAMuF,MAAEA,EAAKgK,OAAEA,EAAMpL,IAAEA,EAAG9B,SAAEA,GAAaI,KAEzC8C,EAAMpB,IAAQoL,EACA,IAATA,GAAwBpL,IAAQ9B,EAAW,GAAGI,KAAK+L,SACxDjJ,EAAMlD,EAAW,IAAM,IACvBI,KAAK+L,QACP,CACU,SAAAgB,CAAUtP,GAClBN,EAAQ6C,MAAM,GACdxD,EAAOiB,GACPuC,KAAK6M,SACL,MAAMG,EAAYhN,KAAK8C,OACjBlD,SAAEA,GAAaI,KACrB,IAAK,IAAI0B,EAAM,EAAGD,EAAMhE,EAAIR,OAAQyE,EAAMD,GAAO,CAC3CzB,KAAK4M,QAAUhN,GAAUI,KAAK+L,SAClC,MAAMpK,EAAOC,KAAKlE,IAAIkC,EAAWI,KAAK4M,OAAQnL,EAAMC,GACpDjE,EAAIwD,IAAI+L,EAAUjL,SAAS/B,KAAK4M,OAAQ5M,KAAK4M,OAASjL,GAAOD,GAC7D1B,KAAK4M,QAAUjL,EACfD,GAAOC,CACT,CACA,OAAOlE,CACT,CACA,OAAAwP,CAAQxP,GAEN,IAAKuC,KAAKkN,UAAW,MAAM,IAAI3Q,MAAM,yCACrC,OAAOyD,KAAK+M,UAAUtP,EACxB,CACA,GAAA0P,CAAIC,GAEF,OADAjR,EAAQiR,GACDpN,KAAKiN,QAAQ,IAAIrQ,WAAWwQ,GACrC;AACA,UAAAlN,CAAWzC,GAET,GADAD,EAAQC,EAAKuC,MACTA,KAAKzC,SAAU,MAAM,IAAIhB,MAAM,+BAGnC,OAFAyD,KAAK+M,UAAUtP,GACfuC,KAAKI,UACE3C,CACT,CACA,MAAAiC,GACE,OAAOM,KAAKE,WAAW,IAAItD,WAAWoD,KAAKrC,WAC7C,CACA,OAAAyC,GACEJ,KAAK1C,WAAY,EACjBM,EAAMoC,KAAK8C,MACb,CACA,UAAAzC,CAAWC,GACT,MAAMV,SAAEA,EAAQkN,OAAEA,EAAMnP,UAAEA,EAASsO,OAAEA,EAAMiB,UAAEA,GAAclN,KAY3D,OAXAM,IAAAA,EAAO,IAAIwL,GAAOlM,EAAUkN,EAAQnP,EAAWuP,EAAWjB,IAC1D3L,EAAG0L,QAAQ/K,IAAIjB,KAAKgM,SACpB1L,EAAGoB,IAAM1B,KAAK0B,IACdpB,EAAGsM,OAAS5M,KAAK4M,OACjBtM,EAAG/C,SAAWyC,KAAKzC,SACnB+C,EAAG2L,OAASA,EAEZ3L,EAAGwM,OAASA,EACZxM,EAAG3C,UAAYA,EACf2C,EAAG4M,UAAYA,EACf5M,EAAGhD,UAAY0C,KAAK1C,UACbgD,CACT,CA3GA,WAAAvD,CACE6C,EACAkN,EACAnP,EACAuP,GAAY,EACZjB,EAAiB,IAYjB,GAVArL,QApBQZ,KAAA0B,IAAM,EACN1B,KAAA4M,OAAS,EACT5M,KAAAzC,UAAW,EAEXyC,KAAA1C,WAAY,EAKZ0C,KAAAkN,WAAY,EAYpBlN,KAAKJ,SAAWA,EAChBI,KAAK8M,OAASA,EACd9M,KAAKrC,UAAYA,EACjBqC,KAAKkN,UAAYA,EACjBlN,KAAKiM,OAASA,EAEd9P,EAAQwB,KAGF,EAAIiC,GAAYA,EAAW,KAC/B,MAAM,IAAIrD,MAAM,2CNpEhB,IAAc0B,EMqEhB+B,KAAK8C,MAAQ,IAAIlG,WAAW,KAC5BoD,KAAKgM,SNtEW/N,EMsEG+B,KAAK8C,MNrEnB,IAAIlE,YAAYX,EAAIE,OAAQF,EAAIG,WAAYwD,KAAKyL,MAAMpP,EAAII,WAAa,IMsE/E,EAyFF,MAAMiP,GAAM,CAACR,EAAgBlN,EAAkBjC,IAC7C0B,EAAa,IAAM,IAAIyM,GAAOlM,EAAUkN,EAAQnP,IAGrC4P,GAAiC,KAAQD,GAAI,EAAM,IAAK,IAAvB,GAEjCE,GAAiC,KAAQF,GAAI,EAAM,IAAK,IAAvB,GAEjCG,GAAiC,KAAQH,GAAI,EAAM,IAAK,IAAvB,GAEjCI,GAAmC,KAAKJ,GAAK,EAAM,GAAI,IAApB,GCtO1CK,GAAe,MACnB,GAA0B,iBAAfC,WAAyB,OAAOA,WAEzCrN,OAAOsN,eAAetN,OAAOuN,UAAW,iBAAkB,CACxD/K,GAAAA,GACE,OAAO/C,IACT,EACA+N,cAAc,IAEhB,IAGE,GAA8B,oBAAnBC,eAAgC,OAAOA,cACpD,CAAA,eAESzN,OAAOuN,UAAUE,cAC1B,CAIF,MAAoB,oBAATC,KAA6BA,KACb,oBAAXC,OAA+BA,OACpB,oBAAXC,OAA+BA,YAA1C,CAGP,EAzBqB,GCMfC,GAAc,CAClB3K,KAAMW,EACN2C,OAAQmD,GACR5D,OAAQ2D,GACRD,OAAQI,GACR7C,OAAQ4C,GACR,WAAYoD,GACZ,WAAYC,GACZ,WAAYC,GACZ,WAAYC,IAQRW,GAAyBC,IAC7B,QAAQ,GACN,IAAK,0BAA0BC,KAAKD,GAClC,MAAO,OACT,IAAK,oBAAoBC,KAAKD,GAC5B,MAAO,SACT,IAAK,oBAAoBC,KAAKD,GAC5B,MAAO,SACT,IAAK,oBAAoBC,KAAKD,GAC5B,MAAO,SACT,IAAK,oBAAoBC,KAAKD,GAC5B,MAAO,SACT,IAAK,cAAcC,KAAKD,GACtB,MAAO,WACT,IAAK,cAAcC,KAAKD,GACtB,MAAO,WACT,IAAK,cAAcC,KAAKD,GACtB,MAAO,WACT,IAAK,cAAcC,KAAKD,GACtB,MAAO,WACT,QACE,MAAM,IAAIE,UAAU,2BAA2BF;EC7C/CG,GAAW,mCAQXC,GAAgB1P,IAKpB,IAAI2P,GAHJ3P,EAAMA,EAAI4P,QAAQ,KAAM,KAGV3R,OACd,KAAwB,MAAjB+B,EAAI2P,EAAM,MAAcA,EAC/B3P,GAAO2P,EAAM3P,EAAI/B,OAAS+B,EAAI6P,UAAU,EAAGF,GAAO3P,GAAK8P,cAEvD,MAAM/O,EAAM,IAAIlD,YAA2B,EAAbmC,EAAI/B,OAAc,EAAK,GAC/CgB,EAAM,IAAIrB,WAAWmD,GAC3B,IAAIgP,EAAO,EACP5M,EAAQ,EACR6M,EAAQ,EAEZ,IAAK,IAAIlR,EAAI,EAAGA,EAAIkB,EAAI/B,OAAQa,IAAK,CACnC,MAAMmR,EAAMR,GAASS,QAAQlQ,EAAIlB,IACjC,QAAImR,EAAY,MAAM,IAAIT,UAAU,4BAA4BxP,EAAIlB,MAEpEqE,EAASA,GAAS,EAAK8M,EACvBF,GAAQ,EAEJA,GAAQ,IACVA,GAAQ,EACR9Q,EAAI+Q,KAAW7M,IAAU4M,EAE7B,CAEA,OAAO9Q,GASHkR,GAAgBlR,IACpB,IAAI8Q,EAAO,EACP5M,EAAQ,EACRnD,EAAM,GAEV,IAAK,IAAIlB,EAAI,EAAGA,EAAIG,EAAIhB,OAAQa,IAI9B,IAHAqE,EAAQA,GAAU,EAAKlE,EAAIH,GAC3BiR,GAAQ,EAEDA,GAAQ,GACb/P,GAAOyP,GAAUtM,IAAW4M,EAAO,EAAM,IACzCA,GAAQ,EAQZ,OAJIA,EAAO,IACT/P,GAAOyP,GAAUtM,GAAU,EAAI4M,EAAS,KAGnC/P,GC/DHoQ,GAAapQ,IAEjBA,EAAMA,EAAI4P,QAAQ,KAAM,IAExB,MAAM7O,EAAM,IAAIlD,YAAYmC,EAAI/B,OAAS,GACnCgB,EAAM,IAAIrB,WAAWmD,GAE3B,IAAK,IAAIjC,EAAI,EAAGA,EAAIkB,EAAI/B,OAAQa,GAAK,EACnCG,EAAIH,EAAI,GAAKuR,SAASrQ,EAAI6P,UAAU/Q,EAAGA,EAAI,GAAI,IAGjD,OAAOG,GAQHqR,GAAarR,IACjB,IAAIe,EAAM,GAEV,IAAK,IAAIlB,EAAI,EAAGA,EAAIG,EAAIhB,OAAQa,IAAK,CACnC,MAAMyR,EAAMtR,EAAIH,GAAG0R,SAAS,IACT,IAAfD,EAAItS,SAAc+B,GAAO,KAC7BA,GAAOuQ,CACT,CAEA,OAAOvQ,EAAI8P,eC5BPW,GAAgBzQ,IACpB,MAAMe,EAAM,IAAIlD,YAAYmC,EAAI/B,QAC1BgB,EAAM,IAAIrB,WAAWmD,GAE3B,IAAK,IAAIjC,EAAI,EAAGA,EAAIkB,EAAI/B,OAAQa,IAC9BG,EAAIH,GAAyB,IAApBkB,EAAI0Q,WAAW5R,GAG1B,OAAOG,GAQH0R,GAAgB1R,IACpB,IAAIe,EAAM,GAEV,IAAK,IAAIlB,EAAI,EAAGA,EAAIG,EAAIhB,OAAQa,IAC9BkB,GAAO4Q,OAAOC,aAAa5R,EAAIH,IAGjC,OAAOkB,GCtBH8Q,GAAUnC,GAAY1O,YAAc,IAAI0O,GAAY1O,YAAgB,KAMpE8Q,GAAUpC,GAAYqC,YAAc,IAAIrC,GAAYqC,YAAgB,KAOpEC,GAAcjR,IAClB,IAAK8Q,GACH,MAAM,IAAIvT,MAAM,8BAGlB,OAAOuT,GAAQ5Q,OAAOF,IAQlBkR,GAAcjS,IAClB,IAAK8R,GACH,MAAM,IAAIxT,MAAM,8BAGlB,OAAOwT,GAAQI,OAAOlS,IC5BxB,MAAMmS,GA6BJ,iBAAOC,CAAWrR,GAChB,OAAO,IAAIoR,GAAO,CAAEjS,OAAQsR,GAAazQ,GAAKb,QAChD,CAOA,eAAOmS,CAAStR,GACd,OAAO,IAAIoR,GAAO,CAAEjS,OAAQ8R,GAAWjR,GAAKb,QAC9C,CAOA,iBAAOoS,CAAWvR,GAChB,OAAO,IAAIoR,GAAO,CAAEjS,OAAQuQ,GAAa1P,GAAKb,QAChD,CAOA,cAAOqS,CAAQxR,GACb,OAAO,IAAIoR,GAAO,CAAEjS,OAAQiR,GAAUpQ,GAAKb,QAC7C,CAOA,UAAIA,GACF,OAAO6B,KAAKoN,MAAMjP,MACpB,CAMA,UAAIsS,GAQF,OAPAlQ,OAAOsN,eAAe7N,KAAM,SAAU,CACpC0Q,YAAY,EACZC,UAAU,EACV5C,cAAc,EACd5L,MAAOwN,GAAa3P,KAAKoN,SAGpBpN,KAAKyQ,MACd,CAMA,QAAIG,GAQF,OAPArQ,OAAOsN,eAAe7N,KAAM,OAAQ,CAClC0Q,YAAY,EACZC,UAAU,EACV5C,cAAc,EACd5L,MAAO+N,GAAWlQ,KAAKoN,SAGlBpN,KAAK4Q,IACd,CAMA,UAAIC,GAQF,OAPAtQ,OAAOsN,eAAe7N,KAAM,SAAU,CACpC0Q,YAAY,EACZC,UAAU,EACV5C,cAAc,EACd5L,MAAOgN,GAAanP,KAAKoN,SAGpBpN,KAAK6Q,MACd,CAMA,OAAItB,GAQF,OAPAhP,OAAOsN,eAAe7N,KAAM,MAAO,CACjC0Q,YAAY,EACZC,UAAU,EACV5C,cAAc;AACd5L,MAAOmN,GAAUtP,KAAKoN,SAGjBpN,KAAKuP,GACd,CAxHA,WAAAxS,EAAYoB,OAAEA,EAAM2S,KAAEA,EAAO,IAAO,CAAA,GAMlC9Q,KAAKoN,WAA0B,IAAXjP,ECbJ,CAAC2S,IAGZ,GAAInD,GAAYoD,QAAQC,gBAC7B,OAAOrD,GAAYoD,OAAOC,gBAAgB,IAAIpU,WAAWkU,IAEzD,MAAM,IAAIvU,MAAM,mCDO6B0U,CAAYH,GAAQ,IAAIlU,WAAWuB,GAGhFoC,OAAOsN,eAAe7N,KAAM,QAAS,CACnC0Q,YAAY,EACZC,UAAU,EACV5C,cAAc,EACd5L,MAAOnC,KAAKoN,OAEhB,EEtBF,MAAM8D,GAaJ,mBAAWC,GACT,MAAO,CACLC,OAAQ,GACRC,MAAO,UACPC,eAAe,EACfhD,UAAW,OACXiD,OAAQ,EACRC,QAAS,EACTtD,OAAQ,EAEZ,CAoEA,eAAOuD,EAASC,OACdA,EAAMpD,UACNA,EAAY4C,GAAKC,SAAS7C,UAASiD,OACnCA,EAASL,GAAKC,SAASI,OAAMC,QAC7BA,EAAUN,GAAKC,SAASK,UAExB,MAAM9R,EP9CS,EAAC4O,EAAWvN,EAAKI,KAK3B,GAAID,EAAM,CACf,MAAMR,EAAO0N,GAAYE,IAAcF,GAAYC,GAAsBC,IACzE,OAAOpN,EAAKR,EAAMK,EAAKI,EACzB,CACE,MAAM,IAAI5E,MAAM,0BOqCDoV,CAAWrD,EAAWoD,EAAOtE,MCrG7B,CAACwE,IAClB,MAAM7R,EAAM,IAAIlD,YAAY,GACtBoB,EAAM,IAAIrB,WAAWmD,GAC3B,IAAI8R,EAAMD,EAEV,IAAK,IAAI9T,EAAI,EAAGA,GAAK,GACP,IAAR+T,EADkB/T,IAEtBG,EAAIH,GAAW,IAAN+T,EACTA,GAAO5T,EAAIH,GACX+T,GAAO,IAGT,OAAO5T,GDyF8C6T,CAAWN,IACxDzN,EAAyC,GAAhCrE,EAAOA,EAAOrB,WAAa,GAQ1C,SANsB,IAAjBqB,EAAOqE,KAAkB,IACH,IAArBrE,EAAOqE,EAAS,KAAa,IACR,IAArBrE,EAAOqE,EAAS,KAAa,EACT,IAArBrE,EAAOqE,EAAS,IACnB,IAAMwN,GAEG/B,WAAWuC,SAASR,EAAQ,IACzC,CAQAE,QAAAA,EAASD,QAAEA,EAAUxR,KAAKwR,WAAc,CAAA,GACtC,OAAON,GAAKO,SAAS,CACnBC,OAAQ1R,KAAK0R,OACbpD,UAAWtO,KAAKsO,UAChBiD,OAAQvR,KAAKuR,OACbC,WAEJ,CAaA,eAAOQ,EAASC,MACdA,EAAKP,OACLA,EAAMpD,UACNA,EAASiD,OACTA,EAASL,GAAKC,SAASI,OAAMC,QAC7BA,EAAUN,GAAKC,SAASK,QAAOtD,OAC/BA,EAASgD,GAAKC,SAASjD,SAGvB,GAAI+D,EAAMhV,SAAWsU,EAAQ,OAAO,KAEpC,IAAIW,EAAQ,KAEZ,MAAMC,EAA+BrU,IACnC,MAAMsU,EAAiBlB,GAAKO,SAAS,CACnCC,SACApD,YACAiD,SACAC,QAAS1T,IExJO,EAACnB,EAAGF,KAGnB,CACL,GAAIE,EAAEM,SAAWR,EAAEQ,OACjB,MAAM,IAAIuR,UAAU,2CAEtB,IAAI1Q,GAAI,EACJL,EAAM,EACV,OAASK,EAAInB,EAAEM,QACbQ,GAAOd,EAAE+S,WAAW5R,GAAKrB,EAAEiT,WAAW5R,GAExC,OAAe,IAARL,CACT,GF6IQ4U,CAAgBJ,EAAOG,KACzBF,EAAQpU,EAAI0T,IAIhBW,EAAMX,GACN,IAAK,IAAI1T,EAAI,EAAGA,GAAKoQ,GAAoB,OAAVgE,IAC7BC,EAAMX,EAAU1T,GACF,OAAVoU,KACJC,EAAMX,EAAU1T,GACF,OAAVoU,KAJ2CpU,GAOjD,OAAOoU,CACT,CAUAF,QAAAA,EAASC,MAAEA,EAAKT,QAAEA,EAAUxR,KAAKwR,QAAOtD,OAAEA,IACxC,OAAOgD,GAAKc,SAAS,CACnBC,QACAP,OAAQ1R,KAAK0R,OACbpD,UAAWtO,KAAKsO,UAChBiD,OAAQvR,KAAKuR,OACbC,UACAtD,UAEJ,CAMAsB,QAAAA,GACE,MAAM8C,EAAIC;CACV,MACE,mBAEEvS,KAAKoR,OAAOnU,OAAS,EACjB+C,KAAKsR,cACH,GAAGgB,EAAEtS,KAAKoR,WAAWkB,EAAEtS,KAAKqR,iBAAiBiB,EAAEtS,KAAKoR,WACpD,GAAGkB,EAAEtS,KAAKqR,iBAAiBiB,EAAEtS,KAAKoR,WACpC,GAAGkB,EAAEtS,KAAKqR,WAEhB,UAAUiB,EAAEtS,KAAK0R,OAAOb,WACxB,aAAayB,EAAEtS,KAAKsO,cACpB,UAAUgE,EAAEtS,KAAKuR,WACjB,WAAWe,EAAEtS,KAAKwR,UAEtB,CA9KA,WAAAzU,EAAYqU,OACVA,EAASF,GAAKC,SAASC,OAAMC,MAC7BA,EAAQH,GAAKC,SAASE,MAAKC,cAC3BA,EAAgBJ,GAAKC,SAASG,cAAaI,OAC3CA,EAAS,IAAItB,GAAQ9B,UACrBA,EAAY4C,GAAKC,SAAS7C,UAASiD,OACnCA,EAASL,GAAKC,SAASI,OAAMC,QAC7BA,EAAUN,GAAKC,SAASK,SACtB,CAAA,GAKFxR,KAAKoR,OAASA,EAKdpR,KAAKqR,MAAQA,EAKbrR,KAAKsR,cAAgBA,EAKrBtR,KAAK0R,OAA2B,iBAAXA,EAAsBtB,GAAOG,WAAWmB,GAAUA,EAKvE1R,KAAKsO,UAAYD,GAAsBC,GAKvCtO,KAAKuR,OAASA,EAKdvR,KAAKwR,QAAUA,CACjB,EGjFF,MAAMgB,GAaJ,mBAAWrB,GACT,MAAO,CACLC,OAAQ,GACRC,MAAO,UACPC,eAAe,EACfhD,UAAW,OACXiD,OAAQ,EACRkB,OAAQ,GACRvE,OAAQ,EAEZ,CAkEA,cAAOsD,EAAQiB,OAAEA,EAASD,GAAKrB,SAASsB,OAAMC,UAAEA,EAAYC,KAAKC,OAAU,CAAA,GACzE,OAAOhR,KAAKyL,MAAMqF,EAAY,IAAOD,EACvC,CAQAjB,OAAAA,EAAQkB,UAAEA,EAAYC,KAAKC,OAAU,CAAA,GACnC,OAAOJ,GAAKhB,QAAQ,CAClBiB,OAAQzS,KAAKyS,OACbC,aAEJ,CASA,gBAAOG,EAAUJ,OAAEA,EAASD,GAAKrB,SAASsB,OAAMC,UAAEA,EAAYC,KAAKC,OAAU,CAAA,GAC3E,OAAgB,IAATH,EAAiBC,GAAsB,IAATD,EACvC,CAQAI,SAAAA,EAAUH,UAAEA,EAAYC,KAAKC,OAAU,CAAA,GACrC,OAAOJ,GAAKK,UAAU,CACpBJ,OAAQzS,KAAKyS,OACbC,aAEJ,CAYA,eAAOjB,EAASC,OAAEA,EAAMpD,UAAEA,EAASiD,OAAEA,EAAMkB,OAAEA,EAASD,GAAKrB,SAASsB,OAAMC,UAAEA,EAAYC,KAAKC,QAC3F,OAAO1B,GAAKO,SAAS,CACnBC,SACApD,YACAiD,SACAC,QAASgB,GAAKhB,QAAQ,CAAEiB,SAAQC,eAEpC,CAQAjB,QAAAA,EAASiB,UAAEA,EAAYC,KAAKC,OAAU,CAAA,GACpC,OAAOJ,GAAKf,SAAS,CACnBC,OAAQ1R,KAAK0R,OACbpD,UAAWtO,KAAKsO,UAChBiD,OAAQvR,KAAKuR,OACbkB,OAAQzS,KAAKyS,OACbC,aAEJ,CAcA,eAAOV,EAASC,MAAEA,EAAKP,OAAEA,EAAMpD,UAAEA,EAASiD,OAAEA,EAAMkB,OAAEA,EAASD,GAAKrB,SAASsB,OAAMC,UAAEA,EAAYC,KAAKC,MAAK1E,OAAEA,IACzG,OAAOgD,GAAKc,SAAS,CACnBC,QACAP,SACApD,YACAiD,SACAC,QAASgB,GAAKhB,QAAQ,CAAEiB,SAAQC,cAChCxE,UAEJ,CAUA8D,QAAAA,EAASC,MAAEA,EAAKS,UAAEA,EAASxE,OAAEA,IAC3B,OAAOsE,GAAKR,SAAS,CACnBC,QACAP,OAAQ1R,KAAK0R,OACbpD,UAAWtO,KAAKsO,UAChBiD,OAAQvR,KAAKuR,OACbkB,OAAQzS,KAAKyS,OACbC,YACAxE,UAEJ,CAMAsB,QAAAA,GACE,MAAM8C,EAAIC;CACV,MACE,mBAEEvS,KAAKoR,OAAOnU,OAAS,EACjB+C,KAAKsR,cACH,GAAGgB,EAAEtS,KAAKoR,WAAWkB,EAAEtS,KAAKqR,iBAAiBiB,EAAEtS,KAAKoR,WACpD,GAAGkB,EAAEtS,KAAKqR,iBAAiBiB,EAAEtS,KAAKoR,WACpC,GAAGkB,EAAEtS,KAAKqR,WAEhB,UAAUiB,EAAEtS,KAAK0R,OAAOb,WACxB,aAAayB,EAAEtS,KAAKsO,cACpB,UAAUgE,EAAEtS,KAAKuR,WACjB,UAAUe,EAAEtS,KAAKyS,SAErB,CAhMA,WAAA1V,EAAYqU,OACVA,EAASoB,GAAKrB,SAASC,OAAMC,MAC7BA,EAAQmB,GAAKrB,SAASE,MAAKC,cAC3BA,EAAgBkB,GAAKrB,SAASG,cAAaI,OAC3CA,EAAS,IAAItB,GAAQ9B,UACrBA,EAAYkE,GAAKrB,SAAS7C,UAASiD,OACnCA,EAASiB,GAAKrB,SAASI,OAAMkB,OAC7BA,EAASD,GAAKrB,SAASsB,QACrB,CAAA,GAKFzS,KAAKoR,OAASA,EAKdpR,KAAKqR,MAAQA,EAKbrR,KAAKsR,cAAgBA,EAKrBtR,KAAK0R,OAA2B,iBAAXA,EAAsBtB,GAAOG,WAAWmB,GAAUA,EAKvE1R,KAAKsO,UAAYD,GAAsBC,GAKvCtO,KAAKuR,OAASA,EAKdvR,KAAKyS,OAASA,CAChB,ECjFF,MAAMK,GAAe,mFAMfC,GAAe,iBAMfC,GAAkB,sDAMlBC,GAAgB,aAMhBC,GAAyB,sDAM/B,MAME,YAAOC,CAAMC,GACX,IAAIC,EAEJ,IACEA,EAAYD,EAAIE,MAAMR,GAExB,CAAE,MAAOS,GAET,CAEA,IAAKC,MAAMC,QAAQJ,GACjB,MAAM,IAAIK,SAAS,sBAIrB,MAAMC,EAAUN,EAAU,GAAGO,cACvBC,EAAWR,EAAU,GAAG7O,MAAM,mBAAoB,GAAG0C,IAAI4M,oBAEzDC,EAAYV,EAAU,GAAG7O,MAAM,KAAKwP,OAAO,CAACnC,EAAKoC,KACrD,MAAMC,EAAUD,EAAIzP,MAAM,QAAS,GAAG0C,IAAI4M,oBACpCK,EAAUD,EAAQ,GAAGN,cACrBQ,EAAUF,EAAQ,GAElBG,EAAUxC,EAGhB,OADAwC,EAAQF,GAAWC,EACZC,GACN,CAAA,GAGH,IAAIC,EACJ,MAAMC,EAAS,CAAA,EAEf,GAAgB,SAAZZ,EAAoB,CAItB,GAHAW,EAAMpD,QAG2B,IAAtB6C,EAAUvC,UAA2ByB,GAAc1E,KAAKwF,EAAUvC,SAG3E,MAAM,IAAIhD,UAAU,0CAFpB+F,EAAO/C,QAAUnC,SAAS0E,EAAUvC,QAAS,GAIjD,KAAO,IAAgB,SAAZmC,EAYT,MAAM,IAAInF,UAAU,oBARpB,GAHA8F,EAAM9B,QAG0B,IAArBuB,EAAUtB,OAAwB,CAC3C,IAAIS,GAAuB3E,KAAKwF,EAAUtB,QAGxC,MAAM,IAAIjE,UAAU,8BAFpB+F,EAAO9B,OAASpD,SAAS0E,EAAUtB,OAAQ,GAI/C,CAGF,CAsBA,QAlBgC,IAArBsB,EAAU3C,SACnBmD,EAAOnD,OAAS2C,EAAU3C,QAEJ,IAApByC,EAAS5W,QACXsX,EAAOlD,MAAQwC,EAAS,QACK,IAAlBU,EAAOnD,QAA4C,KAAlBmD,EAAOnD,OACjDmD,EAAOnD,OAASyC,EAAS,GACA,KAAhBA,EAAS,KAClBU,EAAOjD,eAAgB,KAGzBiD,EAAOlD,MAAQwC,EAAS,QACK,IAAlBU,EAAOnD,QAA4C,KAAlBmD,EAAOnD,SACjDmD,EAAOjD,eAAgB,SAKK,IAArByC,EAAUrC,SAA0BqB,GAAaxE,KAAKwF,EAAUrC,QAGzE,MAAM,IAAIlD,UAAU,yCAItB,GANE+F,EAAO7C,OAASqC,EAAUrC,YAMO,IAAxBqC,EAAUzF,UAA2B;AAC9C,IAAI0E,GAAgBzE,KAAKwF,EAAUzF,WAGjC,MAAM,IAAIE,UAAU,iCAFpB+F,EAAOjG,UAAYyF,EAAUzF,SAIjC,CAGA,QAAgC,IAArByF,EAAUxC,OAAwB,CAC3C,IAAI2B,GAAuB3E,KAAKwF,EAAUxC,QAGxC,MAAM,IAAI/C,UAAU,8BAFpB+F,EAAOhD,OAASlC,SAAS0E,EAAUxC,OAAQ,GAI/C,CAEA,OAAO,IAAI+C,EAAIC,EACjB,CAOA,gBAAOC,CAAUC,GACf,GAAIA,aAAevD,IAAQuD,aAAejC,GACxC,OAAOiC,EAAIjF,WAGb,MAAM,IAAIhB,UAAU,6BACtB,aC1Jc","x_google_ignoreList":[0,1,2,3,4,5,6]}