{"version":3,"file":"index.cjs","sources":["../../../node_modules/@noble/ciphers/utils.js","../../../node_modules/@noble/ciphers/aes.js","../src/aes-ccm.ts","../src/aes-gcm.ts","../src/aes.ts","../../../node_modules/@noble/ciphers/_arx.js","../../../node_modules/@noble/ciphers/_poly1305.js","../../../node_modules/@noble/ciphers/chacha.js","../src/chacha20.ts","../src/des.ts","../src/rc4.ts","../../../node_modules/js-speck/dist/index.mjs","../src/speck.ts","../src/block-offset.ts","../src/triple-des.ts","../src/preset.ts"],"sourcesContent":["/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */\n/**\n * Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.\n * @param a - Value to inspect.\n * @returns `true` when the value is a Uint8Array view, including Node's `Buffer`.\n * @example\n * Guards a value before treating it as raw key material.\n *\n * ```ts\n * isBytes(new Uint8Array());\n * ```\n */\nexport function isBytes(a) {\n    // Plain `instanceof Uint8Array` is too strict for some Buffer / proxy /\n    // cross-realm cases. The fallback still requires a real ArrayBuffer view\n    // so plain JSON-deserialized `{ constructor: ... }`\n    // spoofing is rejected, and `BYTES_PER_ELEMENT === 1` keeps the fallback on byte-oriented views.\n    return (a instanceof Uint8Array ||\n        (ArrayBuffer.isView(a) &&\n            a.constructor.name === 'Uint8Array' &&\n            'BYTES_PER_ELEMENT' in a &&\n            a.BYTES_PER_ELEMENT === 1));\n}\n/**\n * Asserts something is boolean.\n * @param b - Value to validate.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Validates a boolean option before branching on it.\n *\n * ```ts\n * abool(true);\n * ```\n */\nexport function abool(b) {\n    if (typeof b !== 'boolean')\n        throw new TypeError(`boolean expected, not ${b}`);\n}\n/**\n * Asserts something is a non-negative safe integer.\n * @param n - Value to validate.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Validates a non-negative length or counter.\n *\n * ```ts\n * anumber(1);\n * ```\n */\nexport function anumber(n) {\n    if (typeof n !== 'number')\n        throw new TypeError('number expected, got ' + typeof n);\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new RangeError('positive integer expected, got ' + n);\n}\n/**\n * Asserts something is Uint8Array.\n * @param value - Value to validate.\n * @param length - Expected byte length.\n * @param title - Optional label used in error messages.\n * @returns The validated byte array.\n * On Node, `Buffer` is accepted too because it is a Uint8Array view.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument lengths. {@link RangeError}\n * @example\n * Validates a fixed-length nonce or key buffer.\n *\n * ```ts\n * abytes(new Uint8Array([1, 2]), 2);\n * ```\n */\nexport function abytes(value, length, title = '') {\n    const bytes = isBytes(value);\n    const len = value?.length;\n    const needsLen = length !== undefined;\n    if (!bytes || (needsLen && len !== length)) {\n        const prefix = title && `\"${title}\" `;\n        const ofLen = needsLen ? ` of length ${length}` : '';\n        const got = bytes ? `length=${len}` : `type=${typeof value}`;\n        const message = prefix + 'expected Uint8Array' + ofLen + ', got ' + got;\n        if (!bytes)\n            throw new TypeError(message);\n        throw new RangeError(message);\n    }\n    return value;\n}\n/**\n * Asserts a hash- or MAC-like instance has not been destroyed or finished.\n * @param instance - Stateful instance to validate.\n * @param checkFinished - Whether to reject finished instances.\n * When `false`, only `destroyed` is checked.\n * @throws If the hash instance has already been destroyed or finalized. {@link Error}\n * @example\n * Guards against calling `update()` or `digest()` on a finished hash.\n *\n * ```ts\n * aexists({ destroyed: false, finished: false });\n * ```\n */\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/**\n * Asserts output is a properly-sized byte array.\n * @param out - Output buffer to validate.\n * @param instance - Hash-like instance providing `outputLen`.\n * This is the relaxed `digestInto()`-style contract: output must be at least `outputLen`,\n * unlike one-shot cipher helpers elsewhere in the repo that often require exact lengths.\n * @throws On wrong argument types. {@link TypeError}\n * @param onlyAligned - Whether `out` must be 4-byte aligned for zero-allocation word views.\n * @throws On wrong output buffer lengths. {@link RangeError}\n * @throws On wrong output buffer alignment. {@link Error}\n * @example\n * Verifies that a caller-provided output buffer is large enough.\n *\n * ```ts\n * aoutput(new Uint8Array(16), { outputLen: 16 });\n * ```\n */\nexport function aoutput(out, instance, onlyAligned = false) {\n    abytes(out, undefined, 'output');\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new RangeError('digestInto() expects output buffer of length at least ' + min);\n    }\n    if (onlyAligned && !isAligned32(out))\n        throw new Error('invalid output, must be aligned');\n}\n/**\n * Casts a typed-array view to Uint8Array.\n * @param arr - Typed-array view to reinterpret.\n * @returns Uint8Array view over the same bytes.\n * @example\n * Views 32-bit words as raw bytes without copying.\n *\n * ```ts\n * u8(new Uint32Array([1]));\n * ```\n */\nexport function u8(arr) {\n    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Casts a typed-array view to Uint32Array.\n * @param arr - Typed-array view to reinterpret.\n * @returns Uint32Array view over the same bytes. Callers are expected to provide a\n * 4-byte-aligned offset; trailing `1..3` bytes are silently dropped.\n * @example\n * Views a byte buffer as 32-bit words for block processing.\n *\n * ```ts\n * u32(new Uint8Array(4));\n * ```\n */\nexport function u32(arr) {\n    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n/**\n * Zeroizes typed arrays in place.\n * Warning: JS provides no guarantees.\n * @param arrays - Arrays to wipe.\n * @example\n * Wipes a temporary key buffer after use.\n *\n * ```ts\n * const bytes = new Uint8Array([1]);\n * clean(bytes);\n * ```\n */\nexport function clean(...arrays) {\n    for (let i = 0; i < arrays.length; i++) {\n        arrays[i].fill(0);\n    }\n}\n/**\n * Creates a DataView for byte-level manipulation.\n * @param arr - Typed-array view to wrap.\n * @returns DataView over the same bytes.\n * @example\n * Creates an endian-aware view for length encoding.\n *\n * ```ts\n * createView(new Uint8Array(4));\n * ```\n */\nexport function createView(arr) {\n    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n/**\n * Whether the current platform is little-endian.\n * Most are; some IBM systems are not.\n */\nexport const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n/**\n * Reverses byte order of one 32-bit word.\n * @param word - Unsigned 32-bit word to swap.\n * @returns The same word with bytes reversed.\n * @example\n * Swaps a big-endian word into little-endian byte order.\n *\n * ```ts\n * byteSwap(0x11223344);\n * ```\n */\nexport const byteSwap = (word) => ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff);\n/**\n * Normalizes one 32-bit word to the little-endian representation expected by cipher cores.\n * @param n - Unsigned 32-bit word to normalize.\n * @returns Little-endian normalized word on big-endian hosts, else the input word unchanged.\n * @example\n * Normalizes a host-endian word before passing it into an ARX/AES core.\n *\n * ```ts\n * swap8IfBE(0x11223344);\n * ```\n */\nexport const swap8IfBE = isLE\n    ? (n) => n\n    : (n) => byteSwap(n) >>> 0;\n/**\n * Byte-swaps every word of a Uint32Array in place.\n * @param arr - Uint32Array whose words should be swapped.\n * @returns The same array after in-place byte swapping.\n * @example\n * Swaps every 32-bit word in a word-view buffer.\n *\n * ```ts\n * byteSwap32(new Uint32Array([0x11223344]));\n * ```\n */\nexport const byteSwap32 = (arr) => {\n    for (let i = 0; i < arr.length; i++)\n        arr[i] = byteSwap(arr[i]);\n    return arr;\n};\n/**\n * Normalizes a Uint32Array view to the little-endian representation expected by cipher cores.\n * @param u - Word view to normalize in place.\n * @returns Little-endian normalized word view.\n * @example\n * Normalizes a word-view buffer before block processing.\n *\n * ```ts\n * swap32IfBE(new Uint32Array([0x11223344]));\n * ```\n */\nexport const swap32IfBE = isLE\n    ? (u) => u\n    : byteSwap32;\n// Built-in hex conversion:\n// {@link https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex | caniuse entry}\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 * @param bytes - Bytes to encode.\n * @returns Lowercase hexadecimal string.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Formats ciphertext bytes for logs or test vectors.\n *\n * ```ts\n * bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])); // 'cafe0123'\n * ```\n */\nexport function bytesToHex(bytes) {\n    abytes(bytes);\n    // @ts-ignore\n    if (hasHexBuiltin)\n        return bytes.toHex();\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n// 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 * @param hex - Hexadecimal string to decode.\n * @returns Decoded bytes.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On malformed hexadecimal input. {@link RangeError}\n * @example\n * Parses a hex test vector into bytes.\n *\n * ```ts\n * hexToBytes('cafe0123'); // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n * ```\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new TypeError('hex string expected, got ' + typeof hex);\n    if (hasHexBuiltin) {\n        try {\n            return Uint8Array.fromHex(hex);\n        }\n        catch (error) {\n            if (error instanceof SyntaxError)\n                throw new RangeError(error.message);\n            throw error;\n        }\n    }\n    const hl = hex.length;\n    const al = hl / 2;\n    if (hl % 2)\n        throw new RangeError('hex string expected, got unpadded hex of length ' + hl);\n    const array = new Uint8Array(al);\n    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n        const n1 = asciiToBase16(hex.charCodeAt(hi));\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 RangeError('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// Used in micro\n/**\n * Converts a big-endian hex string into bigint.\n * @param hex - Hexadecimal string without `0x`.\n * @returns Parsed bigint value. The empty string is treated as `0n`.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Parses a big-endian field element or counter from hex.\n *\n * ```ts\n * hexToNumber('ff');\n * ```\n */\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new TypeError('hex string expected, got ' + typeof hex);\n    return BigInt(hex === '' ? '0' : '0x' + hex); // Big Endian\n}\n// Used in ff1\n// BE: Big Endian, LE: Little Endian\n/**\n * Converts big-endian bytes into bigint.\n * @param bytes - Big-endian bytes.\n * @returns Parsed bigint value. Empty input is treated as `0n`.\n * @throws On invalid byte input passed to the internal hex conversion. {@link TypeError}\n * @example\n * Reads a big-endian integer from serialized bytes.\n *\n * ```ts\n * bytesToNumberBE(new Uint8Array([1, 0]));\n * ```\n */\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\n// Used in micro, ff1\n/**\n * Converts a number into big-endian bytes of fixed length.\n * @param n - Number to encode.\n * @param len - Output length in bytes.\n * @returns Big-endian bytes padded to `len`.\n * Validation is indirect through `hexToBytes(...)`, so negative values, `len = 0`,\n * and values that do not fit surface through the downstream hex parser instead of a\n * dedicated range guard here.\n * @throws On wrong argument types. {@link TypeError}\n * @throws If the requested output length cannot represent the encoded value. {@link RangeError}\n * @example\n * Encodes a counter as fixed-width big-endian bytes.\n *\n * ```ts\n * numberToBytesBE(1, 2);\n * ```\n */\nexport function numberToBytesBE(n, len) {\n    // Reject coercible non-numeric inputs before string/hex conversion changes behavior.\n    if (typeof n === 'number')\n        anumber(n);\n    else if (typeof n !== 'bigint')\n        throw new TypeError(`number or bigint expected, got ${typeof n}`);\n    anumber(len);\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\n/**\n * Converts string to bytes using UTF8 encoding.\n * @param str - String to encode.\n * @returns UTF-8 bytes in a detached fresh Uint8Array copy.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Encodes application text before encryption or MACing.\n *\n * ```ts\n * utf8ToBytes('abc'); // new Uint8Array([97, 98, 99])\n * ```\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new TypeError('string expected');\n    return new Uint8Array(new TextEncoder().encode(str)); // {@link https://bugzil.la/1681809 | Firefox bug 1681809}\n}\n/**\n * Converts bytes to string using UTF8 encoding.\n * @param bytes - UTF-8 bytes.\n * @returns Decoded string. Input validation is delegated to `TextDecoder`, and malformed\n * UTF-8 is replacement-decoded instead of rejected.\n * @example\n * Decodes UTF-8 plaintext back into a string.\n *\n * ```ts\n * bytesToUtf8(new Uint8Array([97, 98, 99])); // 'abc'\n * ```\n */\nexport function bytesToUtf8(bytes) {\n    return new TextDecoder().decode(bytes);\n}\n/**\n * Checks if two U8A use same underlying buffer and overlaps.\n * This is invalid and can corrupt data.\n * @param a - First byte view.\n * @param b - Second byte view.\n * @returns `true` when the views overlap in memory.\n * @example\n * Detects whether two slices alias the same backing buffer.\n *\n * ```ts\n * overlapBytes(new Uint8Array(4), new Uint8Array(4));\n * ```\n */\nexport function overlapBytes(a, b) {\n    // Zero-length views cannot overwrite anything, even if their offset sits inside another range.\n    if (!a.byteLength || !b.byteLength)\n        return false;\n    return (a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy\n        a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end\n        b.byteOffset < a.byteOffset + a.byteLength // b starts before a end\n    );\n}\n/**\n * If input and output overlap and input starts before output, we will overwrite end of input before\n * we start processing it, so this is not supported for most ciphers\n * (except chacha/salsa, which were designed for this)\n * @param input - Input bytes.\n * @param output - Output bytes.\n * @throws If the output view would overwrite unread input bytes. {@link Error}\n * @example\n * Rejects an in-place layout that would overwrite unread input bytes.\n *\n * ```ts\n * complexOverlapBytes(new Uint8Array(4), new Uint8Array(4));\n * ```\n */\nexport function complexOverlapBytes(input, output) {\n    // This is very cursed. It works somehow, but I'm completely unsure,\n    // reasoning about overlapping aligned windows is very hard.\n    if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)\n        throw new Error('complex overlap of input and output is not supported');\n}\n/**\n * Copies several Uint8Arrays into one.\n * @param arrays - Byte arrays to concatenate.\n * @returns Combined byte array.\n * @throws On wrong argument types inside the byte-array list. {@link TypeError}\n * @example\n * Builds a `nonce || ciphertext` style buffer.\n *\n * ```ts\n * concatBytes(new Uint8Array([1]), new Uint8Array([2]));\n * ```\n */\nexport function concatBytes(...arrays) {\n    let sum = 0;\n    for (let i = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        abytes(a);\n        sum += a.length;\n    }\n    const res = new Uint8Array(sum);\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\n        const a = arrays[i];\n        res.set(a, pad);\n        pad += a.length;\n    }\n    return res;\n}\n/**\n * Merges user options into defaults.\n * @param defaults - Default option values.\n * @param opts - User-provided overrides.\n * @returns Combined options object.\n * The merge mutates `defaults` in place and returns the same object.\n * @throws If options are missing or not an object. {@link Error}\n * @example\n * Applies user overrides to the default cipher options.\n *\n * ```ts\n * checkOpts({ rounds: 20 }, { rounds: 8 });\n * ```\n */\nexport function checkOpts(defaults, opts) {\n    if (opts == null || typeof opts !== 'object')\n        throw new Error('options must be defined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\n/**\n * Compares two byte arrays in kinda constant time once lengths already match.\n * @param a - First byte array.\n * @param b - Second byte array.\n * @returns `true` when the arrays contain the same bytes. Different lengths still return early.\n * @example\n * Compares an expected authentication tag with the received one.\n *\n * ```ts\n * equalBytes(new Uint8Array([1]), new Uint8Array([1]));\n * ```\n */\nexport function equalBytes(a, b) {\n    if (a.length !== b.length)\n        return false;\n    let diff = 0;\n    for (let i = 0; i < a.length; i++)\n        diff |= a[i] ^ b[i];\n    return diff === 0;\n}\n/**\n * Wraps a keyed MAC constructor into a one-shot helper with `.create()`.\n * @param keyLen - Valid probe-key length used to read static metadata once.\n * The probe key is only used for `outputLen` / `blockLen`, so callers with several valid key sizes\n * can pass any representative size as long as those values stay fixed.\n * @param macCons - Keyed MAC constructor or factory.\n * @param fromMsg - Optional adapter that derives extra constructor args from the one-shot message.\n * @returns Callable MAC helper with `.create()`.\n */\nexport function wrapMacConstructor(keyLen, macCons, fromMsg) {\n    const mac = macCons;\n    const getArgs = (fromMsg || (() => []));\n    const macC = (msg, key) => mac(key, ...getArgs(msg))\n        .update(msg)\n        .digest();\n    const tmp = mac(new Uint8Array(keyLen), ...getArgs(new Uint8Array(0)));\n    macC.outputLen = tmp.outputLen;\n    macC.blockLen = tmp.blockLen;\n    macC.create = (key, ...args) => mac(key, ...args);\n    return macC;\n}\n/**\n * Wraps a cipher: validates args, ensures encrypt() can only be called once.\n * Used internally by the exported cipher constructors.\n * Output-buffer support is inferred from the wrapped `encrypt` / `decrypt`\n * arity (`fn.length === 2`), and tag-bearing constructors are expected to use\n * `args[1]` for optional AAD.\n * @__NO_SIDE_EFFECTS__\n * @param params - Static cipher metadata. See {@link CipherParams}.\n * @param constructor - Cipher constructor.\n * @returns Wrapped constructor with validation.\n */\nexport const wrapCipher = (params, constructor) => {\n    function wrappedCipher(key, ...args) {\n        // Validate key\n        abytes(key, undefined, 'key');\n        // Validate nonce if nonceLength is present\n        if (params.nonceLength !== undefined) {\n            const nonce = args[0];\n            abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, 'nonce');\n        }\n        // Validate AAD if tagLength present\n        const tagl = params.tagLength;\n        if (tagl && args[1] !== undefined)\n            abytes(args[1], undefined, 'AAD');\n        const cipher = constructor(key, ...args);\n        const checkOutput = (fnLength, output) => {\n            if (output !== undefined) {\n                if (fnLength !== 2)\n                    throw new Error('cipher output not supported');\n                abytes(output, undefined, 'output');\n            }\n        };\n        // Create wrapped cipher with validation and single-use encryption\n        let called = false;\n        const wrCipher = {\n            encrypt(data, output) {\n                if (called)\n                    throw new Error('cannot encrypt() twice with same key + nonce');\n                called = true;\n                abytes(data);\n                checkOutput(cipher.encrypt.length, output);\n                return cipher.encrypt(data, output);\n            },\n            decrypt(data, output) {\n                abytes(data);\n                if (tagl && data.length < tagl)\n                    throw new Error('\"ciphertext\" expected length bigger than tagLength=' + tagl);\n                checkOutput(cipher.decrypt.length, output);\n                return cipher.decrypt(data, output);\n            },\n        };\n        return wrCipher;\n    }\n    Object.assign(wrappedCipher, params);\n    return wrappedCipher;\n};\n/**\n * By default, returns u8a of length.\n * When out is available, it checks it for validity and uses it.\n * @param expectedLength - Required output length.\n * @param out - Optional destination buffer.\n * @param onlyAligned - Whether `out` must be 4-byte aligned.\n * @returns Output buffer ready for writing.\n * @throws On wrong argument types. {@link TypeError}\n * @throws If the provided output buffer has the wrong size or alignment. {@link Error}\n * @example\n * Reuses a caller-provided output buffer when lengths match.\n *\n * ```ts\n * getOutput(16, new Uint8Array(16));\n * ```\n */\nexport function getOutput(expectedLength, out, onlyAligned = true) {\n    if (out === undefined)\n        return new Uint8Array(expectedLength);\n    // Keep Buffer/cross-realm Uint8Array support here instead of trusting a shape-compatible object.\n    abytes(out, undefined, 'output');\n    if (out.length !== expectedLength)\n        throw new Error('\"output\" expected Uint8Array of length ' + expectedLength + ', got: ' + out.length);\n    if (onlyAligned && !isAligned32(out))\n        throw new Error('invalid output, must be aligned');\n    return out;\n}\n/**\n * Encodes data and AAD bit lengths into a 16-byte buffer.\n * @param dataLength - Data length in bits.\n * @param aadLength - AAD length in bits.\n * The serialized block is still `aadLength || dataLength`, matching GCM/Poly1305\n * conventions even though the helper parameter order is `(dataLength, aadLength)`.\n * @param isLE - Whether to encode lengths as little-endian.\n * @returns 16-byte length block.\n * @throws On wrong argument types passed to the endian validator. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @example\n * Builds the length block appended by GCM and Poly1305.\n *\n * ```ts\n * u64Lengths(16, 8, true);\n * ```\n */\nexport function u64Lengths(dataLength, aadLength, isLE) {\n    // Reject coercible non-number lengths like '10' and true before BigInt(...) accepts them.\n    anumber(dataLength);\n    anumber(aadLength);\n    abool(isLE);\n    const num = new Uint8Array(16);\n    const view = createView(num);\n    view.setBigUint64(0, BigInt(aadLength), isLE);\n    view.setBigUint64(8, BigInt(dataLength), isLE);\n    return num;\n}\n/**\n * Checks whether a byte array is aligned to a 4-byte offset.\n * @param bytes - Byte array to inspect.\n * @returns `true` when the view is 4-byte aligned.\n * @example\n * Checks whether a buffer can be safely viewed as Uint32Array.\n *\n * ```ts\n * isAligned32(new Uint8Array(4));\n * ```\n */\nexport function isAligned32(bytes) {\n    return bytes.byteOffset % 4 === 0;\n}\n/**\n * Copies bytes into a new Uint8Array.\n * @param bytes - Bytes to copy.\n * @returns Copied byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @example\n * Copies input into an aligned Uint8Array before block processing.\n *\n * ```ts\n * copyBytes(new Uint8Array([1, 2]));\n * ```\n */\nexport function copyBytes(bytes) {\n    // `Uint8Array.from(...)` would also accept arrays / other typed arrays. Keep this helper strict\n    // because callers use it at byte-validation boundaries before mutating the detached copy.\n    return Uint8Array.from(abytes(bytes));\n}\n/**\n * Cryptographically secure PRNG.\n * Uses internal OS-level `crypto.getRandomValues`.\n * @param bytesLength - Number of bytes to produce.\n * Validation is delegated to `Uint8Array(bytesLength)` and `getRandomValues`, so\n * non-integers, negative lengths, and oversize requests surface backend/runtime errors.\n * @returns Random byte array.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On wrong argument ranges or values. {@link RangeError}\n * @throws If the runtime does not expose `crypto.getRandomValues`. {@link Error}\n * @example\n * Generates a fresh nonce or key.\n *\n * ```ts\n * randomBytes(16);\n * ```\n */\nexport function randomBytes(bytesLength = 32) {\n    // Validate upfront so fractional / coercible lengths do not silently\n    // truncate through Uint8Array().\n    anumber(bytesLength);\n    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;\n    if (typeof cr?.getRandomValues !== 'function')\n        throw new Error('crypto.getRandomValues must be defined');\n    return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n/**\n * Uses CSPRNG for nonce, nonce injected in ciphertext.\n * For `encrypt`, a `nonceBytes`-length buffer is fetched from CSPRNG and\n * prepended to encrypted ciphertext. For `decrypt`, first `nonceBytes` of ciphertext\n * are treated as nonce. The wrapper always allocates a fresh `nonce || ciphertext`\n * buffer on encrypt and intentionally does not support caller-provided destination buffers.\n * Too-short decrypt inputs are split into short/empty nonce views and then delegated\n * to the wrapped cipher instead of being rejected here first.\n *\n * NOTE: Under the same key, using random nonces (e.g. `managedNonce`) with AES-GCM and ChaCha\n * should be limited to `2**23` (8M) messages to get a collision chance of\n * `2**-50`. Stretching to `2**32` (4B) messages would raise that chance to\n * `2**-33`, still negligible but creeping up.\n * @param fn - Cipher constructor that expects a nonce.\n * @param randomBytes_ - Random-byte source used for nonce generation.\n * @returns Cipher constructor that prepends the nonce to ciphertext.\n * @throws On wrong argument types. {@link TypeError}\n * @throws On invalid nonce lengths observed at wrapper construction or use. {@link RangeError}\n * @example\n * Prepends a fresh random nonce to every ciphertext.\n *\n * ```ts\n * import { gcm } from '@noble/ciphers/aes.js';\n * import { managedNonce, randomBytes } from '@noble/ciphers/utils.js';\n * const wrapped = managedNonce(gcm);\n * const key = randomBytes(16);\n * const ciphertext = wrapped(key).encrypt(new Uint8Array([1, 2, 3]));\n * wrapped(key).decrypt(ciphertext);\n * ```\n */\nexport function managedNonce(fn, randomBytes_ = randomBytes) {\n    const { nonceLength } = fn;\n    anumber(nonceLength);\n    const addNonce = (nonce, ciphertext, plaintext) => {\n        const out = concatBytes(nonce, ciphertext);\n        // Wrapped ciphers may alias caller plaintext on encrypt(); never zero\n        // caller-owned buffers here.\n        if (!overlapBytes(plaintext, ciphertext))\n            ciphertext.fill(0);\n        return out;\n    };\n    // NOTE: we cannot support DST here, it would be mistake:\n    // - we don't know how much dst length cipher requires\n    // - nonce may unalign dst and break everything\n    // - we create new u8a anyway (concatBytes)\n    // - previously we passed all args to cipher, but that was mistake!\n    const res = ((key, ...args) => ({\n        encrypt(plaintext) {\n            abytes(plaintext);\n            const nonce = randomBytes_(nonceLength);\n            const encrypted = fn(key, nonce, ...args).encrypt(plaintext);\n            // @ts-ignore\n            if (encrypted instanceof Promise)\n                return encrypted.then((ct) => addNonce(nonce, ct, plaintext));\n            return addNonce(nonce, encrypted, plaintext);\n        },\n        decrypt(ciphertext) {\n            abytes(ciphertext);\n            const nonce = ciphertext.subarray(0, nonceLength);\n            const decrypted = ciphertext.subarray(nonceLength);\n            return fn(key, nonce, ...args).decrypt(decrypted);\n        },\n    }));\n    // Auto-nonce wrappers still preserve the wrapped payload geometry.\n    if ('blockSize' in fn)\n        res.blockSize = fn.blockSize;\n    if ('tagLength' in fn)\n        res.tagLength = fn.tagLength;\n    return res;\n}\n//# sourceMappingURL=utils.js.map","/**\n * {@link https://en.wikipedia.org/wiki/Advanced_Encryption_Standard | AES}\n * a.k.a. Advanced Encryption Standard\n * is a variant of Rijndael block cipher, standardized by NIST in 2001.\n * We provide the fastest available pure JS implementation.\n *\n * `cipher = encrypt(block, key)`\n *\n * Data is split into 128-bit blocks.\n * Encrypted in 10/12/14 rounds (128/192/256 bits). In every round:\n * 1. **S-box**, table substitution\n * 2. **Shift rows**, cyclic shift left of all rows of data array\n * 3. **Mix columns**, multiplying every column by fixed polynomial\n * 4. **Add round key**, round_key xor i-th column of array\n *\n * Check out\n * {@link https://csrc.nist.gov/files/pubs/fips/197/final/docs/fips-197.pdf | FIPS-197},\n * {@link https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38G.pdf | NIST 800-38G},\n * and {@link https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf | original proposal}.\n * @module\n */\nimport { ghash, polyval } from \"./_polyval.js\";\n// prettier-ignore\nimport { abytes, anumber, aoutput, byteSwap, clean, complexOverlapBytes, concatBytes, copyBytes, createView, equalBytes, getOutput, isAligned32, isLE, overlapBytes, swap32IfBE, swap8IfBE, u32, u64Lengths, u8, wrapCipher, wrapMacConstructor } from \"./utils.js\";\nconst BLOCK_SIZE = 16;\n// AES operates on 16-byte blocks, i.e. 4 32-bit words.\nconst BLOCK_SIZE32 = 4;\n// Shared zero block (`0^128`) used by GCM's `H = CIPH_K(0^128)` / J0 scratch\n// and by CMAC / SIV helpers; callers take `.slice()` before mutating it.\nconst EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE);\n// RFC 5297 §2.1 / §2.4: S2V uses `<one> = 0^127 || 1` for the `n = 0` special case.\nconst ONE_BLOCK = /* @__PURE__ */ Uint8Array.from([\n    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,\n]);\nconst POLY = 0x11b; // 1 + x + x**3 + x**4 + x**8\n// Validates plain AES key sizes only; AES-SIV's doubled-key contract is checked elsewhere.\nfunction validateKeyLength(key) {\n    if (![16, 24, 32].includes(key.length))\n        throw new Error('\"aes key\" expected Uint8Array of length 16/24/32, got length=' + key.length);\n}\n// TODO: remove multiplication, binary ops only\n// Doubles one GF(2^8) field element; callers are expected to stay in byte range.\n// FIPS 197 upd1 §4.3 equation (4.5): XTIMES(b) left-shifts by one and, when\n// b7=1, reduces by m(x); using POLY=0x11b here yields the same byte result\n// as XORing with {1b} after the shift.\nfunction mul2(n) {\n    return (n << 1) ^ (POLY & -(n >> 7));\n}\n// Shift-and-add multiplication in GF(2^8); callers are expected to pass byte values.\n// FIPS 197 upd1 §4.3 equation (4.7): general products are XORs of repeated\n// XTIMES() multiples, e.g. {57}•{13} = {57}⊕{ae}⊕{07}.\nfunction mul(a, b) {\n    let res = 0;\n    for (; b > 0; b >>= 1) {\n        // Usual shift-and-add step in GF(2^8), not a scalar-multiplication ladder.\n        res ^= a & -(b & 1); // if (b&1) res ^=a (but const-time).\n        a = mul2(a); // a = 2*a\n    }\n    return res;\n}\n/**\n * Increments a counter block with wrap around.\n * AES call sites here currently use the big-endian branch, but the helper supports both layouts.\n * NIST SP 800-38A Appendix B.1 and SP 800-38D §6.2 increment the\n * least-significant/rightmost bits.\n * `isLE=false` matches that standard counter-block layout, while `isLE=true`\n * is a generic extension for non-AES callers.\n * The implementation keeps a 32-bit bitwise carry path, so `carry` is capped at `0xffffff00`;\n * larger values throw instead of silently overflowing before the next-byte propagation step.\n */\n// Keep the helper explicitly typed so `--isolatedDeclarations` can expose it\n// through the test-only `__TESTS` export without inference errors.\nconst incBytes = (data, isLE, carry = 1) => {\n    // Keep `carry + byte <= 0xffffffff` so the `| 0` / `>>> 8` path below\n    // never truncates a real carry bit.\n    if (!Number.isSafeInteger(carry) || carry > 0xffffff00)\n        throw new Error('incBytes: wrong carry ' + carry);\n    abytes(data);\n    for (let i = 0; i < data.length; i++) {\n        const pos = !isLE ? data.length - 1 - i : i;\n        carry = (carry + (data[pos] & 0xff)) | 0;\n        data[pos] = carry & 0xff;\n        carry >>>= 8;\n    }\n};\n// AES S-box is generated using finite field inversion,\n// an affine transform, and xor of a constant 0x63.\nconst sbox = /* @__PURE__ */ (() => {\n    const t = new Uint8Array(256);\n    // Repeated multiplication by {03} walks all 255 nonzero field elements\n    // once, so t[255 - i] is the multiplicative inverse of t[i] for the\n    // affine step.\n    for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))\n        t[i] = x;\n    const box = new Uint8Array(256);\n    // FIPS 197 upd1 §5.1.1: SBOX({00}) = {63} because the inverse step leaves\n    // {00} at {00}, then the affine transform xors in c = {63}.\n    box[0] = 0x63;\n    for (let i = 0; i < 255; i++) {\n        let x = t[255 - i];\n        x |= x << 8;\n        box[t[i]] = (x ^ (x >> 4) ^ (x >> 5) ^ (x >> 6) ^ (x >> 7) ^ 0x63) & 0xff;\n    }\n    clean(t);\n    return box;\n})();\n// FIPS 197 upd1 §5.3.2: INVSBOX() is derived from SBOX() by swapping input\n// and output roles (Table 6).\n// `indexOf` is only used once at module init, so the quadratic setup cost stays off hot paths.\nconst invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));\n// FIPS 197 upd1 §5.2: ROTWORD([a0,a1,a2,a3]) = [a1,a2,a3,a0]; with this LE\n// word packing that is a right rotate by 8 bits.\nconst rotr32_8 = (n) => (n << 24) | (n >>> 8);\n// LE T-table helper: rotates one precomputed word by one byte so T1/T2/T3\n// reuse T0's substitution/mix result in the other byte lanes.\nconst rotl32_8 = (n) => (n << 8) | (n >>> 24);\n// T-table is optimization suggested in 5.2 of original proposal (missed from FIPS-197). Changes:\n// - LE instead of BE\n// - bigger tables: T0 and T1 are merged into T01 table and T2 & T3 into T23;\n//   so index is u16, instead of u8. This speeds up things, unexpectedly\nfunction genTtable(sbox, fn) {\n    if (sbox.length !== 256)\n        throw new Error('Wrong sbox length');\n    const T0 = new Uint32Array(256).map((_, j) => fn(sbox[j]));\n    const T1 = T0.map(rotl32_8);\n    const T2 = T1.map(rotl32_8);\n    const T3 = T2.map(rotl32_8);\n    // Pre-xor adjacent lanes so apply0123/applySbox can fetch two substituted\n    // byte lanes per lookup in the LE round layout.\n    const T01 = new Uint32Array(256 * 256);\n    const T23 = new Uint32Array(256 * 256);\n    const sbox2 = new Uint16Array(256 * 256);\n    for (let i = 0; i < 256; i++) {\n        for (let j = 0; j < 256; j++) {\n            const idx = i * 256 + j;\n            T01[idx] = T0[i] ^ T1[j];\n            T23[idx] = T2[i] ^ T3[j];\n            sbox2[idx] = (sbox[i] << 8) | sbox[j];\n        }\n    }\n    return { sbox, sbox2, T0, T1, T2, T3, T01, T23 };\n}\n// Forward round precompute: the packed word stores the MIXCOLUMNS row\n// [{02},{01},{01},{03}] in LE byte-lane order, and the returned `sbox2`\n// is also reused by key expansion and the final round.\nconst tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => (mul(s, 3) << 24) | (s << 16) | (s << 8) | mul(s, 2));\n// Inverse round precompute: the packed word stores the INVMIXCOLUMNS row\n// [{0e},{09},{0d},{0b}] in LE byte-lane order, and the tables are reused\n// by decrypt() and expandKeyDecLE().\nconst tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => (mul(s, 11) << 24) | (mul(s, 13) << 16) | (mul(s, 9) << 8) | mul(s, 14));\n// FIPS 197 upd1 §5.2 Table 5: left-most bytes of Rcon[j] = x^(j-1), generated by repeated XTIMES().\nconst xPowers = /* @__PURE__ */ (() => {\n    const p = new Uint8Array(16);\n    for (let i = 0, x = 1; i < 16; i++, x = mul2(x))\n        p[i] = x;\n    return p;\n})();\n/** Forward AES key expansion used across ECB/CBC/CTR/GCM/CMAC/KW-style paths. */\nfunction expandKeyLE(key) {\n    abytes(key);\n    const len = key.length;\n    validateKeyLength(key);\n    const { sbox2 } = tableEncoding;\n    const toClean = [];\n    // Copy on BE or misaligned inputs so the LE word normalization below never\n    // mutates caller key bytes in place.\n    if (!isLE || !isAligned32(key))\n        toClean.push((key = copyBytes(key)));\n    const k32 = swap32IfBE(u32(key));\n    const Nk = k32.length;\n    // `applySbox` normally reads one byte lane from each argument; repeating\n    // `n` across all four lanes turns it into SUBWORD(n).\n    const subByte = (n) => applySbox(sbox2, n, n, n, n);\n    // AES key sizes are 16/24/32 bytes, so len + 28 yields the 44/52/60\n    // schedule words from FIPS 197 §5.2 / Table 3.\n    const xk = new Uint32Array(len + 28); // expanded key\n    xk.set(k32);\n    // 4.3.1 Key expansion\n    for (let i = Nk; i < xk.length; i++) {\n        let t = xk[i - 1];\n        if (i % Nk === 0)\n            t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];\n        else if (Nk > 6 && i % Nk === 4)\n            t = subByte(t);\n        xk[i] = xk[i - Nk] ^ t;\n    }\n    clean(...toClean);\n    return xk;\n}\nfunction expandKeyDecLE(key) {\n    const encKey = expandKeyLE(key);\n    const xk = encKey.slice();\n    const Nk = encKey.length;\n    const { sbox2 } = tableEncoding;\n    const { T0, T1, T2, T3 } = tableDecoding;\n    // Local decrypt() walks round keys forward from xk[0], so reverse the\n    // encryption round-key blocks first before applying the equivalent-inverse\n    // middle-round transform.\n    for (let i = 0; i < Nk; i += 4) {\n        for (let j = 0; j < 4; j++)\n            xk[i + j] = encKey[Nk - i - 4 + j];\n    }\n    clean(encKey);\n    // Apply InvMixColumn to the reversed round keys using the same LE sbox2\n    // packing as the forward path.\n    // apply InvMixColumn except first & last round\n    for (let i = 4; i < Nk - 4; i++) {\n        const x = xk[i];\n        const w = applySbox(sbox2, x, x, x, x);\n        xk[i] = T0[w & 0xff] ^ T1[(w >>> 8) & 0xff] ^ T2[(w >>> 16) & 0xff] ^ T3[w >>> 24];\n    }\n    return xk;\n}\n// Apply tables\nfunction apply0123(T01, T23, s0, s1, s2, s3) {\n    // `T01` takes the low byte lane from `s0` plus the next lane from `s1`;\n    // `T23` does the same for `s2`/`s3`.\n    // Equivalent to `T0[s0&0xff] ^ T1[(s1>>>8)&0xff] ^ T2[(s2>>>16)&0xff] ^\n    // T3[s3>>>24]`, but with two merged-table fetches.\n    return (T01[((s0 << 8) & 0xff00) | ((s1 >>> 8) & 0xff)] ^\n        T23[((s2 >>> 8) & 0xff00) | ((s3 >>> 24) & 0xff)]);\n}\nfunction applySbox(sbox2, s0, s1, s2, s3) {\n    // `sbox2` packs two substituted byte lanes at a time in the same LE\n    // layout used by the round code.\n    // Equivalent to `SBOX(byte0(s0)) | SBOX(byte1(s1))<<8 |\n    // SBOX(byte2(s2))<<16 | SBOX(byte3(s3))<<24`.\n    return (sbox2[(s0 & 0xff) | (s1 & 0xff00)] |\n        (sbox2[((s2 >>> 16) & 0xff) | ((s3 >>> 16) & 0xff00)] << 16));\n}\nfunction encrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableEncoding;\n    let k = 0;\n    ((s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]));\n    // `xk` has Nr+1 round-key blocks, so after the initial AddRoundKey and the\n    // final S-box-only round there are Nr-1 full table/MixColumns rounds left.\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);\n        ((s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3));\n    }\n    // last round (without mixcolumns, so using SBOX2 table)\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\n// Can't be merged with encrypt: arg positions for apply0123 / applySbox are different\nfunction decrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableDecoding;\n    let k = 0;\n    ((s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]));\n    // With `expandKeyDecLE()` the round keys are already reversed and middle\n    // rounds are InvMixColumns-adjusted, so this loop follows the equivalent\n    // inverse cipher order directly.\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);\n        ((s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3));\n    }\n    // Final equivalent-inverse round omits InvMixColumns, so use inverse\n    // S-box lanes in InvShiftRows order.\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\nfunction ctrCounter(xk, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE, 'nonce');\n    abytes(src);\n    const srcLen = src.length;\n    dst = getOutput(srcLen, dst);\n    complexOverlapBytes(src, dst);\n    // Internal helper: mutate `nonce` in place as the live counter block so\n    // each encrypted block uses the next CTR value.\n    const ctr = nonce;\n    const c32 = u32(ctr);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    // Fill block (empty, ctr=0)\n    let { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ swap8IfBE(s0);\n        dst32[i + 1] = src32[i + 1] ^ swap8IfBE(s1);\n        dst32[i + 2] = src32[i + 2] ^ swap8IfBE(s2);\n        dst32[i + 3] = src32[i + 3] ^ swap8IfBE(s3);\n        incBytes(ctr, false, 1); // Full 128 bit counter with wrap around\n        ({ s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3])));\n    }\n    // NIST SP 800-38A CTR mode uses the leading `u` bits of the next output\n    // block for the final short block.\n    // It's possible to handle > u32 fast, but is it worth it?\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        swap32IfBE(b32);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n        clean(b32);\n    }\n    // Unsafe mutable-counter API only advances whole blocks. Callers that want to\n    // resume after consuming part of this block must re-run from the same counter\n    // with left-padding and strip the already-consumed prefix themselves.\n    return dst;\n}\n// AES CTR with overflowing 32 bit counter\n// It's possible to do 32le significantly simpler (and probably faster) by using u32.\n// But, we need both, and perf bottleneck is in ghash anyway.\n// Unsafe 32-bit CTR helper: mutates `nonce` in place, expects aligned `src`/`dst`,\n// and uses `isLE` to choose which 32-bit counter word is incremented.\nfunction ctr32(xk, isLE, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE, 'nonce');\n    abytes(src);\n    dst = getOutput(src.length, dst);\n    const ctr = nonce; // write new value to nonce, so it can be re-used\n    const c32 = u32(ctr);\n    const view = createView(ctr);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    // NIST SP 800-38D GCTR increments the rightmost 32 bits of J0, while\n    // RFC 8452 AES-GCM-SIV increments the first 32 bits as a little-endian u32.\n    const ctrPos = isLE ? 0 : 12;\n    const srcLen = src.length;\n    // Fill block (empty, ctr=0)\n    let ctrNum = view.getUint32(ctrPos, isLE); // read current counter value\n    let { s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3]));\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ swap8IfBE(s0);\n        dst32[i + 1] = src32[i + 1] ^ swap8IfBE(s1);\n        dst32[i + 2] = src32[i + 2] ^ swap8IfBE(s2);\n        dst32[i + 3] = src32[i + 3] ^ swap8IfBE(s3);\n        ctrNum = (ctrNum + 1) >>> 0; // u32 wrap\n        view.setUint32(ctrPos, ctrNum, isLE);\n        ({ s0, s1, s2, s3 } = encrypt(xk, swap8IfBE(c32[0]), swap8IfBE(c32[1]), swap8IfBE(c32[2]), swap8IfBE(c32[3])));\n    }\n    // leftovers (less than a block)\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        swap32IfBE(b32);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n        clean(b32);\n    }\n    // Same unsafe contract as ctrCounter(): only full blocks advance the stored\n    // mutable counter state; partial-block continuation is caller-managed.\n    return dst;\n}\n/**\n * **CTR** (Counter Mode): turns a block cipher into a stream cipher using a\n * full 16-byte counter block.\n * Efficient and parallelizable. Requires a unique nonce per encryption. Unauthenticated: needs MAC.\n * @param key - AES key bytes.\n * @param nonce - 16-byte counter block, incremented as a full AES block.\n * @returns Cipher instance with `encrypt()` and `decrypt()`.\n * @example\n * Encrypts a short payload with a fresh AES key and counter block.\n *\n * ```ts\n * import { ctr } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * const nonce = randomBytes(16);\n * const cipher = ctr(key, nonce);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const ctr = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aesctr(key, nonce) {\n    function processCtr(buf, dst) {\n        abytes(buf);\n        if (dst !== undefined) {\n            abytes(dst);\n            // Optional output buffers must stay 4-byte aligned because\n            // ctrCounter() reinterprets them as Uint32Array words.\n            if (!isAligned32(dst))\n                throw new Error('unaligned destination');\n        }\n        const xk = expandKeyLE(key);\n        // Public CTR keeps caller nonce bytes immutable even though ctrCounter()\n        // advances the live 16-byte counter block in place.\n        const n = copyBytes(nonce); // align + avoid changing\n        const toClean = [xk, n];\n        if (!isAligned32(buf))\n            toClean.push((buf = copyBytes(buf)));\n        const out = ctrCounter(xk, n, buf, dst);\n        clean(...toClean);\n        return out;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCtr(plaintext, dst),\n        decrypt: (ciphertext, dst) => processCtr(ciphertext, dst),\n    };\n});\nfunction validateBlockDecrypt(data) {\n    abytes(data);\n    // ECB/CBC decryption always consumes whole ciphertext blocks; PKCS#7/CMS\n    // padding, when enabled, is removed only after decrypting the final block.\n    if (data.length % BLOCK_SIZE !== 0) {\n        throw new Error('aes-(cbc/ecb).decrypt ciphertext should consist of blocks with size ' + BLOCK_SIZE);\n    }\n}\n// ECB/CBC core modes operate on whole blocks; `pkcs5` enables the library's\n// PKCS#7/CMS-compatible final-block padding convenience before encryption.\nfunction validateBlockEncrypt(plaintext, pkcs5, dst) {\n    abytes(plaintext);\n    let outLen = plaintext.length;\n    const remaining = outLen % BLOCK_SIZE;\n    if (!pkcs5 && remaining !== 0)\n        throw new Error('aec/(cbc-ecb): unpadded plaintext with disabled padding');\n    if (pkcs5) {\n        let left = BLOCK_SIZE - remaining;\n        // RFC 5652 pads even already-aligned inputs, so a full extra block is\n        // appended when the plaintext length is already a multiple of 16 bytes.\n        if (!left)\n            left = BLOCK_SIZE; // if no bytes left, create empty padding block\n        outLen = outLen + left;\n    }\n    dst = getOutput(outLen, dst);\n    complexOverlapBytes(plaintext, dst);\n    // Copy on BE or misaligned inputs so u32()/swap32IfBE() normalization never\n    // mutates caller plaintext bytes in place before ECB/CBC processing.\n    if (!isLE || !isAligned32(plaintext))\n        plaintext = copyBytes(plaintext);\n    const b = u32(plaintext);\n    swap32IfBE(b);\n    const o = u32(dst);\n    return { b, o, out: dst };\n}\n// `pkcs5` is the historical option name; for AES's 16-byte block this is the\n// generic PKCS#7/CMS-style block-padding rule on decrypt.\nfunction validatePKCS(data, pkcs5) {\n    if (!pkcs5)\n        return data;\n    const len = data.length;\n    // RFC 5652 pads even empty / already-aligned inputs, so a valid padded\n    // ECB/CBC ciphertext is never empty when PKCS#7/CMS unpadding is enabled.\n    // AES-CBC/ECB ciphertext should be full blocks before unpadding\n    if (len === 0)\n        throw new Error('aes/pkcs7: empty ciphertext not allowed');\n    const lastByte = data[len - 1];\n    let valid = 1;\n    valid &= ((lastByte - 1) >>> 31) ^ 1; // pad >= 1\n    valid &= ((16 - lastByte) >>> 31) ^ 1; // pad <= 16\n    // Check exactly 16 tail bytes in constant-shape loop\n    // For i < pad: byte must equal pad\n    // For i >= pad: ignore byte\n    for (let i = 0; i < 16; i++) {\n        // const b = data[len - 1 - i];\n        const shouldCheck = (i - lastByte) >>> 31; // 1 if i < pad else 0\n        const eq = (data[len - 1 - i] ^ lastByte) === 0 ? 1 : 0; // 1 if equal\n        valid &= eq | (shouldCheck ^ 1); // pass if equal OR not checked\n    }\n    // if (invalidLen) throw new Error('aes/pkcs7: ciphertext length must be multiple of 16');\n    if (!valid)\n        throw new Error('aes/pkcs7: wrong padding');\n    return data.subarray(0, len - lastByte);\n}\n// ECB/CBC callers only pass the final short block here, so `left.length` is\n// 0..15 and the helper always emits exactly one padded 16-byte block.\nfunction padPCKS(left) {\n    const tmp = new Uint8Array(16);\n    const tmp32 = u32(tmp);\n    tmp.set(left);\n    const paddingByte = BLOCK_SIZE - left.length;\n    // RFC 5652 §6.3 fills the whole suffix with the padding length byte:\n    // e.g. `aa 0f..0f` for a 1-byte tail, or `10..10` for a full extra block.\n    for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)\n        tmp[i] = paddingByte;\n    return tmp32;\n}\n/**\n * **ECB** (Electronic Codebook): Deterministic encryption; identical plaintext blocks yield\n * identical ciphertexts. Not secure due to pattern leakage.\n * See {@link https://words.filippo.io/the-ecb-penguin/ | the AES Penguin}.\n * @param key - AES key bytes.\n * @param opts - Padding options. See {@link BlockOpts}.\n * @returns Cipher instance with `encrypt()` and `decrypt()`.\n * @example\n * Shows the basic ECB encrypt call shape with a fresh key; avoid ECB in new designs.\n *\n * ```ts\n * import { ecb } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * const cipher = ecb(key);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const ecb = /* @__PURE__ */ wrapCipher({ blockSize: 16 }, function aesecb(key, opts = {}) {\n    const pkcs5 = !opts.disablePadding;\n    return {\n        encrypt(plaintext, dst) {\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pkcs5, dst);\n            const xk = expandKeyLE(key);\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            if (pkcs5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                swap32IfBE(tmp32);\n                const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            swap32IfBE(o);\n            clean(xk);\n            return _out;\n        },\n        decrypt(ciphertext, dst) {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            dst = getOutput(ciphertext.length, dst);\n            const toClean = [xk];\n            complexOverlapBytes(ciphertext, dst);\n            // Copy on BE or misaligned ciphertext so u32()/swap32IfBE()\n            // normalization never mutates caller bytes in place before decrypt().\n            if (!isLE || !isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const b = u32(ciphertext);\n            const o = u32(dst);\n            swap32IfBE(b);\n            for (let i = 0; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            swap32IfBE(o);\n            clean(...toClean);\n            return validatePKCS(dst, pkcs5);\n        },\n    };\n});\n/**\n * **CBC** (Cipher Block Chaining): Each plaintext block is XORed with the\n * previous block of ciphertext before encryption.\n * Hard to use: requires proper padding and an unpredictable IV. Unauthenticated: needs MAC.\n * @param key - AES key bytes.\n * @param iv - 16-byte unpredictable initialization vector.\n * @param opts - Padding options. See {@link BlockOpts}.\n * @returns Cipher instance with `encrypt()` and `decrypt()`.\n * @example\n * Encrypts a padded message with a fresh key and 16-byte IV.\n *\n * ```ts\n * import { cbc } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * const iv = randomBytes(16);\n * const cipher = cbc(key, iv);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const cbc = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aescbc(key, iv, opts = {}) {\n    const pkcs5 = !opts.disablePadding;\n    return {\n        encrypt(plaintext, dst) {\n            const xk = expandKeyLE(key);\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pkcs5, dst);\n            let _iv = iv;\n            const toClean = [xk];\n            // Copy on BE or misaligned inputs so IV normalization and the mutable\n            // local chaining state never write back into caller IV bytes.\n            if (!isLE || !isAligned32(_iv))\n                toClean.push((_iv = copyBytes(_iv)));\n            const n32 = u32(_iv);\n            swap32IfBE(n32);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                ((s0 ^= b[i + 0]), (s1 ^= b[i + 1]), (s2 ^= b[i + 2]), (s3 ^= b[i + 3]));\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            if (pkcs5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                swap32IfBE(tmp32);\n                ((s0 ^= tmp32[0]), (s1 ^= tmp32[1]), (s2 ^= tmp32[2]), (s3 ^= tmp32[3]));\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            swap32IfBE(o);\n            clean(...toClean);\n            return _out;\n        },\n        decrypt(ciphertext, dst) {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            let _iv = iv;\n            const toClean = [xk];\n            // Copy on BE or misaligned inputs so IV normalization and the mutable\n            // local chaining state never write back into caller IV bytes.\n            if (!isLE || !isAligned32(_iv))\n                toClean.push((_iv = copyBytes(_iv)));\n            const n32 = u32(_iv);\n            swap32IfBE(n32);\n            dst = getOutput(ciphertext.length, dst);\n            complexOverlapBytes(ciphertext, dst);\n            // Copy on BE or misaligned ciphertext so u32()/swap32IfBE()\n            // normalization never mutates caller bytes in place before decrypt().\n            if (!isLE || !isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const b = u32(ciphertext);\n            const o = u32(dst);\n            swap32IfBE(b);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            for (let i = 0; i + 4 <= b.length;) {\n                // prettier-ignore\n                const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;\n                ((s0 = b[i + 0]), (s1 = b[i + 1]), (s2 = b[i + 2]), (s3 = b[i + 3]));\n                const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);\n                ((o[i++] = o0 ^ ps0), (o[i++] = o1 ^ ps1), (o[i++] = o2 ^ ps2), (o[i++] = o3 ^ ps3));\n            }\n            swap32IfBE(o);\n            clean(...toClean);\n            return validatePKCS(dst, pkcs5);\n        },\n    };\n});\n/**\n * CFB (CFB-128): Cipher Feedback Mode with 128-bit segments. The input for the\n * block cipher is the previous cipher output.\n * Unauthenticated: needs MAC.\n * @param key - AES key bytes.\n * @param iv - 16-byte unpredictable initialization vector.\n * @returns Cipher instance with `encrypt()` and `decrypt()`.\n * @example\n * Encrypts a short message with feedback mode and a fresh key/IV pair.\n *\n * ```ts\n * import { cfb } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * const iv = randomBytes(16);\n * const cipher = cfb(key, iv);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const cfb = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aescfb(key, iv) {\n    function processCfb(src, isEncrypt, dst) {\n        abytes(src);\n        const srcLen = src.length;\n        dst = getOutput(srcLen, dst);\n        // CFB feeds back previous ciphertext, so overlapping src/dst could\n        // overwrite bytes that are still needed as the next feedback block.\n        if (overlapBytes(src, dst))\n            throw new Error('overlapping src and dst not supported.');\n        const xk = expandKeyLE(key);\n        let _iv = iv;\n        const toClean = [xk];\n        // Copy on BE or misaligned inputs so u32()/swap32IfBE() normalization\n        // never mutates caller IV/src bytes in place before CFB processing.\n        if (!isLE || !isAligned32(_iv))\n            toClean.push((_iv = copyBytes(_iv)));\n        if (!isLE || !isAligned32(src))\n            toClean.push((src = copyBytes(src)));\n        const src32 = u32(src);\n        const dst32 = u32(dst);\n        // NIST SP 800-38A §6.3 feeds back the previous ciphertext segment in\n        // both directions: encrypt reuses freshly written dst words, decrypt\n        // reuses the source ciphertext words.\n        const next32 = isEncrypt ? dst32 : src32;\n        const n32 = u32(_iv);\n        swap32IfBE(src32);\n        swap32IfBE(n32);\n        // prettier-ignore\n        let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n        for (let i = 0; i + 4 <= src32.length;) {\n            const { s0: e0, s1: e1, s2: e2, s3: e3 } = encrypt(xk, s0, s1, s2, s3);\n            dst32[i + 0] = src32[i + 0] ^ e0;\n            dst32[i + 1] = src32[i + 1] ^ e1;\n            dst32[i + 2] = src32[i + 2] ^ e2;\n            dst32[i + 3] = src32[i + 3] ^ e3;\n            ((s0 = next32[i++]), (s1 = next32[i++]), (s2 = next32[i++]), (s3 = next32[i++]));\n        }\n        // leftovers (less than block)\n        const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n        if (start < srcLen) {\n            // Byte-oriented API: for a final short tail, reuse the next CFB-128\n            // output block and XOR only the needed prefix. RFC 3826 §3.1.3 /\n            // §3.1.4 describes the same no-padding rule at bit granularity for a\n            // final r<=128 segment.\n            ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n            const tmp = new Uint32Array([s0, s1, s2, s3]);\n            swap32IfBE(tmp);\n            const buf = u8(tmp);\n            for (let i = start, pos = 0; i < srcLen; i++, pos++)\n                dst[i] = src[i] ^ buf[pos];\n            clean(buf);\n        }\n        swap32IfBE(dst32);\n        clean(...toClean);\n        return dst;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCfb(plaintext, true, dst),\n        decrypt: (ciphertext, dst) => processCfb(ciphertext, false, dst),\n    };\n});\n// TODO: merge with chacha, however gcm has bitLen while chacha has byteLen\n// `data` is the payload covered by the polynomial MAC: ciphertext for GCM,\n// plaintext for GCM-SIV. Keep AAD/data/length as separate updates because\n// GHASH/POLYVAL pad each call to block boundaries, so the chunks must match the\n// spec-defined segments instead of arbitrary concatenation boundaries.\nfunction computeTag(fn, isLE, key, data, AAD) {\n    const aadLength = AAD ? AAD.length : 0;\n    const h = fn.create(key, data.length + aadLength);\n    if (AAD)\n        h.update(AAD);\n    // u64Lengths() takes (dataBits, aadBits) but still serializes the final\n    // block as len(AAD) || len(data), matching both GCM and GCM-SIV.\n    const num = u64Lengths(8 * data.length, 8 * aadLength, isLE);\n    h.update(data);\n    h.update(num);\n    const res = h.digest();\n    clean(num);\n    return res;\n}\n/**\n * **GCM** (Galois/Counter Mode): Combines CTR mode with polynomial MAC. Efficient and widely used.\n * Not perfect:\n * a) conservative key wear-out is `2**32` (4B) msgs.\n * b) key wear-out under random nonces is even smaller: `2**23` (8M) messages for `2**-50` chance.\n * c) MAC can be forged: see Poly1305 documentation.\n * @param key - AES key bytes.\n * @param nonce - Nonce bytes (12 recommended, minimum 8; other lengths use GHASH J0 derivation).\n * @param AAD - Additional authenticated data.\n * @returns AEAD cipher instance with a fixed 16-byte tag.\n * @example\n * Encrypts and authenticates plaintext with a fresh key and 12-byte nonce.\n *\n * ```ts\n * import { gcm } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * const nonce = randomBytes(12);\n * const cipher = gcm(key, nonce);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {\n    // SP 800-38D lets implementations narrow supported IV lengths.\n    // This wrapper intentionally requires at least 8 bytes; OpenSSL accepts shorter IVs too.\n    // 12-byte nonces take the fast path; other allowed lengths use GHASH to derive J0.\n    if (nonce.length < 8)\n        throw new Error('aes/gcm: invalid nonce length');\n    const tagLength = 16;\n    function _computeTag(authKey, tagMask, data) {\n        const tag = computeTag(ghash, false, authKey, data, AAD);\n        for (let i = 0; i < tagMask.length; i++)\n            tag[i] ^= tagMask[i];\n        return tag;\n    }\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const authKey = EMPTY_BLOCK.slice();\n        const counter = EMPTY_BLOCK.slice();\n        ctr32(xk, false, counter, counter, authKey);\n        // NIST 800-38d, page 15: different behavior for 96-bit and non-96-bit nonces\n        if (nonce.length === 12) {\n            counter.set(nonce);\n        }\n        else {\n            const nonceLen = EMPTY_BLOCK.slice();\n            const view = createView(nonceLen);\n            view.setBigUint64(8, BigInt(nonce.length * 8), false);\n            // GHASH.update() pads each call to 16 bytes, so\n            // update(nonce).update(nonceLen) realizes\n            // IV || 0^s || 0^64 || [len(IV)]_64 for non-96-bit nonces.\n            // ghash(nonce || u64be(0) || u64be(nonceLen*8))\n            const g = ghash.create(authKey).update(nonce).update(nonceLen);\n            g.digestInto(counter); // digestInto doesn't trigger '.destroy'\n            g.destroy();\n        }\n        // GCTR_K(J0, 0^128) = E_K(J0); reusing ctr32() here extracts that tag\n        // mask and leaves `counter` advanced to inc32(J0) for payload GCTR.\n        const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);\n        return { xk, authKey, counter, tagMask };\n    }\n    return {\n        encrypt(plaintext) {\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const out = new Uint8Array(plaintext.length + tagLength);\n            const toClean = [xk, authKey, counter, tagMask];\n            if (!isAligned32(plaintext))\n                toClean.push((plaintext = copyBytes(plaintext)));\n            ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));\n            const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));\n            toClean.push(tag);\n            out.set(tag, plaintext.length);\n            clean(...toClean);\n            return out;\n        },\n        decrypt(ciphertext) {\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const toClean = [xk, authKey, tagMask, counter];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = _computeTag(authKey, tagMask, data);\n            toClean.push(tag);\n            // NIST SP 800-38D §7.2 permits equivalent step orderings; verify the\n            // tag before CTR so unauthenticated plaintext is never materialized.\n            if (!equalBytes(tag, passedTag)) {\n                clean(...toClean);\n                throw new Error('aes/gcm: invalid ghash tag');\n            }\n            const out = ctr32(xk, false, counter, data);\n            clean(...toClean);\n            return out;\n        },\n    };\n});\nconst limit = (name, min, max) => (value) => {\n    // Current AES-SIV/GCM-SIV callers pass protocol limits from RFC 8452 / RFC 5297,\n    // not arbitrary library-preference bounds.\n    // Callers feed Uint8Array.length values here, so safe-integer rejection\n    // does not exclude any representable input even when an RFC bound is larger.\n    if (!Number.isSafeInteger(value) || min > value || value > max) {\n        const minmax = '[' + min + '..' + max + ']';\n        throw new Error('' + name + ': expected value in range ' + minmax + ', got ' + value);\n    }\n};\n/**\n * **SIV** (Synthetic IV): GCM with nonce-misuse resistance.\n * Repeating nonces reveal only the fact plaintexts are identical.\n * Also suffers from GCM issues: key wear-out limits & MAC forging.\n * See {@link https://www.rfc-editor.org/rfc/rfc8452 | RFC 8452}.\n * RFC 8452 defines 16-byte and 32-byte AES keys for this mode.\n * This implementation also accepts 24-byte AES-192 keys as a local\n * extension; see the inline comment next to `validateKeyLength(key)` below\n * for the exact scope note.\n * @param key - AES key bytes.\n * @param nonce - 12-byte nonce.\n * @param AAD - Additional authenticated data.\n * @returns AEAD cipher instance.\n * @example\n * Encrypts and authenticates plaintext with a fresh key and nonce, while tolerating reuse.\n *\n * ```ts\n * import { gcmsiv } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * const nonce = randomBytes(12);\n * const cipher = gcmsiv(key, nonce);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const gcmsiv = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aessiv(key, nonce, AAD) {\n    const tagLength = 16;\n    // From RFC 8452: Section 6\n    const AAD_LIMIT = limit('AAD', 0, 2 ** 36);\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 36);\n    const NONCE_LIMIT = limit('nonce', 12, 12);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 36 + 16);\n    abytes(key);\n    // RFC 8452 only standardizes 16-byte and 32-byte key-generating keys.\n    // The accepted 24-byte path is a local AES-192 extension outside the RFC-defined AEADs.\n    validateKeyLength(key);\n    NONCE_LIMIT(nonce.length);\n    if (AAD !== undefined)\n        AAD_LIMIT(AAD.length);\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const encKey = new Uint8Array(key.length);\n        const authKey = new Uint8Array(16);\n        const toClean = [xk, encKey];\n        let _nonce = nonce;\n        // Copy on BE or misaligned nonce so u32()/swap32IfBE() normalization\n        // never mutates caller nonce bytes before RFC 8452 key derivation.\n        if (!isLE || !isAligned32(_nonce))\n            toClean.push((_nonce = copyBytes(_nonce)));\n        const n32 = u32(_nonce);\n        swap32IfBE(n32);\n        // prettier-ignore\n        let s0 = 0, s1 = n32[0], s2 = n32[1], s3 = n32[2];\n        let counter = 0;\n        for (const derivedKey of [authKey, encKey].map(u32)) {\n            const d32 = u32(derivedKey);\n            for (let i = 0; i < d32.length; i += 2) {\n                // aes(u32le(0) || nonce)[:8] || aes(u32le(1) || nonce)[:8] ...\n                const { s0: o0, s1: o1 } = encrypt(xk, s0, s1, s2, s3);\n                d32[i + 0] = o0;\n                d32[i + 1] = o1;\n                s0 = ++counter; // increment counter inside state\n            }\n            swap32IfBE(d32);\n        }\n        const res = { authKey, encKey: expandKeyLE(encKey) };\n        // Cleanup\n        clean(...toClean);\n        return res;\n    }\n    function _computeTag(encKey, authKey, data) {\n        const tag = computeTag(polyval, true, authKey, data, AAD);\n        // Compute the expected tag by XORing S_s and the nonce, clearing the\n        // most significant bit of the last byte and encrypting with the\n        // message-encryption key.\n        for (let i = 0; i < 12; i++)\n            tag[i] ^= nonce[i];\n        tag[15] &= 0x7f; // Clear the highest bit\n        // encrypt tag as block\n        const t32 = u32(tag);\n        swap32IfBE(t32);\n        // prettier-ignore\n        let s0 = t32[0], s1 = t32[1], s2 = t32[2], s3 = t32[3];\n        ({ s0, s1, s2, s3 } = encrypt(encKey, s0, s1, s2, s3));\n        ((t32[0] = s0), (t32[1] = s1), (t32[2] = s2), (t32[3] = s3));\n        swap32IfBE(t32);\n        return tag;\n    }\n    // actual decrypt/encrypt of message.\n    function processSiv(encKey, tag, input) {\n        let block = copyBytes(tag);\n        // RFC 8452 §4 / §5 use the tag with the highest bit of the last byte\n        // forced to one as the initial AES-CTR counter block.\n        block[15] |= 0x80; // Force highest bit\n        const res = ctr32(encKey, true, block, input);\n        // Cleanup\n        clean(block);\n        return res;\n    }\n    return {\n        encrypt(plaintext) {\n            PLAIN_LIMIT(plaintext.length);\n            const { encKey, authKey } = deriveKeys();\n            const tag = _computeTag(encKey, authKey, plaintext);\n            const toClean = [encKey, authKey, tag];\n            if (!isAligned32(plaintext))\n                toClean.push((plaintext = copyBytes(plaintext)));\n            const out = new Uint8Array(plaintext.length + tagLength);\n            out.set(tag, plaintext.length);\n            out.set(processSiv(encKey, tag, plaintext));\n            // Cleanup\n            clean(...toClean);\n            return out;\n        },\n        decrypt(ciphertext) {\n            CIPHER_LIMIT(ciphertext.length);\n            const tag = ciphertext.subarray(-tagLength);\n            const { encKey, authKey } = deriveKeys();\n            const toClean = [encKey, authKey];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const plaintext = processSiv(encKey, tag, ciphertext.subarray(0, -tagLength));\n            const expectedTag = _computeTag(encKey, authKey, plaintext);\n            toClean.push(expectedTag);\n            // RFC 8452 §5: plaintext is unauthenticated here and MUST NOT be\n            // returned until the expected-tag check completes successfully.\n            if (!equalBytes(tag, expectedTag)) {\n                clean(...toClean);\n                throw new Error('invalid polyval tag');\n            }\n            // Cleanup\n            clean(...toClean);\n            return plaintext;\n        },\n    };\n});\nfunction isBytes32(a) {\n    // Plain `instanceof Uint32Array` is too strict for cross-realm expanded-key views.\n    // This is only a best-effort unsafe-export guard, not a provenance proof for `expandKeyLE`.\n    return (a instanceof Uint32Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint32Array'));\n}\n// Unsafe single-block helpers: mutate `block` in place and require its 16-byte\n// Uint8Array view to be 4-byte aligned because `u32(block)` reinterprets it.\nfunction encryptBlock(xk, block) {\n    abytes(block, 16, 'block');\n    if (!isBytes32(xk))\n        throw new Error('_encryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    swap32IfBE(b32);\n    let { s0, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    ((b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3));\n    swap32IfBE(b32);\n    return block;\n}\nfunction decryptBlock(xk, block) {\n    abytes(block, 16, 'block');\n    if (!isBytes32(xk))\n        throw new Error('_decryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    swap32IfBE(b32);\n    let { s0, s1, s2, s3 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    ((b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3));\n    swap32IfBE(b32);\n    return block;\n}\n/**\n * AES-W (base for AESKW/AESKWP).\n * Specs:\n * {@link https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf | SP800-38F},\n * {@link https://www.rfc-editor.org/rfc/rfc3394 | RFC 3394},\n * {@link https://www.rfc-editor.org/rfc/rfc5649 | RFC 5649}.\n * Shared core mutates `out` in place; callers are responsible for prepending\n * the right IV/AIV and checking the recovered value after decrypt.\n */\nconst AESW = {\n    /*\n    High-level pseudocode:\n    ```\n    A: u64 = IV\n    out = []\n    for (let i=0, ctr = 0; i<6; i++) {\n      for (const chunk of chunks(plaintext, 8)) {\n        A ^= swapEndianess(ctr++)\n        [A, res] = chunks(encrypt(A || chunk), 8);\n        out ||= res\n      }\n    }\n    out = A || out\n    ```\n    Decrypt is the same, but reversed.\n    */\n    encrypt(kek, out) {\n        // Current implementation keeps RFC 3394/5649 `t` in a u32-shaped counter,\n        // so the shared core caps plaintext below 4 GiB even though the specs allow more.\n        if (out.length >= 2 ** 32)\n            throw new Error('plaintext should be less than 4gb');\n        const xk = expandKeyLE(kek);\n        // 16-byte `S = A || P[1]` is the RFC 5649 KWP special case for n=1;\n        // KW callers never reach it because KW requires at least two plaintext semiblocks.\n        if (out.length === 16)\n            encryptBlock(xk, out);\n        else {\n            const o32 = u32(out);\n            swap32IfBE(o32);\n            // prettier-ignore\n            let a0 = o32[0], a1 = o32[1]; // A\n            for (let j = 0, ctr = 1; j < 6; j++) {\n                for (let pos = 2; pos < o32.length; pos += 2, ctr++) {\n                    const { s0, s1, s2, s3 } = encrypt(xk, a0, a1, o32[pos], o32[pos + 1]);\n                    // A = MSB(64, B) ^ t where t = (n*j)+i. Under the 32-bit length cap\n                    // above, `t` fits in the low half of `[t]_64`, so xor only the low\n                    // 32 bits of A after converting `ctr` to network order.\n                    ((a0 = s0), (a1 = s1 ^ byteSwap(ctr)), (o32[pos] = s2), (o32[pos + 1] = s3));\n                }\n            }\n            ((o32[0] = a0), (o32[1] = a1)); // out = A || out\n            swap32IfBE(o32);\n        }\n        xk.fill(0);\n    },\n    decrypt(kek, out) {\n        // Same implementation cap on the recovered plaintext length after\n        // removing the 8-byte A/IV prefix.\n        if (out.length - 8 >= 2 ** 32)\n            throw new Error('ciphertext should be less than 4gb');\n        const xk = expandKeyDecLE(kek);\n        const chunks = out.length / 8 - 1; // first chunk is IV\n        // `n = 2` semiblocks is the RFC 5649 KWP special case; KW ciphertexts\n        // always have at least three semiblocks and therefore use the W^-1 loop.\n        if (chunks === 1)\n            decryptBlock(xk, out);\n        else {\n            const o32 = u32(out);\n            swap32IfBE(o32);\n            // prettier-ignore\n            let a0 = o32[0], a1 = o32[1]; // A\n            for (let j = 0, ctr = chunks * 6; j < 6; j++) {\n                for (let pos = chunks * 2; pos >= 1; pos -= 2, ctr--) {\n                    a1 ^= byteSwap(ctr);\n                    const { s0, s1, s2, s3 } = decrypt(xk, a0, a1, o32[pos], o32[pos + 1]);\n                    ((a0 = s0), (a1 = s1), (o32[pos] = s2), (o32[pos + 1] = s3));\n                }\n            }\n            ((o32[0] = a0), (o32[1] = a1));\n            swap32IfBE(o32);\n        }\n        xk.fill(0);\n    },\n};\n// RFC 3394 §2.2.3.1 / NIST SP 800-38F Algorithm 3 / Algorithm 4: KW prepends\n// the default 64-bit ICV1 and unwrap must verify the same value.\nconst AESKW_IV = /* @__PURE__ */ new Uint8Array(8).fill(0xa6); // A6A6A6A6A6A6A6A6\n/**\n * AES-KW (key-wrap). Injects static IV into plaintext, adds counter, encrypts 6 times.\n * Reduces block size from 16 to 8 bytes.\n * Plaintext must be a non-empty multiple of 8 bytes with minimum 16 bytes.\n * 8-byte inputs use aeskwp.\n * Wrapped ciphertext must be a multiple of 8 bytes with minimum 24 bytes.\n * For padded version, use aeskwp.\n * See {@link https://www.rfc-editor.org/rfc/rfc3394/ | RFC 3394} and\n * {@link https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf | NIST SP 800-38F}.\n * @param kek - AES key-encryption key.\n * @returns Key-wrap cipher instance.\n * As with other `wrapCipher(...)` wrappers, `encrypt()` is single-use per\n * instance.\n * @example\n * Wraps a 128-bit content-encryption key with a fresh key-encryption key.\n *\n * ```ts\n * import { aeskw } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const kek = randomBytes(16);\n * const cek = randomBytes(16);\n * const wrap = aeskw(kek);\n * wrap.encrypt(cek);\n * ```\n */\nexport const aeskw = /* @__PURE__ */ wrapCipher({ blockSize: 8 }, (kek) => ({\n    encrypt(plaintext) {\n        if (!plaintext.length || plaintext.length % 8 !== 0)\n            throw new Error('invalid plaintext length');\n        // RFC 3394 / NIST SP 800-38F define KW only for >=2 plaintext\n        // semiblocks; the 1-semiblock case belongs to RFC 5649 KWP.\n        if (plaintext.length === 8)\n            throw new Error('8-byte keys not allowed in AESKW, use AESKWP instead');\n        const out = concatBytes(AESKW_IV, plaintext);\n        AESW.encrypt(kek, out);\n        return out;\n    },\n    decrypt(ciphertext) {\n        // ciphertext must be at least 24 bytes and a multiple of 8 bytes\n        // 24 because should have at least two block (1 iv + 2).\n        // Replace with 16 to enable '8-byte keys'\n        if (ciphertext.length % 8 !== 0 || ciphertext.length < 3 * 8)\n            throw new Error('invalid ciphertext length');\n        // AESW.decrypt() mutates its buffer in place, so keep caller ciphertext\n        // immutable across the unwrap, ICV1 check, and IV scrubbing below.\n        const out = copyBytes(ciphertext);\n        AESW.decrypt(kek, out);\n        if (!equalBytes(out.subarray(0, 8), AESKW_IV))\n            throw new Error('integrity check failed');\n        out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway\n        return out.subarray(8);\n    },\n}));\n/*\nWe don't support 8-byte keys. The rabbit hole:\n\n- Wycheproof says: \"NIST SP 800-38F does not define the wrapping of 8 byte keys.\n  RFC 3394 Section 2  on the other hand specifies that 8 byte keys are wrapped\n  by directly encrypting one block with AES.\"\n    - {@link https://github.com/C2SP/wycheproof/blob/master/doc/key_wrap.md | Wycheproof key-wrap note}\n    - \"RFC 3394 specifies in Section 2, that the input for the key wrap\n      algorithm must be at least two blocks and otherwise the constant\n      field and key are simply encrypted with ECB as a single block\"\n- What RFC 3394 actually says (in Section 2):\n    - \"Before being wrapped, the key data is parsed into n blocks of 64 bits.\n      The only restriction the key wrap algorithm places on n is that n be\n      at least two\"\n    - \"For key data with length less than or equal to 64 bits, the constant\n      field used in this specification and the key data form a single\n      128-bit codebook input making this key wrap unnecessary.\"\n- Which means \"assert(n >= 2)\" and \"use something else for 8 byte keys\"\n- NIST SP800-38F actually prohibits 8-byte in \"5.3.1 Mandatory Limits\".\n  It states that plaintext for KW should be \"2 to 2^54 -1 semiblocks\".\n- So, where does \"directly encrypt single block with AES\" come from?\n    - Not RFC 3394. Pseudocode of key wrap in 2.2 explicitly uses\n      loop of 6 for any code path\n    - There is a weird W3C spec:\n      {@link https://www.w3.org/TR/2002/REC-xmlenc-core-20021210/Overview.html#kw-aes128 | XML Encryption AES key-wrap section}\n    - This spec is outdated, as admitted by Wycheproof authors\n    - There is RFC 5649 for padded key wrap, which is padding construction on\n      top of AESKW. In '4.1.2' it says: \"If the padded plaintext contains exactly\n      eight octets, then prepend the AIV as defined in Section 3 above to P[1] and\n      encrypt the resulting 128-bit block using AES in ECB mode [Modes] with key\n      K (the KEK).  In this case, the output is two 64-bit blocks C[0] and C[1]:\"\n    - Browser subtle crypto is actually crashes on wrapping keys less than 16 bytes:\n      `Error: error:1C8000E6:Provider routines::invalid input length]\n       { opensslErrorStack: [ 'error:030000BD:digital envelope routines::update error' ]`\n\nIn the end, seems like a bug in Wycheproof.\nThe 8-byte check can be easily disabled inside of AES_W.\n*/\n// RFC 5649 §3 / NIST SP 800-38F Algorithm 5 / Algorithm 6: KWP uses ICV2 as\n// the high 32 bits of the AIV; the low 32 bits carry the MLI in network order.\nconst AESKWP_IV = 0xa65959a6; // single u32le value\n/**\n * AES-KW, but with padding and allows random keys.\n * Uses the RFC 5649 alternative initial value; the second u32 stores the\n * 32-bit MLI in network order.\n * Wrapped ciphertext must be at least 16 bytes; malformed lengths are\n * rejected during AIV/padding checks.\n * See {@link https://www.rfc-editor.org/rfc/rfc5649 | RFC 5649}.\n * @param kek - AES key-encryption key.\n * @returns Padded key-wrap cipher instance.\n * @example\n * Wraps a short key blob using the padded variant and a fresh key-encryption key.\n *\n * ```ts\n * import { aeskwp } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const kek = randomBytes(16);\n * const wrap = aeskwp(kek);\n * wrap.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const aeskwp = /* @__PURE__ */ wrapCipher({ blockSize: 8 }, (kek) => ({\n    encrypt(plaintext) {\n        if (!plaintext.length)\n            throw new Error('invalid plaintext length');\n        const padded = Math.ceil(plaintext.length / 8) * 8;\n        const out = new Uint8Array(8 + padded);\n        out.set(plaintext, 8);\n        const out32 = u32(out);\n        out32[0] = swap8IfBE(AESKWP_IV);\n        // RFC 5649 §3: the low 32 bits of the AIV carry the octet-length MLI in\n        // network order, even though this buffer is addressed through LE u32s.\n        out32[1] = swap8IfBE(byteSwap(plaintext.length));\n        AESW.encrypt(kek, out);\n        return out;\n    },\n    decrypt(ciphertext) {\n        // 16 because should have at least one block\n        if (ciphertext.length < 16)\n            throw new Error('invalid ciphertext length');\n        // AESW.decrypt() mutates its buffer in place, so keep caller ciphertext\n        // immutable across the unwrap, AIV checks, and IV scrubbing below.\n        const out = copyBytes(ciphertext);\n        const o32 = u32(out);\n        AESW.decrypt(kek, out);\n        const len = byteSwap(swap8IfBE(o32[1])) >>> 0;\n        const padded = Math.ceil(len / 8) * 8;\n        if (swap8IfBE(o32[0]) !== AESKWP_IV || out.length - 8 !== padded)\n            throw new Error('integrity check failed');\n        // RFC 5649 §3 / NIST SP 800-38F Algorithm 6: recovered padding length\n        // must be in [0,7], and every recovered pad octet must be zero.\n        for (let i = len; i < padded; i++)\n            if (out[8 + i] !== 0)\n                throw new Error('integrity check failed');\n        out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway\n        return out.subarray(8, 8 + len);\n    },\n}));\nclass _AesCtrDRBG {\n    blockLen;\n    key;\n    nonce;\n    state;\n    reseedCnt;\n    constructor(keyLen, seed, personalization) {\n        this.blockLen = ctr.blockSize;\n        const keyLenBytes = keyLen / 8;\n        const nonceLen = 16;\n        // Store the full seedlen state as key || V so CTR_DRBG_Update-style steps\n        // can rewrite the entire internal state in place.\n        this.state = new Uint8Array(keyLenBytes + nonceLen);\n        this.key = this.state.subarray(0, keyLenBytes);\n        this.nonce = this.state.subarray(keyLenBytes, keyLenBytes + nonceLen);\n        this.reseedCnt = 1;\n        // Keep the stored counter one step ahead of SP 800-90A's formal V so\n        // ctr(key, nonce) uses the next counter block directly.\n        incBytes(this.nonce, false, 1);\n        this.addEntropy(seed, personalization);\n    }\n    update(data) {\n        // cannot re-use state here, because we will wipe current key\n        ctr(this.key, this.nonce).encrypt(new Uint8Array(this.state.length), this.state);\n        if (data) {\n            abytes(data);\n            // CTR_DRBG without a derivation function pads shorter additional_input\n            // with zeros to seedlen, so XOR only the provided prefix here.\n            for (let i = 0; i < data.length; i++)\n                this.state[i] ^= data[i];\n        }\n        // Keep storing V+1 so the next ctr(key, nonce) call starts from the\n        // spec's post-update counter state.\n        incBytes(this.nonce, false, 1);\n    }\n    // Optional `info` is additional input XORed into the reseed block and is\n    // limited to the internal state width.\n    addEntropy(seed, info) {\n        abytes(seed, this.state.length, 'seed');\n        // Copy caller entropy before XORing in personalization/additional input,\n        // then wipe the mixed seed material after CTR_DRBG_Update consumes it.\n        const _seed = seed.slice();\n        if (info) {\n            abytes(info);\n            if (info.length > _seed.length)\n                throw new Error('info length is too big');\n            for (let i = 0; i < info.length; i++)\n                _seed[i] ^= info[i];\n        }\n        this.update(_seed);\n        _seed.fill(0);\n        this.reseedCnt = 1;\n    }\n    // Optional `info` is additional input for the pre/post-update steps; bytes\n    // SP 800-90A Rev. 1 CTR_DRBG without a derivation function limits\n    // additional_input to seedlen, which is exactly this internal state width.\n    randomBytes(len, info) {\n        anumber(len);\n        // SP 800-90A Table 3 caps AES CTR_DRBG requests at 2^16 bits = 65536 bytes.\n        if (len > 2 ** 16)\n            throw new Error('requested output is too big');\n        // The spec allows generate while reseed_counter == reseed_interval and increments afterwards.\n        if (this.reseedCnt > 2 ** 48)\n            throw new Error('entropy exhausted');\n        if (info) {\n            abytes(info);\n            if (info.length > this.state.length)\n                throw new Error('info length is too big');\n            this.update(info);\n        }\n        const res = new Uint8Array(len);\n        ctr(this.key, this.nonce).encrypt(res, res);\n        incBytes(this.nonce, false, Math.ceil(len / this.blockLen));\n        this.update(info);\n        this.reseedCnt++;\n        return res;\n    }\n    // Zeroes the current state and resets the counter, but does not make the\n    // instance unusable: later calls continue from the zeroed state.\n    clean() {\n        // `key` and `nonce` alias this backing buffer, so one fill wipes the full\n        // secret state in place.\n        this.state.fill(0);\n        this.reseedCnt = 0;\n    }\n}\n// Internal helper for the exported 128-bit and 256-bit aliases; other key\n// lengths are not validated here.\nconst createAesDrbg = (keyLen) => {\n    return (seed, personalization = undefined) => new _AesCtrDRBG(keyLen, seed, personalization);\n};\n/**\n * AES-CTR DRBG 128-bit - CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n * @param seed - Initial 32-byte entropy input.\n * @param personalization - Optional personalization string.\n * @returns Seeded DRBG instance. The concrete methods also accept optional additional-input bytes.\n * @example\n * Seeds the test-only AES-CTR DRBG from fresh entropy and reads bytes from it.\n *\n * ```ts\n * import { rngAesCtrDrbg128 } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const seed = randomBytes(32);\n * const prg = rngAesCtrDrbg128(seed);\n * prg.randomBytes(8);\n * ```\n */\nexport const rngAesCtrDrbg128 = /* @__PURE__ */ createAesDrbg(128);\n/**\n * AES-CTR DRBG 256-bit - CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n * @param seed - Initial 48-byte entropy input.\n * @param personalization - Optional personalization string.\n * @returns Seeded DRBG instance. The concrete methods also accept optional additional-input bytes.\n * @example\n * Seeds the test-only AES-CTR DRBG from fresh entropy and reads bytes from it.\n *\n * ```ts\n * import { rngAesCtrDrbg256 } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const seed = randomBytes(48);\n * const prg = rngAesCtrDrbg256(seed);\n * prg.randomBytes(8);\n * ```\n */\nexport const rngAesCtrDrbg256 = /* @__PURE__ */ createAesDrbg(256);\n//#region CMAC\n/**\n * Left-shift by one bit and conditionally XOR with 0x87:\n * ```\n * if MSB(L) is equal to 0\n * then    K1 := L << 1;\n * else    K1 := (L << 1) XOR const_Rb;\n * ```\n *\n * Specs:\n * {@link https://www.rfc-editor.org/rfc/rfc4493.html#section-2.3 | RFC 4493 Section 2.3},\n * {@link https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.3 | RFC 5297 Section 2.3}\n *\n * @returns modified `block` (for chaining)\n */\nfunction dbl(block) {\n    let carry = 0;\n    // Left shift by 1 bit\n    for (let i = BLOCK_SIZE - 1; i >= 0; i--) {\n        const newCarry = (block[i] & 0x80) >>> 7;\n        block[i] = (block[i] << 1) | carry;\n        carry = newCarry;\n    }\n    // XOR with 0x87 if there was a carry from the most significant bit\n    if (carry) {\n        // RFC 4493 §2.3 / RFC 5297 §2.1: 0x87 is const_Rb for doubling in the\n        // CMAC/S2V finite field with primitive polynomial x^128 + x^7 + x^2 + x + 1.\n        block[BLOCK_SIZE - 1] ^= 0x87;\n    }\n    return block;\n}\n/**\n * `a XOR b`, running in-place on `a`.\n * @param a left operand and output\n * @param b right operand\n * @returns `a` (for chaining)\n */\nfunction xorBlock(a, b) {\n    if (a.length !== b.length)\n        throw new Error('xorBlock: blocks must have same length');\n    for (let i = 0; i < a.length; i++) {\n        a[i] = a[i] ^ b[i];\n    }\n    return a;\n}\n/**\n * xorend as defined in\n * {@link https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.1 | RFC 5297 Section 2.1}.\n *\n * ```\n * leftmost(A, len(A)-len(B)) || (rightmost(A, len(B)) xor B)\n * ```\n *\n * Mutates `a` in place so the left prefix stays untouched and only the\n * rightmost `len(B)` bytes are xored with `b`.\n */\nfunction xorend(a, b) {\n    if (b.length > a.length) {\n        throw new Error('xorend: len(B) must be less than or equal to len(A)');\n    }\n    // keep leftmost part of `a` unchanged\n    // and xor only the rightmost part:\n    const offset = a.length - b.length;\n    for (let i = 0; i < b.length; i++) {\n        a[offset + i] = a[offset + i] ^ b[i];\n    }\n    return a;\n}\n/**\n * Internal CMAC class.\n */\nclass _CMAC {\n    blockLen = BLOCK_SIZE;\n    outputLen = BLOCK_SIZE;\n    // CMAC can only decide between `K1` and `K2` once the true final block is known,\n    // so updates process older blocks eagerly but keep one pending block buffered.\n    buffer;\n    pos;\n    finished;\n    destroyed;\n    k1;\n    k2;\n    x;\n    xk;\n    constructor(key) {\n        abytes(key);\n        validateKeyLength(key);\n        this.xk = expandKeyLE(key);\n        this.buffer = new Uint8Array(BLOCK_SIZE);\n        this.pos = 0;\n        this.finished = false;\n        this.destroyed = false;\n        this.x = new Uint8Array(BLOCK_SIZE);\n        // L = AES_encrypt(K, const_Zero)\n        const L = new Uint8Array(BLOCK_SIZE);\n        encryptBlock(this.xk, L);\n        // Generate subkeys K1 and K2 from the main key according to\n        // {@link https://www.rfc-editor.org/rfc/rfc4493.html#section-2.3 | RFC 4493 Section 2.3}\n        // K1\n        this.k1 = dbl(L);\n        this.k2 = dbl(new Uint8Array(this.k1));\n    }\n    process(data) {\n        // RFC 4493 §2.4 step 6 loop body: Y := X XOR M_i; X := AES-128(K, Y).\n        xorBlock(this.x, data);\n        encryptBlock(this.xk, this.x);\n    }\n    update(data) {\n        if (this.destroyed)\n            throw new Error('Hash instance has been destroyed');\n        if (this.finished)\n            throw new Error('Hash#digest() has already been called');\n        abytes(data);\n        let pos = 0;\n        if (this.pos) {\n            const take = Math.min(BLOCK_SIZE - this.pos, data.length);\n            this.buffer.set(data.subarray(0, take), this.pos);\n            this.pos += take;\n            pos = take;\n            if (this.pos === BLOCK_SIZE && pos < data.length) {\n                this.process(this.buffer);\n                this.pos = 0;\n            }\n        }\n        // Keep one complete block buffered: an exact 16-byte tail may still be\n        // M_n, and digestInto() must decide there whether RFC 4493 uses K1 or K2.\n        while (pos + BLOCK_SIZE < data.length) {\n            this.process(data.subarray(pos, pos + BLOCK_SIZE));\n            pos += BLOCK_SIZE;\n        }\n        if (pos < data.length) {\n            this.buffer.set(data.subarray(pos), 0);\n            this.pos = data.length - pos;\n        }\n        return this;\n    }\n    // See {@link https://www.rfc-editor.org/rfc/rfc4493.html#section-2.4 | RFC 4493 Section 2.4}.\n    digestInto(out) {\n        if (this.destroyed)\n            throw new Error('Hash instance has been destroyed');\n        if (this.finished)\n            throw new Error('Hash#digest() has already been called');\n        // `digestInto(out)` is the no-allocation fast path, so AES block re-use below\n        // requires a 32-bit-aligned caller buffer instead of hidden temp copies.\n        aoutput(out, this, true);\n        this.finished = true;\n        // `digestInto()` accepts out.length >= outputLen, so only the first block stores the tag.\n        const view = out.subarray(0, this.outputLen);\n        let last = new Uint8Array(BLOCK_SIZE);\n        if (this.pos === BLOCK_SIZE) {\n            // M_last := M_n XOR K1;\n            last.set(this.buffer);\n            xorBlock(last, this.k1);\n        }\n        else {\n            // M_last := padding(M_n) XOR K2;\n            //\n            // [...] padding(x) is the concatenation of x and a single '1',\n            // followed by the minimum number of '0's, so that the total length is\n            // equal to 128 bits.\n            last.set(this.buffer.subarray(0, this.pos));\n            last[this.pos] = 0x80; // single '1' bit\n            xorBlock(last, this.k2);\n        }\n        view.set(this.x); // X := AES_CBC(K, M_1..M_{n-1})\n        xorBlock(view, last); // Y := X XOR M_last\n        encryptBlock(this.xk, view); // T := AES-128(K, Y)\n        clean(last);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        // Copy out before destroy() wipes the internal digest buffer in place.\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    destroy() {\n        const { buffer, destroyed, x, xk, k1, k2 } = this;\n        if (destroyed)\n            return;\n        this.destroyed = true;\n        // Wipe the buffered tail, chaining value, expanded AES key, and both CMAC subkeys.\n        clean(buffer, x, xk, k1, k2);\n    }\n}\n/**\n * AES-CMAC (Cipher-based Message Authentication Code).\n * Specs: {@link https://www.rfc-editor.org/rfc/rfc4493.html | RFC 4493}.\n * @param msg - Message bytes to authenticate.\n * @param key - AES key bytes.\n * @returns 16-byte authentication tag. `cmac.create(...)` follows the same incremental MAC shape as\n * the other keyed helpers in this repo, including `blockLen`,\n * `outputLen`, `digestInto()` and `destroy()`.\n * @example\n * Authenticates a message with AES-CMAC and a fresh key.\n *\n * ```ts\n * import { cmac } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * cmac(new Uint8Array(), key);\n * ```\n */\n// The 16-byte probe key is only used to read static metadata; runtime CMAC\n// still accepts AES-128/192/256 keys.\nexport const cmac = /* @__PURE__ */ wrapMacConstructor(16, (key) => new _CMAC(key));\n/**\n * S2V (Synthetic Initialization Vector) function as described in\n * {@link https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.4 | RFC 5297 Section 2.4}.\n *\n * ```\n * S2V(K, S1, ..., Sn) {\n *   if n = 0 then\n *     return V = AES-CMAC(K, <one>)\n *   fi\n *   D = AES-CMAC(K, <zero>)\n *   for i = 1 to n-1 do\n *     D = dbl(D) xor AES-CMAC(K, Si)\n *   done\n *   if len(Sn) >= 128 then\n *     T = Sn xorend D\n *   else\n *     T = dbl(D) xor pad(Sn)\n *   fi\n *   return V = AES-CMAC(K, T)\n * }\n * ```\n *\n * S2V takes a key and a vector of strings S1, S2, ..., Sn and returns a 128-bit string.\n * The S2V function is used to generate a synthetic IV for AES-SIV.\n *\n * @param key - AES key (128, 192, or 256 bits)\n * @param strings - Array of byte arrays to process\n * @returns 128-bit synthetic IV\n */\nfunction s2v(key, strings) {\n    validateKeyLength(key);\n    const len = strings.length;\n    if (len > 127) {\n        // RFC 5297 §7 only proves S2V secure for at most 127 components; SIV\n        // spends one of those on the plaintext, leaving at most 126 AAD inputs.\n        throw new Error('s2v: number of input strings must be less than or equal to 127');\n    }\n    if (len === 0)\n        return cmac(ONE_BLOCK, key);\n    // D = AES-CMAC(K, <zero>)\n    let d = cmac(EMPTY_BLOCK, key);\n    // for i = 1 to n-1 do\n    //   D = dbl(D) xor AES-CMAC(K, Si)\n    for (let i = 0; i < len - 1; i++) {\n        dbl(d);\n        const cmacResult = cmac(strings[i], key);\n        xorBlock(d, cmacResult);\n        clean(cmacResult);\n    }\n    const s_n = strings[len - 1];\n    // Earlier components are validated through cmac(...); validate the final one explicitly because\n    // the Uint8Array.from()/set() paths below would otherwise coerce array-like inputs silently.\n    abytes(s_n);\n    let t;\n    // if len(Sn) >= 128 then\n    if (s_n.byteLength >= BLOCK_SIZE) {\n        // T = Sn xorend D\n        t = xorend(Uint8Array.from(s_n), d);\n    }\n    else {\n        // pad(Sn):\n        const paddedSn = new Uint8Array(BLOCK_SIZE);\n        paddedSn.set(s_n);\n        paddedSn[s_n.length] = 0x80; // padding: 0x80 followed by zeros\n        // T = dbl(D) xor pad(Sn)\n        t = xorBlock(dbl(d), paddedSn);\n        clean(paddedSn);\n    }\n    // V = AES-CMAC(K, T)\n    const result = cmac(t, key);\n    clean(d, t);\n    return result;\n}\n/**\n * Use `gcmsiv` or `aessiv`.\n * @returns Never; always throws with the migration hint.\n * @throws If called; `siv()` is a removed v1 alias. {@link Error}\n * @example\n * `siv()` was removed in v2; use `gcmsiv()` for nonce-based SIV instead.\n *\n * ```ts\n * import { gcmsiv } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(16);\n * const nonce = randomBytes(12);\n * const cipher = gcmsiv(key, nonce);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const siv = () => {\n    throw new Error('\"siv\" from v1 is now \"gcmsiv\"');\n};\n/**\n * **SIV**: Synthetic Initialization Vector (SIV) Authenticated Encryption\n * Nonce is derived from the plaintext and AAD using the S2V function.\n * Supports at most 126 AAD components. RFC 5297 nonce-based use is expressed by\n * passing the nonce as the final AAD component before the plaintext.\n * See {@link https://datatracker.ietf.org/doc/html/rfc5297.html | RFC 5297}.\n * @param key - 32-byte, 48-byte, or 64-byte key.\n * @param AAD - Additional authenticated data chunks (up to 126).\n * @returns AEAD cipher instance.\n * @example\n * Authenticates and encrypts plaintext with a fresh key without requiring unique nonces.\n *\n * ```ts\n * import { aessiv } from '@noble/ciphers/aes.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const cipher = aessiv(key);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const aessiv = /* @__PURE__ */ wrapCipher({ blockSize: 16, tagLength: 16 }, function aessiv(key, ...AAD) {\n    // From RFC 5297: Section 6.1, 6.2, 6.3:\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 132);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 132 + 16);\n    if (AAD.length > 126) {\n        // RFC 5297 §2.6 / §2.7 / §7: SIV passes the plaintext as the last S2V\n        // component, so callers only get 126 associated-data components.\n        throw new Error('\"AAD\" number of elements must be less than or equal to 126');\n    }\n    AAD.forEach((aad) => abytes(aad));\n    abytes(key);\n    if (![32, 48, 64].includes(key.length))\n        throw new Error('\"aes key\" expected Uint8Array of length 32/48/64, got length=' + key.length);\n    // The key is split into equal halves, K1 = leftmost(K, len(K)/2) and\n    // K2 = rightmost(K, len(K)/2).  K1 is used for S2V and K2 is used for CTR.\n    // This borrows caller key/AAD buffers by reference; mutating them after\n    // construction changes future encrypt/decrypt results.\n    const k1 = key.subarray(0, key.length / 2);\n    const k2 = key.subarray(key.length / 2);\n    return {\n        // {@link https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.6 | RFC 5297 Section 2.6}\n        encrypt(plaintext) {\n            PLAIN_LIMIT(plaintext.length);\n            const v = s2v(k1, [...AAD, plaintext]);\n            // clear out the 31st and 63rd (rightmost) bit:\n            const q = Uint8Array.from(v);\n            q[8] &= 0x7f;\n            q[12] &= 0x7f;\n            // encrypt:\n            const c = ctr(k2, q).encrypt(plaintext);\n            return concatBytes(v, c);\n        },\n        // {@link https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.7 | RFC 5297 Section 2.7}\n        decrypt(ciphertext) {\n            CIPHER_LIMIT(ciphertext.length);\n            const v = ciphertext.subarray(0, BLOCK_SIZE);\n            const c = ciphertext.subarray(BLOCK_SIZE);\n            // clear out the 31st and 63rd (rightmost) bit:\n            const q = Uint8Array.from(v);\n            q[8] &= 0x7f;\n            q[12] &= 0x7f;\n            // decrypt:\n            const p = ctr(k2, q).decrypt(c);\n            // verify tag:\n            const t = s2v(k1, [...AAD, p]);\n            if (equalBytes(t, v)) {\n                return p;\n            }\n            else {\n                throw new Error('invalid siv tag');\n            }\n        },\n    };\n});\n//#endregion\n/**\n * Unsafe low-level internal methods. May change at any time.\n * Callers are expected to use reviewed expanded-key outputs, pass mutable and\n * aligned 16-byte blocks where required, and treat several helpers as in-place\n * mutations of their input buffers or counters.\n */\nexport const unsafe = /* @__PURE__ */ Object.freeze({\n    expandKeyLE,\n    expandKeyDecLE,\n    encrypt,\n    decrypt,\n    encryptBlock,\n    decryptBlock,\n    ctrCounter,\n    ctr32,\n    dbl,\n    xorBlock,\n    xorend,\n    s2v,\n});\nexport const __TESTS = /* @__PURE__ */ Object.freeze({\n    incBytes: incBytes,\n});\n//# sourceMappingURL=aes.js.map","import {\n  assertBytes,\n  concatBytes,\n  equalBytes,\n  type AeadComponent,\n  type AeadCreateContext,\n  type AeadCreateOpenerParams,\n  type AeadCreateParams,\n  type AeadCreateSealerParams,\n  type AeadTransform,\n  type BlockCipher,\n  type Transform,\n} from '@jscrypto/core';\n\nconst BLOCK_SIZE = 16;\nconst KEY_SIZES = [16, 24, 32] as const;\nconst NONCE_SIZES = [7, 8, 9, 10, 11, 12, 13] as const;\nconst TAG_SIZES = [4, 6, 8, 10, 12, 14, 16] as const;\nconst DEFAULT_TAG_LENGTH = 16;\nconst MIN_NONCE_LENGTH = 7;\nconst MAX_NONCE_LENGTH = 13;\nconst AAD_SHORT_LIMIT = 0xff00;\n\nexport function createAesCcmComponent(): AeadComponent<'AES-CCM'> {\n  return {\n    kind: 'aead',\n    name: 'AES-CCM',\n    keySizes: KEY_SIZES,\n    nonceSizes: NONCE_SIZES,\n    recommendedNonceSize: 12,\n    tagSizes: TAG_SIZES,\n    create(params, context) {\n      return createAesCcmTransform(params, context);\n    },\n  };\n}\n\n/** Exported for focused unit tests; not part of the public package surface. */\nexport function encodeCcmAad(aad: Uint8Array): Uint8Array {\n  return concatBytes(encodeCcmAadLength(aad.length), aad);\n}\n\n/**\n * Encode only the CCM AAD length prefix for a given length.\n * Accepts synthetic lengths so the `0xffff` form (>= 2^32) can be unit-tested\n * without allocating multi-gigabyte AAD buffers.\n */\nexport function encodeCcmAadLength(aadLength: number): Uint8Array {\n  if (aadLength === 0) {\n    return new Uint8Array(0);\n  }\n\n  if (aadLength < AAD_SHORT_LIMIT) {\n    const encoded = new Uint8Array(2);\n    encoded[0] = (aadLength >>> 8) & 0xff;\n    encoded[1] = aadLength & 0xff;\n    return encoded;\n  }\n\n  if (aadLength < 0x100000000) {\n    const encoded = new Uint8Array(6);\n    encoded[0] = 0xff;\n    encoded[1] = 0xfe;\n    encoded[2] = (aadLength >>> 24) & 0xff;\n    encoded[3] = (aadLength >>> 16) & 0xff;\n    encoded[4] = (aadLength >>> 8) & 0xff;\n    encoded[5] = aadLength & 0xff;\n    return encoded;\n  }\n\n  const encoded = new Uint8Array(10);\n  encoded[0] = 0xff;\n  encoded[1] = 0xff;\n  let remaining = aadLength;\n  for (let i = 9; i >= 2; i--) {\n    encoded[i] = remaining % 256;\n    remaining = Math.floor(remaining / 256);\n  }\n  return encoded;\n}\n\n/**\n * Encode an unsigned integer into `byteLength` bytes at `out[offset]`.\n * Used for CCM length and counter fields.\n */\nexport function encodeCcmBinaryLength(\n  value: number,\n  byteLength: number,\n  out: Uint8Array,\n  offset: number,\n): void {\n  let remaining = value;\n  for (let i = byteLength - 1; i >= 0; i--) {\n    out[offset + i] = remaining % 256;\n    remaining = Math.floor(remaining / 256);\n  }\n  if (remaining !== 0) {\n    throw new RangeError('AES-CCM plaintext is too large for the nonce length.');\n  }\n}\n\nfunction createAesCcmTransform(\n  { key }: AeadCreateParams,\n  context: AeadCreateContext,\n): AeadTransform {\n  assertBytes(key, 'AES-CCM key');\n  if (key.length !== 16 && key.length !== 24 && key.length !== 32) {\n    throw new Error('AES key must be 128, 192, or 256 bits.');\n  }\n  const cipher = context.createBlockCipher({ cipher: 'AES', key });\n\n  return {\n    createSealer({ nonce, aad, tagLength }: AeadCreateSealerParams): Transform {\n      const resolvedNonce = requireNonce(nonce);\n      const resolvedAad = resolveAad(aad);\n      const resolvedTagLength = resolveTagLength(tagLength);\n      let pendings: Uint8Array[] = [];\n      let finalized = false;\n\n      return {\n        process(input) {\n          assertNotFinalized(finalized);\n          assertBytes(input, 'AES-CCM input');\n          pendings.push(input);\n          return new Uint8Array(0);\n        },\n\n        finalize(input = new Uint8Array(0)) {\n          assertNotFinalized(finalized);\n          if (input.length !== 0) {\n            this.process(input);\n          }\n          finalized = true;\n          const plaintext = collectPending(pendings);\n          pendings = [];\n          return seal(cipher, plaintext, resolvedNonce, resolvedAad, resolvedTagLength);\n        },\n      };\n    },\n\n    createOpener({ nonce, aad, tag, tagLength }: AeadCreateOpenerParams): Transform {\n      const resolvedNonce = requireNonce(nonce);\n      const resolvedAad = resolveAad(aad);\n      const detachedTag = resolveOptionalTag(tag);\n      const resolvedTagLength = detachedTag\n        ? resolveTagLength(detachedTag.length)\n        : resolveTagLength(tagLength);\n      let pendings: Uint8Array[] = [];\n      let finalized = false;\n\n      return {\n        process(input) {\n          assertNotFinalized(finalized);\n          assertBytes(input, 'AES-CCM input');\n          pendings.push(input);\n          return new Uint8Array(0);\n        },\n\n        finalize(input = new Uint8Array(0)) {\n          assertNotFinalized(finalized);\n          if (input.length !== 0) {\n            this.process(input);\n          }\n          finalized = true;\n          const buffered = collectPending(pendings);\n          pendings = [];\n          return open(\n            cipher,\n            buffered,\n            resolvedNonce,\n            resolvedAad,\n            resolvedTagLength,\n            detachedTag,\n          );\n        },\n      };\n    },\n  };\n}\n\nfunction seal(\n  cipher: BlockCipher,\n  plaintext: Uint8Array,\n  nonce: Uint8Array,\n  aad: Uint8Array,\n  tagLength: number,\n): Uint8Array {\n  const L = 15 - nonce.length;\n  assertPlaintextLength(plaintext.length, L);\n\n  const tag = computeTag(cipher, plaintext, nonce, aad, tagLength, L);\n  const ciphertext = ctrCrypt(cipher, plaintext, nonce, L);\n  const sealed = new Uint8Array(ciphertext.length + tagLength);\n  sealed.set(ciphertext, 0);\n  sealed.set(tag, ciphertext.length);\n  return sealed;\n}\n\nfunction open(\n  cipher: BlockCipher,\n  input: Uint8Array,\n  nonce: Uint8Array,\n  aad: Uint8Array,\n  tagLength: number,\n  detachedTag: Uint8Array | undefined,\n): Uint8Array {\n  const L = 15 - nonce.length;\n  let ciphertext: Uint8Array;\n  let tag: Uint8Array;\n\n  if (detachedTag) {\n    ciphertext = input;\n    tag = detachedTag;\n  } else {\n    if (input.length < tagLength) {\n      throw new Error('AES-CCM ciphertext is shorter than the authentication tag.');\n    }\n    ciphertext = input.subarray(0, input.length - tagLength);\n    tag = input.subarray(input.length - tagLength);\n  }\n\n  assertPlaintextLength(ciphertext.length, L);\n  const plaintext = ctrCrypt(cipher, ciphertext, nonce, L);\n  const expectedTag = computeTag(cipher, plaintext, nonce, aad, tagLength, L);\n  if (!equalBytes(tag, expectedTag)) {\n    plaintext.fill(0);\n    throw new Error('AES-CCM authentication failed.');\n  }\n  return plaintext;\n}\n\nfunction computeTag(\n  cipher: BlockCipher,\n  plaintext: Uint8Array,\n  nonce: Uint8Array,\n  aad: Uint8Array,\n  tagLength: number,\n  L: number,\n): Uint8Array {\n  const mac = new Uint8Array(BLOCK_SIZE);\n  const block = new Uint8Array(BLOCK_SIZE);\n\n  buildB0(block, nonce, plaintext.length, aad.length > 0, tagLength, L);\n  encryptBlock(cipher, block, 0, mac, 0);\n\n  if (aad.length > 0) {\n    const encodedAad = encodeCcmAad(aad);\n    cbcMacBlocks(cipher, mac, encodedAad);\n  }\n\n  if (plaintext.length > 0) {\n    cbcMacBlocks(cipher, mac, plaintext);\n  }\n\n  const s0 = new Uint8Array(BLOCK_SIZE);\n  buildCounterBlock(block, nonce, 0, L);\n  encryptBlock(cipher, block, 0, s0, 0);\n\n  const tag = new Uint8Array(tagLength);\n  for (let i = 0; i < tagLength; i++) {\n    tag[i] = mac[i]! ^ s0[i]!;\n  }\n  return tag;\n}\n\nfunction ctrCrypt(\n  cipher: BlockCipher,\n  input: Uint8Array,\n  nonce: Uint8Array,\n  L: number,\n): Uint8Array {\n  if (input.length === 0) {\n    return new Uint8Array(0);\n  }\n\n  const output = new Uint8Array(input.length);\n  const counterBlock = new Uint8Array(BLOCK_SIZE);\n  const keystream = new Uint8Array(BLOCK_SIZE);\n  let counter = 1;\n  let offset = 0;\n\n  while (offset < input.length) {\n    buildCounterBlock(counterBlock, nonce, counter, L);\n    encryptBlock(cipher, counterBlock, 0, keystream, 0);\n    const n = Math.min(BLOCK_SIZE, input.length - offset);\n    for (let i = 0; i < n; i++) {\n      output[offset + i] = input[offset + i]! ^ keystream[i]!;\n    }\n    offset += n;\n    counter += 1;\n  }\n\n  return output;\n}\n\nfunction cbcMacBlocks(cipher: BlockCipher, mac: Uint8Array, data: Uint8Array): void {\n  const block = new Uint8Array(BLOCK_SIZE);\n  let offset = 0;\n\n  while (offset < data.length) {\n    const n = Math.min(BLOCK_SIZE, data.length - offset);\n    block.fill(0);\n    block.set(data.subarray(offset, offset + n));\n    for (let i = 0; i < BLOCK_SIZE; i++) {\n      block[i]! ^= mac[i]!;\n    }\n    encryptBlock(cipher, block, 0, mac, 0);\n    offset += n;\n  }\n}\n\nfunction buildB0(\n  out: Uint8Array,\n  nonce: Uint8Array,\n  messageLength: number,\n  hasAad: boolean,\n  tagLength: number,\n  L: number,\n): void {\n  out[0] = ((hasAad ? 1 : 0) << 6) | (((tagLength - 2) / 2) << 3) | (L - 1);\n  out.set(nonce, 1);\n  encodeCcmBinaryLength(messageLength, L, out, 1 + nonce.length);\n}\n\nfunction buildCounterBlock(\n  out: Uint8Array,\n  nonce: Uint8Array,\n  counter: number,\n  L: number,\n): void {\n  out.fill(0);\n  out[0] = L - 1;\n  out.set(nonce, 1);\n  encodeCcmBinaryLength(counter, L, out, 1 + nonce.length);\n}\n\nfunction encryptBlock(\n  cipher: BlockCipher,\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n): void {\n  if (cipher.encryptBlock) {\n    cipher.encryptBlock(input, inputOffset, output, outputOffset);\n    return;\n  }\n\n  cipher.encrypt(\n    input.subarray(inputOffset, inputOffset + cipher.blockSize),\n    output.subarray(outputOffset, outputOffset + cipher.blockSize),\n  );\n}\n\nfunction assertPlaintextLength(length: number, L: number): void {\n  let remaining = length;\n  for (let i = 0; i < L; i++) {\n    remaining = Math.floor(remaining / 256);\n  }\n  if (remaining !== 0) {\n    throw new RangeError('AES-CCM plaintext is too large for the nonce length.');\n  }\n}\n\nfunction requireNonce(nonce: Uint8Array | undefined): Uint8Array {\n  if (nonce === undefined) {\n    throw new Error('AES-CCM requires a nonce.');\n  }\n  assertBytes(nonce, 'AES-CCM nonce');\n  if (nonce.length < MIN_NONCE_LENGTH || nonce.length > MAX_NONCE_LENGTH) {\n    throw new RangeError('AES-CCM nonce length must be between 7 and 13 bytes.');\n  }\n  return nonce;\n}\n\nfunction resolveAad(aad: Uint8Array | undefined): Uint8Array {\n  if (aad === undefined) {\n    return new Uint8Array(0);\n  }\n  assertBytes(aad, 'AES-CCM aad');\n  return aad;\n}\n\nfunction resolveOptionalTag(tag: Uint8Array | undefined): Uint8Array | undefined {\n  if (tag === undefined) {\n    return undefined;\n  }\n  assertBytes(tag, 'AES-CCM tag');\n  resolveTagLength(tag.length);\n  return tag;\n}\n\nfunction resolveTagLength(tagLength: number | undefined): number {\n  if (tagLength === undefined) {\n    return DEFAULT_TAG_LENGTH;\n  }\n  if (\n    typeof tagLength !== 'number'\n    || !Number.isInteger(tagLength)\n    || (TAG_SIZES as readonly number[]).indexOf(tagLength) === -1\n  ) {\n    throw new RangeError(\n      'AES-CCM tagLength must be one of 4, 6, 8, 10, 12, 14, or 16 bytes.',\n    );\n  }\n  return tagLength;\n}\n\nfunction collectPending(pendings: readonly Uint8Array[]): Uint8Array {\n  if (pendings.length === 0) {\n    return new Uint8Array(0);\n  }\n  if (pendings.length === 1) {\n    return pendings[0]!;\n  }\n  return concatBytes(...pendings);\n}\n\nfunction assertNotFinalized(finalized: boolean): void {\n  if (finalized) {\n    throw new Error('AES-CCM transform already finalized.');\n  }\n}\n","import {\n  assertBytes,\n  type AeadComponent,\n  type AeadCreateContext,\n  type AeadCreateOpenerParams,\n  type AeadCreateParams,\n  type AeadCreateSealerParams,\n  type AeadTransform,\n  type Transform,\n} from '@jscrypto/core';\n\nconst KEY_SIZES = [16, 24, 32] as const;\nconst TAG_SIZES = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] as const;\nconst DEFAULT_TAG_LENGTH = 16;\nconst MIN_TAG_LENGTH = 4;\nconst MAX_TAG_LENGTH = 16;\n\nexport function createAesGcmComponent(): AeadComponent<'AES-GCM'> {\n  return {\n    kind: 'aead',\n    name: 'AES-GCM',\n    keySizes: KEY_SIZES,\n    recommendedNonceSize: 12,\n    tagSizes: TAG_SIZES,\n    create(params, context) {\n      return createAesGcmTransform(params, context);\n    },\n  };\n}\n\nfunction createAesGcmTransform(\n  { key }: AeadCreateParams,\n  context: AeadCreateContext,\n): AeadTransform {\n  assertBytes(key, 'AES-GCM key');\n\n  return {\n    createSealer({ nonce, aad, tagLength, options }: AeadCreateSealerParams): Transform {\n      return context.createEncryptor(toGcmOptions(key, {\n        nonce: requireNonce(nonce),\n        aad: resolveAad(aad),\n        tagLength: resolveTagLength(tagLength),\n        options,\n      }));\n    },\n\n    createOpener({ nonce, aad, tag, tagLength, options }: AeadCreateOpenerParams): Transform {\n      const detachedTag = resolveOptionalTag(tag);\n      return wrapGcmOpener(context.createDecryptor(toGcmOptions(key, {\n        nonce: requireNonce(nonce),\n        aad: resolveAad(aad),\n        tag: detachedTag,\n        tagLength: detachedTag ? resolveTagLength(detachedTag.length) : resolveTagLength(tagLength),\n        options,\n      })));\n    },\n  };\n}\n\nfunction toGcmOptions(\n  key: Uint8Array,\n  {\n    nonce,\n    aad,\n    tag,\n    tagLength,\n    options,\n  }: {\n    nonce: Uint8Array;\n    aad: Uint8Array;\n    tag?: Uint8Array;\n    tagLength: number;\n    options?: unknown;\n  },\n) {\n  return {\n    ...toRecord(options),\n    cipher: 'AES',\n    mode: 'GCM',\n    key,\n    nonce,\n    aad,\n    tag,\n    tagLength,\n  };\n}\n\nfunction wrapGcmOpener(opener: Transform): Transform {\n  return {\n    process(input) {\n      return opener.process(input);\n    },\n\n    finalize(input) {\n      try {\n        return opener.finalize(input);\n      } catch (error) {\n        if (error instanceof Error && error.message === 'GCM authentication failed.') {\n          throw new Error('AES-GCM authentication failed.');\n        }\n        throw error;\n      }\n    },\n  };\n}\n\nfunction requireNonce(nonce: Uint8Array | undefined): Uint8Array {\n  if (nonce === undefined) {\n    throw new Error('AES-GCM requires a nonce.');\n  }\n  assertBytes(nonce, 'AES-GCM nonce');\n  if (nonce.length === 0) {\n    throw new Error('AES-GCM requires a nonce.');\n  }\n  return nonce;\n}\n\nfunction resolveAad(aad: Uint8Array | undefined): Uint8Array {\n  if (aad === undefined) {\n    return new Uint8Array(0);\n  }\n  assertBytes(aad, 'AES-GCM aad');\n  return aad;\n}\n\nfunction resolveOptionalTag(tag: Uint8Array | undefined): Uint8Array | undefined {\n  if (tag === undefined) {\n    return undefined;\n  }\n  assertBytes(tag, 'AES-GCM tag');\n  return tag;\n}\n\nfunction resolveTagLength(tagLength: number | undefined): number {\n  if (tagLength === undefined) {\n    return DEFAULT_TAG_LENGTH;\n  }\n  if (\n    typeof tagLength !== 'number' ||\n    !Number.isInteger(tagLength) ||\n    tagLength < MIN_TAG_LENGTH ||\n    tagLength > MAX_TAG_LENGTH\n  ) {\n    throw new RangeError('AES-GCM tagLength must be an integer between 4 and 16 bytes.');\n  }\n  return tagLength;\n}\n\nfunction toRecord(options: unknown): Record<string, unknown> {\n  return typeof options === 'object' && options !== null ? options as Record<string, unknown> : {};\n}\n","import type { BlockCipher, CipherComponent, PresetComponent } from '@jscrypto/core';\nimport { unsafe as nobleAesUnsafe } from '@noble/ciphers/aes.js';\nimport { createAesCcmComponent } from './aes-ccm.js';\nimport { createAesGcmComponent } from './aes-gcm.js';\n\nconst BLOCK_SIZE = 16;\n\nexport const aes: CipherComponent<'AES'> = {\n  kind: 'cipher',\n  name: 'AES',\n  type: 'block',\n  blockSize: BLOCK_SIZE,\n  keySizes: [16, 24, 32],\n  create(key) {\n    return createAesCipher(key);\n  },\n};\n\nexport const aesGcm = createAesGcmComponent();\nexport const aesCcm = createAesCcmComponent();\n\nexport { createAesCcmComponent } from './aes-ccm.js';\n\nexport const aesPreset: PresetComponent<'aes'> = {\n  kind: 'preset',\n  name: 'aes',\n  components() {\n    return [aes, aesGcm, aesCcm];\n  },\n};\n\nexport function createAesCipher(key: Uint8Array): BlockCipher {\n  if (key.length !== 16 && key.length !== 24 && key.length !== 32) {\n    throw new Error('AES key must be 128, 192, or 256 bits.');\n  }\n\n  const encryptionKey = nobleAesUnsafe.expandKeyLE(key);\n  const decryptionKey = nobleAesUnsafe.expandKeyDecLE(key);\n\n  return {\n    blockSize: BLOCK_SIZE,\n\n    encryptBlock(input, inputOffset, output, outputOffset) {\n      transformBlock(encryptionKey, input, inputOffset, output, outputOffset, nobleAesUnsafe.encrypt);\n    },\n\n    decryptBlock(input, inputOffset, output, outputOffset) {\n      transformBlock(decryptionKey, input, inputOffset, output, outputOffset, nobleAesUnsafe.decrypt);\n    },\n\n    encrypt(input, output) {\n      assertBlocks(input, output);\n      return transformBlocks(encryptionKey, input, output, nobleAesUnsafe.encrypt);\n    },\n\n    decrypt(input, output) {\n      assertBlocks(input, output);\n      return transformBlocks(decryptionKey, input, output, nobleAesUnsafe.decrypt);\n    },\n  };\n}\n\ntype NobleAesTransform = typeof nobleAesUnsafe.encrypt;\n\nfunction transformBlocks(\n  expandedKey: Uint32Array,\n  input: Uint8Array,\n  output: Uint8Array,\n  transform: NobleAesTransform,\n): Uint8Array {\n  for (let offset = 0; offset < input.length; offset += BLOCK_SIZE) {\n    transformBlock(expandedKey, input, offset, output, offset, transform);\n  }\n\n  return output;\n}\n\nfunction transformBlock(\n  expandedKey: Uint32Array,\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n  transform: NobleAesTransform,\n): void {\n  const { s0, s1, s2, s3 } = transform(\n    expandedKey,\n    readUint32LE(input, inputOffset),\n    readUint32LE(input, inputOffset + 4),\n    readUint32LE(input, inputOffset + 8),\n    readUint32LE(input, inputOffset + 12),\n  );\n  writeUint32LE(output, outputOffset, s0);\n  writeUint32LE(output, outputOffset + 4, s1);\n  writeUint32LE(output, outputOffset + 8, s2);\n  writeUint32LE(output, outputOffset + 12, s3);\n}\n\nfunction readUint32LE(input: Uint8Array, offset: number): number {\n  return (\n    input[offset]\n    | (input[offset + 1] << 8)\n    | (input[offset + 2] << 16)\n    | (input[offset + 3] << 24)\n  ) >>> 0;\n}\n\nfunction writeUint32LE(output: Uint8Array, offset: number, value: number): void {\n  output[offset] = value;\n  output[offset + 1] = value >>> 8;\n  output[offset + 2] = value >>> 16;\n  output[offset + 3] = value >>> 24;\n}\n\nfunction assertBlocks(input: Uint8Array, output: Uint8Array): void {\n  if (input.length % BLOCK_SIZE !== 0) {\n    throw new Error('AES input length must be a multiple of 128 bits.');\n  }\n  if (output.length !== input.length) {\n    throw new Error('AES output length must equal input length.');\n  }\n}\n","/**\n * Basic utils for ARX (add-rotate-xor) salsa and chacha ciphers.\n\nRFC8439 requires multi-step cipher stream, where\nauthKey starts with counter: 0, actual msg with counter: 1.\n\nFor this, we need a way to re-use nonce / counter:\n\n    const counter = new Uint8Array(4);\n    chacha(..., counter, ...); // counter is now 1\n    chacha(..., counter, ...); // counter is now 2\n\nThis is complicated:\n\n- 32-bit counters are enough, no need for 64-bit: max ArrayBuffer size in JS is 4GB\n- Original papers don't allow mutating counters\n- Counter overflow is undefined [^1]\n- Idea A: allow providing (nonce | counter) instead of just nonce, re-use it\n- Caveat: Cannot be re-used through all cases:\n- * chacha has (counter | nonce)\n- * xchacha has (nonce16 | counter | nonce16)\n- Idea B: separate nonce / counter and provide separate API for counter re-use\n- Caveat: there are different counter sizes depending on an algorithm.\n- salsa & chacha also differ in structures of key & sigma:\n  salsa20:      s[0] | k(4) | s[1] | nonce(2) | cnt(2) | s[2] | k(4) | s[3]\n  chacha:       s(4) | k(8) | cnt(1) | nonce(3)\n  chacha20orig: s(4) | k(8) | cnt(2) | nonce(2)\n- Idea C: helper method such as `setSalsaState(key, nonce, sigma, data)`\n- Caveat: we can't re-use counter array\n\nxchacha uses the subkey and remaining 8 byte nonce with ChaCha20 as normal\n(prefixed by 4 NUL bytes, since RFC8439 specifies a 12-byte nonce).\nCounter overflow is undefined; see {@link https://mailarchive.ietf.org/arch/msg/cfrg/gsOnTJzcbgG6OqD8Sc0GO5aR_tU/ | the CFRG thread}.\nCurrent noble policy is strict non-wrap for the shared 32-bit counter path:\nexported ARX ciphers reject initial `0xffffffff` and stop before any implicit\nwrap back to zero.\nSee {@link https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha#appendix-A.2 | the XChaCha appendix} for the extended-nonce construction.\n\n * @module\n */\nimport { abool, abytes, anumber, checkOpts, clean, copyBytes, getOutput, isAligned32, isLE, randomBytes, swap32IfBE, u32, } from \"./utils.js\";\n// Replaces `TextEncoder` for ASCII literals, which is enough for sigma constants.\n// Non-ASCII input would not match UTF-8 `TextEncoder` output.\nconst encodeStr = (str) => Uint8Array.from(str.split(''), (c) => c.charCodeAt(0));\n// Raw `createCipher(...)` exports consume these native-endian `u32(...)` views directly.\n// Public `wrapCipher(...)` APIs reject non-little-endian platforms before reaching this path.\n// RFC 8439 §2.3 / RFC 7539 §2.3 only define the 256-bit-key constants; this 16-byte sigma is\n// kept for legacy allowShortKeys Salsa/ChaCha variants.\nconst sigma16_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr('expand 16-byte k'))))();\n// RFC 8439 §2.3 / RFC 7539 §2.3 define words 0-3 as\n// `0x61707865 0x3320646e 0x79622d32 0x6b206574`, i.e. `expand 32-byte k`.\nconst sigma32_32 = /* @__PURE__ */ (() => swap32IfBE(u32(encodeStr('expand 32-byte k'))))();\n/**\n * Rotates a 32-bit word left.\n * @param a - Input word.\n * @param b - Rotation count in bits.\n * @returns Rotated 32-bit word.\n * @example\n * Moves the top byte of `0x12345678` into the low byte position.\n * ```ts\n * rotl(0x12345678, 8);\n * ```\n */\nexport function rotl(a, b) {\n    return (a << b) | (a >>> (32 - b));\n}\n// Salsa and Chacha block length is always 512-bit\nconst BLOCK_LEN = 64;\n// RFC 8439 §2.2 / RFC 7539 §2.2: the ChaCha state has 16 32-bit words.\nconst BLOCK_LEN32 = 16;\n// Counter policy for the shared public `counter` argument:\n// - RFC/IETF ChaCha20 uses a 32-bit counter.\n// - OpenSSL/Node `chacha20` instead treat the full 16-byte IV as a 128-bit\n//   counter state and carry into the next word.\n// - Raw `chacha20orig`, `salsa20`, `xsalsa20`, and `xchacha20` use 64-bit counters in libsodium\n//   and libtomcrypt, while some libs (for example libtomcrypt's RFC/IETF path) reject the max\n//   boundary instead of carrying.\n// - AEAD wrappers diverge too: libsodium `xchacha20poly1305` uses the IETF payload counter from\n//   block 1, while `secretstream_xchacha20poly1305` is a different protocol with rekey/reset.\n// Noble intentionally throws instead of silently picking one wrap model for users. In the default\n// path, even a 32-bit boundary would take 2^32 blocks * 64 bytes = 256 GiB, which is practically\n// unreachable for normal JS callers; advanced users who pass `counter` explicitly can implement\n// whatever wider carry / wrap policy they need on top.\nconst MAX_COUNTER = /* @__PURE__ */ (() => 2 ** 32 - 1)();\nconst U32_EMPTY = /* @__PURE__ */ Uint32Array.of();\nfunction runCipher(core, sigma, key, nonce, data, output, counter, rounds) {\n    const len = data.length;\n    const block = new Uint8Array(BLOCK_LEN);\n    const b32 = u32(block);\n    // Make sure that buffers aligned to 4 bytes\n    const isAligned = isLE && isAligned32(data) && isAligned32(output);\n    const d32 = isAligned ? u32(data) : U32_EMPTY;\n    const o32 = isAligned ? u32(output) : U32_EMPTY;\n    // RFC 8439 §2.4.1 / RFC 7539 §2.4.1 allow XORing one keystream block at a time and\n    // truncating the final partial block instead of materializing the whole keystream.\n    if (!isLE) {\n        for (let pos = 0; pos < len; counter++) {\n            core(sigma, key, nonce, b32, counter, rounds);\n            // RFC 8439 §2.4 / RFC 7539 §2.4 serialize keystream words in little-endian order.\n            swap32IfBE(b32);\n            if (counter >= MAX_COUNTER)\n                throw new Error('arx: counter overflow');\n            const take = Math.min(BLOCK_LEN, len - pos);\n            for (let j = 0, posj; j < take; j++) {\n                posj = pos + j;\n                output[posj] = data[posj] ^ block[j];\n            }\n            pos += take;\n        }\n        return;\n    }\n    for (let pos = 0; pos < len; counter++) {\n        core(sigma, key, nonce, b32, counter, rounds);\n        // See MAX_COUNTER policy note above: never silently wrap the shared public counter.\n        if (counter >= MAX_COUNTER)\n            throw new Error('arx: counter overflow');\n        const take = Math.min(BLOCK_LEN, len - pos);\n        // aligned to 4 bytes\n        if (isAligned && take === BLOCK_LEN) {\n            const pos32 = pos / 4;\n            if (pos % 4 !== 0)\n                throw new Error('arx: invalid block position');\n            for (let j = 0, posj; j < BLOCK_LEN32; j++) {\n                posj = pos32 + j;\n                o32[posj] = d32[posj] ^ b32[j];\n            }\n            pos += BLOCK_LEN;\n            continue;\n        }\n        for (let j = 0, posj; j < take; j++) {\n            posj = pos + j;\n            output[posj] = data[posj] ^ block[j];\n        }\n        pos += take;\n    }\n}\n/**\n * Creates an ARX stream cipher from a 32-bit core permutation.\n * Used internally to build the exported Salsa and ChaCha stream ciphers.\n * @param core - Core function that fills one keystream block.\n * @param opts - Cipher layout and nonce-extension options. See {@link CipherOpts}.\n * @returns Stream cipher function over byte arrays.\n * @throws If the core callback, key size, counter, or output sizing is invalid. {@link Error}\n */\nexport function createCipher(core, opts) {\n    const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);\n    if (typeof core !== 'function')\n        throw new Error('core must be a function');\n    anumber(counterLength);\n    anumber(rounds);\n    abool(counterRight);\n    abool(allowShortKeys);\n    return (key, nonce, data, output, counter = 0) => {\n        abytes(key, undefined, 'key');\n        abytes(nonce, undefined, 'nonce');\n        abytes(data, undefined, 'data');\n        const len = data.length;\n        // Raw XorStream APIs return ciphertext/plaintext bytes directly, so caller-provided outputs\n        // must match the logical result length exactly instead of returning an oversized workspace.\n        output = getOutput(len, output, false);\n        anumber(counter);\n        // See MAX_COUNTER policy note above: reject advanced explicit-counter requests before any wrap.\n        if (counter < 0 || counter >= MAX_COUNTER)\n            throw new Error('arx: counter overflow');\n        const toClean = [];\n        // Key & sigma\n        // key=16 -> sigma16, k=key|key\n        // key=32 -> sigma32, k=key\n        let l = key.length;\n        let k;\n        let sigma;\n        if (l === 32) {\n            // Copy caller keys too: big-endian normalization, extended-nonce subkey derivation, and\n            // final clean(...) all mutate or wipe the temporary buffer in place.\n            toClean.push((k = copyBytes(key)));\n            sigma = sigma32_32;\n        }\n        else if (l === 16 && allowShortKeys) {\n            k = new Uint8Array(32);\n            k.set(key);\n            k.set(key, 16);\n            sigma = sigma16_32;\n            toClean.push(k);\n        }\n        else {\n            abytes(key, 32, 'arx key');\n            throw new Error('invalid key size');\n            // throw new Error(`\"arx key\" expected Uint8Array of length 32, got length=${l}`);\n        }\n        // Nonce\n        // salsa20:      8   (8-byte counter)\n        // chacha20orig: 8   (8-byte counter)\n        // chacha20:     12  (4-byte counter)\n        // xsalsa20:     24  (16 -> hsalsa,  8 -> old nonce)\n        // xchacha20:    24  (16 -> hchacha, 8 -> old nonce)\n        // Copy before taking u32(...) views on misaligned inputs, and on big-endian so later\n        // swap32IfBE(...) never mutates caller nonce bytes in place.\n        if (!isLE || !isAligned32(nonce))\n            toClean.push((nonce = copyBytes(nonce)));\n        let k32 = u32(k);\n        // hsalsa & hchacha: handle extended nonce\n        if (extendNonceFn) {\n            if (nonce.length !== 24)\n                throw new Error(`arx: extended nonce must be 24 bytes`);\n            const n16 = nonce.subarray(0, 16);\n            if (isLE)\n                extendNonceFn(sigma, k32, u32(n16), k32);\n            else {\n                const sigmaRaw = swap32IfBE(Uint32Array.from(sigma));\n                extendNonceFn(sigmaRaw, k32, u32(n16), k32);\n                clean(sigmaRaw);\n                swap32IfBE(k32);\n            }\n            nonce = nonce.subarray(16);\n        }\n        else if (!isLE)\n            swap32IfBE(k32);\n        // Handle nonce counter\n        const nonceNcLen = 16 - counterLength;\n        if (nonceNcLen !== nonce.length)\n            throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);\n        // Normalize 64-bit-nonce layouts to the 12-byte core input: ChaCha/XChaCha prefix 4 zero\n        // counter bytes, while Salsa/XSalsa append them after the nonce words.\n        if (nonceNcLen !== 12) {\n            const nc = new Uint8Array(12);\n            nc.set(nonce, counterRight ? 0 : 12 - nonce.length);\n            nonce = nc;\n            toClean.push(nonce);\n        }\n        const n32 = swap32IfBE(u32(nonce));\n        // Ensure temporary key/nonce copies are wiped even if the remaining\n        // runtime guard in runCipher(...) throws on counter overflow.\n        try {\n            runCipher(core, sigma, k32, n32, data, output, counter, rounds);\n            return output;\n        }\n        finally {\n            clean(...toClean);\n        }\n    };\n}\n/** Internal class which wraps chacha20 or chacha8 to create CSPRNG. */\nexport class _XorStreamPRG {\n    blockLen;\n    keyLen;\n    nonceLen;\n    state;\n    buf;\n    key;\n    nonce;\n    pos;\n    ctr;\n    cipher;\n    constructor(cipher, blockLen, keyLen, nonceLen, seed) {\n        this.cipher = cipher;\n        this.blockLen = blockLen;\n        this.keyLen = keyLen;\n        this.nonceLen = nonceLen;\n        this.state = new Uint8Array(this.keyLen + this.nonceLen);\n        this.reseed(seed);\n        this.ctr = 0;\n        this.pos = this.blockLen;\n        this.buf = new Uint8Array(this.blockLen);\n        // Keep a single key||nonce backing buffer so reseed/addEntropy/clean update the live cipher\n        // inputs in place through these subarray views.\n        this.key = this.state.subarray(0, this.keyLen);\n        this.nonce = this.state.subarray(this.keyLen);\n    }\n    reseed(seed) {\n        abytes(seed);\n        if (!seed || seed.length === 0)\n            throw new Error('entropy required');\n        // Mix variable-length entropy cyclically across the whole key||nonce state, then restart the\n        // keystream so buffered leftovers from the previous state are never reused.\n        for (let i = 0; i < seed.length; i++)\n            this.state[i % this.state.length] ^= seed[i];\n        this.ctr = 0;\n        this.pos = this.blockLen;\n    }\n    addEntropy(seed) {\n        // Reject empty entropy before re-keying, otherwise a throwing call would still advance state.\n        abytes(seed);\n        if (seed.length === 0)\n            throw new Error('entropy required');\n        // Re-key from the current stream first, then mix external entropy into the fresh key||nonce\n        // state through reseed() so stale buffered bytes are discarded.\n        this.state.set(this.randomBytes(this.state.length));\n        this.reseed(seed);\n    }\n    randomBytes(len) {\n        anumber(len);\n        if (len === 0)\n            return new Uint8Array(0);\n        const avail = this.pos < this.blockLen ? this.blockLen - this.pos : 0;\n        const blocks = Math.ceil(Math.max(0, len - avail) / this.blockLen);\n        // Preflight overflow so failed reads don't partially consume keystream\n        // and leave the PRG repeating blocks.\n        if (blocks > 0 && this.ctr > MAX_COUNTER - blocks)\n            throw new Error('arx: counter overflow');\n        const out = new Uint8Array(len);\n        let outPos = 0;\n        // `out` starts zero-filled, and `buf.fill(0)` below does the same for leftovers: XOR-stream\n        // ciphers then emit raw keystream bytes directly into those buffers.\n        // Serve buffered leftovers first so split reads stay identical to one larger read.\n        if (this.pos < this.blockLen) {\n            const take = Math.min(len, this.blockLen - this.pos);\n            out.set(this.buf.subarray(this.pos, this.pos + take), 0);\n            this.pos += take;\n            outPos += take;\n            if (outPos === len)\n                return out; // fast path\n        }\n        // Full blocks directly to out\n        const full = Math.floor((len - outPos) / this.blockLen);\n        if (full > 0) {\n            const blockBytes = full * this.blockLen;\n            const b = out.subarray(outPos, outPos + blockBytes);\n            this.cipher(this.key, this.nonce, b, b, this.ctr);\n            this.ctr += full;\n            outPos += blockBytes;\n        }\n        // Save leftovers\n        const left = len - outPos;\n        if (left > 0) {\n            this.buf.fill(0);\n            // NOTE: cipher will handle overflow\n            this.cipher(this.key, this.nonce, this.buf, this.buf, this.ctr++);\n            out.set(this.buf.subarray(0, left), outPos);\n            this.pos = left;\n        }\n        return out;\n    }\n    // Clone seeds the new instance from this stream, so the source PRG advances too.\n    clone() {\n        return new _XorStreamPRG(this.cipher, this.blockLen, this.keyLen, this.nonceLen, this.randomBytes(this.state.length));\n    }\n    // Zeroes the current state and leftover buffer, but does not make the instance unusable:\n    // Later reads first drain zeros from the cleared buffer and then continue\n    // from zero key||nonce state.\n    clean() {\n        this.pos = 0;\n        this.ctr = 0;\n        this.buf.fill(0);\n        this.state.fill(0);\n    }\n}\n/**\n * Creates a PRG constructor from a stream cipher.\n * @param cipher - Stream cipher used to fill output blocks.\n * @param blockLen - Keystream block length in bytes.\n * @param keyLen - Internal key length in bytes.\n * @param nonceLen - Internal nonce length in bytes.\n * @returns PRG factory for seeded concrete `_XorStreamPRG` instances.\n * @example\n * Builds a PRG from XChaCha20 and reads bytes from a randomly seeded instance.\n * ```ts\n * import { xchacha20 } from '@noble/ciphers/chacha.js';\n * import { createPRG } from '@noble/ciphers/_arx.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const seed = randomBytes(32);\n * const init = createPRG(xchacha20, 64, 32, 24);\n * const prg = init(seed);\n * prg.randomBytes(8);\n * ```\n */\nexport const createPRG = (cipher, blockLen, keyLen, nonceLen) => {\n    return ((seed = randomBytes(32)) => new _XorStreamPRG(cipher, blockLen, keyLen, nonceLen, seed));\n};\n//# sourceMappingURL=_arx.js.map","/**\n * Poly1305 ({@link https://cr.yp.to/mac/poly1305-20050329.pdf | PDF},\n * {@link https://en.wikipedia.org/wiki/Poly1305 | wiki})\n * is a fast and parallel secret-key message-authentication code suitable for\n * a wide variety of applications. It was standardized in\n * {@link https://www.rfc-editor.org/rfc/rfc8439 | RFC 8439} and is now used in TLS 1.3.\n *\n * Polynomial MACs are not perfect for every situation:\n * they lack Random Key Robustness: the MAC can be forged, and can't be used in PAKE schemes.\n * See {@link https://keymaterial.net/2020/09/07/invisible-salamanders-in-aes-gcm-siv/ | the invisible salamanders attack writeup}.\n * To combat invisible salamanders, `hash(key)` can be included in ciphertext,\n * however, this would violate ciphertext indistinguishability:\n * an attacker would know which key was used - so `HKDF(key, i)`\n * could be used instead.\n *\n * Check out the {@link https://cr.yp.to/mac.html | original website}.\n * Based on public-domain {@link https://github.com/floodyberry/poly1305-donna | poly1305-donna}.\n * @module\n */\n// prettier-ignore\nimport { abytes, aexists, aoutput, bytesToHex, clean, concatBytes, copyBytes, hexToNumber, numberToBytesBE, wrapMacConstructor } from \"./utils.js\";\n// Little-endian 2-byte load used by the Poly1305 limb decomposition.\nfunction u8to16(a, i) {\n    return (a[i++] & 0xff) | ((a[i++] & 0xff) << 8);\n}\nfunction bytesToNumberLE(bytes) {\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\n/** Small version of `poly1305` without loop unrolling. Unused, provided for auditability. */\nfunction poly1305_small(msg, key) {\n    abytes(msg);\n    abytes(key, 32, 'key');\n    const POW_2_130_5 = BigInt(2) ** BigInt(130) - BigInt(5); // 2^130-5\n    const POW_2_128_1 = BigInt(2) ** BigInt(128) - BigInt(1); // 2^128-1\n    const CLAMP_R = BigInt('0x0ffffffc0ffffffc0ffffffc0fffffff');\n    const r = bytesToNumberLE(key.subarray(0, 16)) & CLAMP_R;\n    const s = bytesToNumberLE(key.subarray(16));\n    // Process by 16 byte chunks\n    let acc = BigInt(0);\n    for (let i = 0; i < msg.length; i += 16) {\n        const m = msg.subarray(i, i + 16);\n        // RFC 8439 §2.5.1 / RFC 7539 §2.5.1 append [0x01] to each chunk before multiplying by r.\n        const n = bytesToNumberLE(m) | (BigInt(1) << BigInt(8 * m.length));\n        acc = ((acc + n) * r) % POW_2_130_5;\n    }\n    const res = (acc + s) & POW_2_128_1;\n    // RFC 8439 §2.5 / RFC 7539 §2.5 serialize the low 128 bits in little-endian order.\n    return numberToBytesBE(res, 16).reverse(); // LE\n}\n// Can be used to replace `computeTag` in chacha.ts. Unused, provided for auditability.\n// @ts-expect-error\nfunction poly1305_computeTag_small(authKey, \n// AEAD trailer must already be the 16-byte length block:\n// 8-byte little-endian AAD length || 8-byte little-endian ciphertext length.\nlengths, ciphertext, AAD) {\n    // RFC 8439 §2.8.1 / RFC 7539 §2.8.1 MAC input is\n    // AAD || pad16(AAD) || ciphertext || pad16(ciphertext) || lengths.\n    const res = [];\n    const updatePadded2 = (msg) => {\n        res.push(msg);\n        const leftover = msg.length % 16;\n        // RFC 8439 §2.8.1 / RFC 7539 §2.8.1: pad16(x) is empty for aligned\n        // inputs, else 16-(len%16) zero bytes.\n        if (leftover)\n            res.push(new Uint8Array(16).slice(leftover));\n    };\n    if (AAD)\n        updatePadded2(AAD);\n    updatePadded2(ciphertext);\n    res.push(lengths);\n    return poly1305_small(concatBytes(...res), authKey);\n}\n/**\n * Incremental Poly1305 MAC state.\n * Prefer `poly1305()` for one-shot use.\n * @param key - 32-byte Poly1305 one-time key.\n * @example\n * Feeds one chunk into an incremental Poly1305 state with a fresh one-time key.\n *\n * ```ts\n * import { Poly1305 } from '@noble/ciphers/_poly1305.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const mac = new Poly1305(key);\n * mac.update(new Uint8Array([1, 2, 3]));\n * mac.digest();\n * ```\n */\nexport class Poly1305 {\n    blockLen = 16;\n    outputLen = 16;\n    buffer = new Uint8Array(16);\n    r = new Uint16Array(10); // Allocating 1 array with .subarray() here is slower than 3\n    h = new Uint16Array(10);\n    pad = new Uint16Array(8);\n    pos = 0;\n    finished = false;\n    destroyed = false;\n    // Can be speed-up using BigUint64Array, at the cost of complexity\n    constructor(key) {\n        key = copyBytes(abytes(key, 32, 'key'));\n        const t0 = u8to16(key, 0);\n        const t1 = u8to16(key, 2);\n        const t2 = u8to16(key, 4);\n        const t3 = u8to16(key, 6);\n        const t4 = u8to16(key, 8);\n        const t5 = u8to16(key, 10);\n        const t6 = u8to16(key, 12);\n        const t7 = u8to16(key, 14);\n        // RFC 8439 §2.5.1 / RFC 7539 §2.5.1 clamp r before multiplication.\n        // These masks unpack that clamped value into 13-bit limbs, while pad\n        // keeps the raw s half for finalize().\n        // {@link https://github.com/floodyberry/poly1305-donna/blob/e6ad6e091d30d7f4ec2d4f978be1fcfcbce72781/poly1305-donna-16.h#L47 | poly1305-donna reference}\n        this.r[0] = t0 & 0x1fff;\n        this.r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff;\n        this.r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03;\n        this.r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff;\n        this.r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff;\n        this.r[5] = (t4 >>> 1) & 0x1ffe;\n        this.r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff;\n        this.r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81;\n        this.r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff;\n        this.r[9] = (t7 >>> 5) & 0x007f;\n        for (let i = 0; i < 8; i++)\n            this.pad[i] = u8to16(key, 16 + 2 * i);\n    }\n    process(data, offset, isLast = false) {\n        // RFC 8439 §2.5 / §2.5.1 and RFC 7539 §2.5 / §2.5.1 add an extra high\n        // bit to every full 16-byte block. The final partial block gets its\n        // explicit `1` byte during digestInto(), so `hibit` stays zero there.\n        const hibit = isLast ? 0 : 1 << 11;\n        const { h, r } = this;\n        const r0 = r[0];\n        const r1 = r[1];\n        const r2 = r[2];\n        const r3 = r[3];\n        const r4 = r[4];\n        const r5 = r[5];\n        const r6 = r[6];\n        const r7 = r[7];\n        const r8 = r[8];\n        const r9 = r[9];\n        const t0 = u8to16(data, offset + 0);\n        const t1 = u8to16(data, offset + 2);\n        const t2 = u8to16(data, offset + 4);\n        const t3 = u8to16(data, offset + 6);\n        const t4 = u8to16(data, offset + 8);\n        const t5 = u8to16(data, offset + 10);\n        const t6 = u8to16(data, offset + 12);\n        const t7 = u8to16(data, offset + 14);\n        let h0 = h[0] + (t0 & 0x1fff);\n        let h1 = h[1] + (((t0 >>> 13) | (t1 << 3)) & 0x1fff);\n        let h2 = h[2] + (((t1 >>> 10) | (t2 << 6)) & 0x1fff);\n        let h3 = h[3] + (((t2 >>> 7) | (t3 << 9)) & 0x1fff);\n        let h4 = h[4] + (((t3 >>> 4) | (t4 << 12)) & 0x1fff);\n        let h5 = h[5] + ((t4 >>> 1) & 0x1fff);\n        let h6 = h[6] + (((t4 >>> 14) | (t5 << 2)) & 0x1fff);\n        let h7 = h[7] + (((t5 >>> 11) | (t6 << 5)) & 0x1fff);\n        let h8 = h[8] + (((t6 >>> 8) | (t7 << 8)) & 0x1fff);\n        let h9 = h[9] + ((t7 >>> 5) | hibit);\n        let c = 0;\n        let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);\n        c = d0 >>> 13;\n        d0 &= 0x1fff;\n        d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);\n        c += d0 >>> 13;\n        d0 &= 0x1fff;\n        let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);\n        c = d1 >>> 13;\n        d1 &= 0x1fff;\n        d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);\n        c += d1 >>> 13;\n        d1 &= 0x1fff;\n        let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);\n        c = d2 >>> 13;\n        d2 &= 0x1fff;\n        d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);\n        c += d2 >>> 13;\n        d2 &= 0x1fff;\n        let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);\n        c = d3 >>> 13;\n        d3 &= 0x1fff;\n        d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);\n        c += d3 >>> 13;\n        d3 &= 0x1fff;\n        let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;\n        c = d4 >>> 13;\n        d4 &= 0x1fff;\n        d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);\n        c += d4 >>> 13;\n        d4 &= 0x1fff;\n        let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;\n        c = d5 >>> 13;\n        d5 &= 0x1fff;\n        d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);\n        c += d5 >>> 13;\n        d5 &= 0x1fff;\n        let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;\n        c = d6 >>> 13;\n        d6 &= 0x1fff;\n        d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);\n        c += d6 >>> 13;\n        d6 &= 0x1fff;\n        let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;\n        c = d7 >>> 13;\n        d7 &= 0x1fff;\n        d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);\n        c += d7 >>> 13;\n        d7 &= 0x1fff;\n        let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;\n        c = d8 >>> 13;\n        d8 &= 0x1fff;\n        d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);\n        c += d8 >>> 13;\n        d8 &= 0x1fff;\n        let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;\n        c = d9 >>> 13;\n        d9 &= 0x1fff;\n        d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;\n        c += d9 >>> 13;\n        d9 &= 0x1fff;\n        c = ((c << 2) + c) | 0;\n        c = (c + d0) | 0;\n        d0 = c & 0x1fff;\n        c = c >>> 13;\n        d1 += c;\n        h[0] = d0;\n        h[1] = d1;\n        h[2] = d2;\n        h[3] = d3;\n        h[4] = d4;\n        h[5] = d5;\n        h[6] = d6;\n        h[7] = d7;\n        h[8] = d8;\n        h[9] = d9;\n    }\n    finalize() {\n        const { h, pad } = this;\n        const g = new Uint16Array(10);\n        let c = h[1] >>> 13;\n        h[1] &= 0x1fff;\n        for (let i = 2; i < 10; i++) {\n            h[i] += c;\n            c = h[i] >>> 13;\n            h[i] &= 0x1fff;\n        }\n        h[0] += c * 5;\n        c = h[0] >>> 13;\n        h[0] &= 0x1fff;\n        h[1] += c;\n        c = h[1] >>> 13;\n        h[1] &= 0x1fff;\n        h[2] += c;\n        // RFC 8439 §2.5 / RFC 7539 §2.5 reduce modulo 2^130-5 before repacking\n        // to 16-bit words and adding the raw s half.\n        g[0] = h[0] + 5;\n        c = g[0] >>> 13;\n        g[0] &= 0x1fff;\n        for (let i = 1; i < 10; i++) {\n            g[i] = h[i] + c;\n            c = g[i] >>> 13;\n            g[i] &= 0x1fff;\n        }\n        g[9] -= 1 << 13;\n        let mask = (c ^ 1) - 1;\n        for (let i = 0; i < 10; i++)\n            g[i] &= mask;\n        mask = ~mask;\n        for (let i = 0; i < 10; i++)\n            h[i] = (h[i] & mask) | g[i];\n        h[0] = (h[0] | (h[1] << 13)) & 0xffff;\n        h[1] = ((h[1] >>> 3) | (h[2] << 10)) & 0xffff;\n        h[2] = ((h[2] >>> 6) | (h[3] << 7)) & 0xffff;\n        h[3] = ((h[3] >>> 9) | (h[4] << 4)) & 0xffff;\n        h[4] = ((h[4] >>> 12) | (h[5] << 1) | (h[6] << 14)) & 0xffff;\n        h[5] = ((h[6] >>> 2) | (h[7] << 11)) & 0xffff;\n        h[6] = ((h[7] >>> 5) | (h[8] << 8)) & 0xffff;\n        h[7] = ((h[8] >>> 8) | (h[9] << 5)) & 0xffff;\n        let f = h[0] + pad[0];\n        h[0] = f & 0xffff;\n        for (let i = 1; i < 8; i++) {\n            f = (((h[i] + pad[i]) | 0) + (f >>> 16)) | 0;\n            h[i] = f & 0xffff;\n        }\n        clean(g);\n    }\n    update(data) {\n        aexists(this);\n        abytes(data);\n        data = copyBytes(data);\n        const { 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\n            if (take === blockLen) {\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(data, 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(buffer, 0, false);\n                this.pos = 0;\n            }\n        }\n        return this;\n    }\n    destroy() {\n        // `aexists(this)` guards update/digest paths, so destroy must mark the instance unusable too.\n        this.destroyed = true;\n        clean(this.h, this.r, this.buffer, this.pad);\n    }\n    digestInto(out) {\n        aexists(this);\n        aoutput(out, this);\n        this.finished = true;\n        const { buffer, h } = this;\n        let { pos } = this;\n        if (pos) {\n            // RFC 8439 §2.5 / RFC 7539 §2.5: the final short block appends a\n            // single `0x01` byte and zero-fills the remaining bytes before the\n            // last multiplication step.\n            buffer[pos++] = 1;\n            for (; pos < 16; pos++)\n                buffer[pos] = 0;\n            this.process(buffer, 0, true);\n        }\n        this.finalize();\n        let opos = 0;\n        for (let i = 0; i < 8; i++) {\n            out[opos++] = h[i] >>> 0;\n            out[opos++] = h[i] >>> 8;\n        }\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        // Copy out before destroy() zeroes the internal buffer.\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n}\n/**\n * Poly1305 MAC from RFC 8439.\n * @param msg - Message bytes to authenticate.\n * @param key - 32-byte Poly1305 one-time key.\n * @returns 16-byte authentication tag.\n * @example\n * Authenticates one message with a one-shot Poly1305 call and a fresh key.\n *\n * ```ts\n * import { poly1305 } from '@noble/ciphers/_poly1305.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * poly1305(new Uint8Array(), key);\n * ```\n */\nexport const poly1305 = /* @__PURE__ */ wrapMacConstructor(32, (key) => new Poly1305(key));\n//# sourceMappingURL=_poly1305.js.map","/**\n * ChaCha stream cipher, released\n * in 2008. Developed after Salsa20, ChaCha aims to increase diffusion per round.\n * It was standardized in\n * {@link https://www.rfc-editor.org/rfc/rfc8439 | RFC 8439} and\n * is now used in TLS 1.3.\n *\n * {@link https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha | XChaCha20}\n * extended-nonce variant is also provided. Similar to XSalsa, it's safe to use with\n * randomly-generated nonces.\n *\n * Check out\n * {@link http://cr.yp.to/chacha/chacha-20080128.pdf | PDF},\n * {@link https://en.wikipedia.org/wiki/Salsa20 | wiki}, and\n * {@link https://cr.yp.to/chacha.html | website}.\n *\n * @module\n */\nimport { createCipher, createPRG, rotl } from \"./_arx.js\";\nimport { poly1305 } from \"./_poly1305.js\";\nimport { abytes, clean, equalBytes, getOutput, swap8IfBE, swap32IfBE, u64Lengths, wrapCipher, } from \"./utils.js\";\n/**\n * ChaCha core function. It is implemented twice:\n * 1. Simple loop (chachaCore_small, hchacha_small)\n * 2. Unrolled loop (chachaCore, hchacha) - 4x faster, but larger & harder to read\n * The specific implementation is selected in `createCipher` below.\n */\n/** RFC 8439 §2.1 quarter round on words a, b, c, d. */\n// prettier-ignore\nfunction chachaQR(x, a, b, c, d) {\n    x[a] = (x[a] + x[b]) | 0;\n    x[d] = rotl(x[d] ^ x[a], 16);\n    x[c] = (x[c] + x[d]) | 0;\n    x[b] = rotl(x[b] ^ x[c], 12);\n    x[a] = (x[a] + x[b]) | 0;\n    x[d] = rotl(x[d] ^ x[a], 8);\n    x[c] = (x[c] + x[d]) | 0;\n    x[b] = rotl(x[b] ^ x[c], 7);\n}\n/** Repeated ChaCha double rounds; callers are expected to pass an even round count. */\nfunction chachaRound(x, rounds = 20) {\n    for (let r = 0; r < rounds; r += 2) {\n        // RFC 8439 §2.3 / §2.3.1 inner_block: four column rounds, then four diagonal rounds.\n        chachaQR(x, 0, 4, 8, 12);\n        chachaQR(x, 1, 5, 9, 13);\n        chachaQR(x, 2, 6, 10, 14);\n        chachaQR(x, 3, 7, 11, 15);\n        chachaQR(x, 0, 5, 10, 15);\n        chachaQR(x, 1, 6, 11, 12);\n        chachaQR(x, 2, 7, 8, 13);\n        chachaQR(x, 3, 4, 9, 14);\n    }\n}\n// Shared scratch for the auditability-only helper below; only the test-only\n// __TESTS.chachaCore_small hook reaches it, so production exports stay reentrant.\nconst ctmp = /* @__PURE__ */ new Uint32Array(16);\n/** Small version of chacha without loop unrolling. Unused, provided for auditability. */\n// prettier-ignore\nfunction chacha(s, k, i, out, isHChacha = true, rounds = 20) {\n    // `i` is either `[counter, nonce0, nonce1, nonce2]` for the ChaCha block\n    // function or the full 128-bit nonce prefix for the HChaCha subkey path.\n    // Create initial array using common pattern\n    const y = Uint32Array.from([\n        s[0], s[1], s[2], s[3], // \"expa\"   \"nd 3\"  \"2-by\"  \"te k\"\n        k[0], k[1], k[2], k[3], // Key      Key     Key     Key\n        k[4], k[5], k[6], k[7], // Key      Key     Key     Key\n        i[0], i[1], i[2], i[3], // Counter  Counter Nonce   Nonce\n    ]);\n    const x = ctmp;\n    x.set(y);\n    chachaRound(x, rounds);\n    // HChaCha writes words 0..3 and 12..15 after the rounds; the ChaCha\n    // block path adds the original state word-by-word.\n    if (isHChacha) {\n        const xindexes = [0, 1, 2, 3, 12, 13, 14, 15];\n        for (let i = 0; i < 8; i++)\n            out[i] = x[xindexes[i]];\n    }\n    else {\n        for (let i = 0; i < 16; i++)\n            out[i] = (y[i] + x[i]) | 0;\n    }\n}\n/** Identical to `chachaCore`. Reached only through the test-only `__TESTS` export. */\n// @ts-ignore\nconst chachaCore_small = (s, k, n, out, cnt, rounds) => \n// Keep the reference wrapper on the same [counter, nonce0, nonce1, nonce2] layout as chacha().\nchacha(s, k, Uint32Array.from([cnt, n[0], n[1], n[2]]), out, false, rounds);\n/** Identical to `hchacha`. Unused. */\n// @ts-ignore\nconst hchacha_small = chacha;\n/** RFC 8439 §2.3 block core for `state = constants | key | counter | nonce`. */\n// prettier-ignore\nfunction chachaCore(s, k, n, out, cnt, rounds = 20) {\n    let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], // \"expa\"   \"nd 3\"  \"2-by\"  \"te k\"\n    y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], // Key      Key     Key     Key\n    y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], // Key      Key     Key     Key\n    y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2]; // Counter  Nonce   Nonce   Nonce\n    // Save state to temporary variables\n    let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n    for (let r = 0; r < rounds; r += 2) {\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 16);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 12);\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 8);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 7);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 16);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 12);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 8);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 7);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 16);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 12);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 8);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 7);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 16);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 12);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 8);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 7);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 16);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 12);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 8);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 7);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 16);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 12);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 8);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 7);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 16);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 12);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 8);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 7);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 16);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 12);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 8);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 7);\n    }\n    // RFC 8439 §2.3 / §2.3.1: add the original state words back in state order.\n    let oi = 0;\n    out[oi++] = (y00 + x00) | 0;\n    out[oi++] = (y01 + x01) | 0;\n    out[oi++] = (y02 + x02) | 0;\n    out[oi++] = (y03 + x03) | 0;\n    out[oi++] = (y04 + x04) | 0;\n    out[oi++] = (y05 + x05) | 0;\n    out[oi++] = (y06 + x06) | 0;\n    out[oi++] = (y07 + x07) | 0;\n    out[oi++] = (y08 + x08) | 0;\n    out[oi++] = (y09 + x09) | 0;\n    out[oi++] = (y10 + x10) | 0;\n    out[oi++] = (y11 + x11) | 0;\n    out[oi++] = (y12 + x12) | 0;\n    out[oi++] = (y13 + x13) | 0;\n    out[oi++] = (y14 + x14) | 0;\n    out[oi++] = (y15 + x15) | 0;\n}\n/**\n * hchacha hashes key and nonce into key' and nonce' for xchacha20.\n * Algorithmically identical to `hchacha_small`, but this exported path\n * normalizes word order on big-endian hosts.\n * Need to find a way to merge it with `chachaCore` without 25% performance hit.\n * @param s - Sigma constants as 32-bit words.\n * @param k - Key words.\n * @param i - Nonce-prefix words.\n * @param out - Output buffer for the derived subkey.\n * @example\n * Derives the XChaCha subkey from sigma, key, and nonce-prefix words.\n *\n * ```ts\n * const sigma = new Uint32Array(4);\n * const key = new Uint32Array(8);\n * const nonce = new Uint32Array(4);\n * const out = new Uint32Array(8);\n * hchacha(sigma, key, nonce, out);\n * ```\n */\n// prettier-ignore\nexport function hchacha(s, k, i, out) {\n    let x00 = swap8IfBE(s[0]), x01 = swap8IfBE(s[1]), x02 = swap8IfBE(s[2]), x03 = swap8IfBE(s[3]), x04 = swap8IfBE(k[0]), x05 = swap8IfBE(k[1]), x06 = swap8IfBE(k[2]), x07 = swap8IfBE(k[3]), x08 = swap8IfBE(k[4]), x09 = swap8IfBE(k[5]), x10 = swap8IfBE(k[6]), x11 = swap8IfBE(k[7]), x12 = swap8IfBE(i[0]), x13 = swap8IfBE(i[1]), x14 = swap8IfBE(i[2]), x15 = swap8IfBE(i[3]);\n    for (let r = 0; r < 20; r += 2) {\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 16);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 12);\n        x00 = (x00 + x04) | 0;\n        x12 = rotl(x12 ^ x00, 8);\n        x08 = (x08 + x12) | 0;\n        x04 = rotl(x04 ^ x08, 7);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 16);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 12);\n        x01 = (x01 + x05) | 0;\n        x13 = rotl(x13 ^ x01, 8);\n        x09 = (x09 + x13) | 0;\n        x05 = rotl(x05 ^ x09, 7);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 16);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 12);\n        x02 = (x02 + x06) | 0;\n        x14 = rotl(x14 ^ x02, 8);\n        x10 = (x10 + x14) | 0;\n        x06 = rotl(x06 ^ x10, 7);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 16);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 12);\n        x03 = (x03 + x07) | 0;\n        x15 = rotl(x15 ^ x03, 8);\n        x11 = (x11 + x15) | 0;\n        x07 = rotl(x07 ^ x11, 7);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 16);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 12);\n        x00 = (x00 + x05) | 0;\n        x15 = rotl(x15 ^ x00, 8);\n        x10 = (x10 + x15) | 0;\n        x05 = rotl(x05 ^ x10, 7);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 16);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 12);\n        x01 = (x01 + x06) | 0;\n        x12 = rotl(x12 ^ x01, 8);\n        x11 = (x11 + x12) | 0;\n        x06 = rotl(x06 ^ x11, 7);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 16);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 12);\n        x02 = (x02 + x07) | 0;\n        x13 = rotl(x13 ^ x02, 8);\n        x08 = (x08 + x13) | 0;\n        x07 = rotl(x07 ^ x08, 7);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 16);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 12);\n        x03 = (x03 + x04) | 0;\n        x14 = rotl(x14 ^ x03, 8);\n        x09 = (x09 + x14) | 0;\n        x04 = rotl(x04 ^ x09, 7);\n    }\n    // HChaCha derives the subkey from state words 0..3 and 12..15 after 20 rounds.\n    let oi = 0;\n    out[oi++] = x00;\n    out[oi++] = x01;\n    out[oi++] = x02;\n    out[oi++] = x03;\n    out[oi++] = x12;\n    out[oi++] = x13;\n    out[oi++] = x14;\n    out[oi++] = x15;\n    swap32IfBE(out);\n}\n/**\n * Original, non-RFC chacha20 from DJB. 8-byte nonce, 8-byte counter.\n * The nonce/counter layout still reserves 8 counter bytes internally, but the shared public\n * `counter` argument follows noble's strict non-wrapping 32-bit policy. See `src/_arx.ts`\n * near `MAX_COUNTER` for the full counter-policy rationale.\n * @param key - 16-byte or 32-byte key.\n * @param nonce - 8-byte nonce.\n * @param data - Input bytes to xor with the keystream.\n * @param output - Optional destination buffer.\n * @param counter - Initial block counter.\n * @returns Encrypted or decrypted bytes.\n * @example\n * Encrypts bytes with the original 8-byte-nonce ChaCha variant and a fresh key/nonce.\n *\n * ```ts\n * import { chacha20orig } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const nonce = randomBytes(8);\n * chacha20orig(key, nonce, new Uint8Array(4));\n * ```\n */\nexport const chacha20orig = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 8,\n    allowShortKeys: true,\n});\n/**\n * ChaCha stream cipher. Conforms to RFC 8439 (IETF, TLS). 12-byte nonce, 4-byte counter.\n * With smaller nonce, it's not safe to make it random (CSPRNG), due to collision chance.\n * @param key - 32-byte key.\n * @param nonce - 12-byte nonce.\n * @param data - Input bytes to xor with the keystream.\n * @param output - Optional destination buffer.\n * @param counter - Initial block counter.\n * @returns Encrypted or decrypted bytes.\n * @example\n * Encrypts bytes with the RFC 8439 ChaCha20 stream cipher and a fresh key/nonce.\n *\n * ```ts\n * import { chacha20 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const nonce = randomBytes(12);\n * chacha20(key, nonce, new Uint8Array(4));\n * ```\n */\nexport const chacha20 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    allowShortKeys: false,\n});\n/**\n * XChaCha eXtended-nonce ChaCha. With 24-byte nonce, it's safe to make it random (CSPRNG).\n * See {@link https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha | the IRTF draft}.\n * The nonce/counter layout still reserves 8 counter bytes internally, but the shared public\n * `counter` argument follows noble's strict non-wrapping 32-bit policy. See `src/_arx.ts`\n * near `MAX_COUNTER` for the full counter-policy rationale.\n * @param key - 32-byte key.\n * @param nonce - 24-byte extended nonce.\n * @param data - Input bytes to xor with the keystream.\n * @param output - Optional destination buffer.\n * @param counter - Initial block counter.\n * @returns Encrypted or decrypted bytes.\n * @example\n * Encrypts bytes with XChaCha20 using a fresh key and random 24-byte nonce.\n *\n * ```ts\n * import { xchacha20 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const nonce = randomBytes(24);\n * xchacha20(key, nonce, new Uint8Array(4));\n * ```\n */\nexport const xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 8,\n    extendNonceFn: hchacha,\n    allowShortKeys: false,\n});\n/**\n * Reduced 8-round chacha, described in original paper.\n * @param key - 32-byte key.\n * @param nonce - 12-byte nonce.\n * @param data - Input bytes to xor with the keystream.\n * @param output - Optional destination buffer.\n * @param counter - Initial block counter.\n * @returns Encrypted or decrypted bytes.\n * @example\n * Uses the reduced 8-round variant for non-critical workloads with a fresh key/nonce.\n *\n * ```ts\n * import { chacha8 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const nonce = randomBytes(12);\n * chacha8(key, nonce, new Uint8Array(4));\n * ```\n */\nexport const chacha8 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    rounds: 8,\n});\n/**\n * Reduced 12-round chacha, described in original paper.\n * @param key - 32-byte key.\n * @param nonce - 12-byte nonce.\n * @param data - Input bytes to xor with the keystream.\n * @param output - Optional destination buffer.\n * @param counter - Initial block counter.\n * @returns Encrypted or decrypted bytes.\n * @example\n * Uses the reduced 12-round variant for non-critical workloads with a fresh key/nonce.\n *\n * ```ts\n * import { chacha12 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const nonce = randomBytes(12);\n * chacha12(key, nonce, new Uint8Array(4));\n * ```\n */\nexport const chacha12 = /* @__PURE__ */ createCipher(chachaCore, {\n    counterRight: false,\n    counterLength: 4,\n    rounds: 12,\n});\n// Test-only hooks for keeping the simple/reference core aligned with the unrolled production core.\nexport const __TESTS = /* @__PURE__ */ Object.freeze({ chachaCore_small, chachaCore });\n// RFC 8439 §2.8.1 pad16(x): shared zero block for AAD/ciphertext padding.\nconst ZEROS16 = /* @__PURE__ */ new Uint8Array(16);\n// RFC 8439 §2.8 / §2.8.1: aligned inputs add nothing, otherwise append 16-(len%16) zero bytes.\nconst updatePadded = (h, msg) => {\n    h.update(msg);\n    const leftover = msg.length % 16;\n    if (leftover)\n        h.update(ZEROS16.subarray(leftover));\n};\n// RFC 8439 §2.6.1 poly1305_key_gen returns `block[0..31]`, so AEAD key\n// generation only needs 32 zero bytes.\nconst ZEROS32 = /* @__PURE__ */ new Uint8Array(32);\nfunction computeTag(fn, key, nonce, ciphertext, AAD) {\n    if (AAD !== undefined)\n        abytes(AAD, undefined, 'AAD');\n    // RFC 8439 §2.6 / §2.8: derive the Poly1305 one-time key from counter 0,\n    // then MAC AAD || pad16(AAD) || ciphertext || pad16(ciphertext) || len(AAD) || len(ciphertext).\n    const authKey = fn(key, nonce, ZEROS32);\n    const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);\n    // Methods below can be replaced with\n    // return poly1305_computeTag_small(authKey, lengths, ciphertext, AAD)\n    const h = poly1305.create(authKey);\n    if (AAD)\n        updatePadded(h, AAD);\n    updatePadded(h, ciphertext);\n    h.update(lengths);\n    const res = h.digest();\n    clean(authKey, lengths);\n    return res;\n}\n/**\n * AEAD algorithm from RFC 8439.\n * Salsa20 and chacha (RFC 8439) use poly1305 differently.\n * We could have composed them, but it's hard because of authKey:\n * In salsa20, authKey changes position in salsa stream.\n * In chacha, authKey can't be computed inside computeTag, it modifies the counter.\n */\nexport const _poly1305_aead = (xorStream) => (key, nonce, AAD) => {\n    // This borrows caller key/nonce/AAD buffers by reference; mutating them after construction\n    // changes future encrypt/decrypt results.\n    const tagLength = 16;\n    return {\n        encrypt(plaintext, output) {\n            const plength = plaintext.length;\n            output = getOutput(plength + tagLength, output, false);\n            output.set(plaintext);\n            const oPlain = output.subarray(0, -tagLength);\n            // RFC 8439 §2.8: payload encryption starts at counter 1 because counter 0 produced the OTK.\n            xorStream(key, nonce, oPlain, oPlain, 1);\n            const tag = computeTag(xorStream, key, nonce, oPlain, AAD);\n            output.set(tag, plength); // append tag\n            clean(tag);\n            return output;\n        },\n        decrypt(ciphertext, output) {\n            output = getOutput(ciphertext.length - tagLength, output, false);\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = computeTag(xorStream, key, nonce, data, AAD);\n            // RFC 8439 §2.8 / §4: authenticate ciphertext before decrypting it, and compare tags with\n            // the constant-time equalBytes() helper rather than decrypting speculative plaintext first.\n            if (!equalBytes(passedTag, tag)) {\n                clean(tag);\n                throw new Error('invalid tag');\n            }\n            output.set(ciphertext.subarray(0, -tagLength));\n            // Actual decryption\n            xorStream(key, nonce, output, output, 1); // start stream with i=1\n            clean(tag);\n            return output;\n        },\n    };\n};\n/**\n * ChaCha20-Poly1305 from RFC 8439.\n *\n * Unsafe to use random nonces under the same key, due to collision chance.\n * Prefer XChaCha instead.\n * @param key - 32-byte key.\n * @param nonce - 12-byte nonce.\n * @param AAD - Additional authenticated data.\n * @returns AEAD cipher instance.\n * @example\n * Encrypts and authenticates plaintext with a fresh key and nonce.\n *\n * ```ts\n * import { chacha20poly1305 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const nonce = randomBytes(12);\n * const cipher = chacha20poly1305(key, nonce);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const chacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 12, tagLength: 16 }, \n/* @__PURE__ */ _poly1305_aead(chacha20));\n/**\n * XChaCha20-Poly1305 extended-nonce chacha.\n *\n * Can be safely used with random nonces (CSPRNG).\n * See {@link https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha | the IRTF draft}.\n * @param key - 32-byte key.\n * @param nonce - 24-byte nonce.\n * @param AAD - Additional authenticated data.\n * @returns AEAD cipher instance.\n * @example\n * Encrypts and authenticates plaintext with a fresh key and random 24-byte nonce.\n *\n * ```ts\n * import { xchacha20poly1305 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const key = randomBytes(32);\n * const nonce = randomBytes(24);\n * const cipher = xchacha20poly1305(key, nonce);\n * cipher.encrypt(new Uint8Array([1, 2, 3]));\n * ```\n */\nexport const xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16 }, \n/* @__PURE__ */ _poly1305_aead(xchacha20));\n/**\n * Chacha20 CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n * Compatible with libtomcrypt. It does not have a specification, so unclear how secure it is.\n * @param seed - Optional seed bytes mixed into the internal `key || nonce` state. When omitted,\n * only 32 random bytes are mixed into the 40-byte state.\n * @returns Seeded concrete `_XorStreamPRG` instance, including `clone()`.\n * @example\n * Seeds the test-only ChaCha20 DRBG from fresh entropy.\n *\n * ```ts\n * import { rngChacha20 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const seed = randomBytes(32);\n * const prg = rngChacha20(seed);\n * prg.randomBytes(8);\n * ```\n */\nexport const rngChacha20 = /* @__PURE__ */ createPRG(chacha20orig, 64, 32, 8);\n/**\n * Chacha20/8 CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n * Faster than `rngChacha20`.\n * @param seed - Optional seed bytes mixed into the internal `key || nonce` state. When omitted,\n * only 32 random bytes are mixed into the 44-byte state.\n * @returns Seeded concrete `_XorStreamPRG` instance, including `clone()`.\n * @example\n * Seeds the faster test-only ChaCha8 DRBG from fresh entropy.\n *\n * ```ts\n * import { rngChacha8 } from '@noble/ciphers/chacha.js';\n * import { randomBytes } from '@noble/ciphers/utils.js';\n * const seed = randomBytes(32);\n * const prg = rngChacha8(seed);\n * prg.randomBytes(8);\n * ```\n */\nexport const rngChacha8 = /* @__PURE__ */ createPRG(chacha8, 64, 32, 12);\n//# sourceMappingURL=chacha.js.map","import {\n  assertBytes,\n  concatBytes,\n  type AeadComponent,\n  type AeadCreateOpenerParams,\n  type AeadCreateSealerParams,\n  type AeadTransform,\n  type CipherComponent,\n  type PresetComponent,\n  type StreamCipherComponent,\n  type StreamCipherTransformParams,\n  type Transform,\n} from '@jscrypto/core';\nimport {\n  chacha20 as nobleChaCha20,\n  chacha20poly1305 as nobleChaCha20Poly1305,\n  xchacha20 as nobleXChaCha20,\n  xchacha20poly1305 as nobleXChaCha20Poly1305,\n} from '@noble/ciphers/chacha.js';\n\nconst KEY_BYTES = 32;\nconst CHACHA20_NONCE_BYTES = 12;\nconst XCHACHA20_NONCE_BYTES = 24;\nconst TAG_BYTES = 16;\nconst STREAM_BLOCK_BYTES = 64;\nconst MAX_COUNTER = 0xffffffff; // exclusive upper bound, matching @noble/ciphers\n\nexport const chacha20: StreamCipherComponent<'ChaCha20'> = {\n  kind: 'cipher',\n  name: 'ChaCha20',\n  type: 'stream',\n  keySizes: [KEY_BYTES],\n  createEncryptor(params) {\n    return createStreamTransform(params, 'ChaCha20');\n  },\n  createDecryptor(params) {\n    return createStreamTransform(params, 'ChaCha20');\n  },\n};\n\nexport const xchacha20: StreamCipherComponent<'XChaCha20'> = {\n  kind: 'cipher',\n  name: 'XChaCha20',\n  type: 'stream',\n  keySizes: [KEY_BYTES],\n  createEncryptor(params) {\n    return createStreamTransform(params, 'XChaCha20');\n  },\n  createDecryptor(params) {\n    return createStreamTransform(params, 'XChaCha20');\n  },\n};\n\nexport const chacha20Poly1305: AeadComponent<'ChaCha20-Poly1305'> = {\n  kind: 'aead',\n  name: 'ChaCha20-Poly1305',\n  keySizes: [KEY_BYTES],\n  nonceSizes: [CHACHA20_NONCE_BYTES],\n  recommendedNonceSize: CHACHA20_NONCE_BYTES,\n  tagSizes: [TAG_BYTES],\n  create({ key }) {\n    return createAeadTransform(key, 'ChaCha20-Poly1305');\n  },\n};\n\nexport const xchacha20Poly1305: AeadComponent<'XChaCha20-Poly1305'> = {\n  kind: 'aead',\n  name: 'XChaCha20-Poly1305',\n  keySizes: [KEY_BYTES],\n  nonceSizes: [XCHACHA20_NONCE_BYTES],\n  recommendedNonceSize: XCHACHA20_NONCE_BYTES,\n  tagSizes: [TAG_BYTES],\n  create({ key }) {\n    return createAeadTransform(key, 'XChaCha20-Poly1305');\n  },\n};\n\nexport const allChaCha20Components: readonly (CipherComponent | AeadComponent)[] = [\n  chacha20,\n  xchacha20,\n  chacha20Poly1305,\n  xchacha20Poly1305,\n];\n\nexport const chacha20Preset: PresetComponent<'chacha20'> = {\n  kind: 'preset',\n  name: 'chacha20',\n  components() {\n    return allChaCha20Components;\n  },\n};\n\ntype StreamAlgorithm = 'ChaCha20' | 'XChaCha20';\ntype AeadAlgorithm = 'ChaCha20-Poly1305' | 'XChaCha20-Poly1305';\n\nfunction createStreamTransform(\n  params: StreamCipherTransformParams,\n  algorithm: StreamAlgorithm,\n): Transform {\n  assertUnsupportedBlockOptions(params.options, algorithm);\n  assertBytes(params.key, `${algorithm} key`);\n  assertKey(params.key, algorithm);\n  const options = asRecord(params.options);\n  const nonce = requireNonce(options, algorithm);\n  let blockCounter = resolveCounter(options.counter, algorithm);\n  let keystream: Uint8Array<ArrayBufferLike> = new Uint8Array(0);\n  let keystreamOffset = 0;\n  let finalized = false;\n\n  const xorChunk = (input: Uint8Array): Uint8Array => {\n    if (input.length === 0) {\n      return new Uint8Array(0);\n    }\n\n    const output = new Uint8Array(input.length);\n    let inputOffset = 0;\n\n    while (inputOffset < input.length) {\n      if (keystreamOffset >= keystream.length) {\n        const remaining = input.length - inputOffset;\n        const generateLength = Math.ceil(remaining / STREAM_BLOCK_BYTES) * STREAM_BLOCK_BYTES;\n        keystream = applyStream(\n          algorithm,\n          params.key,\n          nonce,\n          new Uint8Array(generateLength),\n          blockCounter,\n        );\n        blockCounter += generateLength / STREAM_BLOCK_BYTES;\n        keystreamOffset = 0;\n      }\n\n      const n = Math.min(input.length - inputOffset, keystream.length - keystreamOffset);\n      for (let i = 0; i < n; i++) {\n        output[inputOffset + i] = (input[inputOffset + i] as number) ^ (keystream[keystreamOffset + i] as number);\n      }\n      inputOffset += n;\n      keystreamOffset += n;\n    }\n\n    return output;\n  };\n\n  return {\n    process(input) {\n      assertNotFinalized(finalized);\n      assertBytes(input, `${algorithm} input`);\n      return xorChunk(input);\n    },\n    finalize(input = new Uint8Array(0)) {\n      assertNotFinalized(finalized);\n      assertBytes(input, `${algorithm} input`);\n      finalized = true;\n      const output = input.length === 0 ? new Uint8Array(0) : xorChunk(input);\n      keystream = new Uint8Array(0);\n      keystreamOffset = 0;\n      return output;\n    },\n  };\n}\n\nfunction createAeadTransform(key: Uint8Array, algorithm: AeadAlgorithm): AeadTransform {\n  assertBytes(key, `${algorithm} key`);\n  assertKey(key, algorithm);\n\n  return {\n    createSealer({ nonce, aad, tagLength }: AeadCreateSealerParams): Transform {\n      const resolvedNonce = requireAeadNonce(nonce, algorithm);\n      const resolvedAad = resolveAad(aad, algorithm);\n      assertTagLength(tagLength, algorithm);\n      let pendings: Uint8Array<ArrayBufferLike>[] = [];\n      let finalized = false;\n\n      return {\n        process(input) {\n          assertNotFinalized(finalized);\n          assertBytes(input, `${algorithm} input`);\n          pendings.push(input);\n          return new Uint8Array(0);\n        },\n\n        finalize(input = new Uint8Array(0)) {\n          assertNotFinalized(finalized);\n          if (input.length !== 0) {\n            this.process(input);\n          }\n          finalized = true;\n\n          const plaintext = collectPending(pendings);\n          pendings = [];\n          const cipher = createNobleAead(algorithm, key, resolvedNonce, resolvedAad);\n          return cipher.encrypt(plaintext);\n        },\n      };\n    },\n\n    createOpener({ nonce, aad, tag, tagLength }: AeadCreateOpenerParams): Transform {\n      const resolvedNonce = requireAeadNonce(nonce, algorithm);\n      const resolvedAad = resolveAad(aad, algorithm);\n      const detachedTag = resolveOptionalTag(tag, algorithm);\n      // When a detached tag is present, tag.length wins and tagLength is ignored.\n      if (detachedTag === undefined) {\n        assertTagLength(tagLength, algorithm);\n      }\n      let pendings: Uint8Array<ArrayBufferLike>[] = [];\n      let finalized = false;\n\n      return {\n        process(input) {\n          assertNotFinalized(finalized);\n          assertBytes(input, `${algorithm} input`);\n          pendings.push(input);\n          return new Uint8Array(0);\n        },\n\n        finalize(input = new Uint8Array(0)) {\n          assertNotFinalized(finalized);\n          if (input.length !== 0) {\n            this.process(input);\n          }\n          finalized = true;\n\n          const ciphertext = collectPending(pendings);\n          pendings = [];\n          const sealed = resolveSealedInput(ciphertext, detachedTag, algorithm);\n          const cipher = createNobleAead(algorithm, key, resolvedNonce, resolvedAad);\n          try {\n            return cipher.decrypt(sealed);\n          } catch {\n            throw new Error(`${algorithm} authentication failed.`);\n          }\n        },\n      };\n    },\n  };\n}\n\nfunction collectPending(pendings: readonly Uint8Array[]): Uint8Array {\n  if (pendings.length === 0) {\n    return new Uint8Array(0);\n  }\n  if (pendings.length === 1) {\n    return pendings[0];\n  }\n  return concatBytes(...pendings);\n}\n\nfunction applyStream(\n  algorithm: StreamAlgorithm,\n  key: Uint8Array,\n  nonce: Uint8Array,\n  data: Uint8Array,\n  counter: number,\n): Uint8Array {\n  if (algorithm === 'ChaCha20') {\n    return nobleChaCha20(key, nonce, data, undefined, counter);\n  }\n  return nobleXChaCha20(key, nonce, data, undefined, counter);\n}\n\nfunction createNobleAead(\n  algorithm: AeadAlgorithm,\n  key: Uint8Array,\n  nonce: Uint8Array,\n  aad: Uint8Array,\n) {\n  if (algorithm === 'ChaCha20-Poly1305') {\n    return nobleChaCha20Poly1305(key, nonce, aad);\n  }\n  return nobleXChaCha20Poly1305(key, nonce, aad);\n}\n\nfunction resolveSealedInput(\n  ciphertext: Uint8Array,\n  tag: Uint8Array | undefined,\n  algorithm: AeadAlgorithm,\n): Uint8Array {\n  if (tag === undefined) {\n    if (ciphertext.length < TAG_BYTES) {\n      throw new Error(`${algorithm} ciphertext must include a 128-bit authentication tag.`);\n    }\n    return ciphertext;\n  }\n  assertTag(tag, algorithm);\n  return concatBytes(ciphertext, tag);\n}\n\nfunction requireNonce(options: Record<string, unknown>, algorithm: StreamAlgorithm): Uint8Array {\n  const nonce = options.nonce;\n  if (nonce === undefined) {\n    throw new Error(`${algorithm} requires a nonce.`);\n  }\n  assertBytes(nonce, `${algorithm} nonce`);\n  assertNonce(nonce, algorithm);\n  return nonce;\n}\n\nfunction requireAeadNonce(nonce: Uint8Array | undefined, algorithm: AeadAlgorithm): Uint8Array {\n  if (nonce === undefined) {\n    throw new Error(`${algorithm} requires a nonce.`);\n  }\n  assertBytes(nonce, `${algorithm} nonce`);\n  assertNonce(nonce, algorithm);\n  return nonce;\n}\n\nfunction resolveOptionalTag(tag: unknown, algorithm: AeadAlgorithm): Uint8Array | undefined {\n  if (tag === undefined) {\n    return undefined;\n  }\n  assertBytes(tag, `${algorithm} tag`);\n  assertTag(tag, algorithm);\n  return tag;\n}\n\nfunction resolveAad(aad: unknown, algorithm: AeadAlgorithm): Uint8Array {\n  if (aad === undefined) {\n    return new Uint8Array(0);\n  }\n  assertBytes(aad, `${algorithm} aad`);\n  return aad;\n}\n\nfunction assertTagLength(tagLength: number | undefined, algorithm: AeadAlgorithm): void {\n  if (tagLength !== undefined && tagLength !== TAG_BYTES) {\n    throw new Error(`${algorithm} tagLength must be 16 bytes.`);\n  }\n}\n\nfunction resolveCounter(counter: unknown, algorithm: StreamAlgorithm): number {\n  if (counter === undefined) {\n    return 0;\n  }\n  if (typeof counter !== 'number' || !Number.isInteger(counter) || counter < 0 || counter >= MAX_COUNTER) {\n    throw new RangeError(`${algorithm} counter must be a 32-bit unsigned integer.`);\n  }\n  return counter;\n}\n\nfunction assertKey(key: Uint8Array, algorithm: string): void {\n  if (key.length !== KEY_BYTES) {\n    throw new Error(`${algorithm} key must be 256 bits.`);\n  }\n}\n\nfunction assertNonce(nonce: Uint8Array, algorithm: StreamAlgorithm | AeadAlgorithm): void {\n  if (algorithm === 'ChaCha20' || algorithm === 'ChaCha20-Poly1305') {\n    if (nonce.length !== CHACHA20_NONCE_BYTES) {\n      throw new Error(`${algorithm} nonce must be 96 bits.`);\n    }\n    return;\n  }\n  if (nonce.length !== XCHACHA20_NONCE_BYTES) {\n    throw new Error(`${algorithm} nonce must be 192 bits.`);\n  }\n}\n\nfunction assertTag(tag: Uint8Array, algorithm: AeadAlgorithm): void {\n  if (tag.length !== TAG_BYTES) {\n    throw new Error(`${algorithm} tag must be 128 bits.`);\n  }\n}\n\nfunction assertUnsupportedBlockOptions(options: unknown, algorithm: string): void {\n  const record = asRecord(options);\n  if (Object.prototype.hasOwnProperty.call(record, 'mode') && record.mode !== undefined) {\n    throw new Error(`${algorithm} does not support mode.`);\n  }\n  if (Object.prototype.hasOwnProperty.call(record, 'padding') && record.padding !== undefined) {\n    throw new Error(`${algorithm} does not support padding.`);\n  }\n}\n\nfunction asRecord(options: unknown): Record<string, unknown> {\n  if (typeof options === 'object' && options !== null) {\n    return options as Record<string, unknown>;\n  }\n  return {};\n}\n\nfunction assertNotFinalized(finalized: boolean): void {\n  if (finalized) {\n    throw new Error('Transform is already finalized.');\n  }\n}\n","import type { BlockCipher, CipherComponent, PresetComponent } from '@jscrypto/core';\n\nexport const des: CipherComponent<'DES'> = {\n  kind: 'cipher',\n  name: 'DES',\n  type: 'block',\n  blockSize: 8,\n  keySizes: [8],\n  create(key) {\n    return createDesCipher(key);\n  },\n};\n\nexport const desPreset: PresetComponent<'des'> = {\n  kind: 'preset',\n  name: 'des',\n  components() {\n    return [des];\n  },\n};\n\nexport function createDesCipher(key: Uint8Array): BlockCipher {\n  if (key.length !== 8) {\n    throw new Error('DES key must be 64 bits.');\n  }\n\n  const subkeys = createSubkeys(key);\n  const tmp = [0, 0];\n\n  return {\n    blockSize: 8,\n\n    encryptBlock(input, inputOffset, output, outputOffset) {\n      processBlock(input, inputOffset, output, outputOffset, subkeys, tmp, true);\n    },\n\n    decryptBlock(input, inputOffset, output, outputOffset) {\n      processBlock(input, inputOffset, output, outputOffset, subkeys, tmp, false);\n    },\n\n    encrypt(input, output) {\n      return processBlocks(input, output, subkeys, true, 'DES');\n    },\n\n    decrypt(input, output) {\n      return processBlocks(input, output, subkeys, false, 'DES');\n    },\n  };\n}\n\nfunction processBlocks(\n  input: Uint8Array,\n  output: Uint8Array,\n  subkeys: readonly number[],\n  encrypting: boolean,\n  name: string,\n): Uint8Array {\n  assertBlocks(input, output, name);\n  const tmp = [0, 0];\n  for (let offset = 0; offset < input.length; offset += 8) {\n    processBlock(input, offset, output, offset, subkeys, tmp, encrypting);\n  }\n  return output;\n}\n\nfunction createSubkeys(key: Uint8Array): number[] {\n  const subkeys = new Array<number>(32);\n  let keyLeft = readUint32BE(key, 0);\n  let keyRight = readUint32BE(key, 4);\n  const tmp = [0, 0];\n\n  permutedChoice1(keyLeft, keyRight, tmp, 0);\n  keyLeft = tmp[0];\n  keyRight = tmp[1];\n\n  for (let index = 0; index < subkeys.length; index += 2) {\n    const shift = KEY_SHIFTS[index >>> 1];\n    keyLeft = rotateLeft28(keyLeft, shift);\n    keyRight = rotateLeft28(keyRight, shift);\n    permutedChoice2(keyLeft, keyRight, subkeys, index);\n  }\n\n  return subkeys;\n}\n\nfunction processBlock(\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n  subkeys: readonly number[],\n  tmp: number[],\n  encrypting: boolean,\n): void {\n  let left = readUint32BE(input, inputOffset);\n  let right = readUint32BE(input, inputOffset + 4);\n\n  initialPermutation(left, right, tmp, 0);\n  left = tmp[0];\n  right = tmp[1];\n\n  if (encrypting) {\n    for (let index = 0; index < subkeys.length; index += 2) {\n      const nextLeft = right;\n      right = (left ^ feistel(right, subkeys[index], subkeys[index + 1], tmp)) >>> 0;\n      left = nextLeft;\n    }\n    reverseInitialPermutation(right, left, tmp, 0);\n  } else {\n    const originalLeft = left;\n    left = right;\n    right = originalLeft;\n    for (let index = subkeys.length - 2; index >= 0; index -= 2) {\n      const nextLeft = left;\n      left = (right ^ feistel(left, subkeys[index], subkeys[index + 1], tmp)) >>> 0;\n      right = nextLeft;\n    }\n    reverseInitialPermutation(left, right, tmp, 0);\n  }\n\n  writeUint32BE(output, tmp[0], outputOffset);\n  writeUint32BE(output, tmp[1], outputOffset + 4);\n}\n\nfunction feistel(right: number, keyLeft: number, keyRight: number, tmp: number[]): number {\n  expand(right, tmp, 0);\n  return permute(substitute((keyLeft ^ tmp[0]) >>> 0, (keyRight ^ tmp[1]) >>> 0));\n}\n\nfunction readUint32BE(bytes: Uint8Array, offset: number): number {\n  return (\n    (bytes[offset] << 24)\n    | (bytes[offset + 1] << 16)\n    | (bytes[offset + 2] << 8)\n    | bytes[offset + 3]\n  ) >>> 0;\n}\n\nfunction writeUint32BE(bytes: Uint8Array, value: number, offset: number): void {\n  bytes[offset] = value >>> 24;\n  bytes[offset + 1] = value >>> 16;\n  bytes[offset + 2] = value >>> 8;\n  bytes[offset + 3] = value;\n}\n\n// Word-based DES helpers adapted from des.js (MIT, Fedor Indutny).\nfunction initialPermutation(inputLeft: number, inputRight: number, output: number[], offset: number): void {\n  let outputLeft = 0;\n  let outputRight = 0;\n\n  for (let bit = 6; bit >= 0; bit -= 2) {\n    for (let shift = 0; shift <= 24; shift += 8) {\n      outputLeft = (outputLeft << 1) | ((inputRight >>> (shift + bit)) & 1);\n    }\n    for (let shift = 0; shift <= 24; shift += 8) {\n      outputLeft = (outputLeft << 1) | ((inputLeft >>> (shift + bit)) & 1);\n    }\n  }\n\n  for (let bit = 6; bit >= 0; bit -= 2) {\n    for (let shift = 1; shift <= 25; shift += 8) {\n      outputRight = (outputRight << 1) | ((inputRight >>> (shift + bit)) & 1);\n    }\n    for (let shift = 1; shift <= 25; shift += 8) {\n      outputRight = (outputRight << 1) | ((inputLeft >>> (shift + bit)) & 1);\n    }\n  }\n\n  output[offset] = outputLeft >>> 0;\n  output[offset + 1] = outputRight >>> 0;\n}\n\nfunction reverseInitialPermutation(inputLeft: number, inputRight: number, output: number[], offset: number): void {\n  let outputLeft = 0;\n  let outputRight = 0;\n\n  for (let bit = 0; bit < 4; bit++) {\n    for (let shift = 24; shift >= 0; shift -= 8) {\n      outputLeft = (outputLeft << 1) | ((inputRight >>> (shift + bit)) & 1);\n      outputLeft = (outputLeft << 1) | ((inputLeft >>> (shift + bit)) & 1);\n    }\n  }\n\n  for (let bit = 4; bit < 8; bit++) {\n    for (let shift = 24; shift >= 0; shift -= 8) {\n      outputRight = (outputRight << 1) | ((inputRight >>> (shift + bit)) & 1);\n      outputRight = (outputRight << 1) | ((inputLeft >>> (shift + bit)) & 1);\n    }\n  }\n\n  output[offset] = outputLeft >>> 0;\n  output[offset + 1] = outputRight >>> 0;\n}\n\nfunction permutedChoice1(inputLeft: number, inputRight: number, output: number[], offset: number): void {\n  let outputLeft = 0;\n  let outputRight = 0;\n  let bit = 0;\n\n  for (bit = 7; bit >= 5; bit--) {\n    for (let shift = 0; shift <= 24; shift += 8) {\n      outputLeft = (outputLeft << 1) | ((inputRight >> (shift + bit)) & 1);\n    }\n    for (let shift = 0; shift <= 24; shift += 8) {\n      outputLeft = (outputLeft << 1) | ((inputLeft >> (shift + bit)) & 1);\n    }\n  }\n  for (let shift = 0; shift <= 24; shift += 8) {\n    outputLeft = (outputLeft << 1) | ((inputRight >> (shift + bit)) & 1);\n  }\n\n  for (bit = 1; bit <= 3; bit++) {\n    for (let shift = 0; shift <= 24; shift += 8) {\n      outputRight = (outputRight << 1) | ((inputRight >> (shift + bit)) & 1);\n    }\n    for (let shift = 0; shift <= 24; shift += 8) {\n      outputRight = (outputRight << 1) | ((inputLeft >> (shift + bit)) & 1);\n    }\n  }\n  for (let shift = 0; shift <= 24; shift += 8) {\n    outputRight = (outputRight << 1) | ((inputLeft >> (shift + bit)) & 1);\n  }\n\n  output[offset] = outputLeft >>> 0;\n  output[offset + 1] = outputRight >>> 0;\n}\n\nfunction rotateLeft28(value: number, shift: number): number {\n  return ((value << shift) & 0xfffffff) | (value >>> (28 - shift));\n}\n\nconst PERMUTED_CHOICE2_TABLE = [\n  14, 11, 17, 4, 27, 23, 25, 0,\n  13, 22, 7, 18, 5, 9, 16, 24,\n  2, 20, 12, 21, 1, 8, 15, 26,\n  15, 4, 25, 19, 9, 1, 26, 16,\n  5, 11, 23, 8, 12, 7, 17, 0,\n  22, 3, 10, 14, 6, 20, 27, 24,\n];\n\nfunction permutedChoice2(inputLeft: number, inputRight: number, output: number[], offset: number): void {\n  let outputLeft = 0;\n  let outputRight = 0;\n  const halfLength = PERMUTED_CHOICE2_TABLE.length >>> 1;\n\n  for (let index = 0; index < halfLength; index++) {\n    outputLeft = (outputLeft << 1) | ((inputLeft >>> PERMUTED_CHOICE2_TABLE[index]) & 1);\n  }\n  for (let index = halfLength; index < PERMUTED_CHOICE2_TABLE.length; index++) {\n    outputRight = (outputRight << 1) | ((inputRight >>> PERMUTED_CHOICE2_TABLE[index]) & 1);\n  }\n\n  output[offset] = outputLeft >>> 0;\n  output[offset + 1] = outputRight >>> 0;\n}\n\nfunction expand(right: number, output: number[], offset: number): void {\n  let outputLeft = ((right & 1) << 5) | (right >>> 27);\n  let outputRight = 0;\n\n  for (let bit = 23; bit >= 15; bit -= 4) {\n    outputLeft = (outputLeft << 6) | ((right >>> bit) & 0x3f);\n  }\n  for (let bit = 11; bit >= 3; bit -= 4) {\n    outputRight |= (right >>> bit) & 0x3f;\n    outputRight <<= 6;\n  }\n  outputRight |= ((right & 0x1f) << 1) | (right >>> 31);\n\n  output[offset] = outputLeft >>> 0;\n  output[offset + 1] = outputRight >>> 0;\n}\n\nfunction substitute(inputLeft: number, inputRight: number): number {\n  let output = 0;\n  for (let index = 0; index < 4; index++) {\n    output = (output << 4) | S_TABLE[index * 0x40 + ((inputLeft >>> (18 - index * 6)) & 0x3f)];\n  }\n  for (let index = 0; index < 4; index++) {\n    output = (output << 4) | S_TABLE[4 * 0x40 + index * 0x40 + ((inputRight >>> (18 - index * 6)) & 0x3f)];\n  }\n  return output >>> 0;\n}\n\nconst PERMUTE_TABLE = [\n  16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22,\n  30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7,\n];\n\nfunction permute(value: number): number {\n  let output = 0;\n  for (const bit of PERMUTE_TABLE) {\n    output = (output << 1) | ((value >>> bit) & 1);\n  }\n  return output >>> 0;\n}\n\nconst KEY_SHIFTS = [\n  1, 1, 2, 2, 2, 2, 2, 2,\n  1, 2, 2, 2, 2, 2, 2, 1,\n];\n\nconst S_TABLE = [\n  14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1,\n  3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8,\n  4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7,\n  15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13,\n  15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14,\n  9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5,\n  0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2,\n  5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9,\n  10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10,\n  1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1,\n  13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7,\n  11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12,\n  7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3,\n  1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9,\n  10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8,\n  15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14,\n  2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1,\n  8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6,\n  4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13,\n  15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3,\n  12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5,\n  0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8,\n  9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10,\n  7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13,\n  4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10,\n  3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6,\n  1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7,\n  10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12,\n  13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4,\n  10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2,\n  7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13,\n  0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11,\n];\n\nfunction assertBlocks(input: Uint8Array, output: Uint8Array, name: string): void {\n  if (input.length % 8 !== 0) {\n    throw new Error(`${name} input length must be a multiple of 64 bits.`);\n  }\n  if (output.length !== input.length) {\n    throw new Error(`${name} output length must equal input length.`);\n  }\n}\n","import type { PresetComponent, StreamCipherComponent, Transform } from '@jscrypto/core';\n\nexport interface Rc4Options {\n  readonly drop?: number;\n}\n\nexport const rc4: StreamCipherComponent<'RC4'> = {\n  kind: 'cipher',\n  name: 'RC4',\n  type: 'stream',\n  createEncryptor({ key, options }) {\n    return createRc4Transform(key, getDrop(options, 0));\n  },\n  createDecryptor({ key, options }) {\n    return createRc4Transform(key, getDrop(options, 0));\n  },\n};\n\nexport const rc4Drop: StreamCipherComponent<'RC4Drop'> = {\n  kind: 'cipher',\n  name: 'RC4Drop',\n  type: 'stream',\n  createEncryptor({ key, options }) {\n    return createRc4Transform(key, getDrop(options, 192));\n  },\n  createDecryptor({ key, options }) {\n    return createRc4Transform(key, getDrop(options, 192));\n  },\n};\n\nexport const rc4Preset: PresetComponent<'rc4'> = {\n  kind: 'preset',\n  name: 'rc4',\n  components() {\n    return [rc4, rc4Drop];\n  },\n};\n\nexport function createRc4Transform(key: Uint8Array, drop = 0): Transform {\n  assertKey(key);\n  assertDrop(drop);\n\n  const state = createInitialState(key);\n  for (let n = 0; n < drop; n++) {\n    nextByte(state);\n  }\n\n  let finalized = false;\n\n  const processInput = (input: Uint8Array): Uint8Array => {\n      const output = new Uint8Array(input.length);\n      for (let i = 0; i < input.length; i++) {\n        output[i] = input[i] ^ nextByte(state);\n      }\n      return output;\n  };\n\n  return {\n    process(input) {\n      assertNotFinalized(finalized);\n      return processInput(input);\n    },\n\n    finalize(input = new Uint8Array(0)) {\n      assertNotFinalized(finalized);\n      finalized = true;\n      return input.length === 0 ? new Uint8Array(0) : processInput(input);\n    },\n  };\n}\n\ninterface Rc4State {\n  readonly s: Uint8Array;\n  i: number;\n  j: number;\n}\n\nfunction createInitialState(key: Uint8Array): Rc4State {\n  const s = new Uint8Array(256);\n  for (let i = 0; i < s.length; i++) {\n    s[i] = i;\n  }\n\n  let j = 0;\n  for (let i = 0; i < s.length; i++) {\n    j = (j + s[i] + key[i % key.length]) & 0xff;\n    swap(s, i, j);\n  }\n\n  return { s, i: 0, j: 0 };\n}\n\nfunction nextByte(state: Rc4State): number {\n  const { s } = state;\n  state.i = (state.i + 1) & 0xff;\n  state.j = (state.j + s[state.i]) & 0xff;\n  swap(s, state.i, state.j);\n  return s[(s[state.i] + s[state.j]) & 0xff];\n}\n\nfunction swap(bytes: Uint8Array, a: number, b: number): void {\n  const value = bytes[a];\n  bytes[a] = bytes[b];\n  bytes[b] = value;\n}\n\nfunction getDrop(options: unknown, defaultDrop: number): number {\n  if (!isRc4Options(options) || options.drop === undefined) {\n    return defaultDrop;\n  }\n  return options.drop;\n}\n\nfunction isRc4Options(options: unknown): options is Rc4Options {\n  return typeof options === 'object' && options !== null;\n}\n\nfunction assertKey(key: Uint8Array): void {\n  if (key.length < 5) {\n    throw new Error('RC4 key should be greater or equal than 40 bits.');\n  }\n}\n\nfunction assertDrop(drop: number): void {\n  if (!Number.isInteger(drop) || drop < 0) {\n    throw new RangeError('RC4 drop must be a non-negative integer.');\n  }\n}\n\nfunction assertNotFinalized(finalized: boolean): void {\n  if (finalized) {\n    throw new Error('Transform is already finalized.');\n  }\n}\n","/*!\n * js-speck v0.1.0\n * Copyright 2026 Chen, Yi-Cyuan\n * Released under the MIT license\n */\n\n// src/bytes.ts\nvar HAS_TYPED_ARRAY = typeof ArrayBuffer !== \"undefined\" && typeof Uint8Array !== \"undefined\" && typeof Uint32Array !== \"undefined\";\nvar ByteArrayClass = HAS_TYPED_ARRAY ? Uint8Array : Array;\nvar WordArrayClass = HAS_TYPED_ARRAY ? Uint32Array : Array;\nvar INPUT_ERROR = \"input is invalid type\";\nvar isArray = !Array.isArray ? function(obj) {\n  return Object.prototype.toString.call(obj) === \"[object Array]\";\n} : Array.isArray;\nfunction toByteArray(input) {\n  const type = typeof input;\n  if (type !== \"object\" || input === null) {\n    throw new Error(INPUT_ERROR);\n  }\n  if (HAS_TYPED_ARRAY) {\n    if (input instanceof Uint8Array) {\n      return input;\n    }\n    if (input instanceof ArrayBuffer) {\n      return new Uint8Array(input);\n    }\n  }\n  if (!isArray(input)) {\n    throw new Error(INPUT_ERROR);\n  }\n  return input;\n}\nfunction assertByteLength(input, length, name) {\n  if (input.length !== length) {\n    throw new RangeError(`${name} must be ${length} bytes.`);\n  }\n}\nfunction toWordLE(bytes, wordBytes) {\n  var words = new WordArrayClass(bytes.length / wordBytes);\n  for (var i = 0; i < words.length; ++i) {\n    var offset = i * wordBytes;\n    var value = 0;\n    for (var j = 0; j < wordBytes; ++j) {\n      value += bytes[offset + j] * Math.pow(2, j * 8);\n    }\n    words[i] = value >>> 0;\n  }\n  return words;\n}\nfunction fromWordLE(words, wordBytes) {\n  var bytes = new ByteArrayClass(words.length * wordBytes);\n  for (var i = 0; i < words.length; ++i) {\n    var offset = i * wordBytes;\n    var value = words[i];\n    for (var j = 0; j < wordBytes; ++j) {\n      bytes[offset + j] = Math.floor(value / Math.pow(2, j * 8)) & 255;\n    }\n  }\n  return bytes;\n}\n\n// src/speck.ts\nfunction createMask(wordBits) {\n  return wordBits === 32 ? 4294967295 : (1 << wordBits) - 1;\n}\nfunction normalize(value, mask, wordBits) {\n  return wordBits === 32 ? value >>> 0 : value & mask;\n}\nfunction rotr(value, shift, wordBits, mask) {\n  return normalize(value >>> shift | value << wordBits - shift, mask, wordBits);\n}\nfunction rotl(value, shift, wordBits, mask) {\n  return normalize(value << shift | value >>> wordBits - shift, mask, wordBits);\n}\nfunction createSpeckVariant(config) {\n  const wordBytes = config.wordBits / 8;\n  const blockBytes = wordBytes * 2;\n  const keyByteLength = wordBytes * config.keyWords;\n  const mask = createMask(config.wordBits);\n  function round(x, y, key) {\n    x = normalize(rotr(x, config.alpha, config.wordBits, mask) + y, mask, config.wordBits);\n    x = normalize(x ^ key, mask, config.wordBits);\n    y = normalize(rotl(y, config.beta, config.wordBits, mask) ^ x, mask, config.wordBits);\n    return [x, y];\n  }\n  function inverseRound(x, y, key) {\n    y = rotr(normalize(y ^ x, mask, config.wordBits), config.beta, config.wordBits, mask);\n    x = rotl(normalize((x ^ key) - y, mask, config.wordBits), config.alpha, config.wordBits, mask);\n    return [x, y];\n  }\n  function assertBlockMultiple(bytes, name) {\n    if (bytes.length % blockBytes !== 0) {\n      throw new RangeError(`${name} length must be a multiple of ${blockBytes} bytes.`);\n    }\n  }\n  function assertWordLength(words, length, name) {\n    if (words.length !== length) {\n      throw new RangeError(`${name} must contain ${length} words.`);\n    }\n  }\n  function assertWordBlockMultiple(words, name) {\n    if (words.length % 2 !== 0) {\n      throw new RangeError(`${name} length must be a multiple of 2 words.`);\n    }\n  }\n  function assertRoundKeysAndDataWords(roundKeys, dataWords) {\n    if (roundKeys.length !== config.rounds) {\n      throw new RangeError(`Round keys must contain ${config.rounds} words.`);\n    }\n    assertWordBlockMultiple(dataWords, \"Data\");\n  }\n  function toWords(key, data) {\n    const keyBytes = toByteArray(key);\n    assertByteLength(keyBytes, keyByteLength, \"Key\");\n    const dataBytes = toByteArray(data);\n    assertBlockMultiple(dataBytes, \"Data\");\n    return [toWordLE(keyBytes, wordBytes), toWordLE(dataBytes, wordBytes)];\n  }\n  function expandKey11(keyWords) {\n    assertWordLength(keyWords, config.keyWords, \"Key\");\n    const l = new WordArrayClass(config.rounds + config.keyWords - 2);\n    const roundKeys = new WordArrayClass(config.rounds);\n    roundKeys[0] = keyWords[0];\n    for (let i = 1; i < config.keyWords; ++i) {\n      l[i - 1] = keyWords[i];\n    }\n    for (let i = 0; i < config.rounds - 1; ++i) {\n      const result = round(l[i], roundKeys[i], i);\n      l[i + config.keyWords - 1] = result[0];\n      roundKeys[i + 1] = result[1];\n    }\n    return roundKeys;\n  }\n  function encrypt11(key, data) {\n    const [keyWords, dataWords] = toWords(key, data);\n    return fromWordLE(encryptWords11(keyWords, dataWords), wordBytes);\n  }\n  function encryptWords11(keyWords, dataWords) {\n    return encryptWordsWithRoundKey11(expandKey11(keyWords), dataWords);\n  }\n  function encryptWordsWithRoundKey11(roundKeys, dataWords) {\n    assertRoundKeysAndDataWords(roundKeys, dataWords);\n    const result = new WordArrayClass(dataWords.length);\n    for (let i = 0; i < dataWords.length; i += 2) {\n      let y = dataWords[i];\n      let x = dataWords[i + 1];\n      for (let j = 0; j < config.rounds; ++j) {\n        const r = round(x, y, roundKeys[j]);\n        x = r[0];\n        y = r[1];\n      }\n      result[i] = y;\n      result[i + 1] = x;\n    }\n    return result;\n  }\n  function decrypt11(key, data) {\n    const [keyWords, dataWords] = toWords(key, data);\n    return fromWordLE(decryptWords11(keyWords, dataWords), wordBytes);\n  }\n  function decryptWords11(keyWords, dataWords) {\n    return decryptWordsWithRoundKey11(expandKey11(keyWords), dataWords);\n  }\n  function decryptWordsWithRoundKey11(roundKeys, dataWords) {\n    assertRoundKeysAndDataWords(roundKeys, dataWords);\n    const result = new WordArrayClass(dataWords.length);\n    for (let i = 0; i < dataWords.length; i += 2) {\n      let y = dataWords[i];\n      let x = dataWords[i + 1];\n      for (let j = config.rounds - 1; j >= 0; --j) {\n        const r = inverseRound(x, y, roundKeys[j]);\n        x = r[0];\n        y = r[1];\n      }\n      result[i] = y;\n      result[i + 1] = x;\n    }\n    return result;\n  }\n  return {\n    blockBytes,\n    keyBytes: keyByteLength,\n    rounds: config.rounds,\n    expandKey: expandKey11,\n    encrypt: encrypt11,\n    decrypt: decrypt11,\n    encryptWords: encryptWords11,\n    decryptWords: decryptWords11,\n    encryptWordsWithRoundKey: encryptWordsWithRoundKey11,\n    decryptWordsWithRoundKey: decryptWordsWithRoundKey11\n  };\n}\n\n// src/speck32-64.ts\nvar speck32_64Block = createSpeckVariant({\n  name: \"Speck32/64\",\n  wordBits: 16,\n  keyWords: 4,\n  rounds: 22,\n  alpha: 7,\n  beta: 2\n});\nvar {\n  expandKey,\n  encrypt,\n  decrypt,\n  encryptWords,\n  decryptWords,\n  encryptWordsWithRoundKey,\n  decryptWordsWithRoundKey\n} = speck32_64Block;\n\n// src/speck48-72.ts\nvar speck48_72Block = createSpeckVariant({\n  name: \"Speck48/72\",\n  wordBits: 24,\n  keyWords: 3,\n  rounds: 22,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey2,\n  encrypt: encrypt2,\n  decrypt: decrypt2,\n  encryptWords: encryptWords2,\n  decryptWords: decryptWords2,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey2,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey2\n} = speck48_72Block;\n\n// src/speck48-96.ts\nvar speck48_96Block = createSpeckVariant({\n  name: \"Speck48/96\",\n  wordBits: 24,\n  keyWords: 4,\n  rounds: 23,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey3,\n  encrypt: encrypt3,\n  decrypt: decrypt3,\n  encryptWords: encryptWords3,\n  decryptWords: decryptWords3,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey3,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey3\n} = speck48_96Block;\n\n// src/speck64-96.ts\nvar speck64_96Block = createSpeckVariant({\n  name: \"Speck64/96\",\n  wordBits: 32,\n  keyWords: 3,\n  rounds: 26,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey4,\n  encrypt: encrypt4,\n  decrypt: decrypt4,\n  encryptWords: encryptWords4,\n  decryptWords: decryptWords4,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey4,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey4\n} = speck64_96Block;\n\n// src/speck64-128.ts\nvar speck64_128Block = createSpeckVariant({\n  name: \"Speck64/128\",\n  wordBits: 32,\n  keyWords: 4,\n  rounds: 27,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey5,\n  encrypt: encrypt5,\n  decrypt: decrypt5,\n  encryptWords: encryptWords5,\n  decryptWords: decryptWords5,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey5,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey5\n} = speck64_128Block;\n\n// src/speck-long.ts\nfunction addLong(aLo, aHi, bLo, bHi, highMask) {\n  const lo = aLo + bLo >>> 0;\n  const hi = (aHi + bHi + (lo < aLo >>> 0 ? 1 : 0) & highMask) >>> 0;\n  return [lo, hi];\n}\nfunction subLong(aLo, aHi, bLo, bHi, highMask) {\n  const lo = aLo - bLo >>> 0;\n  const hi = (aHi - bHi - (aLo >>> 0 < bLo >>> 0 ? 1 : 0) & highMask) >>> 0;\n  return [lo, hi];\n}\nfunction rotlLong(lo, hi, shift, highBits, highMask) {\n  return [\n    (lo << shift | hi >>> highBits - shift) >>> 0,\n    ((hi << shift | lo >>> 32 - shift) & highMask) >>> 0\n  ];\n}\nfunction rotrLong(lo, hi, shift, highBits, highMask) {\n  const shiftMask = (1 << shift) - 1;\n  return [\n    (lo >>> shift | (hi & shiftMask) << 32 - shift) >>> 0,\n    ((hi >>> shift | (lo & shiftMask) << highBits - shift) & highMask) >>> 0\n  ];\n}\nfunction toLongWordPairsLE(bytes, wordBytes) {\n  const lanesPerWord = 2;\n  const words = new WordArrayClass(bytes.length / wordBytes * lanesPerWord);\n  for (let i = 0; i < words.length; i += lanesPerWord) {\n    const offset = i / lanesPerWord * wordBytes;\n    words[i] = (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;\n    let high = 0;\n    for (let j = 4; j < wordBytes; ++j) {\n      high |= bytes[offset + j] << (j - 4) * 8;\n    }\n    words[i + 1] = high >>> 0;\n  }\n  return words;\n}\nfunction fromLongWordPairsLE(words, wordBytes) {\n  const lanesPerWord = 2;\n  const bytes = new ByteArrayClass(words.length / lanesPerWord * wordBytes);\n  for (let i = 0; i < words.length; i += lanesPerWord) {\n    const lo = words[i];\n    const hi = words[i + 1];\n    const offset = i / lanesPerWord * wordBytes;\n    bytes[offset] = lo & 255;\n    bytes[offset + 1] = lo >>> 8 & 255;\n    bytes[offset + 2] = lo >>> 16 & 255;\n    bytes[offset + 3] = lo >>> 24 & 255;\n    for (let j = 4; j < wordBytes; ++j) {\n      bytes[offset + j] = hi >>> (j - 4) * 8 & 255;\n    }\n  }\n  return bytes;\n}\nfunction createSpeckLongVariant(config) {\n  const lanesPerWord = 2;\n  const wordBytes = config.wordBits / 8;\n  const highBits = config.wordBits - 32;\n  const highMask = config.wordBits === 64 ? 4294967295 : (1 << highBits) - 1;\n  const blockBytes = wordBytes * 2;\n  const keyByteLength = wordBytes * config.keyWords;\n  const keyLaneLength = config.keyWords * lanesPerWord;\n  const roundKeyLaneLength = config.rounds * lanesPerWord;\n  function round(xLo, xHi, yLo, yHi, keyLo, keyHi) {\n    let rotated = rotrLong(xLo, xHi, config.alpha, highBits, highMask);\n    rotated = addLong(rotated[0], rotated[1], yLo, yHi, highMask);\n    xLo = (rotated[0] ^ keyLo) >>> 0;\n    xHi = ((rotated[1] ^ keyHi) & highMask) >>> 0;\n    rotated = rotlLong(yLo, yHi, config.beta, highBits, highMask);\n    yLo = (rotated[0] ^ xLo) >>> 0;\n    yHi = ((rotated[1] ^ xHi) & highMask) >>> 0;\n    return [xLo, xHi, yLo, yHi];\n  }\n  function inverseRound(xLo, xHi, yLo, yHi, keyLo, keyHi) {\n    let rotated = rotrLong((yLo ^ xLo) >>> 0, ((yHi ^ xHi) & highMask) >>> 0, config.beta, highBits, highMask);\n    yLo = rotated[0];\n    yHi = rotated[1];\n    const subtracted = subLong((xLo ^ keyLo) >>> 0, ((xHi ^ keyHi) & highMask) >>> 0, yLo, yHi, highMask);\n    rotated = rotlLong(subtracted[0], subtracted[1], config.alpha, highBits, highMask);\n    xLo = rotated[0];\n    xHi = rotated[1];\n    return [xLo, xHi, yLo, yHi];\n  }\n  function assertBlockMultiple(bytes, name) {\n    if (bytes.length % blockBytes !== 0) {\n      throw new RangeError(`${name} length must be a multiple of ${blockBytes} bytes.`);\n    }\n  }\n  function assertLaneLength(words, length, name) {\n    if (words.length !== length) {\n      throw new RangeError(`${name} must contain ${length} 32-bit lanes.`);\n    }\n  }\n  function assertLaneBlockMultiple(words, name) {\n    if (words.length % 4 !== 0) {\n      throw new RangeError(`${name} length must be a multiple of 4 32-bit lanes.`);\n    }\n  }\n  function assertRoundKeysAndDataWords(roundKeys, dataWords) {\n    if (roundKeys.length !== roundKeyLaneLength) {\n      throw new RangeError(`Round keys must contain ${roundKeyLaneLength} 32-bit lanes.`);\n    }\n    assertLaneBlockMultiple(dataWords, \"Data\");\n  }\n  function toWords(key, data) {\n    const keyBytes = toByteArray(key);\n    assertByteLength(keyBytes, keyByteLength, \"Key\");\n    const dataBytes = toByteArray(data);\n    assertBlockMultiple(dataBytes, \"Data\");\n    return [toLongWordPairsLE(keyBytes, wordBytes), toLongWordPairsLE(dataBytes, wordBytes)];\n  }\n  function expandKey11(keyWords) {\n    assertLaneLength(keyWords, keyLaneLength, \"Key\");\n    const l = new WordArrayClass((config.rounds + config.keyWords - 2) * lanesPerWord);\n    const roundKeys = new WordArrayClass(roundKeyLaneLength);\n    roundKeys[0] = keyWords[0];\n    roundKeys[1] = keyWords[1];\n    for (let i = 1; i < config.keyWords; ++i) {\n      const target = (i - 1) * lanesPerWord;\n      const source = i * lanesPerWord;\n      l[target] = keyWords[source];\n      l[target + 1] = keyWords[source + 1];\n    }\n    for (let i = 0; i < config.rounds - 1; ++i) {\n      const lOffset = i * lanesPerWord;\n      const keyOffset = i * lanesPerWord;\n      const result = round(l[lOffset], l[lOffset + 1], roundKeys[keyOffset], roundKeys[keyOffset + 1], i, 0);\n      const nextLOffset = (i + config.keyWords - 1) * lanesPerWord;\n      const nextKeyOffset = (i + 1) * lanesPerWord;\n      l[nextLOffset] = result[0];\n      l[nextLOffset + 1] = result[1];\n      roundKeys[nextKeyOffset] = result[2];\n      roundKeys[nextKeyOffset + 1] = result[3];\n    }\n    return roundKeys;\n  }\n  function encrypt11(key, data) {\n    const [keyWords, dataWords] = toWords(key, data);\n    return fromLongWordPairsLE(encryptWords11(keyWords, dataWords), wordBytes);\n  }\n  function encryptWords11(keyWords, dataWords) {\n    return encryptWordsWithRoundKey11(expandKey11(keyWords), dataWords);\n  }\n  function encryptWordsWithRoundKey11(roundKeys, dataWords) {\n    assertRoundKeysAndDataWords(roundKeys, dataWords);\n    const result = new WordArrayClass(dataWords.length);\n    for (let i = 0; i < dataWords.length; i += 4) {\n      let yLo = dataWords[i];\n      let yHi = dataWords[i + 1];\n      let xLo = dataWords[i + 2];\n      let xHi = dataWords[i + 3];\n      for (let j = 0; j < config.rounds; ++j) {\n        const keyOffset = j * lanesPerWord;\n        const r = round(xLo, xHi, yLo, yHi, roundKeys[keyOffset], roundKeys[keyOffset + 1]);\n        xLo = r[0];\n        xHi = r[1];\n        yLo = r[2];\n        yHi = r[3];\n      }\n      result[i] = yLo;\n      result[i + 1] = yHi;\n      result[i + 2] = xLo;\n      result[i + 3] = xHi;\n    }\n    return result;\n  }\n  function decrypt11(key, data) {\n    const [keyWords, dataWords] = toWords(key, data);\n    return fromLongWordPairsLE(decryptWords11(keyWords, dataWords), wordBytes);\n  }\n  function decryptWords11(keyWords, dataWords) {\n    return decryptWordsWithRoundKey11(expandKey11(keyWords), dataWords);\n  }\n  function decryptWordsWithRoundKey11(roundKeys, dataWords) {\n    assertRoundKeysAndDataWords(roundKeys, dataWords);\n    const result = new WordArrayClass(dataWords.length);\n    for (let i = 0; i < dataWords.length; i += 4) {\n      let yLo = dataWords[i];\n      let yHi = dataWords[i + 1];\n      let xLo = dataWords[i + 2];\n      let xHi = dataWords[i + 3];\n      for (let j = config.rounds - 1; j >= 0; --j) {\n        const keyOffset = j * lanesPerWord;\n        const r = inverseRound(xLo, xHi, yLo, yHi, roundKeys[keyOffset], roundKeys[keyOffset + 1]);\n        xLo = r[0];\n        xHi = r[1];\n        yLo = r[2];\n        yHi = r[3];\n      }\n      result[i] = yLo;\n      result[i + 1] = yHi;\n      result[i + 2] = xLo;\n      result[i + 3] = xHi;\n    }\n    return result;\n  }\n  return {\n    blockBytes,\n    keyBytes: keyByteLength,\n    rounds: config.rounds,\n    expandKey: expandKey11,\n    encrypt: encrypt11,\n    decrypt: decrypt11,\n    encryptWords: encryptWords11,\n    decryptWords: decryptWords11,\n    encryptWordsWithRoundKey: encryptWordsWithRoundKey11,\n    decryptWordsWithRoundKey: decryptWordsWithRoundKey11\n  };\n}\n\n// src/speck96-96.ts\nvar speck96_96Block = createSpeckLongVariant({\n  wordBits: 48,\n  keyWords: 2,\n  rounds: 28,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey6,\n  encrypt: encrypt6,\n  decrypt: decrypt6,\n  encryptWords: encryptWords6,\n  decryptWords: decryptWords6,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey6,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey6\n} = speck96_96Block;\n\n// src/speck96-144.ts\nvar speck96_144Block = createSpeckLongVariant({\n  wordBits: 48,\n  keyWords: 3,\n  rounds: 29,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey7,\n  encrypt: encrypt7,\n  decrypt: decrypt7,\n  encryptWords: encryptWords7,\n  decryptWords: decryptWords7,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey7,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey7\n} = speck96_144Block;\n\n// src/speck128-128.ts\nvar speck128_128Block = createSpeckLongVariant({\n  wordBits: 64,\n  keyWords: 2,\n  rounds: 32,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey8,\n  encrypt: encrypt8,\n  decrypt: decrypt8,\n  encryptWords: encryptWords8,\n  decryptWords: decryptWords8,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey8,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey8\n} = speck128_128Block;\n\n// src/speck128-192.ts\nvar speck128_192Block = createSpeckLongVariant({\n  wordBits: 64,\n  keyWords: 3,\n  rounds: 33,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey9,\n  encrypt: encrypt9,\n  decrypt: decrypt9,\n  encryptWords: encryptWords9,\n  decryptWords: decryptWords9,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey9,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey9\n} = speck128_192Block;\n\n// src/speck128-256.ts\nvar speck128_256Block = createSpeckLongVariant({\n  wordBits: 64,\n  keyWords: 4,\n  rounds: 34,\n  alpha: 8,\n  beta: 3\n});\nvar {\n  expandKey: expandKey10,\n  encrypt: encrypt10,\n  decrypt: decrypt10,\n  encryptWords: encryptWords10,\n  decryptWords: decryptWords10,\n  encryptWordsWithRoundKey: encryptWordsWithRoundKey10,\n  decryptWordsWithRoundKey: decryptWordsWithRoundKey10\n} = speck128_256Block;\n\n// src/index.ts\nvar speck32_64 = speck32_64Block;\nvar speck48_72 = speck48_72Block;\nvar speck48_96 = speck48_96Block;\nvar speck64_96 = speck64_96Block;\nvar speck64_128 = speck64_128Block;\nvar speck96_96 = speck96_96Block;\nvar speck96_144 = speck96_144Block;\nvar speck128_128 = speck128_128Block;\nvar speck128_192 = speck128_192Block;\nvar speck128_256 = speck128_256Block;\nexport {\n  decrypt8 as decryptSpeck128_128,\n  decryptWords8 as decryptSpeck128_128Words,\n  decryptWordsWithRoundKey8 as decryptSpeck128_128WordsWithRoundKey,\n  decrypt9 as decryptSpeck128_192,\n  decryptWords9 as decryptSpeck128_192Words,\n  decryptWordsWithRoundKey9 as decryptSpeck128_192WordsWithRoundKey,\n  decrypt10 as decryptSpeck128_256,\n  decryptWords10 as decryptSpeck128_256Words,\n  decryptWordsWithRoundKey10 as decryptSpeck128_256WordsWithRoundKey,\n  decrypt as decryptSpeck32_64,\n  decryptWords as decryptSpeck32_64Words,\n  decryptWordsWithRoundKey as decryptSpeck32_64WordsWithRoundKey,\n  decrypt2 as decryptSpeck48_72,\n  decryptWords2 as decryptSpeck48_72Words,\n  decryptWordsWithRoundKey2 as decryptSpeck48_72WordsWithRoundKey,\n  decrypt3 as decryptSpeck48_96,\n  decryptWords3 as decryptSpeck48_96Words,\n  decryptWordsWithRoundKey3 as decryptSpeck48_96WordsWithRoundKey,\n  decrypt5 as decryptSpeck64_128,\n  decryptWords5 as decryptSpeck64_128Words,\n  decryptWordsWithRoundKey5 as decryptSpeck64_128WordsWithRoundKey,\n  decrypt4 as decryptSpeck64_96,\n  decryptWords4 as decryptSpeck64_96Words,\n  decryptWordsWithRoundKey4 as decryptSpeck64_96WordsWithRoundKey,\n  decrypt7 as decryptSpeck96_144,\n  decryptWords7 as decryptSpeck96_144Words,\n  decryptWordsWithRoundKey7 as decryptSpeck96_144WordsWithRoundKey,\n  decrypt6 as decryptSpeck96_96,\n  decryptWords6 as decryptSpeck96_96Words,\n  decryptWordsWithRoundKey6 as decryptSpeck96_96WordsWithRoundKey,\n  encrypt8 as encryptSpeck128_128,\n  encryptWords8 as encryptSpeck128_128Words,\n  encryptWordsWithRoundKey8 as encryptSpeck128_128WordsWithRoundKey,\n  encrypt9 as encryptSpeck128_192,\n  encryptWords9 as encryptSpeck128_192Words,\n  encryptWordsWithRoundKey9 as encryptSpeck128_192WordsWithRoundKey,\n  encrypt10 as encryptSpeck128_256,\n  encryptWords10 as encryptSpeck128_256Words,\n  encryptWordsWithRoundKey10 as encryptSpeck128_256WordsWithRoundKey,\n  encrypt as encryptSpeck32_64,\n  encryptWords as encryptSpeck32_64Words,\n  encryptWordsWithRoundKey as encryptSpeck32_64WordsWithRoundKey,\n  encrypt2 as encryptSpeck48_72,\n  encryptWords2 as encryptSpeck48_72Words,\n  encryptWordsWithRoundKey2 as encryptSpeck48_72WordsWithRoundKey,\n  encrypt3 as encryptSpeck48_96,\n  encryptWords3 as encryptSpeck48_96Words,\n  encryptWordsWithRoundKey3 as encryptSpeck48_96WordsWithRoundKey,\n  encrypt5 as encryptSpeck64_128,\n  encryptWords5 as encryptSpeck64_128Words,\n  encryptWordsWithRoundKey5 as encryptSpeck64_128WordsWithRoundKey,\n  encrypt4 as encryptSpeck64_96,\n  encryptWords4 as encryptSpeck64_96Words,\n  encryptWordsWithRoundKey4 as encryptSpeck64_96WordsWithRoundKey,\n  encrypt7 as encryptSpeck96_144,\n  encryptWords7 as encryptSpeck96_144Words,\n  encryptWordsWithRoundKey7 as encryptSpeck96_144WordsWithRoundKey,\n  encrypt6 as encryptSpeck96_96,\n  encryptWords6 as encryptSpeck96_96Words,\n  encryptWordsWithRoundKey6 as encryptSpeck96_96WordsWithRoundKey,\n  expandKey8 as expandSpeck128_128Key,\n  expandKey9 as expandSpeck128_192Key,\n  expandKey10 as expandSpeck128_256Key,\n  expandKey as expandSpeck32_64Key,\n  expandKey2 as expandSpeck48_72Key,\n  expandKey3 as expandSpeck48_96Key,\n  expandKey5 as expandSpeck64_128Key,\n  expandKey4 as expandSpeck64_96Key,\n  expandKey7 as expandSpeck96_144Key,\n  expandKey6 as expandSpeck96_96Key,\n  speck128_128,\n  speck128_192,\n  speck128_256,\n  speck32_64,\n  speck48_72,\n  speck48_96,\n  speck64_128,\n  speck64_96,\n  speck96_144,\n  speck96_96\n};\n//# sourceMappingURL=index.mjs.map\n","import type { BlockCipher, CipherComponent, PresetComponent } from '@jscrypto/core';\nimport {\n  speck128_128 as speck128_128Impl,\n  speck128_192 as speck128_192Impl,\n  speck128_256 as speck128_256Impl,\n  speck32_64 as speck32_64Impl,\n  speck48_72 as speck48_72Impl,\n  speck48_96 as speck48_96Impl,\n  speck64_96 as speck64_96Impl,\n  speck64_128 as speck64_128Impl,\n  speck96_96 as speck96_96Impl,\n  speck96_144 as speck96_144Impl,\n} from 'js-speck';\n\nexport type SpeckVariantName =\n  | '32-64'\n  | '48-72'\n  | '48-96'\n  | '64-96'\n  | '64-128'\n  | '96-96'\n  | '96-144'\n  | '128-128'\n  | '128-192'\n  | '128-256';\n\ntype SpeckImpl = {\n  readonly blockBytes: number;\n  readonly keyBytes: number;\n  encrypt(key: Uint8Array, data: Uint8Array): ArrayLike<number>;\n  decrypt(key: Uint8Array, data: Uint8Array): ArrayLike<number>;\n};\n\nconst variants: Record<SpeckVariantName, SpeckImpl> = {\n  '32-64': speck32_64Impl,\n  '48-72': speck48_72Impl,\n  '48-96': speck48_96Impl,\n  '64-96': speck64_96Impl,\n  '64-128': speck64_128Impl,\n  '96-96': speck96_96Impl,\n  '96-144': speck96_144Impl,\n  '128-128': speck128_128Impl,\n  '128-192': speck128_192Impl,\n  '128-256': speck128_256Impl,\n};\n\nexport function createSpeckCipher(variant: SpeckVariantName, key: Uint8Array): BlockCipher {\n  if (!variant) {\n    throw new Error('SPECK variant is required.');\n  }\n\n  const impl = variants[variant];\n  if (!impl) {\n    throw new Error(`Unknown SPECK variant: ${String(variant)}.`);\n  }\n\n  if (key.length !== impl.keyBytes) {\n    throw new Error(`SPECK ${variant} key must be ${impl.keyBytes * 8} bits.`);\n  }\n\n  const blockSize = impl.blockBytes;\n\n  return {\n    blockSize,\n\n    encryptBlock(input, inputOffset, output, outputOffset) {\n      transformBlock(impl, key, input, inputOffset, output, outputOffset, true);\n    },\n\n    decryptBlock(input, inputOffset, output, outputOffset) {\n      transformBlock(impl, key, input, inputOffset, output, outputOffset, false);\n    },\n\n    encrypt(input, output) {\n      return transformBlocks(impl, key, input, output, true);\n    },\n\n    decrypt(input, output) {\n      return transformBlocks(impl, key, input, output, false);\n    },\n  };\n}\n\nfunction createComponent<Name extends string>(\n  name: Name,\n  variant: SpeckVariantName,\n): CipherComponent<Name> {\n  const impl = variants[variant];\n  return {\n    kind: 'cipher',\n    name,\n    type: 'block',\n    blockSize: impl.blockBytes,\n    keySizes: [impl.keyBytes],\n    create(key) {\n      return createSpeckCipher(variant, key);\n    },\n  };\n}\n\nexport const speck32_64 = createComponent('SPECK32/64', '32-64');\nexport const speck48_72 = createComponent('SPECK48/72', '48-72');\nexport const speck48_96 = createComponent('SPECK48/96', '48-96');\nexport const speck64_96 = createComponent('SPECK64/96', '64-96');\nexport const speck64_128 = createComponent('SPECK64/128', '64-128');\nexport const speck96_96 = createComponent('SPECK96/96', '96-96');\nexport const speck96_144 = createComponent('SPECK96/144', '96-144');\nexport const speck128_128 = createComponent('SPECK128/128', '128-128');\nexport const speck128_192 = createComponent('SPECK128/192', '128-192');\nexport const speck128_256 = createComponent('SPECK128/256', '128-256');\n\nexport const allSpeckComponents: readonly CipherComponent[] = [\n  speck32_64,\n  speck48_72,\n  speck48_96,\n  speck64_96,\n  speck64_128,\n  speck96_96,\n  speck96_144,\n  speck128_128,\n  speck128_192,\n  speck128_256,\n];\n\nexport const speckPreset: PresetComponent<'speck'> = {\n  kind: 'preset',\n  name: 'speck',\n  components() {\n    return allSpeckComponents;\n  },\n};\n\nfunction transformBlocks(\n  impl: SpeckImpl,\n  key: Uint8Array,\n  input: Uint8Array,\n  output: Uint8Array,\n  encrypting: boolean,\n): Uint8Array {\n  assertBlocks(input, output, impl.blockBytes);\n  for (let offset = 0; offset < input.length; offset += impl.blockBytes) {\n    transformBlock(impl, key, input, offset, output, offset, encrypting);\n  }\n  return output;\n}\n\nfunction transformBlock(\n  impl: SpeckImpl,\n  key: Uint8Array,\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n  encrypting: boolean,\n): void {\n  const block = input.subarray(inputOffset, inputOffset + impl.blockBytes);\n  if (block.length !== impl.blockBytes) {\n    throw new Error(`SPECK block must be ${impl.blockBytes * 8} bits.`);\n  }\n  const transformed = encrypting ? impl.encrypt(key, block) : impl.decrypt(key, block);\n  output.set(transformed, outputOffset);\n}\n\nfunction assertBlocks(input: Uint8Array, output: Uint8Array, blockSize: number): void {\n  if (input.length % blockSize !== 0) {\n    throw new Error(`SPECK input length must be a multiple of ${blockSize * 8} bits.`);\n  }\n  if (output.length !== input.length) {\n    throw new Error('SPECK output length must equal input length.');\n  }\n}\n","import type { BlockCipher } from '@jscrypto/core';\n\nexport function encryptWithBlockOffset(\n  cipher: BlockCipher,\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n): void {\n  if (cipher.encryptBlock) {\n    cipher.encryptBlock(input, inputOffset, output, outputOffset);\n    return;\n  }\n\n  cipher.encrypt(\n    input.subarray(inputOffset, inputOffset + cipher.blockSize),\n    output.subarray(outputOffset, outputOffset + cipher.blockSize),\n  );\n}\n\nexport function decryptWithBlockOffset(\n  cipher: BlockCipher,\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n): void {\n  if (cipher.decryptBlock) {\n    cipher.decryptBlock(input, inputOffset, output, outputOffset);\n    return;\n  }\n\n  cipher.decrypt(\n    input.subarray(inputOffset, inputOffset + cipher.blockSize),\n    output.subarray(outputOffset, outputOffset + cipher.blockSize),\n  );\n}\n","import type { BlockCipher, CipherComponent, PresetComponent } from '@jscrypto/core';\nimport { decryptWithBlockOffset, encryptWithBlockOffset } from './block-offset.js';\nimport { createDesCipher } from './des.js';\n\nexport const tripleDes: CipherComponent<'TripleDES'> = {\n  kind: 'cipher',\n  name: 'TripleDES',\n  type: 'block',\n  blockSize: 8,\n  keySizes: [16, 24],\n  create(key) {\n    return createTripleDesCipher(key);\n  },\n};\n\nexport const tripleDesPreset: PresetComponent<'triple-des'> = {\n  kind: 'preset',\n  name: 'triple-des',\n  components() {\n    return [tripleDes];\n  },\n};\n\nexport function createTripleDesCipher(key: Uint8Array): BlockCipher {\n  if (key.length !== 16 && key.length !== 24) {\n    throw new Error('Triple DES key must be 128 or 192 bits.');\n  }\n\n  const first = createDesCipher(key.subarray(0, 8));\n  const second = createDesCipher(key.subarray(8, 16));\n  const third = createDesCipher(key.length === 24 ? key.subarray(16, 24) : key.subarray(0, 8));\n  const firstOutput = new Uint8Array(8);\n  const secondOutput = new Uint8Array(8);\n\n  return {\n    blockSize: 8,\n\n    encryptBlock(input, inputOffset, output, outputOffset) {\n      encryptTripleBlockAt(input, inputOffset, output, outputOffset, first, second, third, firstOutput, secondOutput);\n    },\n\n    decryptBlock(input, inputOffset, output, outputOffset) {\n      decryptTripleBlockAt(input, inputOffset, output, outputOffset, first, second, third, firstOutput, secondOutput);\n    },\n\n    encrypt(input, output) {\n      assertBlocks(input, output);\n      for (let offset = 0; offset < input.length; offset += 8) {\n        encryptTripleBlockAt(input, offset, output, offset, first, second, third, firstOutput, secondOutput);\n      }\n      return output;\n    },\n\n    decrypt(input, output) {\n      assertBlocks(input, output);\n      for (let offset = 0; offset < input.length; offset += 8) {\n        decryptTripleBlockAt(input, offset, output, offset, first, second, third, firstOutput, secondOutput);\n      }\n      return output;\n    },\n  };\n}\n\nfunction encryptTripleBlockAt(\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n  first: BlockCipher,\n  second: BlockCipher,\n  third: BlockCipher,\n  firstOutput: Uint8Array,\n  secondOutput: Uint8Array,\n): void {\n  encryptWithBlockOffset(first, input, inputOffset, firstOutput, 0);\n  decryptWithBlockOffset(second, firstOutput, 0, secondOutput, 0);\n  encryptWithBlockOffset(third, secondOutput, 0, output, outputOffset);\n}\n\nfunction decryptTripleBlockAt(\n  input: Uint8Array,\n  inputOffset: number,\n  output: Uint8Array,\n  outputOffset: number,\n  first: BlockCipher,\n  second: BlockCipher,\n  third: BlockCipher,\n  thirdOutput: Uint8Array,\n  secondOutput: Uint8Array,\n): void {\n  decryptWithBlockOffset(third, input, inputOffset, thirdOutput, 0);\n  encryptWithBlockOffset(second, thirdOutput, 0, secondOutput, 0);\n  decryptWithBlockOffset(first, secondOutput, 0, output, outputOffset);\n}\n\nfunction assertBlocks(input: Uint8Array, output: Uint8Array): void {\n  if (input.length % 8 !== 0) {\n    throw new Error('Triple DES input length must be a multiple of 64 bits.');\n  }\n  if (output.length !== input.length) {\n    throw new Error('Triple DES output length must equal input length.');\n  }\n}\n","import type { PresetComponent } from '@jscrypto/core';\nimport { aesPreset } from './aes.js';\nimport { chacha20Preset } from './chacha20.js';\nimport { desPreset } from './des.js';\nimport { rc4Preset } from './rc4.js';\nimport { speckPreset } from './speck.js';\nimport { tripleDesPreset } from './triple-des.js';\n\nexport function classicCiphersPreset(): PresetComponent<'classic-ciphers'> {\n  return {\n    kind: 'preset',\n    name: 'classic-ciphers',\n    components() {\n      return [aesPreset, desPreset, rc4Preset, tripleDesPreset];\n    },\n  };\n}\n\nexport function ciphersPreset(): PresetComponent<'ciphers'> {\n  return {\n    kind: 'preset',\n    name: 'ciphers',\n    components() {\n      return [classicCiphersPreset(), speckPreset, chacha20Preset];\n    },\n  };\n}\n"],"names":["BLOCK_SIZE","encrypt","decrypt","encryptBlock","KEY_SIZES","TAG_SIZES","DEFAULT_TAG_LENGTH","concatBytes","assertBytes","requireNonce","resolveAad","resolveTagLength","assertNotFinalized","collectPending","resolveOptionalTag","computeTag","equalBytes","nobleAesUnsafe","transformBlock","assertBlocks","transformBlocks","rotl","MAX_COUNTER","chacha20","xchacha20","assertKey","nobleChaCha20","nobleXChaCha20","nobleChaCha20Poly1305","nobleXChaCha20Poly1305","speck32_64","speck48_72","speck48_96","speck64_96","speck64_128","speck96_96","speck96_144","speck128_128","speck128_192","speck128_256","speck32_64Impl","speck48_72Impl","speck48_96Impl","speck64_96Impl","speck64_128Impl","speck96_96Impl","speck96_144Impl","speck128_128Impl","speck128_192Impl","speck128_256Impl"],"mappings":"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E,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE;AACtC,IAAI,IAAI,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtX,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE;AACpC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC;AACjC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;AAC7B,QAAQ,GAAG,GAAGA,MAAI,CAAC,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;AAChC,IAAI;AACJ;AACA,IAAI,IAAI,EAAE,GAAG,CAAC;AACd,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG;AACnB,IAAI,UAAU,CAAC,GAAG,CAAC;AACnB;AA4BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,UAAQ,mBAAmB,YAAY,CAAC,UAAU,EAAE;AACjE,IAAI,YAAY,EAAE,KAAK;AACvB,IAAI,aAAa,EAAE,CAAC;AACpB,IAAI,cAAc,EAAE,KAAK;AACzB,CAAC,CAAC;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,WAAS,mBAAmB,YAAY,CAAC,UAAU,EAAE;AAClE,IAAI,YAAY,EAAE,KAAK;AACvB,IAAI,aAAa,EAAE,CAAC;AACpB,IAAI,aAAa,EAAE,OAAO;AAC1B,IAAI,cAAc,EAAE,KAAK;AACzB,CAAC,CAAC;AAmDF;AACA,MAAM,OAAO,mBAAmB,IAAI,UAAU,CAAC,EAAE,CAAC;AAClD;AACA,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,GAAG,KAAK;AACjC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;AACjB,IAAI,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,GAAG,EAAE;AACpC,IAAI,IAAI,QAAQ;AAChB,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAC5C,CAAC;AACD;AACA;AACA,MAAM,OAAO,mBAAmB,IAAI,UAAU,CAAC,EAAE,CAAC;AAClD,SAAS,UAAU,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE;AACrD,IAAI,IAAI,GAAG,KAAK,SAAS;AACzB,QAAQ,MAAM,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC;AACrC;AACA;AACA,IAAI,MAAM,OAAO,GAAG,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC;AAC3C,IAAI,MAAM,OAAO,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,CAAC;AAC7E;AACA;AACA,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;AACtC,IAAI,IAAI,GAAG;AACX,QAAQ,YAAY,CAAC,CAAC,EAAE,GAAG,CAAC;AAC5B,IAAI,YAAY,CAAC,CAAC,EAAE,UAAU,CAAC;AAC/B,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;AACrB,IAAI,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,EAAE;AAC1B,IAAI,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC;AAC3B,IAAI,OAAO,GAAG;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,cAAc,GAAG,CAAC,SAAS,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,KAAK;AAClE;AACA;AACA,IAAI,MAAM,SAAS,GAAG,EAAE;AACxB,IAAI,OAAO;AACX,QAAQ,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE;AACnC,YAAY,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM;AAC5C,YAAY,MAAM,GAAG,SAAS,CAAC,OAAO,GAAG,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC;AAClE,YAAY,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;AACjC,YAAY,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC;AACzD;AACA,YAAY,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;AACpD,YAAY,MAAM,GAAG,GAAG,UAAU,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC;AACtE,YAAY,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AACrC,YAAY,KAAK,CAAC,GAAG,CAAC;AACtB,YAAY,OAAO,MAAM;AACzB,QAAQ,CAAC;AACT,QAAQ,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE;AACpC,YAAY,MAAM,GAAG,SAAS,CAAC,UAAU,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC;AAC5E,YAAY,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC;AAC3D,YAAY,MAAM,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC;AAC7D,YAAY,MAAM,GAAG,GAAG,UAAU,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC;AACpE;AACA;AACA,YAAY,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,EAAE;AAC7C,gBAAgB,KAAK,CAAC,GAAG,CAAC;AAC1B,gBAAgB,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC;AAC9C,YAAY;AACZ,YAAY,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AAC1D;AACA,YAAY,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;AACrD,YAAY,KAAK,CAAC,GAAG,CAAC;AACtB,YAAY,OAAO,MAAM;AACzB,QAAQ,CAAC;AACT,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,gBAAgB,mBAAmB,UAAU,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE;AAC5G,gBAAgB,cAAc,CAACD,UAAQ,CAAC,CAAC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM,iBAAiB,mBAAmB,UAAU,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE;AAC7G,gBAAgB,cAAc,CAACC,WAAS,CAAC,CAAC;;ACngB1C,MAAM,SAAS,GAAG,EAAE;AACpB,MAAM,oBAAoB,GAAG,EAAE;AAC/B,MAAM,qBAAqB,GAAG,EAAE;AAChC,MAAM,SAAS,GAAG,EAAE;AACpB,MAAM,kBAAkB,GAAG,EAAE;AAC7B,MAAM,WAAW,GAAG,UAAU,CAAC;AAExB,MAAM,QAAQ,GAAsC;AACzD,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,IAAI,EAAE,UAAU;AAChB,IAAA,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,SAAS,CAAC;AACrB,IAAA,eAAe,CAAC,MAAM,EAAA;AACpB,QAAA,OAAO,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC;IAClD,CAAC;AACD,IAAA,eAAe,CAAC,MAAM,EAAA;AACpB,QAAA,OAAO,qBAAqB,CAAC,MAAM,EAAE,UAAU,CAAC;IAClD,CAAC;;AAGI,MAAM,SAAS,GAAuC;AAC3D,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,IAAI,EAAE,WAAW;AACjB,IAAA,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,SAAS,CAAC;AACrB,IAAA,eAAe,CAAC,MAAM,EAAA;AACpB,QAAA,OAAO,qBAAqB,CAAC,MAAM,EAAE,WAAW,CAAC;IACnD,CAAC;AACD,IAAA,eAAe,CAAC,MAAM,EAAA;AACpB,QAAA,OAAO,qBAAqB,CAAC,MAAM,EAAE,WAAW,CAAC;IACnD,CAAC;;AAGI,MAAM,gBAAgB,GAAuC;AAClE,IAAA,IAAI,EAAE,MAAM;AACZ,IAAA,IAAI,EAAE,mBAAmB;IACzB,QAAQ,EAAE,CAAC,SAAS,CAAC;IACrB,UAAU,EAAE,CAAC,oBAAoB,CAAC;AAClC,IAAA,oBAAoB,EAAE,oBAAoB;IAC1C,QAAQ,EAAE,CAAC,SAAS,CAAC;IACrB,MAAM,CAAC,EAAE,GAAG,EAAE,EAAA;AACZ,QAAA,OAAO,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,CAAC;IACtD,CAAC;;AAGI,MAAM,iBAAiB,GAAwC;AACpE,IAAA,IAAI,EAAE,MAAM;AACZ,IAAA,IAAI,EAAE,oBAAoB;IAC1B,QAAQ,EAAE,CAAC,SAAS,CAAC;IACrB,UAAU,EAAE,CAAC,qBAAqB,CAAC;AACnC,IAAA,oBAAoB,EAAE,qBAAqB;IAC3C,QAAQ,EAAE,CAAC,SAAS,CAAC;IACrB,MAAM,CAAC,EAAE,GAAG,EAAE,EAAA;AACZ,QAAA,OAAO,mBAAmB,CAAC,GAAG,EAAE,oBAAoB,CAAC;IACvD,CAAC;;AAGI,MAAM,qBAAqB,GAAiD;IACjF,QAAQ;IACR,SAAS;IACT,gBAAgB;IAChB,iBAAiB;;AAGZ,MAAM,cAAc,GAAgC;AACzD,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,IAAI,EAAE,UAAU;IAChB,UAAU,GAAA;AACR,QAAA,OAAO,qBAAqB;IAC9B,CAAC;;AAMH,SAAS,qBAAqB,CAC5B,MAAmC,EACnC,SAA0B,EAAA;AAE1B,IAAA,6BAA6B,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC;IACxDhB,gBAAW,CAAC,MAAM,CAAC,GAAG,EAAE,CAAA,EAAG,SAAS,CAAA,IAAA,CAAM,CAAC;AAC3C,IAAAiB,WAAS,CAAC,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC;IAChC,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;IACxC,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,EAAE,SAAS,CAAC;IAC9C,IAAI,YAAY,GAAG,cAAc,CAAC,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC;AAC7D,IAAA,IAAI,SAAS,GAAgC,IAAI,UAAU,CAAC,CAAC,CAAC;IAC9D,IAAI,eAAe,GAAG,CAAC;IACvB,IAAI,SAAS,GAAG,KAAK;AAErB,IAAA,MAAM,QAAQ,GAAG,CAAC,KAAiB,KAAgB;AACjD,QAAA,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACtB,YAAA,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC;QAC1B;QAEA,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC;QAC3C,IAAI,WAAW,GAAG,CAAC;AAEnB,QAAA,OAAO,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE;AACjC,YAAA,IAAI,eAAe,IAAI,SAAS,CAAC,MAAM,EAAE;AACvC,gBAAA,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,GAAG,WAAW;AAC5C,gBAAA,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,kBAAkB,CAAC,GAAG,kBAAkB;AACrF,gBAAA,SAAS,GAAG,WAAW,CACrB,SAAS,EACT,MAAM,CAAC,GAAG,EACV,KAAK,EACL,IAAI,UAAU,CAAC,cAAc,CAAC,EAC9B,YAAY,CACb;AACD,gBAAA,YAAY,IAAI,cAAc,GAAG,kBAAkB;gBACnD,eAAe,GAAG,CAAC;YACrB;AAEA,YAAA,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,WAAW,EAAE,SAAS,CAAC,MAAM,GAAG,eAAe,CAAC;AAClF,YAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC1B,gBAAA,MAAM,CAAC,WAAW,GAAG,CAAC,CAAC,GAAI,KAAK,CAAC,WAAW,GAAG,CAAC,CAAY,GAAI,SAAS,CAAC,eAAe,GAAG,CAAC,CAAY;YAC3G;YACA,WAAW,IAAI,CAAC;YAChB,eAAe,IAAI,CAAC;QACtB;AAEA,QAAA,OAAO,MAAM;AACf,IAAA,CAAC;IAED,OAAO;AACL,QAAA,OAAO,CAAC,KAAK,EAAA;YACXb,oBAAkB,CAAC,SAAS,CAAC;AAC7B,YAAAJ,gBAAW,CAAC,KAAK,EAAE,GAAG,SAAS,CAAA,MAAA,CAAQ,CAAC;AACxC,YAAA,OAAO,QAAQ,CAAC,KAAK,CAAC;QACxB,CAAC;AACD,QAAA,QAAQ,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,EAAA;YAChCI,oBAAkB,CAAC,SAAS,CAAC;AAC7B,YAAAJ,gBAAW,CAAC,KAAK,EAAE,GAAG,SAAS,CAAA,MAAA,CAAQ,CAAC;YACxC,SAAS,GAAG,IAAI;YAChB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,KAAK,CAAC,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;AACvE,YAAA,SAAS,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC;YAC7B,eAAe,GAAG,CAAC;AACnB,YAAA,OAAO,MAAM;QACf,CAAC;KACF;AACH;AAEA,SAAS,mBAAmB,CAAC,GAAe,EAAE,SAAwB,EAAA;AACpE,IAAAA,gBAAW,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA,IAAA,CAAM,CAAC;AACpC,IAAAiB,WAAS,CAAC,GAAG,EAAE,SAAS,CAAC;IAEzB,OAAO;AACL,QAAA,YAAY,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAA0B,EAAA;YAC5D,MAAM,aAAa,GAAG,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC;YACxD,MAAM,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;AAC9C,YAAA,eAAe,CAAC,SAAS,EAAE,SAAS,CAAC;YACrC,IAAI,QAAQ,GAAkC,EAAE;YAChD,IAAI,SAAS,GAAG,KAAK;YAErB,OAAO;AACL,gBAAA,OAAO,CAAC,KAAK,EAAA;oBACXb,oBAAkB,CAAC,SAAS,CAAC;AAC7B,oBAAAJ,gBAAW,CAAC,KAAK,EAAE,GAAG,SAAS,CAAA,MAAA,CAAQ,CAAC;AACxC,oBAAA,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;AACpB,oBAAA,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC;gBAC1B,CAAC;AAED,gBAAA,QAAQ,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,EAAA;oBAChCI,oBAAkB,CAAC,SAAS,CAAC;AAC7B,oBAAA,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACtB,wBAAA,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;oBACrB;oBACA,SAAS,GAAG,IAAI;AAEhB,oBAAA,MAAM,SAAS,GAAG,cAAc,CAAC,QAAQ,CAAC;oBAC1C,QAAQ,GAAG,EAAE;AACb,oBAAA,MAAM,MAAM,GAAG,eAAe,CAAC,SAAS,EAAE,GAAG,EAAE,aAAa,EAAE,WAAW,CAAC;AAC1E,oBAAA,OAAO,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC;gBAClC,CAAC;aACF;QACH,CAAC;QAED,YAAY,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,SAAS,EAA0B,EAAA;YACjE,MAAM,aAAa,GAAG,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC;YACxD,MAAM,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC;YAC9C,MAAM,WAAW,GAAG,kBAAkB,CAAC,GAAG,EAAE,SAAS,CAAC;;AAEtD,YAAA,IAAI,WAAW,KAAK,SAAS,EAAE;AAC7B,gBAAA,eAAe,CAAC,SAAS,EAAE,SAAS,CAAC;YACvC;YACA,IAAI,QAAQ,GAAkC,EAAE;YAChD,IAAI,SAAS,GAAG,KAAK;YAErB,OAAO;AACL,gBAAA,OAAO,CAAC,KAAK,EAAA;oBACXA,oBAAkB,CAAC,SAAS,CAAC;AAC7B,oBAAAJ,gBAAW,CAAC,KAAK,EAAE,GAAG,SAAS,CAAA,MAAA,CAAQ,CAAC;AACxC,oBAAA,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC;AACpB,oBAAA,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC;gBAC1B,CAAC;AAED,gBAAA,QAAQ,CAAC,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,EAAA;oBAChCI,oBAAkB,CAAC,SAAS,CAAC;AAC7B,oBAAA,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;AACtB,wBAAA,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;oBACrB;oBACA,SAAS,GAAG,IAAI;AAEhB,oBAAA,MAAM,UAAU,GAAG,cAAc,CAAC,QAAQ,CAAC;oBAC3C,QAAQ,GAAG,EAAE;oBACb,MAAM,MAAM,GAAG,kBAAkB,CAAC,UAAU,EAAE,WAAW,EAAE,SAAS,CAAC;AACrE,oBAAA,MAAM,MAAM,GAAG,eAAe,CAAC,SAAS,EAAE,GAAG,EAAE,aAAa,EAAE,WAAW,CAAC;AAC1E,oBAAA,IAAI;AACF,wBAAA,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC;oBAC/B;AAAE,oBAAA,MAAM;AACN,wBAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,uBAAA,CAAyB,CAAC;oBACxD;gBACF,CAAC;aACF;QACH,CAAC;KACF;AACH;AAEA,SAAS,cAAc,CAAC,QAA+B,EAAA;AACrD,IAAA,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;AACzB,QAAA,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC;IAC1B;AACA,IAAA,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;AACzB,QAAA,OAAO,QAAQ,CAAC,CAAC,CAAC;IACpB;AACA,IAAA,OAAOL,gBAAW,CAAC,GAAG,QAAQ,CAAC;AACjC;AAEA,SAAS,WAAW,CAClB,SAA0B,EAC1B,GAAe,EACf,KAAiB,EACjB,IAAgB,EAChB,OAAe,EAAA;AAEf,IAAA,IAAI,SAAS,KAAK,UAAU,EAAE;AAC5B,QAAA,OAAOmB,UAAa,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC;IAC5D;AACA,IAAA,OAAOC,WAAc,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC;AAC7D;AAEA,SAAS,eAAe,CACtB,SAAwB,EACxB,GAAe,EACf,KAAiB,EACjB,GAAe,EAAA;AAEf,IAAA,IAAI,SAAS,KAAK,mBAAmB,EAAE;QACrC,OAAOC,gBAAqB,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC;IAC/C;IACA,OAAOC,iBAAsB,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC;AAChD;AAEA,SAAS,kBAAkB,CACzB,UAAsB,EACtB,GAA2B,EAC3B,SAAwB,EAAA;AAExB,IAAA,IAAI,GAAG,KAAK,SAAS,EAAE;AACrB,QAAA,IAAI,UAAU,CAAC,MAAM,GAAG,SAAS,EAAE;AACjC,YAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,sDAAA,CAAwD,CAAC;QACvF;AACA,QAAA,OAAO,UAAU;IACnB;AACA,IAAA,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC;AACzB,IAAA,OAAOtB,gBAAW,CAAC,UAAU,EAAE,GAAG,CAAC;AACrC;AAEA,SAAS,YAAY,CAAC,OAAgC,EAAE,SAA0B,EAAA;AAChF,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK;AAC3B,IAAA,IAAI,KAAK,KAAK,SAAS,EAAE;AACvB,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,kBAAA,CAAoB,CAAC;IACnD;AACA,IAAAC,gBAAW,CAAC,KAAK,EAAE,GAAG,SAAS,CAAA,MAAA,CAAQ,CAAC;AACxC,IAAA,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC;AAC7B,IAAA,OAAO,KAAK;AACd;AAEA,SAAS,gBAAgB,CAAC,KAA6B,EAAE,SAAwB,EAAA;AAC/E,IAAA,IAAI,KAAK,KAAK,SAAS,EAAE;AACvB,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,kBAAA,CAAoB,CAAC;IACnD;AACA,IAAAA,gBAAW,CAAC,KAAK,EAAE,GAAG,SAAS,CAAA,MAAA,CAAQ,CAAC;AACxC,IAAA,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC;AAC7B,IAAA,OAAO,KAAK;AACd;AAEA,SAAS,kBAAkB,CAAC,GAAY,EAAE,SAAwB,EAAA;AAChE,IAAA,IAAI,GAAG,KAAK,SAAS,EAAE;AACrB,QAAA,OAAO,SAAS;IAClB;AACA,IAAAA,gBAAW,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA,IAAA,CAAM,CAAC;AACpC,IAAA,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC;AACzB,IAAA,OAAO,GAAG;AACZ;AAEA,SAAS,UAAU,CAAC,GAAY,EAAE,SAAwB,EAAA;AACxD,IAAA,IAAI,GAAG,KAAK,SAAS,EAAE;AACrB,QAAA,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC;IAC1B;AACA,IAAAA,gBAAW,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA,IAAA,CAAM,CAAC;AACpC,IAAA,OAAO,GAAG;AACZ;AAEA,SAAS,eAAe,CAAC,SAA6B,EAAE,SAAwB,EAAA;IAC9E,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,SAAS,EAAE;AACtD,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,4BAAA,CAA8B,CAAC;IAC7D;AACF;AAEA,SAAS,cAAc,CAAC,OAAgB,EAAE,SAA0B,EAAA;AAClE,IAAA,IAAI,OAAO,KAAK,SAAS,EAAE;AACzB,QAAA,OAAO,CAAC;IACV;IACA,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,IAAI,OAAO,IAAI,WAAW,EAAE;AACtG,QAAA,MAAM,IAAI,UAAU,CAAC,GAAG,SAAS,CAAA,2CAAA,CAA6C,CAAC;IACjF;AACA,IAAA,OAAO,OAAO;AAChB;AAEA,SAASiB,WAAS,CAAC,GAAe,EAAE,SAAiB,EAAA;AACnD,IAAA,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE;AAC5B,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,sBAAA,CAAwB,CAAC;IACvD;AACF;AAEA,SAAS,WAAW,CAAC,KAAiB,EAAE,SAA0C,EAAA;IAChF,IAAI,SAAS,KAAK,UAAU,IAAI,SAAS,KAAK,mBAAmB,EAAE;AACjE,QAAA,IAAI,KAAK,CAAC,MAAM,KAAK,oBAAoB,EAAE;AACzC,YAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,uBAAA,CAAyB,CAAC;QACxD;QACA;IACF;AACA,IAAA,IAAI,KAAK,CAAC,MAAM,KAAK,qBAAqB,EAAE;AAC1C,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,wBAAA,CAA0B,CAAC;IACzD;AACF;AAEA,SAAS,SAAS,CAAC,GAAe,EAAE,SAAwB,EAAA;AAC1D,IAAA,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE;AAC5B,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,sBAAA,CAAwB,CAAC;IACvD;AACF;AAEA,SAAS,6BAA6B,CAAC,OAAgB,EAAE,SAAiB,EAAA;AACxE,IAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC;AAChC,IAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE;AACrF,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,uBAAA,CAAyB,CAAC;IACxD;AACA,IAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE;AAC3F,QAAA,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,CAAA,0BAAA,CAA4B,CAAC;IAC3D;AACF;AAEA,SAAS,QAAQ,CAAC,OAAgB,EAAA;IAChC,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,EAAE;AACnD,QAAA,OAAO,OAAkC;IAC3C;AACA,IAAA,OAAO,EAAE;AACX;AAEA,SAASb,oBAAkB,CAAC,SAAkB,EAAA;IAC5C,IAAI,SAAS,EAAE;AACb,QAAA,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC;IACpD;AACF;;AC9XO,MAAM,GAAG,GAA2B;AACzC,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,IAAI,EAAE,KAAK;AACX,IAAA,IAAI,EAAE,OAAO;AACb,IAAA,SAAS,EAAE,CAAC;IACZ,QAAQ,EAAE,CAAC,CAAC,CAAC;AACb,IAAA,MAAM,CAAC,GAAG,EAAA;AACR,QAAA,OAAO,eAAe,CAAC,GAAG,CAAC;IAC7B,CAAC;;AAGI,MAAM,SAAS,GAA2B;AAC/C,IAAA,IAAI,EAAE,QAAQ;AACd,IAAA,IAAI,EAAE,KAAK;IACX,UAAU,GAAA;QACR,OAAO,CAAC,GAAG,CAAC;IACd,CAAC;;AAGG,SAAU,eAAe,CAAC,GAAe,EAAA;AAC7C,IAAA,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;AACpB,QAAA,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC;IAC7C;AAEA,IAAA,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC;AAClC,IAAA,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAElB,OAAO;AACL,QAAA,SAAS,EAAE,CAAC;AAEZ,QAAA,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAA;AACnD,YAAA,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC;QAC5E,CAAC;AAED,QAAA,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAA;AACnD,YAAA,YAAY,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC;QAC7E,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,MAAM,EAAA;AACnB,YAAA,OAAO,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC;QAC3D,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,MAAM,EAAA;AACnB,YAAA,OAAO,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC;QAC5D,CAAC;KACF;AACH;AAEA,SAAS,aAAa,CACpB,KAAiB,EACjB,MAAkB,EAClB,OAA0B,EAC1B,UAAmB,EACnB,IAAY,EAAA;AAEZ,IAAAO,cAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC;AACjC,IAAA,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;AAClB,IAAA,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,EAAE;AACvD,QAAA,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,UAAU,CAAC;IACvE;AACA,IAAA,OAAO,MAAM;AACf;AAEA,SAAS,aAAa,CAAC,GAAe,EAAA;AACpC,IAAA,MAAM,OAAO,GAAG,IAAI,KAAK,CAAS,EAAE,CAAC;IACrC,IAAI,OAAO,GAAG,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC;IAClC,IAAI,QAAQ,GAAG,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC;AACnC,IAAA,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAElB,eAAe,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;AAC1C,IAAA,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC;AAChB,IAAA,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC;AAEjB,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE;QACtD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,KAAK,CAAC,CAAC;AACrC,QAAA,OAAO,GAAG,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC;AACtC,QAAA,QAAQ,GAAG,YAAY,CAAC,QAAQ,EAAE,KAAK,CAAC;QACxC,eAAe,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC;IACpD;AAEA,IAAA,OAAO,OAAO;AAChB;AAEA,SAAS,YAAY,CACnB,KAAiB,EACjB,WAAmB,EACnB,MAAkB,EAClB,YAAoB,EACpB,OAA0B,EAC1B,GAAa,EACb,UAAmB,EAAA;IAEnB,IAAI,IAAI,GAAG,YAAY,CAAC,KAAK,EAAE,WAAW,CAAC;IAC3C,IAAI,KAAK,GAAG,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,CAAC,CAAC;IAEhD,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;AACvC,IAAA,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC;AACb,IAAA,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC;IAEd,IAAI,UAAU,EAAE;AACd,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE;YACtD,MAAM,QAAQ,GAAG,KAAK;YACtB,KAAK,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;YAC9E,IAAI,GAAG,QAAQ;QACjB;QACA,yBAAyB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;IAChD;SAAO;QACL,MAAM,YAAY,GAAG,IAAI;QACzB,IAAI,GAAG,KAAK;QACZ,KAAK,GAAG,YAAY;AACpB,QAAA,KAAK,IAAI,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3D,MAAM,QAAQ,GAAG,IAAI;YACrB,IAAI,GAAG,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;YAC7E,KAAK,GAAG,QAAQ;QAClB;QACA,yBAAyB,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IAChD;IAEA,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC;AAC3C,IAAA,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC;AACjD;AAEA,SAAS,OAAO,CAAC,KAAa,EAAE,OAAe,EAAE,QAAgB,EAAE,GAAa,EAAA;AAC9E,IAAA,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IACrB,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AACjF;AAEA,SAAS,YAAY,CAAC,KAAiB,EAAE,MAAc,EAAA;IACrD,OAAO,CACL,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE;WACjB,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE;WACvB,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC;UACvB,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,MACf,CAAC;AACT;AAEA,SAAS,aAAa,CAAC,KAAiB,EAAE,KAAa,EAAE,MAAc,EAAA;AACrE,IAAA,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,KAAK,EAAE;IAC5B,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,KAAK,KAAK,EAAE;IAChC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC;AAC/B,IAAA,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,KAAK;AAC3B;AAEA;AACA,SAAS,kBAAkB,CAAC,SAAiB,EAAE,UAAkB,EAAE,MAAgB,EAAE,MAAc,EAAA;IACjG,IAAI,UAAU,GAAG,CAAC;IAClB,IAAI,WAAW,GAAG,CAAC;AAEnB,IAAA,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE;AACpC,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,UAAU,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACvE;AACA,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,SAAS,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACtE;IACF;AAEA,IAAA,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE;AACpC,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,UAAU,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACzE;AACA,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,SAAS,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACxE;IACF;AAEA,IAAA,MAAM,CAAC,MAAM,CAAC,GAAG,UAAU,KAAK,CAAC;IACjC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,WAAW,KAAK,CAAC;AACxC;AAEA,SAAS,yBAAyB,CAAC,SAAiB,EAAE,UAAkB,EAAE,MAAgB,EAAE,MAAc,EAAA;IACxG,IAAI,UAAU,GAAG,CAAC;IAClB,IAAI,WAAW,GAAG,CAAC;AAEnB,IAAA,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE;AAChC,QAAA,KAAK,IAAI,KAAK,GAAG,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,UAAU,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;YACrE,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,SAAS,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACtE;IACF;AAEA,IAAA,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE;AAChC,QAAA,KAAK,IAAI,KAAK,GAAG,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,UAAU,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;YACvE,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,SAAS,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACxE;IACF;AAEA,IAAA,MAAM,CAAC,MAAM,CAAC,GAAG,UAAU,KAAK,CAAC;IACjC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,WAAW,KAAK,CAAC;AACxC;AAEA,SAAS,eAAe,CAAC,SAAiB,EAAE,UAAkB,EAAE,MAAgB,EAAE,MAAc,EAAA;IAC9F,IAAI,UAAU,GAAG,CAAC;IAClB,IAAI,WAAW,GAAG,CAAC;IACnB,IAAI,GAAG,GAAG,CAAC;IAEX,KAAK,GAAG,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE;AAC7B,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACtE;AACA,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACrE;IACF;AACA,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;QAC3C,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACtE;IAEA,KAAK,GAAG,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE;AAC7B,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACxE;AACA,QAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;YAC3C,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACvE;IACF;AACA,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE;QAC3C,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACvE;AAEA,IAAA,MAAM,CAAC,MAAM,CAAC,GAAG,UAAU,KAAK,CAAC;IACjC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,WAAW,KAAK,CAAC;AACxC;AAEA,SAAS,YAAY,CAAC,KAAa,EAAE,KAAa,EAAA;AAChD,IAAA,OAAO,CAAC,CAAC,KAAK,IAAI,KAAK,IAAI,SAAS,KAAK,KAAK,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC;AAClE;AAEA,MAAM,sBAAsB,GAAG;AAC7B,IAAA,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AAC5B,IAAA,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE;AAC3B,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE;AAC3B,IAAA,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE;AAC3B,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;AAC1B,IAAA,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;CAC7B;AAED,SAAS,eAAe,CAAC,SAAiB,EAAE,UAAkB,EAAE,MAAgB,EAAE,MAAc,EAAA;IAC9F,IAAI,UAAU,GAAG,CAAC;IAClB,IAAI,WAAW,GAAG,CAAC;AACnB,IAAA,MAAM,UAAU,GAAG,sBAAsB,CAAC,MAAM,KAAK,CAAC;AAEtD,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,UAAU,EAAE,KAAK,EAAE,EAAE;AAC/C,QAAA,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,SAAS,KAAK,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACtF;AACA,IAAA,KAAK,IAAI,KAAK,GAAG,UAAU,EAAE,KAAK,GAAG,sBAAsB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;AAC3E,QAAA,WAAW,GAAG,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,UAAU,KAAK,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACzF;AAEA,IAAA,MAAM,CAAC,MAAM,CAAC,GAAG,UAAU,KAAK,CAAC;IACjC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,WAAW,KAAK,CAAC;AACxC;AAEA,SAAS,MAAM,CAAC,KAAa,EAAE,MAAgB,EAAE,MAAc,EAAA;AAC7D,IAAA,IAAI,UAAU,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;IACpD,IAAI,WAAW,GAAG,CAAC;AAEnB,IAAA,KAAK,IAAI,GAAG,GAAG,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,EAAE;AACtC,QAAA,UAAU,GAAG,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,IAAI,IAAI,CAAC;IAC3D;AACA,IAAA,KAAK,IAAI,GAAG,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE;QACrC,WAAW,IAAI,CAAC,KAAK,KAAK,GAAG,IAAI,IAAI;QACrC,WAAW,KAAK,CAAC;IACnB;AACA,IAAA,WAAW,IAAI,CAAC,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;AAErD,IAAA,MAAM,CAAC,MAAM,CAAC,GAAG,UAAU,KAAK,CAAC;IACjC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,WAAW,KAAK,CAAC;AACxC;AAEA,SAAS,UAAU,CAAC,SAAiB,EAAE,UAAkB,EAAA;IACvD,IAAI,MAAM,GAAG,CAAC;AACd,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE;AACtC,QAAA,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,GAAG,IAAI,IAAI,CAAC,SAAS,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IAC5F;AACA,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE;AACtC,QAAA,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,IAAI,CAAC,UAAU,MAAM,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;IACxG;IACA,OAAO,MAAM,KAAK,CAAC;AACrB;AAEA,MAAM,aAAa,GAAG;AACpB,IAAA,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE;AACzD,IAAA,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;CAC1D;AAED,SAAS,OAAO,CAAC,KAAa,EAAA;IAC5B,IAAI,MAAM,GAAG,CAAC;AACd,IAAA,KAAK,MAAM,GAAG,IAAI,aAAa,EAAE;AAC/B,QAAA,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,IAAI,CAAC,CAAC;IAChD;IACA,OAAO,MAAM,KAAK,CAAC;AACrB;AAEA,MAAM,UAAU,GAAG;AACjB,IAAA,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACtB,IAAA,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;CACvB;AAED,MAAM,OAAO,GAAG;AACd,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;AACrD,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACnD,IAAA,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;AACnD,IAAA,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACrD,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACpD,IAAA,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACpD,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACrD,IAAA,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACnD,IAAA,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACnD,IAAA,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;AACrD,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAClD,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACtD,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;AACpD,IAAA,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACpD,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACrD,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACnD,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC;AACrD,IAAA,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACnD,IAAA,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACrD,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;AACnD,IAAA,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACpD,IAAA,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;AACpD,IAAA,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE;AACpD,IAAA,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACpD,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE;AACrD,IAAA,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACnD,IAAA,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;AACrD,IAAA,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACnD,IAAA,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACpD,IAAA,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACpD,IAAA,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;AACpD,IAAA,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CA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","x_google_ignoreList":[0,1,5,6,7,11]}