@metamask/browser-playground 0.7.0 → 0.7.1

package/build/static/js/288.51cc5192.chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static/js/288.51cc5192.chunk.js","mappings":"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","sources":["../../../node_modules/eciesjs/dist/utils/index.js","../../../node_modules/eciesjs/dist/utils/hex.js","../../../node_modules/@noble/ciphers/src/_polyval.ts","../../../node_modules/@noble/ciphers/src/aes.ts","../../../node_modules/eciesjs/dist/keys/index.js","../../../node_modules/@ecies/ciphers/dist/chacha/noble.js","../../../node_modules/@noble/ciphers/src/crypto.ts","../../../node_modules/@noble/ciphers/src/webcrypto.ts","../../../node_modules/@noble/ciphers/src/_arx.ts","../../../node_modules/@noble/ciphers/src/_poly1305.ts","../../../node_modules/@noble/ciphers/src/chacha.ts","../../../node_modules/eciesjs/dist/index.js","../../../node_modules/@noble/ciphers/src/utils.ts","../../../node_modules/eciesjs/dist/utils/elliptic.js","../../../node_modules/eciesjs/dist/utils/hash.js","../../../node_modules/eciesjs/dist/utils/symmetric.js","../../../node_modules/eciesjs/dist/keys/PrivateKey.js","../../../node_modules/@ecies/ciphers/dist/aes/noble.js","../../../node_modules/eciesjs/dist/keys/PublicKey.js","../../../node_modules/eciesjs/dist/consts.js","../../../node_modules/@noble/hashes/src/hkdf.ts","../../../node_modules/eciesjs/dist/config.js"],"sourcesContent":["\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./elliptic.js\"), exports);\n__exportStar(require(\"./hash.js\"), exports);\n__exportStar(require(\"./hex.js\"), exports);\n__exportStar(require(\"./symmetric.js\"), exports);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeHex = exports.remove0x = void 0;\nvar utils_1 = require(\"@noble/ciphers/utils\");\nvar remove0x = function (hex) {\n    return hex.startsWith(\"0x\") || hex.startsWith(\"0X\") ? hex.slice(2) : hex;\n};\nexports.remove0x = remove0x;\nvar decodeHex = function (hex) { return (0, utils_1.hexToBytes)((0, exports.remove0x)(hex)); };\nexports.decodeHex = decodeHex;\n","/**\n * GHash from AES-GCM and its little-endian \"mirror image\" Polyval from AES-SIV.\n *\n * Implemented in terms of GHash with conversion function for keys\n * GCM GHASH from\n * [NIST SP800-38d](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf),\n * SIV from\n * [RFC 8452](https://datatracker.ietf.org/doc/html/rfc8452).\n *\n * GHASH   modulo: x^128 + x^7   + x^2   + x     + 1\n * POLYVAL modulo: x^128 + x^127 + x^126 + x^121 + 1\n *\n * @module\n */\n// prettier-ignore\nimport {\n  abytes, aexists, aoutput,\n  clean, copyBytes, createView, Hash, type Input, toBytes, u32,\n} from './utils.ts';\n\nconst BLOCK_SIZE = 16;\n// TODO: rewrite\n// temporary padding buffer\nconst ZEROS16 = /* @__PURE__ */ new Uint8Array(16);\nconst ZEROS32 = u32(ZEROS16);\nconst POLY = 0xe1; // v = 2*v % POLY\n\n// v = 2*v % POLY\n// NOTE: because x + x = 0 (add/sub is same), mul2(x) != x+x\n// We can multiply any number using montgomery ladder and this function (works as double, add is simple xor)\nconst mul2 = (s0: number, s1: number, s2: number, s3: number) => {\n  const hiBit = s3 & 1;\n  return {\n    s3: (s2 << 31) | (s3 >>> 1),\n    s2: (s1 << 31) | (s2 >>> 1),\n    s1: (s0 << 31) | (s1 >>> 1),\n    s0: (s0 >>> 1) ^ ((POLY << 24) & -(hiBit & 1)), // reduce % poly\n  };\n};\n\nconst swapLE = (n: number) =>\n  (((n >>> 0) & 0xff) << 24) |\n  (((n >>> 8) & 0xff) << 16) |\n  (((n >>> 16) & 0xff) << 8) |\n  ((n >>> 24) & 0xff) |\n  0;\n\n/**\n * `mulX_POLYVAL(ByteReverse(H))` from spec\n * @param k mutated in place\n */\nexport function _toGHASHKey(k: Uint8Array): Uint8Array {\n  k.reverse();\n  const hiBit = k[15] & 1;\n  // k >>= 1\n  let carry = 0;\n  for (let i = 0; i < k.length; i++) {\n    const t = k[i];\n    k[i] = (t >>> 1) | carry;\n    carry = (t & 1) << 7;\n  }\n  k[0] ^= -hiBit & 0xe1; // if (hiBit) n ^= 0xe1000000000000000000000000000000;\n  return k;\n}\n\ntype Value = { s0: number; s1: number; s2: number; s3: number };\n\nconst estimateWindow = (bytes: number) => {\n  if (bytes > 64 * 1024) return 8;\n  if (bytes > 1024) return 4;\n  return 2;\n};\n\nclass GHASH implements Hash<GHASH> {\n  readonly blockLen = BLOCK_SIZE;\n  readonly outputLen = BLOCK_SIZE;\n  protected s0 = 0;\n  protected s1 = 0;\n  protected s2 = 0;\n  protected s3 = 0;\n  protected finished = false;\n  protected t: Value[];\n  private W: number;\n  private windowSize: number;\n  // We select bits per window adaptively based on expectedLength\n  constructor(key: Input, expectedLength?: number) {\n    key = toBytes(key);\n    abytes(key, 16);\n    const kView = createView(key);\n    let k0 = kView.getUint32(0, false);\n    let k1 = kView.getUint32(4, false);\n    let k2 = kView.getUint32(8, false);\n    let k3 = kView.getUint32(12, false);\n    // generate table of doubled keys (half of montgomery ladder)\n    const doubles: Value[] = [];\n    for (let i = 0; i < 128; i++) {\n      doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });\n      ({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2(k0, k1, k2, k3));\n    }\n    const W = estimateWindow(expectedLength || 1024);\n    if (![1, 2, 4, 8].includes(W))\n      throw new Error('ghash: invalid window size, expected 2, 4 or 8');\n    this.W = W;\n    const bits = 128; // always 128 bits;\n    const windows = bits / W;\n    const windowSize = (this.windowSize = 2 ** W);\n    const items: Value[] = [];\n    // Create precompute table for window of W bits\n    for (let w = 0; w < windows; w++) {\n      // truth table: 00, 01, 10, 11\n      for (let byte = 0; byte < windowSize; byte++) {\n        // prettier-ignore\n        let s0 = 0, s1 = 0, s2 = 0, s3 = 0;\n        for (let j = 0; j < W; j++) {\n          const bit = (byte >>> (W - j - 1)) & 1;\n          if (!bit) continue;\n          const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W * w + j];\n          (s0 ^= d0), (s1 ^= d1), (s2 ^= d2), (s3 ^= d3);\n        }\n        items.push({ s0, s1, s2, s3 });\n      }\n    }\n    this.t = items;\n  }\n  protected _updateBlock(s0: number, s1: number, s2: number, s3: number) {\n    (s0 ^= this.s0), (s1 ^= this.s1), (s2 ^= this.s2), (s3 ^= this.s3);\n    const { W, t, windowSize } = this;\n    // prettier-ignore\n    let o0 = 0, o1 = 0, o2 = 0, o3 = 0;\n    const mask = (1 << W) - 1; // 2**W will kill performance.\n    let w = 0;\n    for (const num of [s0, s1, s2, s3]) {\n      for (let bytePos = 0; bytePos < 4; bytePos++) {\n        const byte = (num >>> (8 * bytePos)) & 0xff;\n        for (let bitPos = 8 / W - 1; bitPos >= 0; bitPos--) {\n          const bit = (byte >>> (W * bitPos)) & mask;\n          const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];\n          (o0 ^= e0), (o1 ^= e1), (o2 ^= e2), (o3 ^= e3);\n          w += 1;\n        }\n      }\n    }\n    this.s0 = o0;\n    this.s1 = o1;\n    this.s2 = o2;\n    this.s3 = o3;\n  }\n  update(data: Input): this {\n    aexists(this);\n    data = toBytes(data);\n    abytes(data);\n    const b32 = u32(data);\n    const blocks = Math.floor(data.length / BLOCK_SIZE);\n    const left = data.length % BLOCK_SIZE;\n    for (let i = 0; i < blocks; i++) {\n      this._updateBlock(b32[i * 4 + 0], b32[i * 4 + 1], b32[i * 4 + 2], b32[i * 4 + 3]);\n    }\n    if (left) {\n      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));\n      this._updateBlock(ZEROS32[0], ZEROS32[1], ZEROS32[2], ZEROS32[3]);\n      clean(ZEROS32); // clean tmp buffer\n    }\n    return this;\n  }\n  destroy() {\n    const { t } = this;\n    // clean precompute table\n    for (const elm of t) {\n      (elm.s0 = 0), (elm.s1 = 0), (elm.s2 = 0), (elm.s3 = 0);\n    }\n  }\n  digestInto(out: Uint8Array) {\n    aexists(this);\n    aoutput(out, this);\n    this.finished = true;\n    const { s0, s1, s2, s3 } = this;\n    const o32 = u32(out);\n    o32[0] = s0;\n    o32[1] = s1;\n    o32[2] = s2;\n    o32[3] = s3;\n    return out;\n  }\n  digest(): Uint8Array {\n    const res = new Uint8Array(BLOCK_SIZE);\n    this.digestInto(res);\n    this.destroy();\n    return res;\n  }\n}\n\nclass Polyval extends GHASH {\n  constructor(key: Input, expectedLength?: number) {\n    key = toBytes(key);\n    abytes(key);\n    const ghKey = _toGHASHKey(copyBytes(key));\n    super(ghKey, expectedLength);\n    clean(ghKey);\n  }\n  update(data: Input): this {\n    data = toBytes(data);\n    aexists(this);\n    const b32 = u32(data);\n    const left = data.length % BLOCK_SIZE;\n    const blocks = Math.floor(data.length / BLOCK_SIZE);\n    for (let i = 0; i < blocks; i++) {\n      this._updateBlock(\n        swapLE(b32[i * 4 + 3]),\n        swapLE(b32[i * 4 + 2]),\n        swapLE(b32[i * 4 + 1]),\n        swapLE(b32[i * 4 + 0])\n      );\n    }\n    if (left) {\n      ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));\n      this._updateBlock(\n        swapLE(ZEROS32[3]),\n        swapLE(ZEROS32[2]),\n        swapLE(ZEROS32[1]),\n        swapLE(ZEROS32[0])\n      );\n      clean(ZEROS32);\n    }\n    return this;\n  }\n  digestInto(out: Uint8Array) {\n    aexists(this);\n    aoutput(out, this);\n    this.finished = true;\n    // tmp ugly hack\n    const { s0, s1, s2, s3 } = this;\n    const o32 = u32(out);\n    o32[0] = s0;\n    o32[1] = s1;\n    o32[2] = s2;\n    o32[3] = s3;\n    return out.reverse();\n  }\n}\n\nexport type CHashPV = ReturnType<typeof wrapConstructorWithKey>;\nfunction wrapConstructorWithKey<H extends Hash<H>>(\n  hashCons: (key: Input, expectedLength?: number) => Hash<H>\n): {\n  (msg: Input, key: Input): Uint8Array;\n  outputLen: number;\n  blockLen: number;\n  create(key: Input, expectedLength?: number): Hash<H>;\n} {\n  const hashC = (msg: Input, key: Input): Uint8Array =>\n    hashCons(key, msg.length).update(toBytes(msg)).digest();\n  const tmp = hashCons(new Uint8Array(16), 0);\n  hashC.outputLen = tmp.outputLen;\n  hashC.blockLen = tmp.blockLen;\n  hashC.create = (key: Input, expectedLength?: number) => hashCons(key, expectedLength);\n  return hashC;\n}\n\n/** GHash MAC for AES-GCM. */\nexport const ghash: CHashPV = wrapConstructorWithKey(\n  (key, expectedLength) => new GHASH(key, expectedLength)\n);\n\n/** Polyval MAC for AES-SIV. */\nexport const polyval: CHashPV = wrapConstructorWithKey(\n  (key, expectedLength) => new Polyval(key, expectedLength)\n);\n","/**\n * [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)\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 * Data is split into 128-bit blocks. 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 [FIPS-197](https://csrc.nist.gov/files/pubs/fips/197/final/docs/fips-197.pdf)\n * and [original proposal](https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf)\n * @module\n */\nimport { ghash, polyval } from './_polyval.ts';\n// prettier-ignore\nimport {\n  abytes, clean, complexOverlapBytes, concatBytes,\n  copyBytes, createView, equalBytes, getOutput, isAligned32, overlapBytes,\n  setBigUint64, u32, u64Lengths, u8, wrapCipher,\n  type Cipher, type CipherWithOutput,\n} from './utils.ts';\n\nconst BLOCK_SIZE = 16;\nconst BLOCK_SIZE32 = 4;\nconst EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE);\nconst POLY = 0x11b; // 1 + x + x**3 + x**4 + x**8\n\n// TODO: remove multiplication, binary ops only\nfunction mul2(n: number) {\n  return (n << 1) ^ (POLY & -(n >> 7));\n}\n\nfunction mul(a: number, b: number) {\n  let res = 0;\n  for (; b > 0; b >>= 1) {\n    // Montgomery 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// 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  for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x)) t[i] = x;\n  const box = new Uint8Array(256);\n  box[0] = 0x63; // first elm\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\n// Inverted S-box\nconst invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));\n\n// Rotate u32 by 8\nconst rotr32_8 = (n: number) => (n << 24) | (n >>> 8);\nconst rotl32_8 = (n: number) => (n << 8) | (n >>> 24);\n// The byte swap operation for uint32 (LE<->BE)\nconst byteSwap = (word: number) =>\n  ((word << 24) & 0xff000000) |\n  ((word << 8) & 0xff0000) |\n  ((word >>> 8) & 0xff00) |\n  ((word >>> 24) & 0xff);\n\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: Uint8Array, fn: (n: number) => number) {\n  if (sbox.length !== 256) 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  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\nconst tableEncoding = /* @__PURE__ */ genTtable(\n  sbox,\n  (s: number) => (mul(s, 3) << 24) | (s << 16) | (s << 8) | mul(s, 2)\n);\nconst tableDecoding = /* @__PURE__ */ genTtable(\n  invSbox,\n  (s) => (mul(s, 11) << 24) | (mul(s, 13) << 16) | (mul(s, 9) << 8) | mul(s, 14)\n);\n\nconst xPowers = /* @__PURE__ */ (() => {\n  const p = new Uint8Array(16);\n  for (let i = 0, x = 1; i < 16; i++, x = mul2(x)) p[i] = x;\n  return p;\n})();\n\n/** Key expansion used in CTR. */\nfunction expandKeyLE(key: Uint8Array): Uint32Array {\n  abytes(key);\n  const len = key.length;\n  if (![16, 24, 32].includes(len))\n    throw new Error('aes: invalid key size, should be 16, 24 or 32, got ' + len);\n  const { sbox2 } = tableEncoding;\n  const toClean = [];\n  if (!isAligned32(key)) toClean.push((key = copyBytes(key)));\n  const k32 = u32(key);\n  const Nk = k32.length;\n  const subByte = (n: number) => applySbox(sbox2, n, n, n, n);\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) t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];\n    else if (Nk > 6 && i % Nk === 4) t = subByte(t);\n    xk[i] = xk[i - Nk] ^ t;\n  }\n  clean(...toClean);\n  return xk;\n}\n\nfunction expandKeyDecLE(key: Uint8Array): Uint32Array {\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  // Inverse key by chunks of 4 (rounds)\n  for (let i = 0; i < Nk; i += 4) {\n    for (let j = 0; j < 4; j++) xk[i + j] = encKey[Nk - i - 4 + j];\n  }\n  clean(encKey);\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\n// Apply tables\nfunction apply0123(\n  T01: Uint32Array,\n  T23: Uint32Array,\n  s0: number,\n  s1: number,\n  s2: number,\n  s3: number\n) {\n  return (\n    T01[((s0 << 8) & 0xff00) | ((s1 >>> 8) & 0xff)] ^\n    T23[((s2 >>> 8) & 0xff00) | ((s3 >>> 24) & 0xff)]\n  );\n}\n\nfunction applySbox(sbox2: Uint16Array, s0: number, s1: number, s2: number, s3: number) {\n  return (\n    sbox2[(s0 & 0xff) | (s1 & 0xff00)] |\n    (sbox2[((s2 >>> 16) & 0xff) | ((s3 >>> 16) & 0xff00)] << 16)\n  );\n}\n\nfunction encrypt(\n  xk: Uint32Array,\n  s0: number,\n  s1: number,\n  s2: number,\n  s3: number\n): { s0: number; s1: number; s2: number; s3: number } {\n  const { sbox2, T01, T23 } = tableEncoding;\n  let k = 0;\n  (s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);\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\n// Can't be merged with encrypt: arg positions for apply0123 / applySbox are different\nfunction decrypt(\n  xk: Uint32Array,\n  s0: number,\n  s1: number,\n  s2: number,\n  s3: number\n): {\n  s0: number;\n  s1: number;\n  s2: number;\n  s3: number;\n} {\n  const { sbox2, T01, T23 } = tableDecoding;\n  let k = 0;\n  (s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);\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  // Last round\n  const t0: number = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);\n  const t1: number = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);\n  const t2: number = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);\n  const t3: number = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);\n  return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\n\n// TODO: investigate merging with ctr32\nfunction ctrCounter(\n  xk: Uint32Array,\n  nonce: Uint8Array,\n  src: Uint8Array,\n  dst?: Uint8Array\n): Uint8Array {\n  abytes(nonce, BLOCK_SIZE);\n  abytes(src);\n  const srcLen = src.length;\n  dst = getOutput(srcLen, dst);\n  complexOverlapBytes(src, dst);\n  const ctr = nonce;\n  const c32 = u32(ctr);\n  // Fill block (empty, ctr=0)\n  let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n  const src32 = u32(src);\n  const dst32 = u32(dst);\n  // process blocks\n  for (let i = 0; i + 4 <= src32.length; i += 4) {\n    dst32[i + 0] = src32[i + 0] ^ s0;\n    dst32[i + 1] = src32[i + 1] ^ s1;\n    dst32[i + 2] = src32[i + 2] ^ s2;\n    dst32[i + 3] = src32[i + 3] ^ s3;\n    // Full 128 bit counter with wrap around\n    let carry = 1;\n    for (let i = ctr.length - 1; i >= 0; i--) {\n      carry = (carry + (ctr[i] & 0xff)) | 0;\n      ctr[i] = carry & 0xff;\n      carry >>>= 8;\n    }\n    ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n  }\n  // leftovers (less than 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    const buf = u8(b32);\n    for (let i = start, pos = 0; i < srcLen; i++, pos++) dst[i] = src[i] ^ buf[pos];\n    clean(b32);\n  }\n  return dst;\n}\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.\nfunction ctr32(\n  xk: Uint32Array,\n  isLE: boolean,\n  nonce: Uint8Array,\n  src: Uint8Array,\n  dst?: Uint8Array\n): Uint8Array {\n  abytes(nonce, BLOCK_SIZE);\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  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, c32[0], c32[1], c32[2], c32[3]);\n  // process blocks\n  for (let i = 0; i + 4 <= src32.length; i += 4) {\n    dst32[i + 0] = src32[i + 0] ^ s0;\n    dst32[i + 1] = src32[i + 1] ^ s1;\n    dst32[i + 2] = src32[i + 2] ^ s2;\n    dst32[i + 3] = src32[i + 3] ^ s3;\n    ctrNum = (ctrNum + 1) >>> 0; // u32 wrap\n    view.setUint32(ctrPos, ctrNum, isLE);\n    ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], 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    const buf = u8(b32);\n    for (let i = start, pos = 0; i < srcLen; i++, pos++) dst[i] = src[i] ^ buf[pos];\n    clean(b32);\n  }\n  return dst;\n}\n\n/**\n * CTR: counter mode. Creates stream cipher.\n * Requires good IV. Parallelizable. OK, but no MAC.\n */\nexport const ctr: ((key: Uint8Array, nonce: Uint8Array) => CipherWithOutput) & {\n  blockSize: number;\n  nonceLength: number;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 16, nonceLength: 16 },\n  function aesctr(key: Uint8Array, nonce: Uint8Array): CipherWithOutput {\n    function processCtr(buf: Uint8Array, dst?: Uint8Array) {\n      abytes(buf);\n      if (dst !== undefined) {\n        abytes(dst);\n        if (!isAligned32(dst)) throw new Error('unaligned destination');\n      }\n      const xk = expandKeyLE(key);\n      const n = copyBytes(nonce); // align + avoid changing\n      const toClean = [xk, n];\n      if (!isAligned32(buf)) 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: Uint8Array, dst?: Uint8Array) => processCtr(plaintext, dst),\n      decrypt: (ciphertext: Uint8Array, dst?: Uint8Array) => processCtr(ciphertext, dst),\n    };\n  }\n);\n\nfunction validateBlockDecrypt(data: Uint8Array) {\n  abytes(data);\n  if (data.length % BLOCK_SIZE !== 0) {\n    throw new Error(\n      'aes-(cbc/ecb).decrypt ciphertext should consist of blocks with size ' + BLOCK_SIZE\n    );\n  }\n}\n\nfunction validateBlockEncrypt(plaintext: Uint8Array, pcks5: boolean, dst?: Uint8Array) {\n  abytes(plaintext);\n  let outLen = plaintext.length;\n  const remaining = outLen % BLOCK_SIZE;\n  if (!pcks5 && remaining !== 0)\n    throw new Error('aec/(cbc-ecb): unpadded plaintext with disabled padding');\n  if (!isAligned32(plaintext)) plaintext = copyBytes(plaintext);\n  const b = u32(plaintext);\n  if (pcks5) {\n    let left = BLOCK_SIZE - remaining;\n    if (!left) 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  const o = u32(dst);\n  return { b, o, out: dst };\n}\n\nfunction validatePCKS(data: Uint8Array, pcks5: boolean) {\n  if (!pcks5) return data;\n  const len = data.length;\n  if (!len) throw new Error('aes/pcks5: empty ciphertext not allowed');\n  const lastByte = data[len - 1];\n  if (lastByte <= 0 || lastByte > 16) throw new Error('aes/pcks5: wrong padding');\n  const out = data.subarray(0, -lastByte);\n  for (let i = 0; i < lastByte; i++)\n    if (data[len - i - 1] !== lastByte) throw new Error('aes/pcks5: wrong padding');\n  return out;\n}\n\nfunction padPCKS(left: Uint8Array) {\n  const tmp = new Uint8Array(16);\n  const tmp32 = u32(tmp);\n  tmp.set(left);\n  const paddingByte = BLOCK_SIZE - left.length;\n  for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++) tmp[i] = paddingByte;\n  return tmp32;\n}\n\n/** Options for ECB and CBC. */\nexport type BlockOpts = { disablePadding?: boolean };\n\n/**\n * ECB: Electronic CodeBook. Simple deterministic replacement.\n * Dangerous: always map x to y. See [AES Penguin](https://words.filippo.io/the-ecb-penguin/).\n */\nexport const ecb: ((key: Uint8Array, opts?: BlockOpts) => CipherWithOutput) & {\n  blockSize: number;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 16 },\n  function aesecb(key: Uint8Array, opts: BlockOpts = {}): CipherWithOutput {\n    const pcks5 = !opts.disablePadding;\n    return {\n      encrypt(plaintext: Uint8Array, dst?: Uint8Array) {\n        const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, 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 (pcks5) {\n          const tmp32 = padPCKS(plaintext.subarray(i * 4));\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        clean(xk);\n        return _out;\n      },\n      decrypt(ciphertext: Uint8Array, dst?: Uint8Array) {\n        validateBlockDecrypt(ciphertext);\n        const xk = expandKeyDecLE(key);\n        dst = getOutput(ciphertext.length, dst);\n        const toClean: (Uint8Array | Uint32Array)[] = [xk];\n        if (!isAligned32(ciphertext)) toClean.push((ciphertext = copyBytes(ciphertext)));\n        complexOverlapBytes(ciphertext, dst);\n        const b = u32(ciphertext);\n        const o = u32(dst);\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        clean(...toClean);\n        return validatePCKS(dst, pcks5);\n      },\n    };\n  }\n);\n\n/**\n * CBC: Cipher-Block-Chaining. Key is previous round’s block.\n * Fragile: needs proper padding. Unauthenticated: needs MAC.\n */\nexport const cbc: ((key: Uint8Array, iv: Uint8Array, opts?: BlockOpts) => CipherWithOutput) & {\n  blockSize: number;\n  nonceLength: number;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 16, nonceLength: 16 },\n  function aescbc(key: Uint8Array, iv: Uint8Array, opts: BlockOpts = {}): CipherWithOutput {\n    const pcks5 = !opts.disablePadding;\n    return {\n      encrypt(plaintext: Uint8Array, dst?: Uint8Array) {\n        const xk = expandKeyLE(key);\n        const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n        let _iv = iv;\n        const toClean: (Uint8Array | Uint32Array)[] = [xk];\n        if (!isAligned32(_iv)) toClean.push((_iv = copyBytes(_iv)));\n        const n32 = u32(_iv);\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 (pcks5) {\n          const tmp32 = padPCKS(plaintext.subarray(i * 4));\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        clean(...toClean);\n        return _out;\n      },\n      decrypt(ciphertext: Uint8Array, dst?: Uint8Array) {\n        validateBlockDecrypt(ciphertext);\n        const xk = expandKeyDecLE(key);\n        let _iv = iv;\n        const toClean: (Uint8Array | Uint32Array)[] = [xk];\n        if (!isAligned32(_iv)) toClean.push((_iv = copyBytes(_iv)));\n        const n32 = u32(_iv);\n        dst = getOutput(ciphertext.length, dst);\n        if (!isAligned32(ciphertext)) toClean.push((ciphertext = copyBytes(ciphertext)));\n        complexOverlapBytes(ciphertext, dst);\n        const b = u32(ciphertext);\n        const o = u32(dst);\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        clean(...toClean);\n        return validatePCKS(dst, pcks5);\n      },\n    };\n  }\n);\n\n/**\n * CFB: Cipher Feedback Mode. The input for the block cipher is the previous cipher output.\n * Unauthenticated: needs MAC.\n */\nexport const cfb: ((key: Uint8Array, iv: Uint8Array) => CipherWithOutput) & {\n  blockSize: number;\n  nonceLength: number;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 16, nonceLength: 16 },\n  function aescfb(key: Uint8Array, iv: Uint8Array): CipherWithOutput {\n    function processCfb(src: Uint8Array, isEncrypt: boolean, dst?: Uint8Array) {\n      abytes(src);\n      const srcLen = src.length;\n      dst = getOutput(srcLen, dst);\n      if (overlapBytes(src, dst)) throw new Error('overlapping src and dst not supported.');\n      const xk = expandKeyLE(key);\n      let _iv = iv;\n      const toClean: (Uint8Array | Uint32Array)[] = [xk];\n      if (!isAligned32(_iv)) toClean.push((_iv = copyBytes(_iv)));\n      if (!isAligned32(src)) toClean.push((src = copyBytes(src)));\n      const src32 = u32(src);\n      const dst32 = u32(dst);\n      const next32 = isEncrypt ? dst32 : src32;\n      const n32 = u32(_iv);\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        ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n        const buf = u8(new Uint32Array([s0, s1, s2, s3]));\n        for (let i = start, pos = 0; i < srcLen; i++, pos++) dst[i] = src[i] ^ buf[pos];\n        clean(buf);\n      }\n      clean(...toClean);\n      return dst;\n    }\n    return {\n      encrypt: (plaintext: Uint8Array, dst?: Uint8Array) => processCfb(plaintext, true, dst),\n      decrypt: (ciphertext: Uint8Array, dst?: Uint8Array) => processCfb(ciphertext, false, dst),\n    };\n  }\n);\n\n// TODO: merge with chacha, however gcm has bitLen while chacha has byteLen\nfunction computeTag(\n  fn: typeof ghash,\n  isLE: boolean,\n  key: Uint8Array,\n  data: Uint8Array,\n  AAD?: Uint8Array\n) {\n  const aadLength = AAD ? AAD.length : 0;\n  const h = fn.create(key, data.length + aadLength);\n  if (AAD) h.update(AAD);\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/**\n * GCM: Galois/Counter Mode.\n * Modern, parallel version of CTR, with MAC.\n * Be careful: MACs can be forged.\n * Unsafe to use random nonces under the same key, due to collision chance.\n * As for nonce size, prefer 12-byte, instead of 8-byte.\n */\nexport const gcm: ((key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array) => Cipher) & {\n  blockSize: number;\n  nonceLength: number;\n  tagLength: number;\n  varSizeNonce: true;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true },\n  function aesgcm(key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array): Cipher {\n    // NIST 800-38d doesn't enforce minimum nonce length.\n    // We enforce 8 bytes for compat with openssl.\n    // 12 bytes are recommended. More than 12 bytes would be converted into 12.\n    if (nonce.length < 8) throw new Error('aes/gcm: invalid nonce length');\n    const tagLength = 16;\n    function _computeTag(authKey: Uint8Array, tagMask: Uint8Array, data: Uint8Array) {\n      const tag = computeTag(ghash, false, authKey, data, AAD);\n      for (let i = 0; i < tagMask.length; i++) 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      } else {\n        const nonceLen = EMPTY_BLOCK.slice();\n        const view = createView(nonceLen);\n        setBigUint64(view, 8, BigInt(nonce.length * 8), false);\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      const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);\n      return { xk, authKey, counter, tagMask };\n    }\n    return {\n      encrypt(plaintext: Uint8Array) {\n        const { xk, authKey, counter, tagMask } = deriveKeys();\n        const out = new Uint8Array(plaintext.length + tagLength);\n        const toClean: (Uint8Array | Uint32Array)[] = [xk, authKey, counter, tagMask];\n        if (!isAligned32(plaintext)) 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: Uint8Array) {\n        const { xk, authKey, counter, tagMask } = deriveKeys();\n        const toClean: (Uint8Array | Uint32Array)[] = [xk, authKey, tagMask, counter];\n        if (!isAligned32(ciphertext)) 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        if (!equalBytes(tag, passedTag)) throw new Error('aes/gcm: invalid ghash tag');\n        const out = ctr32(xk, false, counter, data);\n        clean(...toClean);\n        return out;\n      },\n    };\n  }\n);\n\nconst limit = (name: string, min: number, max: number) => (value: number) => {\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/**\n * AES-GCM-SIV: classic AES-GCM with nonce-misuse resistance.\n * Guarantees that, when a nonce is repeated, the only security loss is that identical\n * plaintexts will produce identical ciphertexts.\n * RFC 8452, https://datatracker.ietf.org/doc/html/rfc8452\n */\nexport const gcmsiv: ((key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array) => Cipher) & {\n  blockSize: number;\n  nonceLength: number;\n  tagLength: number;\n  varSizeNonce: true;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true },\n  function aessiv(key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array): Cipher {\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, 16, 24, 32);\n    NONCE_LIMIT(nonce.length);\n    if (AAD !== undefined) 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: (Uint8Array | Uint32Array)[] = [xk, encKey];\n      let _nonce = nonce;\n      if (!isAligned32(_nonce)) toClean.push((_nonce = copyBytes(_nonce)));\n      const n32 = u32(_nonce);\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      }\n      const res = { authKey, encKey: expandKeyLE(encKey) };\n      // Cleanup\n      clean(...toClean);\n      return res;\n    }\n    function _computeTag(encKey: Uint32Array, authKey: Uint8Array, data: Uint8Array) {\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++) tag[i] ^= nonce[i];\n      tag[15] &= 0x7f; // Clear the highest bit\n      // encrypt tag as block\n      const t32 = u32(tag);\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      return tag;\n    }\n    // actual decrypt/encrypt of message.\n    function processSiv(encKey: Uint32Array, tag: Uint8Array, input: Uint8Array) {\n      let block = copyBytes(tag);\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: Uint8Array) {\n        PLAIN_LIMIT(plaintext.length);\n        const { encKey, authKey } = deriveKeys();\n        const tag = _computeTag(encKey, authKey, plaintext);\n        const toClean: (Uint8Array | Uint32Array)[] = [encKey, authKey, tag];\n        if (!isAligned32(plaintext)) 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: Uint8Array) {\n        CIPHER_LIMIT(ciphertext.length);\n        const tag = ciphertext.subarray(-tagLength);\n        const { encKey, authKey } = deriveKeys();\n        const toClean: (Uint8Array | Uint32Array)[] = [encKey, authKey];\n        if (!isAligned32(ciphertext)) 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        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  }\n);\n\n/**\n * AES-GCM-SIV, not AES-SIV.\n * This is legace name, use `gcmsiv` export instead.\n * @deprecated\n */\nexport const siv: typeof gcmsiv = gcmsiv;\n\nfunction isBytes32(a: unknown): a is Uint32Array {\n  return (\n    a instanceof Uint32Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint32Array')\n  );\n}\n\nfunction encryptBlock(xk: Uint32Array, block: Uint8Array): Uint8Array {\n  abytes(block, 16);\n  if (!isBytes32(xk)) throw new Error('_encryptBlock accepts result of expandKeyLE');\n  const b32 = u32(block);\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  return block;\n}\n\nfunction decryptBlock(xk: Uint32Array, block: Uint8Array): Uint8Array {\n  abytes(block, 16);\n  if (!isBytes32(xk)) throw new Error('_decryptBlock accepts result of expandKeyLE');\n  const b32 = u32(block);\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  return block;\n}\n\n/**\n * AES-W (base for AESKW/AESKWP).\n * Specs: [SP800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf),\n * [RFC 3394](https://datatracker.ietf.org/doc/rfc3394/),\n * [RFC 5649](https://datatracker.ietf.org/doc/rfc5649/).\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: Uint8Array, out: Uint8Array) {\n    // Size is limited to 4GB, otherwise ctr will overflow and we'll need to switch to bigints.\n    // If you need it larger, open an issue.\n    if (out.length >= 2 ** 32) throw new Error('plaintext should be less than 4gb');\n    const xk = expandKeyLE(kek);\n    if (out.length === 16) encryptBlock(xk, out);\n    else {\n      const o32 = u32(out);\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\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    }\n    xk.fill(0);\n  },\n  decrypt(kek: Uint8Array, out: Uint8Array) {\n    if (out.length - 8 >= 2 ** 32) 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    if (chunks === 1) decryptBlock(xk, out);\n    else {\n      const o32 = u32(out);\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    }\n    xk.fill(0);\n  },\n};\n\nconst AESKW_IV = /* @__PURE__ */ new Uint8Array(8).fill(0xa6); // A6A6A6A6A6A6A6A6\n\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 * For padded version, use aeskwp.\n * [RFC 3394](https://datatracker.ietf.org/doc/rfc3394/),\n * [NIST.SP.800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf).\n */\nexport const aeskw: ((kek: Uint8Array) => Cipher) & {\n  blockSize: number;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 8 },\n  (kek: Uint8Array): Cipher => ({\n    encrypt(plaintext: Uint8Array) {\n      if (!plaintext.length || plaintext.length % 8 !== 0)\n        throw new Error('invalid plaintext length');\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: Uint8Array) {\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      const out = copyBytes(ciphertext);\n      AESW.decrypt(kek, out);\n      if (!equalBytes(out.subarray(0, 8), AESKW_IV)) 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);\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    - https://github.com/C2SP/wycheproof/blob/master/doc/key_wrap.md\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      https://www.w3.org/TR/2002/REC-xmlenc-core-20021210/Overview.html#kw-aes128\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] { 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\nconst AESKWP_IV = 0xa65959a6; // single u32le value\n\n/**\n * AES-KW, but with padding and allows random keys.\n * Second u32 of IV is used as counter for length.\n * [RFC 5649](https://www.rfc-editor.org/rfc/rfc5649)\n */\nexport const aeskwp: ((kek: Uint8Array) => Cipher) & {\n  blockSize: number;\n} = /* @__PURE__ */ wrapCipher(\n  { blockSize: 8 },\n  (kek: Uint8Array): Cipher => ({\n    encrypt(plaintext: Uint8Array) {\n      if (!plaintext.length) 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] = AESKWP_IV;\n      out32[1] = byteSwap(plaintext.length);\n      AESW.encrypt(kek, out);\n      return out;\n    },\n    decrypt(ciphertext: Uint8Array) {\n      // 16 because should have at least one block\n      if (ciphertext.length < 16) throw new Error('invalid ciphertext length');\n      const out = copyBytes(ciphertext);\n      const o32 = u32(out);\n      AESW.decrypt(kek, out);\n      const len = byteSwap(o32[1]) >>> 0;\n      const padded = Math.ceil(len / 8) * 8;\n      if (o32[0] !== AESKWP_IV || out.length - 8 !== padded)\n        throw new Error('integrity check failed');\n      for (let i = len; i < padded; i++)\n        if (out[8 + i] !== 0) 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  })\n);\n\n/** Unsafe low-level internal methods. May change at any time. */\nexport const unsafe: {\n  expandKeyLE: typeof expandKeyLE;\n  expandKeyDecLE: typeof expandKeyDecLE;\n  encrypt: typeof encrypt;\n  decrypt: typeof decrypt;\n  encryptBlock: typeof encryptBlock;\n  decryptBlock: typeof decryptBlock;\n  ctrCounter: typeof ctrCounter;\n  ctr32: typeof ctr32;\n} = {\n  expandKeyLE,\n  expandKeyDecLE,\n  encrypt,\n  decrypt,\n  encryptBlock,\n  decryptBlock,\n  ctrCounter,\n  ctr32,\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PublicKey = exports.PrivateKey = void 0;\n// treat Buffer as Uint8array, i.e. no call of Buffer specific functions\n// finally Uint8Array only\nvar PrivateKey_js_1 = require(\"./PrivateKey.js\");\nObject.defineProperty(exports, \"PrivateKey\", { enumerable: true, get: function () { return PrivateKey_js_1.PrivateKey; } });\nvar PublicKey_js_1 = require(\"./PublicKey.js\");\nObject.defineProperty(exports, \"PublicKey\", { enumerable: true, get: function () { return PublicKey_js_1.PublicKey; } });\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.chacha20 = exports.xchacha20 = void 0;\nvar chacha_1 = require(\"@noble/ciphers/chacha\");\nvar xchacha20 = function (key, nonce, AAD) {\n    return (0, chacha_1.xchacha20poly1305)(key, nonce, AAD);\n};\nexports.xchacha20 = xchacha20;\nvar chacha20 = function (key, nonce, AAD) {\n    return (0, chacha_1.chacha20poly1305)(key, nonce, AAD);\n};\nexports.chacha20 = chacha20;\n","/**\n * Internal webcrypto alias.\n * We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n * See utils.ts for details.\n * @module\n */\ndeclare const globalThis: Record<string, any> | undefined;\nexport const crypto: any =\n  typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n","/**\n * WebCrypto-based AES gcm/ctr/cbc, `managedNonce` and `randomBytes`.\n * We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n * node.js versions earlier than v19 don't declare it in global scope.\n * For node.js, package.js on#exports field mapping rewrites import\n * from `crypto` to `cryptoNode`, which imports native module.\n * Makes the utils un-importable in browsers without a bundler.\n * Once node.js 18 is deprecated, we can just drop the import.\n * @module\n */\n// Use full path so that Node.js can rewrite it to `cryptoNode.js`.\nimport { crypto } from '@noble/ciphers/crypto';\nimport { abytes, anumber, type AsyncCipher, type Cipher, concatBytes } from './utils.ts';\n\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32): Uint8Array {\n  if (crypto && typeof crypto.getRandomValues === 'function') {\n    return crypto.getRandomValues(new Uint8Array(bytesLength));\n  }\n  // Legacy Node.js compatibility\n  if (crypto && typeof crypto.randomBytes === 'function') {\n    return Uint8Array.from(crypto.randomBytes(bytesLength));\n  }\n  throw new Error('crypto.getRandomValues must be defined');\n}\n\nexport function getWebcryptoSubtle(): any {\n  if (crypto && typeof crypto.subtle === 'object' && crypto.subtle != null) return crypto.subtle;\n  throw new Error('crypto.subtle must be defined');\n}\n\ntype RemoveNonceInner<T extends any[], Ret> = ((...args: T) => Ret) extends (\n  arg0: any,\n  arg1: any,\n  ...rest: infer R\n) => any\n  ? (key: Uint8Array, ...args: R) => Ret\n  : never;\n\ntype RemoveNonce<T extends (...args: any) => any> = RemoveNonceInner<Parameters<T>, ReturnType<T>>;\ntype CipherWithNonce = ((key: Uint8Array, nonce: Uint8Array, ...args: any[]) => Cipher) & {\n  nonceLength: number;\n};\n\n/**\n * Uses CSPRG for nonce, nonce injected in ciphertext.\n * @example\n * const gcm = managedNonce(aes.gcm);\n * const ciphr = gcm(key).encrypt(data);\n * const plain = gcm(key).decrypt(ciph);\n */\nexport function managedNonce<T extends CipherWithNonce>(fn: T): RemoveNonce<T> {\n  const { nonceLength } = fn;\n  anumber(nonceLength);\n  return ((key: Uint8Array, ...args: any[]): any => ({\n    encrypt(plaintext: Uint8Array, ...argsEnc: any[]) {\n      const nonce = randomBytes(nonceLength);\n      const ciphertext = (fn(key, nonce, ...args).encrypt as any)(plaintext, ...argsEnc);\n      const out = concatBytes(nonce, ciphertext);\n      ciphertext.fill(0);\n      return out;\n    },\n    decrypt(ciphertext: Uint8Array, ...argsDec: any[]) {\n      const nonce = ciphertext.subarray(0, nonceLength);\n      const data = ciphertext.subarray(nonceLength);\n      return (fn(key, nonce, ...args).decrypt as any)(data, ...argsDec);\n    },\n  })) as RemoveNonce<T>;\n}\n\n// Overridable\n// @TODO\nexport const utils: {\n  encrypt: (key: Uint8Array, ...all: any[]) => Promise<Uint8Array>;\n  decrypt: (key: Uint8Array, ...all: any[]) => Promise<Uint8Array>;\n} = {\n  async encrypt(\n    key: Uint8Array,\n    keyParams: any,\n    cryptParams: any,\n    plaintext: Uint8Array\n  ): Promise<Uint8Array> {\n    const cr = getWebcryptoSubtle();\n    const iKey = await cr.importKey('raw', key, keyParams, true, ['encrypt']);\n    const ciphertext = await cr.encrypt(cryptParams, iKey, plaintext);\n    return new Uint8Array(ciphertext);\n  },\n  async decrypt(\n    key: Uint8Array,\n    keyParams: any,\n    cryptParams: any,\n    ciphertext: Uint8Array\n  ): Promise<Uint8Array> {\n    const cr = getWebcryptoSubtle();\n    const iKey = await cr.importKey('raw', key, keyParams, true, ['decrypt']);\n    const plaintext = await cr.decrypt(cryptParams, iKey, ciphertext);\n    return new Uint8Array(plaintext);\n  },\n};\n\nconst mode = {\n  CBC: 'AES-CBC',\n  CTR: 'AES-CTR',\n  GCM: 'AES-GCM',\n} as const;\ntype BlockMode = (typeof mode)[keyof typeof mode];\n\nfunction getCryptParams(algo: BlockMode, nonce: Uint8Array, AAD?: Uint8Array) {\n  if (algo === mode.CBC) return { name: mode.CBC, iv: nonce };\n  if (algo === mode.CTR) return { name: mode.CTR, counter: nonce, length: 64 };\n  if (algo === mode.GCM) {\n    if (AAD) return { name: mode.GCM, iv: nonce, additionalData: AAD };\n    else return { name: mode.GCM, iv: nonce };\n  }\n\n  throw new Error('unknown aes block mode');\n}\n\nfunction generate(algo: BlockMode) {\n  return (key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array): AsyncCipher => {\n    abytes(key);\n    abytes(nonce);\n    const keyParams = { name: algo, length: key.length * 8 };\n    const cryptParams = getCryptParams(algo, nonce, AAD);\n    let consumed = false;\n    return {\n      // keyLength,\n      encrypt(plaintext: Uint8Array) {\n        abytes(plaintext);\n        if (consumed) throw new Error('Cannot encrypt() twice with same key / nonce');\n        consumed = true;\n        return utils.encrypt(key, keyParams, cryptParams, plaintext);\n      },\n      decrypt(ciphertext: Uint8Array) {\n        abytes(ciphertext);\n        return utils.decrypt(key, keyParams, cryptParams, ciphertext);\n      },\n    };\n  };\n}\n\n/** AES-CBC, native webcrypto version */\nexport const cbc: (key: Uint8Array, iv: Uint8Array) => AsyncCipher = /* @__PURE__ */ (() =>\n  generate(mode.CBC))();\n/** AES-CTR, native webcrypto version */\nexport const ctr: (key: Uint8Array, nonce: Uint8Array) => AsyncCipher = /* @__PURE__ */ (() =>\n  generate(mode.CTR))();\n/** AES-GCM, native webcrypto version */\nexport const gcm: (key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array) => AsyncCipher =\n  /* @__PURE__ */ (() => generate(mode.GCM))();\n\n// // Type tests\n// import { siv, gcm, ctr, ecb, cbc } from '../aes.ts';\n// import { xsalsa20poly1305 } from '../salsa.ts';\n// import { chacha20poly1305, xchacha20poly1305 } from '../chacha.ts';\n\n// const wsiv = managedNonce(siv);\n// const wgcm = managedNonce(gcm);\n// const wctr = managedNonce(ctr);\n// const wcbc = managedNonce(cbc);\n// const wsalsapoly = managedNonce(xsalsa20poly1305);\n// const wchacha = managedNonce(chacha20poly1305);\n// const wxchacha = managedNonce(xchacha20poly1305);\n\n// // should fail\n// const wcbc2 = managedNonce(managedNonce(cbc));\n// const wctr = managedNonce(ctr);\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) | ctr(2) | s[2] | k(4) | s[3]\n  chacha:       s(4) | k(8) | ctr(1) | nonce(3)\n  chacha20orig: s(4) | k(8) | ctr(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 [^2] 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).\n\n[^1]: https://mailarchive.ietf.org/arch/msg/cfrg/gsOnTJzcbgG6OqD8Sc0GO5aR_tU/\n[^2]: https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha#appendix-A.2\n\n * @module\n */\n// prettier-ignore\nimport {\n  type XorStream, abool, abytes, anumber, checkOpts, clean, copyBytes, u32\n} from './utils.ts';\n\n// We can't make top-level var depend on utils.utf8ToBytes\n// because it's not present in all envs. Creating a similar fn here\nconst _utf8ToBytes = (str: string) => Uint8Array.from(str.split('').map((c) => c.charCodeAt(0)));\nconst sigma16 = _utf8ToBytes('expand 16-byte k');\nconst sigma32 = _utf8ToBytes('expand 32-byte k');\nconst sigma16_32 = u32(sigma16);\nconst sigma32_32 = u32(sigma32);\n\nexport function rotl(a: number, b: number): number {\n  return (a << b) | (a >>> (32 - b));\n}\n\n/** Ciphers must use u32 for efficiency. */\nexport type CipherCoreFn = (\n  sigma: Uint32Array,\n  key: Uint32Array,\n  nonce: Uint32Array,\n  output: Uint32Array,\n  counter: number,\n  rounds?: number\n) => void;\n\n/** Method which extends key + short nonce into larger nonce / diff key. */\nexport type ExtendNonceFn = (\n  sigma: Uint32Array,\n  key: Uint32Array,\n  input: Uint32Array,\n  output: Uint32Array\n) => void;\n\n/** ARX cipher options.\n * * `allowShortKeys` for 16-byte keys\n * * `counterLength` in bytes\n * * `counterRight`: right: `nonce|counter`; left: `counter|nonce`\n * */\nexport type CipherOpts = {\n  allowShortKeys?: boolean; // Original salsa / chacha allow 16-byte keys\n  extendNonceFn?: ExtendNonceFn;\n  counterLength?: number;\n  counterRight?: boolean;\n  rounds?: number;\n};\n\n// Is byte array aligned to 4 byte offset (u32)?\nfunction isAligned32(b: Uint8Array) {\n  return b.byteOffset % 4 === 0;\n}\n\n// Salsa and Chacha block length is always 512-bit\nconst BLOCK_LEN = 64;\nconst BLOCK_LEN32 = 16;\n\n// new Uint32Array([2**32])   // => Uint32Array(1) [ 0 ]\n// new Uint32Array([2**32-1]) // => Uint32Array(1) [ 4294967295 ]\nconst MAX_COUNTER = 2 ** 32 - 1;\n\nconst U32_EMPTY = new Uint32Array();\nfunction runCipher(\n  core: CipherCoreFn,\n  sigma: Uint32Array,\n  key: Uint32Array,\n  nonce: Uint32Array,\n  data: Uint8Array,\n  output: Uint8Array,\n  counter: number,\n  rounds: number\n): void {\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 = isAligned32(data) && isAligned32(output);\n  const d32 = isAligned ? u32(data) : U32_EMPTY;\n  const o32 = isAligned ? u32(output) : U32_EMPTY;\n  for (let pos = 0; pos < len; counter++) {\n    core(sigma, key, nonce, b32, counter, rounds);\n    if (counter >= MAX_COUNTER) 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) throw new Error('arx: invalid block position');\n      for (let j = 0, posj: number; 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 ARX-like (ChaCha, Salsa) cipher stream from core function. */\nexport function createCipher(core: CipherCoreFn, opts: CipherOpts): XorStream {\n  const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts(\n    { allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 },\n    opts\n  );\n  if (typeof core !== 'function') throw new Error('core must be a function');\n  anumber(counterLength);\n  anumber(rounds);\n  abool(counterRight);\n  abool(allowShortKeys);\n  return (\n    key: Uint8Array,\n    nonce: Uint8Array,\n    data: Uint8Array,\n    output?: Uint8Array,\n    counter = 0\n  ): Uint8Array => {\n    abytes(key);\n    abytes(nonce);\n    abytes(data);\n    const len = data.length;\n    if (output === undefined) output = new Uint8Array(len);\n    abytes(output);\n    anumber(counter);\n    if (counter < 0 || counter >= MAX_COUNTER) throw new Error('arx: counter overflow');\n    if (output.length < len)\n      throw new Error(`arx: output (${output.length}) is shorter than data (${len})`);\n    const toClean = [];\n\n    // Key & sigma\n    // key=16 -> sigma16, k=key|key\n    // key=32 -> sigma32, k=key\n    let l = key.length;\n    let k: Uint8Array;\n    let sigma: Uint32Array;\n    if (l === 32) {\n      toClean.push((k = copyBytes(key)));\n      sigma = sigma32_32;\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    } else {\n      throw new Error(`arx: invalid 32-byte key, got length=${l}`);\n    }\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    // Align nonce to 4 bytes\n    if (!isAligned32(nonce)) toClean.push((nonce = copyBytes(nonce)));\n\n    const k32 = u32(k);\n    // hsalsa & hchacha: handle extended nonce\n    if (extendNonceFn) {\n      if (nonce.length !== 24) throw new Error(`arx: extended nonce must be 24 bytes`);\n      extendNonceFn(sigma, k32, u32(nonce.subarray(0, 16)), k32);\n      nonce = nonce.subarray(16);\n    }\n\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\n    // Pad counter when nonce is 64 bit\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 = u32(nonce);\n    runCipher(core, sigma, k32, n32, data, output, counter, rounds);\n    clean(...toClean);\n    return output;\n  };\n}\n","/**\n * Poly1305 ([PDF](https://cr.yp.to/mac/poly1305-20050329.pdf),\n * [wiki](https://en.wikipedia.org/wiki/Poly1305))\n * is a fast and parallel secret-key message-authentication code suitable for\n * a wide variety of applications. It was standardized in\n * [RFC 8439](https://datatracker.ietf.org/doc/html/rfc8439) 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 [invisible salamanders attack](https://keymaterial.net/2020/09/07/invisible-salamanders-in-aes-gcm-siv/).\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 [original website](https://cr.yp.to/mac.html).\n * @module\n */\nimport { Hash, type Input, abytes, aexists, aoutput, clean, toBytes } from './utils.ts';\n\n// Based on Public Domain poly1305-donna https://github.com/floodyberry/poly1305-donna\nconst u8to16 = (a: Uint8Array, i: number) => (a[i++] & 0xff) | ((a[i++] & 0xff) << 8);\nclass Poly1305 implements Hash<Poly1305> {\n  readonly blockLen = 16;\n  readonly outputLen = 16;\n  private buffer = new Uint8Array(16);\n  private r = new Uint16Array(10);\n  private h = new Uint16Array(10);\n  private pad = new Uint16Array(8);\n  private pos = 0;\n  protected finished = false;\n\n  constructor(key: Input) {\n    key = toBytes(key);\n    abytes(key, 32);\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\n    // https://github.com/floodyberry/poly1305-donna/blob/e6ad6e091d30d7f4ec2d4f978be1fcfcbce72781/poly1305-donna-16.h#L47\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++) this.pad[i] = u8to16(key, 16 + 2 * i);\n  }\n\n  private process(data: Uint8Array, offset: number, isLast = false) {\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\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\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\n    let c = 0;\n\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\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\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\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\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\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\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\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\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\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\n    c = ((c << 2) + c) | 0;\n    c = (c + d0) | 0;\n    d0 = c & 0x1fff;\n    c = c >>> 13;\n    d1 += c;\n\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\n  private 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\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\n    let mask = (c ^ 1) - 1;\n    for (let i = 0; i < 10; i++) g[i] &= mask;\n    mask = ~mask;\n    for (let i = 0; i < 10; i++) 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\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: Input): this {\n    aexists(this);\n    data = toBytes(data);\n    abytes(data);\n    const { buffer, blockLen } = this;\n    const len = data.length;\n\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) 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    clean(this.h, this.r, this.buffer, this.pad);\n  }\n  digestInto(out: Uint8Array) {\n    aexists(this);\n    aoutput(out, this);\n    this.finished = true;\n    const { buffer, h } = this;\n    let { pos } = this;\n    if (pos) {\n      buffer[pos++] = 1;\n      for (; pos < 16; pos++) 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    return out;\n  }\n  digest(): Uint8Array {\n    const { buffer, outputLen } = this;\n    this.digestInto(buffer);\n    const res = buffer.slice(0, outputLen);\n    this.destroy();\n    return res;\n  }\n}\n\nexport type CHash = ReturnType<typeof wrapConstructorWithKey>;\nexport function wrapConstructorWithKey<H extends Hash<H>>(\n  hashCons: (key: Input) => Hash<H>\n): {\n  (msg: Input, key: Input): Uint8Array;\n  outputLen: number;\n  blockLen: number;\n  create(key: Input): Hash<H>;\n} {\n  const hashC = (msg: Input, key: Input): Uint8Array => hashCons(key).update(toBytes(msg)).digest();\n  const tmp = hashCons(new Uint8Array(32));\n  hashC.outputLen = tmp.outputLen;\n  hashC.blockLen = tmp.blockLen;\n  hashC.create = (key: Input) => hashCons(key);\n  return hashC;\n}\n\n/** Poly1305 MAC from RFC 8439. */\nexport const poly1305: CHash = wrapConstructorWithKey((key) => new Poly1305(key));\n","/**\n * [ChaCha20](https://cr.yp.to/chacha.html) stream cipher, released\n * in 2008. Developed after Salsa20, ChaCha aims to increase diffusion per round.\n * It was standardized in [RFC 8439](https://datatracker.ietf.org/doc/html/rfc8439) and\n * is now used in TLS 1.3.\n *\n * [XChaCha20](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha)\n * extended-nonce variant is also provided. Similar to XSalsa, it's safe to use with\n * randomly-generated nonces.\n *\n * Check out [PDF](http://cr.yp.to/chacha/chacha-20080128.pdf) and\n * [wiki](https://en.wikipedia.org/wiki/Salsa20).\n * @module\n */\nimport { createCipher, rotl } from './_arx.ts';\nimport { poly1305 } from './_poly1305.ts';\nimport {\n  type ARXCipher,\n  type CipherWithOutput,\n  type XorStream,\n  clean,\n  equalBytes,\n  getOutput,\n  u64Lengths,\n  wrapCipher,\n} from './utils.ts';\n\n/**\n * ChaCha core function.\n */\n// prettier-ignore\nfunction chachaCore(\n  s: Uint32Array, k: Uint32Array, n: Uint32Array, out: Uint32Array, cnt: number, rounds = 20\n): void {\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  Counter\tNonce   Nonce\n  // Save state to temporary variables\n  let x00 = y00, x01 = y01, x02 = y02, x03 = y03,\n      x04 = y04, x05 = y05, x06 = y06, x07 = y07,\n      x08 = y08, x09 = y09, x10 = y10, x11 = y11,\n      x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n  for (let r = 0; r < rounds; r += 2) {\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 16);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 12);\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 8);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 7);\n\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 16);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 12);\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 8);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 7);\n\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 16);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 12);\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 8);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 7);\n\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 16);\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 12);\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 8)\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 7);\n\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 16);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 12);\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 8);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 7);\n\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 16);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 12);\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 8);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 7);\n\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 16);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 12);\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 8);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 7);\n\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 16)\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 12);\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 8);\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 7);\n  }\n  // Write output\n  let oi = 0;\n  out[oi++] = (y00 + x00) | 0; out[oi++] = (y01 + x01) | 0;\n  out[oi++] = (y02 + x02) | 0; out[oi++] = (y03 + x03) | 0;\n  out[oi++] = (y04 + x04) | 0; out[oi++] = (y05 + x05) | 0;\n  out[oi++] = (y06 + x06) | 0; out[oi++] = (y07 + x07) | 0;\n  out[oi++] = (y08 + x08) | 0; out[oi++] = (y09 + x09) | 0;\n  out[oi++] = (y10 + x10) | 0; out[oi++] = (y11 + x11) | 0;\n  out[oi++] = (y12 + x12) | 0; out[oi++] = (y13 + x13) | 0;\n  out[oi++] = (y14 + x14) | 0; out[oi++] = (y15 + x15) | 0;\n}\n/**\n * hchacha helper method, used primarily in xchacha, to hash\n * key and nonce into key' and nonce'.\n * Same as chachaCore, but there doesn't seem to be a way to move the block\n * out without 25% performance hit.\n */\n// prettier-ignore\nexport function hchacha(\n  s: Uint32Array, k: Uint32Array, i: Uint32Array, o32: Uint32Array\n): void {\n  let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3],\n      x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3],\n      x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7],\n      x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3];\n  for (let r = 0; r < 20; r += 2) {\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 16);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 12);\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 8);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 7);\n\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 16);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 12);\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 8);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 7);\n\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 16);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 12);\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 8);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 7);\n\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 16);\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 12);\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 8)\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 7);\n\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 16);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 12);\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 8);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 7);\n\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 16);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 12);\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 8);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 7);\n\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 16);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 12);\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 8);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 7);\n\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 16)\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 12);\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 8);\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 7);\n  }\n  let oi = 0;\n  o32[oi++] = x00; o32[oi++] = x01;\n  o32[oi++] = x02; o32[oi++] = x03;\n  o32[oi++] = x12; o32[oi++] = x13;\n  o32[oi++] = x14; o32[oi++] = x15;\n}\n/**\n * Original, non-RFC chacha20 from DJB. 8-byte nonce, 8-byte counter.\n */\nexport const chacha20orig: XorStream = /* @__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 12-byte nonce, it's not safe to use fill it with random (CSPRNG), due to collision chance.\n */\nexport const chacha20: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 4,\n  allowShortKeys: false,\n});\n\n/**\n * XChaCha eXtended-nonce ChaCha. 24-byte nonce.\n * With 24-byte nonce, it's safe to use fill it with random (CSPRNG).\n * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha\n */\nexport const xchacha20: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 8,\n  extendNonceFn: hchacha,\n  allowShortKeys: false,\n});\n\n/**\n * Reduced 8-round chacha, described in original paper.\n */\nexport const chacha8: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 4,\n  rounds: 8,\n});\n\n/**\n * Reduced 12-round chacha, described in original paper.\n */\nexport const chacha12: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 4,\n  rounds: 12,\n});\n\nconst ZEROS16 = /* @__PURE__ */ new Uint8Array(16);\n// Pad to digest size with zeros\nconst updatePadded = (h: ReturnType<typeof poly1305.create>, msg: Uint8Array) => {\n  h.update(msg);\n  const left = msg.length % 16;\n  if (left) h.update(ZEROS16.subarray(left));\n};\n\nconst ZEROS32 = /* @__PURE__ */ new Uint8Array(32);\nfunction computeTag(\n  fn: XorStream,\n  key: Uint8Array,\n  nonce: Uint8Array,\n  data: Uint8Array,\n  AAD?: Uint8Array\n): Uint8Array {\n  const authKey = fn(key, nonce, ZEROS32);\n  const h = poly1305.create(authKey);\n  if (AAD) updatePadded(h, AAD);\n  updatePadded(h, data);\n  const num = u64Lengths(data.length, AAD ? AAD.length : 0, true);\n  h.update(num);\n  const res = h.digest();\n  clean(authKey, num);\n  return res;\n}\n\n/**\n * AEAD algorithm from RFC 8439.\n * Salsa20 and chacha (RFC 8439) use poly1305 differently.\n * We could have composed them similar to:\n * https://github.com/paulmillr/scure-base/blob/b266c73dde977b1dd7ef40ef7a23cc15aab526b3/index.ts#L250\n * 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 =\n  (xorStream: XorStream) =>\n  (key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array): CipherWithOutput => {\n    const tagLength = 16;\n    return {\n      encrypt(plaintext: Uint8Array, output?: Uint8Array) {\n        const plength = plaintext.length;\n        output = getOutput(plength + tagLength, output, false);\n        output.set(plaintext);\n        const oPlain = output.subarray(0, -tagLength);\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: Uint8Array, output?: Uint8Array) {\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        if (!equalBytes(passedTag, tag)) throw new Error('invalid tag');\n        output.set(ciphertext.subarray(0, -tagLength));\n        xorStream(key, nonce, output, output, 1); // start stream with i=1\n        clean(tag);\n        return output;\n      },\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 */\nexport const chacha20poly1305: ARXCipher = /* @__PURE__ */ wrapCipher(\n  { blockSize: 64, nonceLength: 12, tagLength: 16 },\n  _poly1305_aead(chacha20)\n);\n/**\n * XChaCha20-Poly1305 extended-nonce chacha.\n *\n * Can be safely used with random nonces (CSPRNG).\n * See [IRTF draft](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha).\n */\nexport const xchacha20poly1305: ARXCipher = /* @__PURE__ */ wrapCipher(\n  { blockSize: 64, nonceLength: 24, tagLength: 16 },\n  _poly1305_aead(xchacha20)\n);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.utils = exports.PublicKey = exports.PrivateKey = exports.ECIES_CONFIG = void 0;\nexports.encrypt = encrypt;\nexports.decrypt = decrypt;\nvar utils_1 = require(\"@noble/ciphers/utils\");\nvar config_js_1 = require(\"./config.js\");\nvar index_js_1 = require(\"./keys/index.js\");\nvar index_js_2 = require(\"./utils/index.js\");\n/**\n * Encrypts data with a receiver's public key.\n * @description From version 0.5.0, `Uint8Array` will be returned instead of `Buffer`.\n * To keep the same behavior, use `Buffer.from(encrypt(...))`.\n *\n * @param receiverRawPK - Raw public key of the receiver, either as a hex `string` or a `Uint8Array`.\n * @param data - Data to encrypt.\n * @returns Encrypted payload, format: `public key || encrypted`.\n */\nfunction encrypt(receiverRawPK, data) {\n    return Buffer.from(_encrypt(receiverRawPK, data, config_js_1.ECIES_CONFIG));\n}\nfunction _encrypt(receiverRawPK, data, config) {\n    var curve = config.ellipticCurve;\n    var ephemeralSK = new index_js_1.PrivateKey(undefined, curve);\n    var receiverPK = receiverRawPK instanceof Uint8Array\n        ? new index_js_1.PublicKey(receiverRawPK, curve)\n        : index_js_1.PublicKey.fromHex(receiverRawPK, curve);\n    var sharedKey = ephemeralSK.encapsulate(receiverPK, config.isHkdfKeyCompressed);\n    var ephemeralPK = ephemeralSK.publicKey.toBytes(config.isEphemeralKeyCompressed);\n    var encrypted = (0, index_js_2.symEncrypt)(sharedKey, data);\n    return (0, utils_1.concatBytes)(ephemeralPK, encrypted);\n}\n/**\n * Decrypts data with a receiver's private key.\n * @description From version 0.5.0, `Uint8Array` will be returned instead of `Buffer`.\n * To keep the same behavior, use `Buffer.from(decrypt(...))`.\n *\n * @param receiverRawSK - Raw private key of the receiver, either as a hex `string` or a `Uint8Array`.\n * @param data - Data to decrypt.\n * @returns Decrypted plain text.\n */\nfunction decrypt(receiverRawSK, data) {\n    return Buffer.from(_decrypt(receiverRawSK, data));\n}\nfunction _decrypt(receiverRawSK, data, config) {\n    if (config === void 0) { config = config_js_1.ECIES_CONFIG; }\n    var curve = config.ellipticCurve;\n    var receiverSK = receiverRawSK instanceof Uint8Array\n        ? new index_js_1.PrivateKey(receiverRawSK, curve)\n        : index_js_1.PrivateKey.fromHex(receiverRawSK, curve);\n    var keySize = config.ephemeralKeySize;\n    var ephemeralPK = new index_js_1.PublicKey(data.subarray(0, keySize), curve);\n    var encrypted = data.subarray(keySize);\n    var sharedKey = ephemeralPK.decapsulate(receiverSK, config.isHkdfKeyCompressed);\n    return (0, index_js_2.symDecrypt)(sharedKey, encrypted);\n}\nvar config_js_2 = require(\"./config.js\");\nObject.defineProperty(exports, \"ECIES_CONFIG\", { enumerable: true, get: function () { return config_js_2.ECIES_CONFIG; } });\nvar index_js_3 = require(\"./keys/index.js\");\nObject.defineProperty(exports, \"PrivateKey\", { enumerable: true, get: function () { return index_js_3.PrivateKey; } });\nObject.defineProperty(exports, \"PublicKey\", { enumerable: true, get: function () { return index_js_3.PublicKey; } });\n/** @deprecated - use `import * as utils from \"eciesjs/utils\"` instead. */\nexports.utils = {\n    // TODO: remove these after 0.5.0\n    aesEncrypt: index_js_2.aesEncrypt,\n    aesDecrypt: index_js_2.aesDecrypt,\n    symEncrypt: index_js_2.symEncrypt,\n    symDecrypt: index_js_2.symDecrypt,\n    decodeHex: index_js_2.decodeHex,\n    getValidSecret: index_js_2.getValidSecret,\n    remove0x: index_js_2.remove0x,\n};\n","/**\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. */\nexport function isBytes(a: unknown): a is Uint8Array {\n  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n\n/** Asserts something is boolean. */\nexport function abool(b: boolean): void {\n  if (typeof b !== 'boolean') throw new Error(`boolean expected, not ${b}`);\n}\n\n/** Asserts something is positive integer. */\nexport function anumber(n: number): void {\n  if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);\n}\n\n/** Asserts something is Uint8Array. */\nexport function abytes(b: Uint8Array | undefined, ...lengths: number[]): void {\n  if (!isBytes(b)) throw new Error('Uint8Array expected');\n  if (lengths.length > 0 && !lengths.includes(b.length))\n    throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n\n/**\n * Asserts something is hash\n * TODO: remove\n * @deprecated\n */\nexport function ahash(h: IHash): void {\n  if (typeof h !== 'function' || typeof h.create !== 'function')\n    throw new Error('Hash should be wrapped by utils.createHasher');\n  anumber(h.outputLen);\n  anumber(h.blockLen);\n}\n\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance: any, checkFinished = true): void {\n  if (instance.destroyed) throw new Error('Hash instance has been destroyed');\n  if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');\n}\n\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out: any, instance: any): void {\n  abytes(out);\n  const min = instance.outputLen;\n  if (out.length < min) {\n    throw new Error('digestInto() expects output buffer of length at least ' + min);\n  }\n}\n\nexport type IHash = {\n  (data: string | Uint8Array): Uint8Array;\n  blockLen: number;\n  outputLen: number;\n  create: any;\n};\n\n/** Generic type encompassing 8/16/32-byte arrays - but not 64-byte. */\n// prettier-ignore\nexport type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array |\n  Uint16Array | Int16Array | Uint32Array | Int32Array;\n\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr: TypedArray): Uint8Array {\n  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr: TypedArray): Uint32Array {\n  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays: TypedArray[]): void {\n  for (let i = 0; i < arrays.length; i++) {\n    arrays[i].fill(0);\n  }\n}\n\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr: TypedArray): DataView {\n  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE: boolean = /* @__PURE__ */ (() =>\n  new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin: boolean = /* @__PURE__ */ (() =>\n  // @ts-ignore\n  typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>\n  i.toString(16).padStart(2, '0')\n);\n\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  abytes(bytes);\n  // @ts-ignore\n  if (hasHexBuiltin) 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\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 } as const;\nfunction asciiToBase16(ch: number): number | undefined {\n  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48\n  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n  return;\n}\n\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  // @ts-ignore\n  if (hasHexBuiltin) return Uint8Array.fromHex(hex);\n  const hl = hex.length;\n  const al = hl / 2;\n  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);\n  const array = new Uint8Array(al);\n  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n    const n1 = asciiToBase16(hex.charCodeAt(hi));\n    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n    if (n1 === undefined || n2 === undefined) {\n      const char = hex[hi] + hex[hi + 1];\n      throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n    }\n    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n  }\n  return array;\n}\n\n// Used in micro\nexport function hexToNumber(hex: string): bigint {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  return BigInt(hex === '' ? '0' : '0x' + hex); // Big Endian\n}\n\n// Used in ff1\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes: Uint8Array): bigint {\n  return hexToNumber(bytesToHex(bytes));\n}\n\n// Used in micro, ff1\nexport function numberToBytesBE(n: number | bigint, len: number): Uint8Array {\n  return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\n\n// TODO: remove\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async (): Promise<void> => {};\n\n// Global symbols, but ts doesn't see them: https://github.com/microsoft/TypeScript/issues/31535\ndeclare const TextEncoder: any;\ndeclare const TextDecoder: any;\n\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str: string): Uint8Array {\n  if (typeof str !== 'string') throw new Error('string expected');\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes: Uint8Array): string {\n  return new TextDecoder().decode(bytes);\n}\n\n// TODO: remove\nexport type Input = Uint8Array | string;\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data: string | Uint8Array): Uint8Array {\n  if (typeof data === 'string') data = utf8ToBytes(data);\n  else if (isBytes(data)) data = copyBytes(data);\n  else throw new Error('Uint8Array expected, got ' + typeof data);\n  return data;\n}\n\n/**\n * Checks if two U8A use same underlying buffer and overlaps.\n * This is invalid and can corrupt data.\n */\nexport function overlapBytes(a: Uint8Array, b: Uint8Array): boolean {\n  return (\n    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/**\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 (except chacha/salse, which designed with this)\n */\nexport function complexOverlapBytes(input: Uint8Array, output: Uint8Array): void {\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/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays: Uint8Array[]): Uint8Array {\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// Used in ARX only\ntype EmptyObj = {};\nexport function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(\n  defaults: T1,\n  opts: T2\n): T1 & T2 {\n  if (opts == null || typeof opts !== 'object') throw new Error('options must be defined');\n  const merged = Object.assign(defaults, opts);\n  return merged as T1 & T2;\n}\n\n/** Compares 2 uint8array-s in kinda constant time. */\nexport function equalBytes(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let diff = 0;\n  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];\n  return diff === 0;\n}\n\n// TODO: remove\n/** For runtime check if class implements interface. */\nexport abstract class Hash<T extends Hash<T>> {\n  abstract blockLen: number; // Bytes per block\n  abstract outputLen: number; // Bytes in output\n  abstract update(buf: string | Uint8Array): this;\n  // Writes digest into buf\n  abstract digestInto(buf: Uint8Array): void;\n  abstract digest(): Uint8Array;\n  /**\n   * Resets internal state. Makes Hash instance unusable.\n   * Reset is impossible for keyed hashes if key is consumed into state. If digest is not consumed\n   * by user, they will need to manually call `destroy()` when zeroing is necessary.\n   */\n  abstract destroy(): void;\n}\n\n// This will allow to re-use with composable things like packed & base encoders\n// Also, we probably can make tags composable\n\n/** Sync cipher: takes byte array and returns byte array. */\nexport type Cipher = {\n  encrypt(plaintext: Uint8Array): Uint8Array;\n  decrypt(ciphertext: Uint8Array): Uint8Array;\n};\n\n/** Async cipher e.g. from built-in WebCrypto. */\nexport type AsyncCipher = {\n  encrypt(plaintext: Uint8Array): Promise<Uint8Array>;\n  decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;\n};\n\n/** Cipher with `output` argument which can optimize by doing 1 less allocation. */\nexport type CipherWithOutput = Cipher & {\n  encrypt(plaintext: Uint8Array, output?: Uint8Array): Uint8Array;\n  decrypt(ciphertext: Uint8Array, output?: Uint8Array): Uint8Array;\n};\n\n/**\n * Params are outside of return type, so it is accessible before calling constructor.\n * If function support multiple nonceLength's, we return the best one.\n */\nexport type CipherParams = {\n  blockSize: number;\n  nonceLength?: number;\n  tagLength?: number;\n  varSizeNonce?: boolean;\n};\n/** ARX cipher, like salsa or chacha. */\nexport type ARXCipher = ((\n  key: Uint8Array,\n  nonce: Uint8Array,\n  AAD?: Uint8Array\n) => CipherWithOutput) & {\n  blockSize: number;\n  nonceLength: number;\n  tagLength: number;\n};\nexport type CipherCons<T extends any[]> = (key: Uint8Array, ...args: T) => Cipher;\n/**\n * Wraps a cipher: validates args, ensures encrypt() can only be called once.\n * @__NO_SIDE_EFFECTS__\n */\nexport const wrapCipher = <C extends CipherCons<any>, P extends CipherParams>(\n  params: P,\n  constructor: C\n): C & P => {\n  function wrappedCipher(key: Uint8Array, ...args: any[]): CipherWithOutput {\n    // Validate key\n    abytes(key);\n\n    // Big-Endian hardware is rare. Just in case someone still decides to run ciphers:\n    if (!isLE) throw new Error('Non little-endian hardware is not yet supported');\n\n    // Validate nonce if nonceLength is present\n    if (params.nonceLength !== undefined) {\n      const nonce = args[0];\n      if (!nonce) throw new Error('nonce / iv required');\n      if (params.varSizeNonce) abytes(nonce);\n      else abytes(nonce, params.nonceLength);\n    }\n\n    // Validate AAD if tagLength present\n    const tagl = params.tagLength;\n    if (tagl && args[1] !== undefined) {\n      abytes(args[1]);\n    }\n\n    const cipher = constructor(key, ...args);\n    const checkOutput = (fnLength: number, output?: Uint8Array) => {\n      if (output !== undefined) {\n        if (fnLength !== 2) throw new Error('cipher output not supported');\n        abytes(output);\n      }\n    };\n    // Create wrapped cipher with validation and single-use encryption\n    let called = false;\n    const wrCipher = {\n      encrypt(data: Uint8Array, output?: Uint8Array) {\n        if (called) 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 as CipherWithOutput).encrypt(data, output);\n      },\n      decrypt(data: Uint8Array, output?: Uint8Array) {\n        abytes(data);\n        if (tagl && data.length < tagl)\n          throw new Error('invalid ciphertext length: smaller than tagLength=' + tagl);\n        checkOutput(cipher.decrypt.length, output);\n        return (cipher as CipherWithOutput).decrypt(data, output);\n      },\n    };\n\n    return wrCipher;\n  }\n\n  Object.assign(wrappedCipher, params);\n  return wrappedCipher as C & P;\n};\n\n/** Represents salsa / chacha stream. */\nexport type XorStream = (\n  key: Uint8Array,\n  nonce: Uint8Array,\n  data: Uint8Array,\n  output?: Uint8Array,\n  counter?: number\n) => Uint8Array;\n\n/**\n * By default, returns u8a of length.\n * When out is available, it checks it for validity and uses it.\n */\nexport function getOutput(\n  expectedLength: number,\n  out?: Uint8Array,\n  onlyAligned = true\n): Uint8Array {\n  if (out === undefined) return new Uint8Array(expectedLength);\n  if (out.length !== expectedLength)\n    throw new Error('invalid output length, expected ' + expectedLength + ', got: ' + out.length);\n  if (onlyAligned && !isAligned32(out)) throw new Error('invalid output, must be aligned');\n  return out;\n}\n\n/** Polyfill for Safari 14. */\nexport function setBigUint64(\n  view: DataView,\n  byteOffset: number,\n  value: bigint,\n  isLE: boolean\n): void {\n  if (typeof view.setBigUint64 === 'function') return view.setBigUint64(byteOffset, value, isLE);\n  const _32n = BigInt(32);\n  const _u32_max = BigInt(0xffffffff);\n  const wh = Number((value >> _32n) & _u32_max);\n  const wl = Number(value & _u32_max);\n  const h = isLE ? 4 : 0;\n  const l = isLE ? 0 : 4;\n  view.setUint32(byteOffset + h, wh, isLE);\n  view.setUint32(byteOffset + l, wl, isLE);\n}\n\nexport function u64Lengths(dataLength: number, aadLength: number, isLE: boolean): Uint8Array {\n  abool(isLE);\n  const num = new Uint8Array(16);\n  const view = createView(num);\n  setBigUint64(view, 0, BigInt(aadLength), isLE);\n  setBigUint64(view, 8, BigInt(dataLength), isLE);\n  return num;\n}\n\n// Is byte array aligned to 4 byte offset (u32)?\nexport function isAligned32(bytes: Uint8Array): boolean {\n  return bytes.byteOffset % 4 === 0;\n}\n\n// copy bytes to new u8a (aligned). Because Buffer.slice is broken.\nexport function copyBytes(bytes: Uint8Array): Uint8Array {\n  return Uint8Array.from(bytes);\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hexToPublicKey = exports.convertPublicKeyFormat = exports.getSharedPoint = exports.getPublicKey = exports.isValidPrivateKey = exports.getValidSecret = void 0;\nvar webcrypto_1 = require(\"@noble/ciphers/webcrypto\");\nvar ed25519_1 = require(\"@noble/curves/ed25519\");\nvar secp256k1_1 = require(\"@noble/curves/secp256k1\");\nvar config_js_1 = require(\"../config.js\");\nvar consts_js_1 = require(\"../consts.js\");\nvar hex_js_1 = require(\"./hex.js\");\nvar getValidSecret = function (curve) {\n    var key;\n    do {\n        key = (0, webcrypto_1.randomBytes)(consts_js_1.SECRET_KEY_LENGTH);\n    } while (!(0, exports.isValidPrivateKey)(key, curve));\n    return key;\n};\nexports.getValidSecret = getValidSecret;\nvar isValidPrivateKey = function (secret, curve) {\n    // on secp256k1: only key ∈ (0, group order) is valid\n    // on curve25519: any 32-byte key is valid\n    return _exec(curve, function (curve) { return curve.utils.isValidSecretKey(secret); }, function () { return true; }, function () { return true; });\n};\nexports.isValidPrivateKey = isValidPrivateKey;\nvar getPublicKey = function (secret, curve) {\n    return _exec(curve, function (curve) { return curve.getPublicKey(secret); }, function (curve) { return curve.getPublicKey(secret); }, function (curve) { return curve.getPublicKey(secret); });\n};\nexports.getPublicKey = getPublicKey;\nvar getSharedPoint = function (sk, pk, compressed, curve) {\n    return _exec(curve, function (curve) { return curve.getSharedSecret(sk, pk, compressed); }, function (curve) { return curve.getSharedSecret(sk, pk); }, function (curve) { return getSharedPointOnEd25519(curve, sk, pk); });\n};\nexports.getSharedPoint = getSharedPoint;\nvar convertPublicKeyFormat = function (pk, compressed, curve) {\n    // only for secp256k1\n    return _exec(curve, function (curve) {\n        return curve.getSharedSecret(Uint8Array.from(Array(31).fill(0).concat([1])), // 1 as private key\n        pk, compressed);\n    }, function () { return pk; }, function () { return pk; });\n};\nexports.convertPublicKeyFormat = convertPublicKeyFormat;\nvar hexToPublicKey = function (hex, curve) {\n    var decoded = (0, hex_js_1.decodeHex)(hex);\n    return _exec(curve, function () { return compatEthPublicKey(decoded); }, function () { return decoded; }, function () { return decoded; });\n};\nexports.hexToPublicKey = hexToPublicKey;\nfunction _exec(curve, secp256k1Callback, x25519Callback, ed25519Callback) {\n    var _curve = curve || config_js_1.ECIES_CONFIG.ellipticCurve; // TODO: remove after 0.5.0\n    /* v8 ignore else -- @preserve */\n    if (_curve === \"secp256k1\") {\n        return secp256k1Callback(secp256k1_1.secp256k1);\n    }\n    else if (_curve === \"x25519\") {\n        return x25519Callback(ed25519_1.x25519);\n    }\n    else if (_curve === \"ed25519\") {\n        return ed25519Callback(ed25519_1.ed25519);\n    }\n    else {\n        throw new Error(\"Not implemented\");\n    }\n}\nvar compatEthPublicKey = function (pk) {\n    if (pk.length === consts_js_1.ETH_PUBLIC_KEY_SIZE) {\n        var fixed = new Uint8Array(1 + pk.length);\n        fixed.set([0x04]);\n        fixed.set(pk, 1);\n        return fixed;\n    }\n    return pk;\n};\nvar getSharedPointOnEd25519 = function (curve, sk, pk) {\n    // Note: scalar is hashed from sk\n    var scalar = curve.utils.getExtendedPublicKey(sk).scalar;\n    var point = curve.Point.fromBytes(pk).multiply(scalar);\n    return point.toBytes();\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getSharedKey = exports.deriveKey = void 0;\nvar utils_1 = require(\"@noble/ciphers/utils\");\nvar hkdf_1 = require(\"@noble/hashes/hkdf\");\nvar sha2_1 = require(\"@noble/hashes/sha2\");\nvar deriveKey = function (master, salt, info) {\n    // 32 bytes shared secret for aes256 and xchacha20 derived from HKDF-SHA256\n    return (0, hkdf_1.hkdf)(sha2_1.sha256, master, salt, info, 32);\n};\nexports.deriveKey = deriveKey;\nvar getSharedKey = function () {\n    var parts = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        parts[_i] = arguments[_i];\n    }\n    return (0, exports.deriveKey)(utils_1.concatBytes.apply(void 0, parts));\n};\nexports.getSharedKey = getSharedKey;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.aesDecrypt = exports.aesEncrypt = exports.symDecrypt = exports.symEncrypt = void 0;\nvar aes_1 = require(\"@ecies/ciphers/aes\");\nvar chacha_1 = require(\"@ecies/ciphers/chacha\");\nvar utils_1 = require(\"@noble/ciphers/utils\");\nvar webcrypto_1 = require(\"@noble/ciphers/webcrypto\");\nvar config_js_1 = require(\"../config.js\");\nvar consts_js_1 = require(\"../consts.js\");\nvar symEncrypt = function (key, plainText, AAD) {\n    return _exec(_encrypt, config_js_1.ECIES_CONFIG.symmetricAlgorithm, config_js_1.ECIES_CONFIG.symmetricNonceLength, key, plainText, AAD);\n};\nexports.symEncrypt = symEncrypt;\nvar symDecrypt = function (key, cipherText, AAD) {\n    return _exec(_decrypt, config_js_1.ECIES_CONFIG.symmetricAlgorithm, config_js_1.ECIES_CONFIG.symmetricNonceLength, key, cipherText, AAD);\n};\nexports.symDecrypt = symDecrypt;\n/** @deprecated - use `symEncrypt` instead. */\nexports.aesEncrypt = exports.symEncrypt; // TODO: delete\n/** @deprecated - use `symDecrypt` instead. */\nexports.aesDecrypt = exports.symDecrypt; // TODO: delete\nfunction _exec(callback, algorithm, nonceLength, // aes-256-gcm only\nkey, data, AAD) {\n    if (algorithm === \"aes-256-gcm\") {\n        return callback(aes_1.aes256gcm, key, data, nonceLength, consts_js_1.AEAD_TAG_LENGTH, AAD);\n    }\n    else if (algorithm === \"xchacha20\") {\n        return callback(chacha_1.xchacha20, key, data, consts_js_1.XCHACHA20_NONCE_LENGTH, consts_js_1.AEAD_TAG_LENGTH, AAD);\n    }\n    else if (algorithm === \"aes-256-cbc\") {\n        // NOT RECOMMENDED. There is neither AAD nor AEAD tag in cbc mode\n        // aes-256-cbc always uses 16 bytes iv\n        return callback(aes_1.aes256cbc, key, data, 16, 0);\n    }\n    else {\n        throw new Error(\"Not implemented\");\n    }\n}\nfunction _encrypt(func, key, data, nonceLength, tagLength, AAD) {\n    var nonce = (0, webcrypto_1.randomBytes)(nonceLength);\n    var cipher = func(key, nonce, AAD);\n    // @noble/ciphers format: cipherText || tag\n    var encrypted = cipher.encrypt(data);\n    if (tagLength === 0) {\n        return (0, utils_1.concatBytes)(nonce, encrypted);\n    }\n    var cipherTextLength = encrypted.length - tagLength;\n    var cipherText = encrypted.subarray(0, cipherTextLength);\n    var tag = encrypted.subarray(cipherTextLength);\n    // ecies payload format: pk || nonce || tag || cipherText\n    return (0, utils_1.concatBytes)(nonce, tag, cipherText);\n}\nfunction _decrypt(func, key, data, nonceLength, tagLength, AAD) {\n    var nonce = data.subarray(0, nonceLength);\n    var cipher = func(key, Uint8Array.from(nonce), AAD); // to reset byteOffset\n    var encrypted = data.subarray(nonceLength);\n    if (tagLength === 0) {\n        return cipher.decrypt(encrypted);\n    }\n    var tag = encrypted.subarray(0, tagLength);\n    var cipherText = encrypted.subarray(tagLength);\n    return cipher.decrypt((0, utils_1.concatBytes)(cipherText, tag));\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PrivateKey = void 0;\nvar utils_1 = require(\"@noble/ciphers/utils\");\nvar index_js_1 = require(\"../utils/index.js\");\nvar PublicKey_js_1 = require(\"./PublicKey.js\");\nvar PrivateKey = /** @class */ (function () {\n    function PrivateKey(secret, curve) {\n        this.curve = curve;\n        if (secret === undefined) {\n            this.data = (0, index_js_1.getValidSecret)(curve);\n        }\n        else if ((0, index_js_1.isValidPrivateKey)(secret, curve)) {\n            this.data = secret;\n        }\n        else {\n            throw new Error(\"Invalid private key\");\n        }\n        this.publicKey = new PublicKey_js_1.PublicKey((0, index_js_1.getPublicKey)(this.data, curve), curve);\n    }\n    PrivateKey.fromHex = function (hex, curve) {\n        return new PrivateKey((0, index_js_1.decodeHex)(hex), curve);\n    };\n    Object.defineProperty(PrivateKey.prototype, \"secret\", {\n        /** @description From version 0.5.0, `Uint8Array` will be returned instead of `Buffer`. */\n        get: function () {\n            // TODO: Uint8Array\n            return Buffer.from(this.data);\n        },\n        enumerable: false,\n        configurable: true\n    });\n    PrivateKey.prototype.toHex = function () {\n        return (0, utils_1.bytesToHex)(this.data);\n    };\n    /**\n     * Derives a shared secret from ephemeral private key (this) and receiver's public key (pk).\n     * @description The shared key is 32 bytes, derived with `HKDF-SHA256(senderPoint || sharedPoint)`. See implementation for details.\n     *\n     * There are some variations in different ECIES implementations:\n     * which key derivation function to use, compressed or uncompressed `senderPoint`/`sharedPoint`, whether to include `senderPoint`, etc.\n     *\n     * Because the entropy of `senderPoint`, `sharedPoint` is enough high[1], we don't need salt to derive keys.\n     *\n     * [1]: Two reasons: the public keys are \"random\" bytes (albeit secp256k1 public keys are **not uniformly** random), and ephemeral keys are generated in every encryption.\n     *\n     * @param pk - Receiver's public key.\n     * @param compressed - (default: `false`) Whether to use compressed or uncompressed public keys in the key derivation (secp256k1 only).\n     * @returns Shared secret, derived with HKDF-SHA256.\n     */\n    PrivateKey.prototype.encapsulate = function (pk, compressed) {\n        if (compressed === void 0) { compressed = false; }\n        var senderPoint = this.publicKey.toBytes(compressed);\n        var sharedPoint = this.multiply(pk, compressed);\n        return (0, index_js_1.getSharedKey)(senderPoint, sharedPoint);\n    };\n    PrivateKey.prototype.multiply = function (pk, compressed) {\n        if (compressed === void 0) { compressed = false; }\n        return (0, index_js_1.getSharedPoint)(this.data, pk.toBytes(true), compressed, this.curve);\n    };\n    PrivateKey.prototype.equals = function (other) {\n        return (0, utils_1.equalBytes)(this.data, other.data);\n    };\n    return PrivateKey;\n}());\nexports.PrivateKey = PrivateKey;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.aes256cbc = exports.aes256gcm = void 0;\nvar aes_1 = require(\"@noble/ciphers/aes\");\nvar aes256gcm = function (key, nonce, AAD) {\n    return (0, aes_1.gcm)(key, nonce, AAD);\n};\nexports.aes256gcm = aes256gcm;\nvar aes256cbc = function (key, nonce, _AAD) {\n    return (0, aes_1.cbc)(key, nonce);\n};\nexports.aes256cbc = aes256cbc;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.PublicKey = void 0;\nvar utils_1 = require(\"@noble/ciphers/utils\");\nvar index_js_1 = require(\"../utils/index.js\");\nvar PublicKey = /** @class */ (function () {\n    function PublicKey(data, curve) {\n        // data can be either compressed or uncompressed if secp256k1\n        var compressed = (0, index_js_1.convertPublicKeyFormat)(data, true, curve);\n        var uncompressed = (0, index_js_1.convertPublicKeyFormat)(data, false, curve);\n        this.data = compressed;\n        this.dataUncompressed =\n            compressed.length !== uncompressed.length ? uncompressed : null;\n    }\n    PublicKey.fromHex = function (hex, curve) {\n        return new PublicKey((0, index_js_1.hexToPublicKey)(hex, curve), curve);\n    };\n    Object.defineProperty(PublicKey.prototype, \"_uncompressed\", {\n        get: function () {\n            return this.dataUncompressed !== null ? this.dataUncompressed : this.data;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(PublicKey.prototype, \"uncompressed\", {\n        /** @deprecated - use `PublicKey.toBytes(false)` instead. You may also need `Buffer.from`. */\n        get: function () {\n            return Buffer.from(this._uncompressed); // TODO: delete\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(PublicKey.prototype, \"compressed\", {\n        /** @deprecated - use `PublicKey.toBytes()` instead. You may also need `Buffer.from`. */\n        get: function () {\n            return Buffer.from(this.data); // TODO: delete\n        },\n        enumerable: false,\n        configurable: true\n    });\n    PublicKey.prototype.toBytes = function (compressed) {\n        if (compressed === void 0) { compressed = true; }\n        return compressed ? this.data : this._uncompressed;\n    };\n    PublicKey.prototype.toHex = function (compressed) {\n        if (compressed === void 0) { compressed = true; }\n        return (0, utils_1.bytesToHex)(this.toBytes(compressed));\n    };\n    /**\n     * Derives a shared secret from receiver's private key (sk) and ephemeral public key (this).\n     * Opposite of `encapsulate`.\n     * @see PrivateKey.encapsulate\n     *\n     * @param sk - Receiver's private key.\n     * @param compressed - (default: `false`) Whether to use compressed or uncompressed public keys in the key derivation (secp256k1 only).\n     * @returns Shared secret, derived with HKDF-SHA256.\n     */\n    PublicKey.prototype.decapsulate = function (sk, compressed) {\n        if (compressed === void 0) { compressed = false; }\n        var senderPoint = this.toBytes(compressed);\n        var sharedPoint = sk.multiply(this, compressed);\n        return (0, index_js_1.getSharedKey)(senderPoint, sharedPoint);\n    };\n    PublicKey.prototype.equals = function (other) {\n        return (0, utils_1.equalBytes)(this.data, other.data);\n    };\n    return PublicKey;\n}());\nexports.PublicKey = PublicKey;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AEAD_TAG_LENGTH = exports.XCHACHA20_NONCE_LENGTH = exports.CURVE25519_PUBLIC_KEY_SIZE = exports.ETH_PUBLIC_KEY_SIZE = exports.UNCOMPRESSED_PUBLIC_KEY_SIZE = exports.COMPRESSED_PUBLIC_KEY_SIZE = exports.SECRET_KEY_LENGTH = void 0;\n// elliptic\nexports.SECRET_KEY_LENGTH = 32;\nexports.COMPRESSED_PUBLIC_KEY_SIZE = 33;\nexports.UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;\nexports.ETH_PUBLIC_KEY_SIZE = 64;\nexports.CURVE25519_PUBLIC_KEY_SIZE = 32;\n// symmetric\nexports.XCHACHA20_NONCE_LENGTH = 24;\nexports.AEAD_TAG_LENGTH = 16;\n","/**\n * HKDF (RFC 5869): extract + expand in one step.\n * See https://soatok.blog/2021/11/17/understanding-hkdf/.\n * @module\n */\nimport { hmac } from './hmac.ts';\nimport { ahash, anumber, type CHash, clean, type Input, toBytes } from './utils.ts';\n\n/**\n * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`\n * Arguments position differs from spec (IKM is first one, since it is not optional)\n * @param hash - hash function that would be used (e.g. sha256)\n * @param ikm - input keying material, the initial key\n * @param salt - optional salt value (a non-secret random value)\n */\nexport function extract(hash: CHash, ikm: Input, salt?: Input): Uint8Array {\n  ahash(hash);\n  // NOTE: some libraries treat zero-length array as 'not provided';\n  // we don't, since we have undefined as 'not provided'\n  // https://github.com/RustCrypto/KDFs/issues/15\n  if (salt === undefined) salt = new Uint8Array(hash.outputLen);\n  return hmac(hash, toBytes(salt), toBytes(ikm));\n}\n\nconst HKDF_COUNTER = /* @__PURE__ */ Uint8Array.from([0]);\nconst EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();\n\n/**\n * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`\n * @param hash - hash function that would be used (e.g. sha256)\n * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)\n * @param info - optional context and application specific information (can be a zero-length string)\n * @param length - length of output keying material in bytes\n */\nexport function expand(hash: CHash, prk: Input, info?: Input, length: number = 32): Uint8Array {\n  ahash(hash);\n  anumber(length);\n  const olen = hash.outputLen;\n  if (length > 255 * olen) throw new Error('Length should be <= 255*HashLen');\n  const blocks = Math.ceil(length / olen);\n  if (info === undefined) info = EMPTY_BUFFER;\n  // first L(ength) octets of T\n  const okm = new Uint8Array(blocks * olen);\n  // Re-use HMAC instance between blocks\n  const HMAC = hmac.create(hash, prk);\n  const HMACTmp = HMAC._cloneInto();\n  const T = new Uint8Array(HMAC.outputLen);\n  for (let counter = 0; counter < blocks; counter++) {\n    HKDF_COUNTER[0] = counter + 1;\n    // T(0) = empty string (zero length)\n    // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)\n    HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)\n      .update(info)\n      .update(HKDF_COUNTER)\n      .digestInto(T);\n    okm.set(T, olen * counter);\n    HMAC._cloneInto(HMACTmp);\n  }\n  HMAC.destroy();\n  HMACTmp.destroy();\n  clean(T, HKDF_COUNTER);\n  return okm.slice(0, length);\n}\n\n/**\n * HKDF (RFC 5869): derive keys from an initial input.\n * Combines hkdf_extract + hkdf_expand in one step\n * @param hash - hash function that would be used (e.g. sha256)\n * @param ikm - input keying material, the initial key\n * @param salt - optional salt value (a non-secret random value)\n * @param info - optional context and application specific information (can be a zero-length string)\n * @param length - length of output keying material in bytes\n * @example\n * import { hkdf } from '@noble/hashes/hkdf';\n * import { sha256 } from '@noble/hashes/sha2';\n * import { randomBytes } from '@noble/hashes/utils';\n * const inputKey = randomBytes(32);\n * const salt = randomBytes(32);\n * const info = 'application-key';\n * const hk1 = hkdf(sha256, inputKey, salt, info, 32);\n */\nexport const hkdf = (\n  hash: CHash,\n  ikm: Input,\n  salt: Input | undefined,\n  info: Input | undefined,\n  length: number\n): Uint8Array => expand(hash, extract(hash, ikm, salt), info, length);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ephemeralKeySize = exports.symmetricNonceLength = exports.symmetricAlgorithm = exports.isHkdfKeyCompressed = exports.isEphemeralKeyCompressed = exports.ellipticCurve = exports.ECIES_CONFIG = exports.Config = void 0;\nvar consts_js_1 = require(\"./consts.js\");\nvar Config = /** @class */ (function () {\n    function Config() {\n        this.ellipticCurve = \"secp256k1\";\n        this.isEphemeralKeyCompressed = false; // secp256k1 only\n        this.isHkdfKeyCompressed = false; // secp256k1 only\n        this.symmetricAlgorithm = \"aes-256-gcm\";\n        this.symmetricNonceLength = 16; // aes-256-gcm only\n    }\n    Object.defineProperty(Config.prototype, \"ephemeralKeySize\", {\n        get: function () {\n            var mapping = {\n                secp256k1: this.isEphemeralKeyCompressed\n                    ? consts_js_1.COMPRESSED_PUBLIC_KEY_SIZE\n                    : consts_js_1.UNCOMPRESSED_PUBLIC_KEY_SIZE,\n                x25519: consts_js_1.CURVE25519_PUBLIC_KEY_SIZE,\n                ed25519: consts_js_1.CURVE25519_PUBLIC_KEY_SIZE,\n            };\n            /* v8 ignore else -- @preserve */\n            if (this.ellipticCurve in mapping) {\n                return mapping[this.ellipticCurve];\n            }\n            else {\n                throw new Error(\"Not implemented\");\n            }\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Config;\n}());\nexports.Config = Config;\nexports.ECIES_CONFIG = new Config();\n// TODO: remove these after 0.5.0\n/** @deprecated - use individual attribute instead */\nvar ellipticCurve = function () { return exports.ECIES_CONFIG.ellipticCurve; };\nexports.ellipticCurve = ellipticCurve;\n/** @deprecated - use individual attribute instead */\nvar isEphemeralKeyCompressed = function () { return exports.ECIES_CONFIG.isEphemeralKeyCompressed; };\nexports.isEphemeralKeyCompressed = isEphemeralKeyCompressed;\n/** @deprecated - use individual attribute instead */\nvar isHkdfKeyCompressed = function () { return exports.ECIES_CONFIG.isHkdfKeyCompressed; };\nexports.isHkdfKeyCompressed = isHkdfKeyCompressed;\n/** @deprecated - use individual attribute instead */\nvar symmetricAlgorithm = function () { return exports.ECIES_CONFIG.symmetricAlgorithm; };\nexports.symmetricAlgorithm = symmetricAlgorithm;\n/** @deprecated - use individual attribute instead */\nvar symmetricNonceLength = function () { return exports.ECIES_CONFIG.symmetricNonceLength; };\nexports.symmetricNonceLength = symmetricNonceLength;\n/** @deprecated - use individual attribute instead */\nvar ephemeralKeySize = function () { return exports.ECIES_CONFIG.ephemeralKeySize; };\nexports.ephemeralKeySize = ephemeralKeySize;\n"],"names":["__createBinding","this","Object","create","o","m","k","k2","undefined","desc","getOwnPropertyDescriptor","__esModule","writable","configurable","enumerable","get","defineProperty","__exportStar","exports","p","prototype","hasOwnProperty","call","value","require","decodeHex","remove0x","utils_1","hex","startsWith","slice","hexToBytes","BLOCK_SIZE","ZEROS16","Uint8Array","ZEROS32","u32","mul2","s0","s1","s2","s3","swapLE","n","GHASH","constructor","key","expectedLength","blockLen","outputLen","finished","toBytes","abytes","kView","createView","k0","getUint32","k1","k3","doubles","i","push","W","bytes","includes","Error","windows","windowSize","items","w","byte","j","d0","d1","d2","d3","t","_updateBlock","o0","o1","o2","o3","mask","num","bytePos","bitPos","bit","e0","e1","e2","e3","update","data","aexists","b32","blocks","Math","floor","length","left","set","subarray","clean","destroy","elm","digestInto","out","aoutput","o32","digest","res","Polyval","ghKey","reverse","hiBit","carry","_toGHASHKey","copyBytes","super","wrapConstructorWithKey","hashCons","hashC","msg","tmp","ghash","polyval","EMPTY_BLOCK","mul","a","b","sbox","x","box","invSbox","map","_","indexOf","rotr32_8","rotl32_8","byteSwap","word","genTtable","fn","T0","Uint32Array","T1","T2","T3","T01","T23","sbox2","Uint16Array","idx","tableEncoding","s","tableDecoding","xPowers","expandKeyLE","len","toClean","isAligned32","k32","Nk","subByte","applySbox","xk","expandKeyDecLE","encKey","apply0123","encrypt","rounds","t0","t1","t2","t3","decrypt","ctrCounter","nonce","src","dst","srcLen","getOutput","complexOverlapBytes","ctr","c32","src32","dst32","start","buf","u8","pos","ctr32","isLE","view","ctrPos","ctrNum","setUint32","wrapCipher","blockSize","nonceLength","processCtr","plaintext","ciphertext","validateBlockDecrypt","validateBlockEncrypt","pcks5","outLen","remaining","validatePCKS","lastByte","padPCKS","tmp32","paddingByte","ecb","arguments","disablePadding","_out","cbc","iv","_iv","n32","ps0","ps1","ps2","ps3","cfb","processCfb","isEncrypt","overlapBytes","next32","computeTag","AAD","aadLength","h","u64Lengths","gcm","tagLength","varSizeNonce","_computeTag","authKey","tagMask","tag","deriveKeys","counter","nonceLen","setBigUint64","BigInt","g","passedTag","equalBytes","limit","name","min","max","Number","isSafeInteger","gcmsiv","AAD_LIMIT","PLAIN_LIMIT","NONCE_LIMIT","CIPHER_LIMIT","_nonce","derivedKey","d32","t32","processSiv","input","block","expectedTag","siv","isBytes32","ArrayBuffer","isView","encryptBlock","decryptBlock","AESW","kek","a0","a1","fill","chunks","AESKW_IV","aeskw","concatBytes","AESKWP_IV","aeskwp","padded","ceil","out32","unsafe","PublicKey","PrivateKey","PrivateKey_js_1","PublicKey_js_1","chacha20","xchacha20","chacha_1","xchacha20poly1305","chacha20poly1305","crypto","globalThis","randomBytes","bytesLength","getRandomValues","from","getWebcryptoSubtle","subtle","managedNonce","anumber","_len","args","Array","_key","_len2","argsEnc","_key2","_len3","argsDec","_key3","utils","keyParams","cryptParams","cr","iKey","importKey","mode","generate","algo","additionalData","getCryptParams","consumed","_utf8ToBytes","str","split","c","charCodeAt","sigma16","sigma32","sigma16_32","sigma32_32","rotl","byteOffset","MAX_COUNTER","U32_EMPTY","createCipher","core","opts","allowShortKeys","extendNonceFn","counterLength","counterRight","checkOpts","abool","output","concat","sigma","l","nonceNcLen","nc","isAligned","take","pos32","posj","runCipher","u8to16","Poly1305","buffer","r","pad","t4","t5","t6","t7","process","offset","hibit","r0","r1","r2","r3","r4","r5","r6","r7","r8","r9","h0","h1","h2","h3","h4","h5","h6","h7","h8","h9","d4","d5","d6","d7","d8","d9","finalize","f","opos","poly1305","chachaCore","cnt","y00","y01","y02","y03","y04","y05","y06","y07","y08","y09","y10","y11","y12","y13","y14","y15","x00","x01","x02","x03","x04","x05","x06","x07","x08","x09","x10","x11","x12","x13","x14","x15","oi","hchacha","chacha20orig","chacha8","chacha12","updatePadded","_poly1305_aead","xorStream","plength","oPlain","ECIES_CONFIG","receiverRawPK","Buffer","config","curve","ellipticCurve","ephemeralSK","index_js_1","receiverPK","fromHex","sharedKey","encapsulate","isHkdfKeyCompressed","ephemeralPK","publicKey","isEphemeralKeyCompressed","encrypted","index_js_2","symEncrypt","_encrypt","config_js_1","receiverRawSK","receiverSK","keySize","ephemeralKeySize","decapsulate","symDecrypt","_decrypt","config_js_2","index_js_3","aesEncrypt","aesDecrypt","getValidSecret","isBytes","lengths","ahash","instance","checkFinished","destroyed","arr","byteLength","arrays","DataView","hasHexBuiltin","toHex","hexes","toString","padStart","bytesToHex","asciis","_0","_9","A","F","asciiToBase16","ch","hl","al","array","ai","hi","n1","n2","char","hexToNumber","bytesToNumberBE","numberToBytesBE","nextTick","async","utf8ToBytes","TextEncoder","encode","bytesToUtf8","TextDecoder","decode","sum","defaults","assign","diff","Hash","params","wrappedCipher","tagl","cipher","checkOutput","fnLength","called","onlyAligned","_32n","_u32_max","wh","wl","dataLength","hexToPublicKey","convertPublicKeyFormat","getSharedPoint","getPublicKey","isValidPrivateKey","webcrypto_1","ed25519_1","secp256k1_1","consts_js_1","hex_js_1","SECRET_KEY_LENGTH","secret","_exec","isValidSecretKey","sk","pk","compressed","getSharedSecret","getSharedPointOnEd25519","secp256k1Callback","x25519Callback","ed25519Callback","_curve","secp256k1","x25519","ed25519","decoded","compatEthPublicKey","ETH_PUBLIC_KEY_SIZE","fixed","scalar","getExtendedPublicKey","Point","fromBytes","multiply","getSharedKey","deriveKey","hkdf_1","sha2_1","master","salt","info","hkdf","sha256","parts","_i","apply","aes_1","plainText","symmetricAlgorithm","symmetricNonceLength","callback","algorithm","aes256gcm","AEAD_TAG_LENGTH","XCHACHA20_NONCE_LENGTH","aes256cbc","func","cipherTextLength","cipherText","senderPoint","sharedPoint","equals","other","_AAD","uncompressed","dataUncompressed","_uncompressed","CURVE25519_PUBLIC_KEY_SIZE","UNCOMPRESSED_PUBLIC_KEY_SIZE","COMPRESSED_PUBLIC_KEY_SIZE","extract","hash","ikm","hmac","HKDF_COUNTER","EMPTY_BUFFER","of","expand","prk","olen","okm","HMAC","HMACTmp","_cloneInto","T","Config","mapping"],"sourceRoot":""}