@holoscript/core 7.0.0 → 8.0.0

package/dist/ml-dsa-FSKBTE3W.cjs

@@ -0,0 +1,1265 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+function anumber(n, title = "") {
+  if (typeof n !== "number") {
+    const prefix = title && `"${title}" `;
+    throw new TypeError(`${prefix}expected number, got ${typeof n}`);
+  }
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new RangeError(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+    if (!bytes)
+      throw new TypeError(message);
+    throw new RangeError(message);
+  }
+  return value;
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new RangeError('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+function concatBytes(...arrays) {
+  let sum = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    abytes(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+function randomBytes(bytesLength = 32) {
+  anumber(bytesLength, "bytesLength");
+  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof cr?.getRandomValues !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  if (bytesLength > 65536)
+    throw new RangeError(`"bytesLength" expected <= 65536, got ${bytesLength}`);
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+var isLE, swap32IfBE, oidNist;
+var init_utils = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/utils.js"() {
+    isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+    swap32IfBE = isLE ? (u) => u : byteSwap32;
+    oidNist = (suffix) => ({
+      // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+      // Larger suffix values would need base-128 OID encoding and a different length byte.
+      oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/utils.js
+function abool(value, title = "") {
+  if (typeof value !== "boolean") {
+    const prefix = title && `"${title}" `;
+    throw new TypeError(prefix + "expected boolean, got type=" + typeof value);
+  }
+  return value;
+}
+var init_utils2 = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/utils.js"() {
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
+var init_u64 = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/_u64.js"() {
+    U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    _32n = /* @__PURE__ */ BigInt(32);
+    rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/sha3.js
+function keccakP(s, rounds = 24) {
+  anumber(rounds, "rounds");
+  if (rounds < 1 || rounds > 24)
+    throw new Error('"rounds" expected integer 1..24');
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      const b0 = s[y], b1 = s[y + 1], b2 = s[y + 2], b3 = s[y + 3];
+      s[y] ^= ~s[y + 2] & s[y + 4];
+      s[y + 1] ^= ~s[y + 3] & s[y + 5];
+      s[y + 2] ^= ~s[y + 4] & s[y + 6];
+      s[y + 3] ^= ~s[y + 5] & s[y + 7];
+      s[y + 4] ^= ~s[y + 6] & s[y + 8];
+      s[y + 5] ^= ~s[y + 7] & s[y + 9];
+      s[y + 6] ^= ~s[y + 8] & b0;
+      s[y + 7] ^= ~s[y + 9] & b1;
+      s[y + 8] ^= ~b0 & b2;
+      s[y + 9] ^= ~b1 & b3;
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, genShake, shake128, shake256;
+var init_sha3 = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/sha3.js"() {
+    init_u64();
+    init_utils();
+    _0n = BigInt(0);
+    _1n = BigInt(1);
+    _2n = BigInt(2);
+    _7n = BigInt(7);
+    _256n = BigInt(256);
+    _0x71n = BigInt(113);
+    SHA3_PI = [];
+    SHA3_ROTL = [];
+    _SHA3_IOTA = [];
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+      [x, y] = [y, (2 * x + 3 * y) % 5];
+      SHA3_PI.push(2 * (5 * y + x));
+      SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+      let t = _0n;
+      for (let j = 0; j < 7; j++) {
+        R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+        if (R & _2n)
+          t ^= _1n << (_1n << BigInt(j)) - _1n;
+      }
+      _SHA3_IOTA.push(t);
+    }
+    IOTAS = split(_SHA3_IOTA, true);
+    SHA3_IOTA_H = IOTAS[0];
+    SHA3_IOTA_L = IOTAS[1];
+    rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+    rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+    Keccak = class _Keccak {
+      // NOTE: we accept arguments in bytes instead of bits here.
+      constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        chunkHCCQLAA4_cjs.__publicField(this, "state");
+        chunkHCCQLAA4_cjs.__publicField(this, "pos", 0);
+        chunkHCCQLAA4_cjs.__publicField(this, "posOut", 0);
+        chunkHCCQLAA4_cjs.__publicField(this, "finished", false);
+        chunkHCCQLAA4_cjs.__publicField(this, "state32");
+        chunkHCCQLAA4_cjs.__publicField(this, "destroyed", false);
+        chunkHCCQLAA4_cjs.__publicField(this, "blockLen");
+        chunkHCCQLAA4_cjs.__publicField(this, "suffix");
+        chunkHCCQLAA4_cjs.__publicField(this, "outputLen");
+        chunkHCCQLAA4_cjs.__publicField(this, "canXOF");
+        chunkHCCQLAA4_cjs.__publicField(this, "enableXOF", false);
+        chunkHCCQLAA4_cjs.__publicField(this, "rounds");
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.canXOF = enableXOF;
+        this.rounds = rounds;
+        anumber(outputLen, "outputLen");
+        if (!(0 < blockLen && blockLen < 200))
+          throw new Error("only keccak-f1600 function is supported");
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+      }
+      clone() {
+        return this._cloneInto();
+      }
+      keccak() {
+        swap32IfBE(this.state32);
+        keccakP(this.state32, this.rounds);
+        swap32IfBE(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+      }
+      update(data) {
+        aexists(this);
+        abytes(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len; ) {
+          const take = Math.min(blockLen - this.pos, len - pos);
+          for (let i = 0; i < take; i++)
+            state[this.pos++] ^= data[pos++];
+          if (this.pos === blockLen)
+            this.keccak();
+        }
+        return this;
+      }
+      finish() {
+        if (this.finished)
+          return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        state[pos] ^= suffix;
+        if ((suffix & 128) !== 0 && pos === blockLen - 1)
+          this.keccak();
+        state[blockLen - 1] ^= 128;
+        this.keccak();
+      }
+      writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len; ) {
+          if (this.posOut >= blockLen)
+            this.keccak();
+          const take = Math.min(blockLen - this.posOut, len - pos);
+          out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+          this.posOut += take;
+          pos += take;
+        }
+        return out;
+      }
+      xofInto(out) {
+        if (!this.enableXOF)
+          throw new Error("XOF is not possible for this instance");
+        return this.writeInto(out);
+      }
+      xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+      }
+      digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+          throw new Error("digest() was already called");
+        this.writeInto(out.subarray(0, this.outputLen));
+        this.destroy();
+      }
+      digest() {
+        const out = new Uint8Array(this.outputLen);
+        this.digestInto(out);
+        return out;
+      }
+      destroy() {
+        this.destroyed = true;
+        clean(this.state);
+      }
+      _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.blockLen = blockLen;
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.canXOF = this.canXOF;
+        to.destroyed = this.destroyed;
+        return to;
+      }
+    };
+    genShake = (suffix, blockLen, outputLen, info = {}) => createHasher((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true), info);
+    shake128 = /* @__PURE__ */ genShake(31, 168, 16, /* @__PURE__ */ oidNist(11));
+    shake256 = /* @__PURE__ */ genShake(31, 136, 32, /* @__PURE__ */ oidNist(12));
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/abstract/fft.js
+function checkU32(n) {
+  if (!Number.isSafeInteger(n) || n < 0 || n > 4294967295)
+    throw new Error("wrong u32 integer:" + n);
+  return n;
+}
+function isPowerOfTwo(x) {
+  checkU32(x);
+  return (x & x - 1) === 0 && x !== 0;
+}
+function reverseBits(n, bits) {
+  checkU32(n);
+  if (!Number.isSafeInteger(bits) || bits < 0 || bits > 32)
+    throw new Error(`expected integer 0 <= bits <= 32, got ${bits}`);
+  let reversed = 0;
+  for (let i = 0; i < bits; i++, n >>>= 1)
+    reversed = reversed << 1 | n & 1;
+  return reversed >>> 0;
+}
+function log2(n) {
+  checkU32(n);
+  return 31 - Math.clz32(n);
+}
+function bitReversalInplace(values) {
+  const n = values.length;
+  if (!isPowerOfTwo(n))
+    throw new Error("expected positive power-of-two length, got " + n);
+  const bits = log2(n);
+  for (let i = 0; i < n; i++) {
+    const j = reverseBits(i, bits);
+    if (i < j) {
+      const tmp = values[i];
+      values[i] = values[j];
+      values[j] = tmp;
+    }
+  }
+  return values;
+}
+var FFTCore;
+var init_fft = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/abstract/fft.js"() {
+    FFTCore = (F2, coreOpts) => {
+      const { N: N2, roots, dit, invertButterflies = false, skipStages = 0, brp = true } = coreOpts;
+      const bits = log2(N2);
+      if (!isPowerOfTwo(N2))
+        throw new Error("FFT: Polynomial size should be power of two");
+      if (roots.length !== N2)
+        throw new Error(`FFT: wrong roots length: expected ${N2}, got ${roots.length}`);
+      const isDit = dit !== invertButterflies;
+      return (values) => {
+        if (values.length !== N2)
+          throw new Error("FFT: wrong Polynomial length");
+        if (dit && brp)
+          bitReversalInplace(values);
+        for (let i = 0, g = 1; i < bits - skipStages; i++) {
+          const s = dit ? i + 1 + skipStages : bits - i;
+          const m = 1 << s;
+          const m2 = m >> 1;
+          const stride = N2 >> s;
+          for (let k = 0; k < N2; k += m) {
+            for (let j = 0, grp = g++; j < m2; j++) {
+              const rootPos = invertButterflies ? dit ? N2 - grp : grp : j * stride;
+              const i0 = k + j;
+              const i1 = k + j + m2;
+              const omega = roots[rootPos];
+              const b = values[i1];
+              const a = values[i0];
+              if (isDit) {
+                const t = F2.mul(b, omega);
+                values[i0] = F2.add(a, t);
+                values[i1] = F2.sub(a, t);
+              } else if (invertButterflies) {
+                values[i0] = F2.add(b, a);
+                values[i1] = F2.mul(F2.sub(b, a), omega);
+              } else {
+                values[i0] = F2.add(a, b);
+                values[i1] = F2.mul(F2.sub(a, b), omega);
+              }
+            }
+          }
+        }
+        if (!dit && brp)
+          bitReversalInplace(values);
+        return values;
+      };
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+post-quantum@0.6.1/node_modules/@noble/post-quantum/utils.js
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+function validateOpts(opts) {
+  if (Object.prototype.toString.call(opts) !== "[object Object]")
+    throw new TypeError("expected valid options object");
+}
+function validateVerOpts(opts) {
+  validateOpts(opts);
+  if (opts.context !== void 0)
+    abytes(opts.context, void 0, "opts.context");
+}
+function validateSigOpts(opts) {
+  validateVerOpts(opts);
+  if (opts.extraEntropy !== false && opts.extraEntropy !== void 0)
+    abytes(opts.extraEntropy, void 0, "opts.extraEntropy");
+}
+function splitCoder(label, ...lengths) {
+  const getLength = (c) => typeof c === "number" ? c : c.bytesLen;
+  const bytesLen = lengths.reduce((sum, a) => sum + getLength(a), 0);
+  return {
+    bytesLen,
+    encode: (bufs) => {
+      const res = new Uint8Array(bytesLen);
+      for (let i = 0, pos = 0; i < lengths.length; i++) {
+        const c = lengths[i];
+        const l = getLength(c);
+        const b = typeof c === "number" ? bufs[i] : c.encode(bufs[i]);
+        abytes(b, l, label);
+        res.set(b, pos);
+        if (typeof c !== "number")
+          b.fill(0);
+        pos += l;
+      }
+      return res;
+    },
+    decode: (buf) => {
+      abytes(buf, bytesLen, label);
+      const res = [];
+      for (const c of lengths) {
+        const l = getLength(c);
+        const b = buf.subarray(0, l);
+        res.push(typeof c === "number" ? b : c.decode(b));
+        buf = buf.subarray(l);
+      }
+      return res;
+    }
+  };
+}
+function vecCoder(c, vecLen) {
+  const coder = c;
+  const bytesLen = vecLen * coder.bytesLen;
+  return {
+    bytesLen,
+    encode: (u) => {
+      if (u.length !== vecLen)
+        throw new RangeError(`vecCoder.encode: wrong length=${u.length}. Expected: ${vecLen}`);
+      const res = new Uint8Array(bytesLen);
+      for (let i = 0, pos = 0; i < u.length; i++) {
+        const b = coder.encode(u[i]);
+        res.set(b, pos);
+        b.fill(0);
+        pos += b.length;
+      }
+      return res;
+    },
+    decode: (a) => {
+      abytes(a, bytesLen);
+      const r = [];
+      for (let i = 0; i < a.length; i += coder.bytesLen)
+        r.push(coder.decode(a.subarray(i, i + coder.bytesLen)));
+      return r;
+    }
+  };
+}
+function cleanBytes(...list) {
+  for (const t of list) {
+    if (Array.isArray(t))
+      for (const b of t)
+        b.fill(0);
+    else
+      t.fill(0);
+  }
+}
+function getMask(bits) {
+  if (!Number.isSafeInteger(bits) || bits < 0 || bits > 32)
+    throw new RangeError(`expected bits in [0..32], got ${bits}`);
+  return bits === 32 ? 4294967295 : ~(-1 << bits) >>> 0;
+}
+function getMessage(msg, ctx = EMPTY) {
+  abytes(msg);
+  abytes(ctx);
+  if (ctx.length > 255)
+    throw new RangeError("context should be 255 bytes or less");
+  return concatBytes(new Uint8Array([0, ctx.length]), ctx, msg);
+}
+function checkHash(hash, requiredStrength = 0) {
+  if (!hash.oid || !equalBytes(hash.oid.subarray(0, 10), oidNistP))
+    throw new Error("hash.oid is invalid: expected NIST hash");
+  const collisionResistance = hash.outputLen * 8 / 2;
+  if (requiredStrength > collisionResistance) {
+    throw new Error("Pre-hash security strength too low: " + collisionResistance + ", required: " + requiredStrength);
+  }
+}
+function getMessagePrehash(hash, msg, ctx = EMPTY) {
+  abytes(msg);
+  abytes(ctx);
+  if (ctx.length > 255)
+    throw new RangeError("context should be 255 bytes or less");
+  const hashed = hash(msg);
+  return concatBytes(new Uint8Array([1, ctx.length]), ctx, hash.oid, hashed);
+}
+var abytesDoc, randomBytes2, EMPTY, oidNistP;
+var init_utils3 = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+post-quantum@0.6.1/node_modules/@noble/post-quantum/utils.js"() {
+    init_utils();
+    abytesDoc = abytes;
+    randomBytes2 = randomBytes;
+    EMPTY = /* @__PURE__ */ Uint8Array.of();
+    oidNistP = /* @__PURE__ */ Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2]);
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+post-quantum@0.6.1/node_modules/@noble/post-quantum/_crystals.js
+var genCrystals, createXofShake, XOF128, XOF256;
+var init_crystals = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+post-quantum@0.6.1/node_modules/@noble/post-quantum/_crystals.js"() {
+    init_fft();
+    init_sha3();
+    init_utils3();
+    genCrystals = (opts) => {
+      const { newPoly: newPoly2, N: N2, Q: Q2, F: F2, ROOT_OF_UNITY: ROOT_OF_UNITY2, brvBits, isKyber } = opts;
+      const mod = (a, modulo = Q2) => {
+        const result = a % modulo | 0;
+        return (result >= 0 ? result | 0 : modulo + result | 0) | 0;
+      };
+      const smod = (a, modulo = Q2) => {
+        const r = mod(a, modulo) | 0;
+        return (r > modulo >> 1 ? r - modulo | 0 : r) | 0;
+      };
+      function getZettas() {
+        const out = newPoly2(N2);
+        for (let i = 0; i < N2; i++) {
+          const b = reverseBits(i, brvBits);
+          const p = BigInt(ROOT_OF_UNITY2) ** BigInt(b) % BigInt(Q2);
+          out[i] = Number(p) | 0;
+        }
+        return out;
+      }
+      const nttZetas = getZettas();
+      const field = {
+        add: (a, b) => mod((a | 0) + (b | 0)) | 0,
+        sub: (a, b) => mod((a | 0) - (b | 0)) | 0,
+        mul: (a, b) => mod((a | 0) * (b | 0)) | 0,
+        inv: (_a) => {
+          throw new Error("not implemented");
+        }
+      };
+      const nttOpts = {
+        N: N2,
+        roots: nttZetas,
+        invertButterflies: true,
+        skipStages: isKyber ? 1 : 0,
+        brp: false
+      };
+      const dif = FFTCore(field, { dit: false, ...nttOpts });
+      const dit = FFTCore(field, { dit: true, ...nttOpts });
+      const NTT = {
+        encode: (r) => {
+          return dif(r);
+        },
+        decode: (r) => {
+          dit(r);
+          for (let i = 0; i < r.length; i++)
+            r[i] = mod(F2 * r[i]);
+          return r;
+        }
+      };
+      const bitsCoder = (d, c) => {
+        const mask = getMask(d);
+        const bytesLen = d * (N2 / 8);
+        return {
+          bytesLen,
+          encode: (poly_) => {
+            const poly = poly_;
+            const r = new Uint8Array(bytesLen);
+            for (let i = 0, buf = 0, bufLen = 0, pos = 0; i < poly.length; i++) {
+              buf |= (c.encode(poly[i]) & mask) << bufLen;
+              bufLen += d;
+              for (; bufLen >= 8; bufLen -= 8, buf >>= 8)
+                r[pos++] = buf & getMask(bufLen);
+            }
+            return r;
+          },
+          decode: (bytes) => {
+            const r = newPoly2(N2);
+            for (let i = 0, buf = 0, bufLen = 0, pos = 0; i < bytes.length; i++) {
+              buf |= bytes[i] << bufLen;
+              bufLen += 8;
+              for (; bufLen >= d; bufLen -= d, buf >>= d)
+                r[pos++] = c.decode(buf & mask);
+            }
+            return r;
+          }
+        };
+      };
+      return {
+        mod,
+        smod,
+        nttZetas,
+        NTT: {
+          encode: (r) => NTT.encode(r),
+          decode: (r) => NTT.decode(r)
+        },
+        bitsCoder
+      };
+    };
+    createXofShake = (shake) => (seed, blockLen) => {
+      if (!blockLen)
+        blockLen = shake.blockLen;
+      const _seed = new Uint8Array(seed.length + 2);
+      _seed.set(seed);
+      const seedLen = seed.length;
+      const buf = new Uint8Array(blockLen);
+      let h = shake.create({});
+      let calls = 0;
+      let xofs = 0;
+      return {
+        stats: () => ({ calls, xofs }),
+        get: (x, y) => {
+          _seed[seedLen + 0] = x;
+          _seed[seedLen + 1] = y;
+          h.destroy();
+          h = shake.create({}).update(_seed);
+          calls++;
+          return () => {
+            xofs++;
+            return h.xofInto(buf);
+          };
+        },
+        clean: () => {
+          h.destroy();
+          cleanBytes(buf, _seed);
+        }
+      };
+    };
+    XOF128 = /* @__PURE__ */ createXofShake(shake128);
+    XOF256 = /* @__PURE__ */ createXofShake(shake256);
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+post-quantum@0.6.1/node_modules/@noble/post-quantum/ml-dsa.js
+function validateInternalOpts(opts) {
+  validateOpts(opts);
+  if (opts.externalMu !== void 0)
+    abool(opts.externalMu, "opts.externalMu");
+}
+function RejNTTPoly(xof_) {
+  const xof = xof_;
+  const r = newPoly(N);
+  for (let j = 0; j < N; ) {
+    const b = xof();
+    if (b.length % 3)
+      throw new Error("RejNTTPoly: unaligned block");
+    for (let i = 0; j < N && i <= b.length - 3; i += 3) {
+      const t = (b[i + 0] | b[i + 1] << 8 | b[i + 2] << 16) & 8388607;
+      if (t < Q)
+        r[j++] = t;
+    }
+  }
+  return r;
+}
+function getDilithium(opts_) {
+  const opts = opts_;
+  const { K, L, GAMMA1, GAMMA2, TAU, ETA, OMEGA } = opts;
+  const { CRH_BYTES, TR_BYTES, C_TILDE_BYTES, XOF128: XOF1282, XOF256: XOF2562, securityLevel } = opts;
+  if (![2, 4].includes(ETA))
+    throw new Error("Wrong ETA");
+  if (![1 << 17, 1 << 19].includes(GAMMA1))
+    throw new Error("Wrong GAMMA1");
+  if (![GAMMA2_1, GAMMA2_2].includes(GAMMA2))
+    throw new Error("Wrong GAMMA2");
+  const BETA = TAU * ETA;
+  const decompose = (r) => {
+    const rPlus = crystals.mod(r);
+    const r0 = crystals.smod(rPlus, 2 * GAMMA2) | 0;
+    if (rPlus - r0 === Q - 1)
+      return { r1: 0 | 0, r0: r0 - 1 | 0 };
+    const r1 = Math.floor((rPlus - r0) / (2 * GAMMA2)) | 0;
+    return { r1, r0 };
+  };
+  const HighBits = (r) => decompose(r).r1;
+  const LowBits = (r) => decompose(r).r0;
+  const MakeHint = (z, r) => {
+    const res0 = z <= GAMMA2 || z > Q - GAMMA2 || z === Q - GAMMA2 && r === 0 ? 0 : 1;
+    return res0;
+  };
+  const UseHint = (h, r) => {
+    const m = Math.floor((Q - 1) / (2 * GAMMA2));
+    const { r1, r0 } = decompose(r);
+    if (h === 1)
+      return r0 > 0 ? crystals.mod(r1 + 1, m) | 0 : crystals.mod(r1 - 1, m) | 0;
+    return r1 | 0;
+  };
+  const Power2Round = (r) => {
+    const rPlus = crystals.mod(r);
+    const r0 = crystals.smod(rPlus, 2 ** D) | 0;
+    return { r1: Math.floor((rPlus - r0) / 2 ** D) | 0, r0 };
+  };
+  const hintCoder = {
+    bytesLen: OMEGA + K,
+    encode: (h_) => {
+      const h = h_;
+      if (h === false)
+        throw new Error("hint.encode: hint is false");
+      const res = new Uint8Array(OMEGA + K);
+      for (let i = 0, k = 0; i < K; i++) {
+        for (let j = 0; j < N; j++)
+          if (h[i][j] !== 0)
+            res[k++] = j;
+        res[OMEGA + i] = k;
+      }
+      return res;
+    },
+    decode: (buf) => {
+      const h = [];
+      let k = 0;
+      for (let i = 0; i < K; i++) {
+        const hi = newPoly(N);
+        if (buf[OMEGA + i] < k || buf[OMEGA + i] > OMEGA)
+          return false;
+        for (let j = k; j < buf[OMEGA + i]; j++) {
+          if (j > k && buf[j] <= buf[j - 1])
+            return false;
+          hi[buf[j]] = 1;
+        }
+        k = buf[OMEGA + i];
+        h.push(hi);
+      }
+      for (let j = k; j < OMEGA; j++)
+        if (buf[j] !== 0)
+          return false;
+      return h;
+    }
+  };
+  const ETACoder = polyCoder(ETA === 2 ? 3 : 4, (i) => ETA - i, (i) => {
+    if (!(-ETA <= i && i <= ETA))
+      throw new Error(`malformed key s1/s3 ${i} outside of ETA range [${-ETA}, ${ETA}]`);
+    return i;
+  });
+  const T0Coder = polyCoder(13, (i) => (1 << D - 1) - i);
+  const T1Coder = polyCoder(10);
+  const ZCoder = polyCoder(GAMMA1 === 1 << 17 ? 18 : 20, (i) => crystals.smod(GAMMA1 - i));
+  const W1Coder = polyCoder(GAMMA2 === GAMMA2_1 ? 6 : 4);
+  const W1Vec = vecCoder(W1Coder, K);
+  const publicCoder = splitCoder("publicKey", 32, vecCoder(T1Coder, K));
+  const secretCoder = splitCoder("secretKey", 32, 32, TR_BYTES, vecCoder(ETACoder, L), vecCoder(ETACoder, K), vecCoder(T0Coder, K));
+  const sigCoder = splitCoder("signature", C_TILDE_BYTES, vecCoder(ZCoder, L), hintCoder);
+  const CoefFromHalfByte = ETA === 2 ? (n) => n < 15 ? 2 - n % 5 : false : (n) => n < 9 ? 4 - n : false;
+  function RejBoundedPoly(xof_) {
+    const xof = xof_;
+    const r = newPoly(N);
+    for (let j = 0; j < N; ) {
+      const b = xof();
+      for (let i = 0; j < N && i < b.length; i += 1) {
+        const d1 = CoefFromHalfByte(b[i] & 15);
+        const d2 = CoefFromHalfByte(b[i] >> 4 & 15);
+        if (d1 !== false)
+          r[j++] = d1;
+        if (j < N && d2 !== false)
+          r[j++] = d2;
+      }
+    }
+    return r;
+  }
+  const SampleInBall = (seed) => {
+    const pre = newPoly(N);
+    const s = shake256.create({}).update(seed);
+    const buf = new Uint8Array(shake256.blockLen);
+    s.xofInto(buf);
+    const masks = buf.slice(0, 8);
+    for (let i = N - TAU, pos = 8, maskPos = 0, maskBit = 0; i < N; i++) {
+      let b = i + 1;
+      for (; b > i; ) {
+        b = buf[pos++];
+        if (pos < shake256.blockLen)
+          continue;
+        s.xofInto(buf);
+        pos = 0;
+      }
+      pre[i] = pre[b];
+      pre[b] = 1 - ((masks[maskPos] >> maskBit++ & 1) << 1);
+      if (maskBit >= 8) {
+        maskPos++;
+        maskBit = 0;
+      }
+    }
+    return pre;
+  };
+  const polyPowerRound = (p_) => {
+    const p = p_;
+    const res0 = newPoly(N);
+    const res1 = newPoly(N);
+    for (let i = 0; i < p.length; i++) {
+      const { r0, r1 } = Power2Round(p[i]);
+      res0[i] = r0;
+      res1[i] = r1;
+    }
+    return { r0: res0, r1: res1 };
+  };
+  const polyUseHint = (u_, h_) => {
+    const u = u_;
+    const h = h_;
+    for (let i = 0; i < N; i++)
+      u[i] = UseHint(h[i], u[i]);
+    return u;
+  };
+  const polyMakeHint = (a_, b_) => {
+    const a = a_;
+    const b = b_;
+    const v = newPoly(N);
+    let cnt = 0;
+    for (let i = 0; i < N; i++) {
+      const h = MakeHint(a[i], b[i]);
+      v[i] = h;
+      cnt += h;
+    }
+    return { v, cnt };
+  };
+  const signRandBytes = 32;
+  const seedCoder = splitCoder("seed", 32, 64, 32);
+  const internal = Object.freeze({
+    info: Object.freeze({ type: "internal-ml-dsa" }),
+    lengths: Object.freeze({
+      secretKey: secretCoder.bytesLen,
+      publicKey: publicCoder.bytesLen,
+      seed: 32,
+      signature: sigCoder.bytesLen,
+      signRand: signRandBytes
+    }),
+    keygen: (seed) => {
+      const seedDst = new Uint8Array(32 + 2);
+      const randSeed = seed === void 0;
+      if (randSeed)
+        seed = randomBytes2(32);
+      abytesDoc(seed, 32, "seed");
+      seedDst.set(seed);
+      if (randSeed)
+        cleanBytes(seed);
+      seedDst[32] = K;
+      seedDst[33] = L;
+      const [rho, rhoPrime, K_] = seedCoder.decode(shake256(seedDst, { dkLen: seedCoder.bytesLen }));
+      const xofPrime = XOF2562(rhoPrime);
+      const s1 = [];
+      for (let i = 0; i < L; i++)
+        s1.push(RejBoundedPoly(xofPrime.get(i & 255, i >> 8 & 255)));
+      const s2 = [];
+      for (let i = L; i < L + K; i++)
+        s2.push(RejBoundedPoly(xofPrime.get(i & 255, i >> 8 & 255)));
+      const s1Hat = s1.map((i) => crystals.NTT.encode(i.slice()));
+      const t0 = [];
+      const t1 = [];
+      const xof = XOF1282(rho);
+      const t = newPoly(N);
+      for (let i = 0; i < K; i++) {
+        cleanBytes(t);
+        for (let j = 0; j < L; j++) {
+          const aij = RejNTTPoly(xof.get(j, i));
+          polyAdd(t, MultiplyNTTs(aij, s1Hat[j]));
+        }
+        crystals.NTT.decode(t);
+        const { r0, r1 } = polyPowerRound(polyAdd(t, s2[i]));
+        t0.push(r0);
+        t1.push(r1);
+      }
+      const publicKey = publicCoder.encode([rho, t1]);
+      const tr = shake256(publicKey, { dkLen: TR_BYTES });
+      const secretKey = secretCoder.encode([rho, K_, tr, s1, s2, t0]);
+      xof.clean();
+      xofPrime.clean();
+      cleanBytes(rho, rhoPrime, K_, s1, s2, s1Hat, t, t0, t1, tr, seedDst);
+      return {
+        publicKey,
+        secretKey
+      };
+    },
+    getPublicKey: (secretKey) => {
+      const [rho, _K, _tr, s1, s2, _t0] = secretCoder.decode(secretKey);
+      const xof = XOF1282(rho);
+      const s1Hat = s1.map((p) => crystals.NTT.encode(p.slice()));
+      const t1 = [];
+      const tmp = newPoly(N);
+      for (let i = 0; i < K; i++) {
+        tmp.fill(0);
+        for (let j = 0; j < L; j++) {
+          const aij = RejNTTPoly(xof.get(j, i));
+          polyAdd(tmp, MultiplyNTTs(aij, s1Hat[j]));
+        }
+        crystals.NTT.decode(tmp);
+        polyAdd(tmp, s2[i]);
+        const { r1 } = polyPowerRound(tmp);
+        t1.push(r1);
+      }
+      xof.clean();
+      cleanBytes(tmp, s1Hat, _t0, s1, s2);
+      return publicCoder.encode([rho, t1]);
+    },
+    // NOTE: random is optional.
+    sign: (msg, secretKey, opts2 = {}) => {
+      validateSigOpts(opts2);
+      validateInternalOpts(opts2);
+      let { extraEntropy: random, externalMu = false } = opts2;
+      const [rho, _K, tr, s1, s2, t0] = secretCoder.decode(secretKey);
+      const A = [];
+      const xof = XOF1282(rho);
+      for (let i = 0; i < K; i++) {
+        const pv = [];
+        for (let j = 0; j < L; j++)
+          pv.push(RejNTTPoly(xof.get(j, i)));
+        A.push(pv);
+      }
+      xof.clean();
+      for (let i = 0; i < L; i++)
+        crystals.NTT.encode(s1[i]);
+      for (let i = 0; i < K; i++) {
+        crystals.NTT.encode(s2[i]);
+        crystals.NTT.encode(t0[i]);
+      }
+      const mu = externalMu ? msg : (
+        // 6: µ ← H(tr||M, 512)
+        //    ▷ Compute message representative µ
+        shake256.create({ dkLen: CRH_BYTES }).update(tr).update(msg).digest()
+      );
+      const rnd = random === false ? new Uint8Array(32) : random === void 0 ? randomBytes2(signRandBytes) : random;
+      abytesDoc(rnd, 32, "extraEntropy");
+      const rhoprime = shake256.create({ dkLen: CRH_BYTES }).update(_K).update(rnd).update(mu).digest();
+      abytesDoc(rhoprime, CRH_BYTES);
+      const x256 = XOF2562(rhoprime, ZCoder.bytesLen);
+      main_loop: for (let kappa = 0; ; ) {
+        const y = [];
+        for (let i = 0; i < L; i++, kappa++)
+          y.push(ZCoder.decode(x256.get(kappa & 255, kappa >> 8)()));
+        const z = y.map((i) => crystals.NTT.encode(i.slice()));
+        const w = [];
+        for (let i = 0; i < K; i++) {
+          const wi = newPoly(N);
+          for (let j = 0; j < L; j++)
+            polyAdd(wi, MultiplyNTTs(A[i][j], z[j]));
+          crystals.NTT.decode(wi);
+          w.push(wi);
+        }
+        const w1 = w.map((j) => j.map(HighBits));
+        const cTilde = shake256.create({ dkLen: C_TILDE_BYTES }).update(mu).update(W1Vec.encode(w1)).digest();
+        const cHat = crystals.NTT.encode(SampleInBall(cTilde));
+        const cs1 = s1.map((i) => MultiplyNTTs(i, cHat));
+        for (let i = 0; i < L; i++) {
+          polyAdd(crystals.NTT.decode(cs1[i]), y[i]);
+          if (polyChknorm(cs1[i], GAMMA1 - BETA))
+            continue main_loop;
+        }
+        let cnt = 0;
+        const h = [];
+        for (let i = 0; i < K; i++) {
+          const cs2 = crystals.NTT.decode(MultiplyNTTs(s2[i], cHat));
+          const r0 = polySub(w[i], cs2).map(LowBits);
+          if (polyChknorm(r0, GAMMA2 - BETA))
+            continue main_loop;
+          const ct0 = crystals.NTT.decode(MultiplyNTTs(t0[i], cHat));
+          if (polyChknorm(ct0, GAMMA2))
+            continue main_loop;
+          polyAdd(r0, ct0);
+          const hint = polyMakeHint(r0, w1[i]);
+          h.push(hint.v);
+          cnt += hint.cnt;
+        }
+        if (cnt > OMEGA)
+          continue;
+        x256.clean();
+        const res = sigCoder.encode([cTilde, cs1, h]);
+        cleanBytes(cTilde, cs1, h, cHat, w1, w, z, y, rhoprime, s1, s2, t0, ...A);
+        if (!externalMu)
+          cleanBytes(mu);
+        return res;
+      }
+      throw new Error("Unreachable code path reached, report this error");
+    },
+    verify: (sig, msg, publicKey, opts2 = {}) => {
+      validateInternalOpts(opts2);
+      const { externalMu = false } = opts2;
+      const [rho, t1] = publicCoder.decode(publicKey);
+      const tr = shake256(publicKey, { dkLen: TR_BYTES });
+      if (sig.length !== sigCoder.bytesLen)
+        return false;
+      const [cTilde, z, h] = sigCoder.decode(sig);
+      if (h === false)
+        return false;
+      for (let i = 0; i < L; i++)
+        if (polyChknorm(z[i], GAMMA1 - BETA))
+          return false;
+      const mu = externalMu ? msg : (
+        // 7: µ ← H(tr||M, 512)
+        shake256.create({ dkLen: CRH_BYTES }).update(tr).update(msg).digest()
+      );
+      const c = crystals.NTT.encode(SampleInBall(cTilde));
+      const zNtt = z.map((i) => i.slice());
+      for (let i = 0; i < L; i++)
+        crystals.NTT.encode(zNtt[i]);
+      const wTick1 = [];
+      const xof = XOF1282(rho);
+      for (let i = 0; i < K; i++) {
+        const ct12d = MultiplyNTTs(crystals.NTT.encode(polyShiftl(t1[i])), c);
+        const Az = newPoly(N);
+        for (let j = 0; j < L; j++) {
+          const aij = RejNTTPoly(xof.get(j, i));
+          polyAdd(Az, MultiplyNTTs(aij, zNtt[j]));
+        }
+        const wApprox = crystals.NTT.decode(polySub(Az, ct12d));
+        wTick1.push(polyUseHint(wApprox, h[i]));
+      }
+      xof.clean();
+      const c2 = shake256.create({ dkLen: C_TILDE_BYTES }).update(mu).update(W1Vec.encode(wTick1)).digest();
+      for (const t of h) {
+        const sum = t.reduce((acc, i) => acc + i, 0);
+        if (!(sum <= OMEGA))
+          return false;
+      }
+      for (const t of z)
+        if (polyChknorm(t, GAMMA1 - BETA))
+          return false;
+      return equalBytes(cTilde, c2);
+    }
+  });
+  return Object.freeze({
+    info: Object.freeze({ type: "ml-dsa" }),
+    internal,
+    securityLevel,
+    keygen: internal.keygen,
+    lengths: internal.lengths,
+    getPublicKey: internal.getPublicKey,
+    sign: (msg, secretKey, opts2 = {}) => {
+      validateSigOpts(opts2);
+      const M = getMessage(msg, opts2.context);
+      const res = internal.sign(M, secretKey, opts2);
+      cleanBytes(M);
+      return res;
+    },
+    verify: (sig, msg, publicKey, opts2 = {}) => {
+      validateVerOpts(opts2);
+      return internal.verify(sig, getMessage(msg, opts2.context), publicKey);
+    },
+    prehash: (hash) => {
+      checkHash(hash, securityLevel);
+      return Object.freeze({
+        info: Object.freeze({ type: "hashml-dsa" }),
+        securityLevel,
+        lengths: internal.lengths,
+        keygen: internal.keygen,
+        getPublicKey: internal.getPublicKey,
+        sign: (msg, secretKey, opts2 = {}) => {
+          validateSigOpts(opts2);
+          const M = getMessagePrehash(hash, msg, opts2.context);
+          const res = internal.sign(M, secretKey, opts2);
+          cleanBytes(M);
+          return res;
+        },
+        verify: (sig, msg, publicKey, opts2 = {}) => {
+          validateVerOpts(opts2);
+          return internal.verify(sig, getMessagePrehash(hash, msg, opts2.context), publicKey);
+        }
+      });
+    }
+  });
+}
+var N, Q, ROOT_OF_UNITY, F, D, GAMMA2_1, GAMMA2_2; exports.PARAMS = void 0; var newPoly, crystals, id, polyCoder, polyAdd, polySub, polyShiftl, polyChknorm, MultiplyNTTs; exports.ml_dsa44 = void 0; exports.ml_dsa65 = void 0; exports.ml_dsa87 = void 0;
+var init_ml_dsa = chunkHCCQLAA4_cjs.__esm({
+  "../../node_modules/.pnpm/@noble+post-quantum@0.6.1/node_modules/@noble/post-quantum/ml-dsa.js"() {
+    init_utils2();
+    init_sha3();
+    init_crystals();
+    init_utils3();
+    N = 256;
+    Q = 8380417;
+    ROOT_OF_UNITY = 1753;
+    F = 8347681;
+    D = 13;
+    GAMMA2_1 = Math.floor((Q - 1) / 88) | 0;
+    GAMMA2_2 = Math.floor((Q - 1) / 32) | 0;
+    exports.PARAMS = /* @__PURE__ */ (() => Object.freeze({
+      2: Object.freeze({
+        K: 4,
+        L: 4,
+        D,
+        GAMMA1: 2 ** 17,
+        GAMMA2: GAMMA2_1,
+        TAU: 39,
+        ETA: 2,
+        OMEGA: 80
+      }),
+      3: Object.freeze({
+        K: 6,
+        L: 5,
+        D,
+        GAMMA1: 2 ** 19,
+        GAMMA2: GAMMA2_2,
+        TAU: 49,
+        ETA: 4,
+        OMEGA: 55
+      }),
+      5: Object.freeze({
+        K: 8,
+        L: 7,
+        D,
+        GAMMA1: 2 ** 19,
+        GAMMA2: GAMMA2_2,
+        TAU: 60,
+        ETA: 2,
+        OMEGA: 75
+      })
+    }))();
+    newPoly = (n) => new Int32Array(n);
+    crystals = /* @__PURE__ */ genCrystals({
+      N,
+      Q,
+      F,
+      ROOT_OF_UNITY,
+      newPoly,
+      isKyber: false,
+      brvBits: 8
+    });
+    id = (n) => n;
+    polyCoder = (d, compress = id, verify = id) => crystals.bitsCoder(d, {
+      encode: (i) => compress(verify(i)),
+      decode: (i) => verify(compress(i))
+    });
+    polyAdd = (a_, b_) => {
+      const a = a_;
+      const b = b_;
+      for (let i = 0; i < a.length; i++)
+        a[i] = crystals.mod(a[i] + b[i]);
+      return a;
+    };
+    polySub = (a_, b_) => {
+      const a = a_;
+      const b = b_;
+      for (let i = 0; i < a.length; i++)
+        a[i] = crystals.mod(a[i] - b[i]);
+      return a;
+    };
+    polyShiftl = (p_) => {
+      const p = p_;
+      for (let i = 0; i < N; i++)
+        p[i] <<= D;
+      return p;
+    };
+    polyChknorm = (p_, B) => {
+      const p = p_;
+      for (let i = 0; i < N; i++)
+        if (Math.abs(crystals.smod(p[i])) >= B)
+          return true;
+      return false;
+    };
+    MultiplyNTTs = (a_, b_) => {
+      const a = a_;
+      const b = b_;
+      const c = newPoly(N);
+      for (let i = 0; i < a.length; i++)
+        c[i] = crystals.mod(a[i] * b[i]);
+      return c;
+    };
+    exports.ml_dsa44 = /* @__PURE__ */ (() => getDilithium({
+      ...exports.PARAMS[2],
+      CRH_BYTES: 64,
+      TR_BYTES: 64,
+      C_TILDE_BYTES: 32,
+      XOF128,
+      XOF256,
+      securityLevel: 128
+    }))();
+    exports.ml_dsa65 = /* @__PURE__ */ (() => getDilithium({
+      ...exports.PARAMS[3],
+      CRH_BYTES: 64,
+      TR_BYTES: 64,
+      C_TILDE_BYTES: 48,
+      XOF128,
+      XOF256,
+      securityLevel: 192
+    }))();
+    exports.ml_dsa87 = /* @__PURE__ */ (() => getDilithium({
+      ...exports.PARAMS[5],
+      CRH_BYTES: 64,
+      TR_BYTES: 64,
+      C_TILDE_BYTES: 64,
+      XOF128,
+      XOF256,
+      securityLevel: 256
+    }))();
+  }
+});
+init_ml_dsa();
+/*! Bundled license information:
+
+@noble/curves/utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/post-quantum/utils.js:
+@noble/post-quantum/_crystals.js:
+@noble/post-quantum/ml-dsa.js:
+  (*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=ml-dsa-FSKBTE3W.cjs.map
+//# sourceMappingURL=ml-dsa-FSKBTE3W.cjs.map