@blamejs/core 0.18.55 → 0.18.56

package/lib/vendor/noble-curves.cjs

@@ -1,4 +1,4 @@
-// @noble/curves v2.3.0 — vendored from Paul Miller
+// @noble/curves v2.4.0 — vendored from Paul Miller
 // License: MIT — https://github.com/paulmillr/noble-curves
 // Bundled with esbuild. Exports the RFC 9497 OPRF suites:
 //   ristretto255_oprf (ristretto255-SHA512), p256_oprf (P-256-SHA256),
@@ -104,6 +104,14 @@ var aobject = (value, label) => {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
 };
+var aopts = (value, label) => {
+  aobject(value, label);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    throw new TypeError(`"${label}" expected plain object`);
+  if (Object.hasOwn(value, "__proto__"))
+    throw new TypeError(`"${label}.__proto__" is not allowed`);
+};
 function aexists(instance, checkFinished = true) {
   if (instance.destroyed)
     throw new Error("hash was destroyed");
@@ -190,10 +198,10 @@ function concatBytes(...arrays) {
   return res;
 }
 function checkOpts(defaults, opts, title = "opts") {
-  aobject(defaults, "defaults");
+  aopts(defaults, "defaults");
   if (opts !== void 0)
-    aobject(opts, title);
-  const merged = Object.assign(defaults, opts);
+    aopts(opts, title);
+  const merged = Object.assign(/* @__PURE__ */ Object.create(null), defaults, opts);
   return merged;
 }
 function createHasher(hashCons, info = {}) {
@@ -1019,6 +1027,17 @@ function invert(number, modulo) {
     throw new Error("invert: does not exist");
   return mod(x, modulo);
 }
+function invertCt(a, prime) {
+  if (prime <= _1n2)
+    throw new Error("invertCt: expected prime modulus > 1, got " + prime);
+  const an = mod(a, prime);
+  if (an === _0n2)
+    throw new Error("invertCt: expected non-zero number");
+  const inverse = pow(an, prime - _2n, prime);
+  if (mod(an * inverse, prime) !== _1n2)
+    throw new Error("invertCt: does not exist");
+  return inverse;
+}
 function assertIsSquare(Fp2, root, n) {
   const F = Fp2;
   if (!F.eql(F.sqr(root), n))
@@ -2454,12 +2473,13 @@ function createOPRF(opts) {
     hashToGroup: "function"
   });
   validatePointCons(opts.Point);
-  const { name, Point, hash } = opts;
+  const { name, Point, hash, hashToGroup: hashToGroupHook, hashToScalar } = opts;
   const { Fn: Fn2 } = Point;
-  const hashToGroup = (msg, ctx) => opts.hashToGroup(msg, {
+  const invertSecret = (value) => invertCt(value, Fn2.ORDER);
+  const hashToGroup = (msg, ctx) => hashToGroupHook(msg, {
     DST: concatBytes2(asciiToBytes("HashToGroup-"), ctx)
   });
-  const hashToScalarPrefixed = (msg, ctx) => opts.hashToScalar(msg, { DST: concatBytes2(_DST_scalarBytes, ctx) });
+  const hashToScalarPrefixed = (msg, ctx) => hashToScalar(msg, { DST: concatBytes2(_DST_scalarBytes, ctx) });
   const randomScalar = (rng = randomBytes2) => {
     if (typeof rng !== "function")
       throw new TypeError('"rng" expected function, got type=' + typeof rng);
@@ -2551,7 +2571,7 @@ function createOPRF(opts) {
     const msg = concatBytes2(seed, encode(info), Uint8Array.of(0));
     for (let counter = 0; counter <= 255; counter++) {
       msg[msg.length - 1] = counter;
-      const skS = opts.hashToScalar(msg, { DST: dst });
+      const skS = hashToScalar(msg, { DST: dst });
       if (Fn2.is0(skS))
         continue;
       return {
@@ -2669,7 +2689,7 @@ function createOPRF(opts) {
           throw new Error("expected array");
         const skS = Fn2.fromBytes(secretKey);
         const t = Fn2.add(skS, m);
-        const invT = Fn2.inv(t);
+        const invT = invertSecret(t);
         const blindedPoints = blinded.map((i) => wirePoint("blinded", i));
         const evalPoints = blindedPoints.map((i) => i.multiply(invT));
         const tweakedKey = Point.BASE.multiply(t);
@@ -2702,13 +2722,13 @@ function createOPRF(opts) {
         if (inputPoint.equals(Point.ZERO))
           throw new Error("Input point at infinity");
         const t = Fn2.add(skS, m);
-        const invT = Fn2.inv(t);
+        const invT = invertSecret(t);
         const unblinded = inputPoint.multiply(invT).toBytes();
         return hashInput(input, info, unblinded);
       }
     });
   };
-  const res = { name, oprf, voprf, poprf, __tests: Object.freeze({ Fn: Fn2 }) };
+  const res = { name, oprf, voprf, poprf, __tests: Object.freeze({ Fn: Fn2, invertSecret }) };
   return Object.freeze(res);
 }
 
@@ -2999,21 +3019,28 @@ function weierstrass(params, extraOpts = {}) {
     endo: "object",
     randomBytes: "function"
   });
-  const { endo, allowInfinityPoint } = extraOpts;
+  const { endo: endoOpts, allowInfinityPoint, clearCofactor, isTorsionFree, fromBytes, toBytes } = extraOpts;
   const randomBytes3 = extraOpts.randomBytes === void 0 ? randomBytes2 : extraOpts.randomBytes;
-  if (endo) {
-    if (!Fp2.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) {
+  if (endoOpts) {
+    if (!Fp2.is0(CURVE.a) || typeof endoOpts.beta !== "bigint" || !Array.isArray(endoOpts.basises)) {
       throw new Error('invalid endo: expected "beta": bigint and "basises": array');
     }
   }
+  const endo = endoOpts ? {
+    beta: endoOpts.beta,
+    basises: endoOpts.basises.map((basis) => [...basis])
+  } : void 0;
   const lengths = getWLengths(Fp2, Fn2);
   function assertCompressionIsSupported() {
     if (!Fp2.isOdd)
       throw new Error("compression is not supported: Field does not have .isOdd()");
   }
   function pointToBytes(_c, point, isCompressed) {
-    if (allowInfinityPoint && point.is0())
+    if (point.is0()) {
+      if (!allowInfinityPoint)
+        throw new Error("bad point: ZERO");
       return Uint8Array.of(0);
+    }
     const { x, y } = point.toAffine();
     const bx = Fp2.toBytes(x);
     abool(isCompressed, "isCompressed");
@@ -3062,8 +3089,8 @@ function weierstrass(params, extraOpts = {}) {
       throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
     }
   }
-  const encodePoint = extraOpts.toBytes === void 0 ? pointToBytes : extraOpts.toBytes;
-  const decodePoint = extraOpts.fromBytes === void 0 ? pointFromBytes : extraOpts.fromBytes;
+  const encodePoint = toBytes === void 0 ? pointToBytes : toBytes;
+  const decodePoint = fromBytes === void 0 ? pointFromBytes : fromBytes;
   const b3 = Fp2.mul(CURVE.b, _3n3);
   const mulA = Fp2.is0(CURVE.a) ? (_) => Fp2.ZERO : (x) => Fp2.mul(CURVE.a, x);
   function weierstrassEquation(x) {
@@ -3085,7 +3112,7 @@ function weierstrass(params, extraOpts = {}) {
   function acoord(title, n, banZero = false) {
     if (!Fp2.isValid(n) || banZero && Fp2.is0(n))
       throw new Error(`bad point coordinate ${title}`);
-    return n;
+    return typeof n === "object" && n !== null ? Fp2.create(n) : n;
   }
   function aprjpoint(other) {
     if (!(other instanceof Point))
@@ -3167,7 +3194,7 @@ function weierstrass(params, extraOpts = {}) {
     assertValidity() {
       const p = this;
       if (p.is0()) {
-        if (extraOpts.allowInfinityPoint && Fp2.is0(p.X) && Fp2.eql(p.Y, Fp2.ONE) && Fp2.is0(p.Z))
+        if (allowInfinityPoint && Fp2.is0(p.X) && Fp2.eql(p.Y, Fp2.ONE) && Fp2.is0(p.Z))
           return;
         throw new Error("bad point: ZERO");
       }
@@ -3379,7 +3406,6 @@ function weierstrass(params, extraOpts = {}) {
      * Always torsion-free for cofactor=1 curves.
      */
     isTorsionFree() {
-      const { isTorsionFree } = extraOpts;
       if (cofactor === _1n7)
         return true;
       if (isTorsionFree)
@@ -3387,7 +3413,6 @@ function weierstrass(params, extraOpts = {}) {
       return wnaf.mulUnsafe(this, CURVE_ORDER).is0();
     }
     clearCofactor() {
-      const { clearCofactor } = extraOpts;
       if (cofactor === _1n7)
         return this;
       if (clearCofactor)

package/lib/vendor/noble-post-quantum.cjs

@@ -1,4 +1,4 @@
-// @noble/post-quantum v0.7.0 — vendored from Paul Miller
+// @noble/post-quantum v0.7.1 — vendored from Paul Miller
 // License: MIT — https://github.com/paulmillr/noble-post-quantum
 // Bundled with esbuild. Exports: ml_kem512 / ml_kem768 / ml_kem1024 (FIPS 203 KEM),
 //   ml_dsa44 / ml_dsa65 / ml_dsa87 (FIPS 204 lattice signatures),
@@ -124,6 +124,14 @@ var aobject = (value, label) => {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
 };
+var aopts = (value, label) => {
+  aobject(value, label);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    throw new TypeError(`"${label}" expected plain object`);
+  if (Object.hasOwn(value, "__proto__"))
+    throw new TypeError(`"${label}.__proto__" is not allowed`);
+};
 function aexists(instance, checkFinished = true) {
   if (instance.destroyed)
     throw new Error("hash was destroyed");
@@ -224,10 +232,10 @@ function concatBytes(...arrays) {
   return res;
 }
 function checkOpts(defaults, opts2, title = "opts") {
-  aobject(defaults, "defaults");
+  aopts(defaults, "defaults");
   if (opts2 !== void 0)
-    aobject(opts2, title);
-  const merged = Object.assign(defaults, opts2);
+    aopts(opts2, title);
+  const merged = Object.assign(/* @__PURE__ */ Object.create(null), defaults, opts2);
   return merged;
 }
 function createHasher(hashCons, info = {}) {
@@ -686,22 +694,47 @@ function equalBytes(a, b) {
   return diff === 0;
 }
 function copyBytes(bytes) {
-  return Uint8Array.from(abytes(bytes));
+  return new Uint8Array(abytes(bytes));
 }
 function validateOpts(opts2) {
   if (isBytes(opts2))
     throw new TypeError('"opts" expected object, got Uint8Array');
   aobject3(opts2, "opts");
+  const proto = Object.getPrototypeOf(opts2);
+  if (proto !== null && proto !== Object.prototype)
+    throw new TypeError('"opts" expected a plain object');
 }
-function validateVerOpts(opts2) {
+var VER_OPT_KEYS = /* @__PURE__ */ Object.freeze([
+  "context"
+]);
+var SIG_OPT_KEYS = /* @__PURE__ */ Object.freeze([
+  "context",
+  "extraEntropy"
+]);
+function checkOptKeys(opts2, allowed) {
   validateOpts(opts2);
-  if (opts2.context !== void 0)
-    abytes(opts2.context, void 0, "opts.context");
-}
-function validateSigOpts(opts2) {
-  validateVerOpts(opts2);
-  if (opts2.extraEntropy !== false && opts2.extraEntropy !== void 0)
-    abytes(opts2.extraEntropy, void 0, "opts.extraEntropy");
+  const normalized = Object.assign(/* @__PURE__ */ Object.create(null), opts2);
+  for (const [k, v] of Object.entries(normalized)) {
+    if (v === void 0)
+      continue;
+    if (!allowed.includes(k))
+      throw new TypeError('unexpected option "' + String(k) + '"; expected one of: ' + allowed.join(", "));
+  }
+  return Object.freeze(normalized);
+}
+function validateVerOpts(opts2, allowed = VER_OPT_KEYS) {
+  const normalized = checkOptKeys(opts2, allowed);
+  if (normalized.context !== void 0)
+    abytes(normalized.context, void 0, "opts.context");
+  return normalized;
+}
+function validateSigOpts(opts2, allowed = SIG_OPT_KEYS) {
+  const normalized = checkOptKeys(opts2, allowed);
+  if (normalized.context !== void 0)
+    abytes(normalized.context, void 0, "opts.context");
+  if (normalized.extraEntropy !== false && normalized.extraEntropy !== void 0)
+    abytes(normalized.extraEntropy, void 0, "opts.extraEntropy");
+  return normalized;
 }
 function splitCoder(label, ...lengths) {
   const getLength = (c) => typeof c === "number" ? c : c.bytesLen;
@@ -786,6 +819,12 @@ function getMessage(msg, ctx = EMPTY) {
   return concatBytes(new Uint8Array([0, ctx.length]), ctx, msg);
 }
 var oidNistP = /* @__PURE__ */ Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2]);
+var XOF_OID_OUTPUT_LEN = /* @__PURE__ */ (() => ({
+  "060960864801650304020b": 32,
+  // id-shake128, SHAKE128(M, 256)
+  "060960864801650304020c": 64
+  // id-shake256, SHAKE256(M, 512)
+}))();
 function checkHash(hash, requiredStrength = 0) {
   if (typeof hash !== "function" || typeof hash.create !== "function")
     throw new TypeError('"hash" expected hash function, got type=' + typeof hash);
@@ -795,6 +834,10 @@ function checkHash(hash, requiredStrength = 0) {
   abytes(oid, void 0, "hash.oid");
   if (!equalBytes(oid.subarray(0, 10), oidNistP))
     throw new Error('"hash.oid" is invalid: expected NIST hash');
+  const xofLen = XOF_OID_OUTPUT_LEN[bytesToHex(oid)];
+  if (xofLen !== void 0 && hash.outputLen !== xofLen) {
+    throw new Error("Pre-hash XOF output length must be " + xofLen + " bytes for this OID, got: " + hash.outputLen);
+  }
   const collisionResistance = hash.outputLen * 8 / 2;
   if (requiredStrength > collisionResistance) {
     throw new Error("Pre-hash security strength too low: " + collisionResistance + ", required: " + requiredStrength);
@@ -1162,8 +1205,9 @@ var genKPKE = (opts_) => {
       for (let i = 0; i < K; i++)
         polyAdd(tmp, MultiplyNTTs(sk[i], crystals.NTT.encode(u[i])));
       polySub(v, crystals.NTT.decode(tmp));
-      cleanBytes(tmp, sk, u);
-      return poly1.encode(v);
+      const res = poly1.encode(v);
+      cleanBytes(tmp, sk, u, v);
+      return res;
     }
   };
 };
@@ -1193,32 +1237,55 @@ function createKyber(opts2) {
   return Object.freeze({
     info: Object.freeze({ type: "ml-kem" }),
     lengths: kemLengths,
-    keygen: (seed = randomBytes2(seedLen)) => {
-      abytesDoc(seed, seedLen, "seed");
-      const { publicKey, secretKey: sk } = KPKE.keygen(seed.subarray(0, 32));
-      const publicKeyHash = HASH256(publicKey);
-      const secretKey = secretCoder.encode([sk, publicKey, publicKeyHash, seed.subarray(32)]);
-      cleanBytes(sk, publicKeyHash);
-      return {
-        publicKey,
-        secretKey
-      };
+    keygen: (seed) => {
+      const ownSeed = seed === void 0;
+      const s = ownSeed ? randomBytes2(seedLen) : seed;
+      let sk;
+      let publicKeyHash;
+      try {
+        abytesDoc(s, seedLen, "seed");
+        const keys = KPKE.keygen(s.subarray(0, 32));
+        const publicKey = keys.publicKey;
+        sk = keys.secretKey;
+        publicKeyHash = HASH256(publicKey);
+        const secretKey = secretCoder.encode([sk, publicKey, publicKeyHash, s.subarray(32)]);
+        return {
+          publicKey,
+          secretKey
+        };
+      } finally {
+        if (sk !== void 0)
+          cleanBytes(sk);
+        if (publicKeyHash !== void 0)
+          cleanBytes(publicKeyHash);
+        if (ownSeed)
+          cleanBytes(s);
+      }
     },
     getPublicKey: (secretKey) => {
       const [_sk, publicKey, _publicKeyHash, _z] = secretCoder.decode(secretKey);
       return Uint8Array.from(publicKey);
     },
-    encapsulate: (publicKey, msg = randomBytes2(msgLen)) => {
-      abytesDoc(publicKey, lengths.publicKey, "publicKey");
-      abytesDoc(msg, msgLen, "message");
-      validateModulus(publicKey, "encapsulate");
-      const kr = HASH512.create().update(msg).update(HASH256(publicKey)).digest();
-      const cipherText = KPKE.encrypt(publicKey, msg, kr.subarray(32, 64));
-      cleanBytes(kr.subarray(32));
-      return {
-        cipherText,
-        sharedSecret: kr.subarray(0, 32)
-      };
+    encapsulate: (publicKey, msg) => {
+      const ownMsg = msg === void 0;
+      const m = ownMsg ? randomBytes2(msgLen) : msg;
+      let kr;
+      try {
+        abytesDoc(publicKey, lengths.publicKey, "publicKey");
+        abytesDoc(m, msgLen, "message");
+        validateModulus(publicKey, "encapsulate");
+        kr = HASH512.create().update(m).update(HASH256(publicKey)).digest();
+        const cipherText = KPKE.encrypt(publicKey, m, kr.subarray(32, 64));
+        return {
+          cipherText,
+          sharedSecret: kr.subarray(0, 32)
+        };
+      } finally {
+        if (kr !== void 0)
+          cleanBytes(kr.subarray(32));
+        if (ownMsg)
+          cleanBytes(m);
+      }
     },
     decapsulate: (cipherText, secretKey) => {
       abytesDoc(secretKey, secretCoder.bytesLen, "secretKey");
@@ -1251,15 +1318,24 @@ function createKyber(opts2) {
       const cached = KPKE.prepare(ek);
       return Object.freeze({
         publicKey: ek,
-        encapsulate: (msg = randomBytes2(msgLen)) => {
-          abytesDoc(msg, msgLen, "message");
-          const kr = HASH512.create().update(msg).update(publicKeyHash).digest();
-          const cipherText = cached.encrypt(msg, kr.subarray(32, 64));
-          cleanBytes(kr.subarray(32));
-          return {
-            cipherText,
-            sharedSecret: kr.subarray(0, 32)
-          };
+        encapsulate: (msg) => {
+          const ownMsg = msg === void 0;
+          const m = ownMsg ? randomBytes2(msgLen) : msg;
+          let kr;
+          try {
+            abytesDoc(m, msgLen, "message");
+            kr = HASH512.create().update(m).update(publicKeyHash).digest();
+            const cipherText = cached.encrypt(m, kr.subarray(32, 64));
+            return {
+              cipherText,
+              sharedSecret: kr.subarray(0, 32)
+            };
+          } finally {
+            if (kr !== void 0)
+              cleanBytes(kr.subarray(32));
+            if (ownMsg)
+              cleanBytes(m);
+          }
         },
         decapsulate: (cipherText, secretKey) => {
           abytesDoc(secretKey, secretCoder.bytesLen, "secretKey");
@@ -1300,10 +1376,16 @@ var ml_kem768 = /* @__PURE__ */ (() => mk(PARAMS[768]))();
 var ml_kem1024 = /* @__PURE__ */ (() => mk(PARAMS[1024]))();
 
 // node_modules/@noble/post-quantum/ml-dsa.js
-function validateInternalOpts(opts2) {
-  validateOpts(opts2);
-  if (opts2.externalMu !== void 0)
-    abool2(opts2.externalMu, "opts.externalMu");
+var INTERNAL_SIG_OPT_KEYS = /* @__PURE__ */ Object.freeze([
+  "extraEntropy",
+  "externalMu"
+]);
+var INTERNAL_VER_OPT_KEYS = /* @__PURE__ */ Object.freeze(["externalMu"]);
+function validateInternalOpts(opts2, allowed) {
+  const normalized = checkOptKeys(opts2, allowed);
+  if (normalized.externalMu !== void 0)
+    abool2(normalized.externalMu, "opts.externalMu");
+  return normalized;
 }
 var N2 = 256;
 var Q2 = 8380417;
@@ -1646,8 +1728,8 @@ function getDilithium(opts_) {
     },
     // NOTE: random is optional.
     sign: (msg, secretKey, opts3 = {}) => {
-      validateSigOpts(opts3);
-      validateInternalOpts(opts3);
+      opts3 = validateSigOpts(opts3, INTERNAL_SIG_OPT_KEYS);
+      opts3 = validateInternalOpts(opts3, INTERNAL_SIG_OPT_KEYS);
       const { extraEntropy: random, externalMu = false } = opts3;
       if (externalMu)
         abytesDoc(msg, CRH_BYTES, "mu");
@@ -1708,26 +1790,34 @@ function getDilithium(opts_) {
         const cs1 = s1.map((i) => MultiplyNTTs2(i, cHat));
         for (let i = 0; i < L; i++) {
           polyAdd2(crystals2.NTT.decode(cs1[i]), y[i]);
-          if (polyChknorm(cs1[i], GAMMA1 - BETA))
+          if (polyChknorm(cs1[i], GAMMA1 - BETA)) {
+            cleanBytes(cTilde, cs1, cHat, w1, w, z, y);
             continue main_loop;
+          }
         }
         let cnt = 0;
         const h = [];
         for (let i = 0; i < K; i++) {
           const cs2 = crystals2.NTT.decode(MultiplyNTTs2(s2[i], cHat));
           const r0 = polySub2(w[i], cs2).map(LowBits);
-          if (polyChknorm(r0, GAMMA2 - BETA))
+          if (polyChknorm(r0, GAMMA2 - BETA)) {
+            cleanBytes(cTilde, cs1, cHat, w1, w, z, y, h, cs2, r0);
             continue main_loop;
+          }
           const ct0 = crystals2.NTT.decode(MultiplyNTTs2(t0[i], cHat));
-          if (polyChknorm(ct0, GAMMA2))
+          if (polyChknorm(ct0, GAMMA2)) {
+            cleanBytes(cTilde, cs1, cHat, w1, w, z, y, h, cs2, r0, ct0);
             continue main_loop;
+          }
           polyAdd2(r0, ct0);
           const hint = polyMakeHint(r0, w1[i]);
           h.push(hint.v);
           cnt += hint.cnt;
         }
-        if (cnt > OMEGA)
+        if (cnt > OMEGA) {
+          cleanBytes(cTilde, cs1, cHat, w1, w, z, y, h);
           continue;
+        }
         x256.clean();
         const res = sigCoder.encode([cTilde, cs1, h]);
         cleanBytes(cTilde, cs1, h, cHat, w1, w, z, y, rhoprime, s1, s2, t0, ...A);
@@ -1738,7 +1828,7 @@ function getDilithium(opts_) {
       throw new Error("Unreachable code path reached, report this error");
     },
     verify: (sig, msg, publicKey, opts3 = {}) => {
-      validateInternalOpts(opts3);
+      opts3 = validateInternalOpts(opts3, INTERNAL_VER_OPT_KEYS);
       const { externalMu = false } = opts3;
       if (externalMu)
         abytesDoc(msg, CRH_BYTES, "mu");
@@ -1793,16 +1883,19 @@ function getDilithium(opts_) {
     lengths: internal.lengths,
     getPublicKey: internal.getPublicKey,
     sign: (msg, secretKey, opts3 = {}) => {
-      validateSigOpts(opts3);
+      opts3 = validateSigOpts(opts3);
       const M = getMessage(msg, opts3.context);
-      const res = internal.sign(M, secretKey, opts3);
+      const res = internal.sign(M, secretKey, {
+        extraEntropy: opts3.extraEntropy,
+        externalMu: false
+      });
       cleanBytes(M);
       return res;
     },
     verify: (sig, msg, publicKey, opts3 = {}) => {
-      validateVerOpts(opts3);
+      opts3 = validateVerOpts(opts3);
       abytesDoc(sig, void 0, "signature");
-      return internal.verify(sig, getMessage(msg, opts3.context), publicKey);
+      return internal.verify(sig, getMessage(msg, opts3.context), publicKey, { externalMu: false });
     },
     prehash: (hash) => {
       checkHash(hash, securityLevel);
@@ -1814,16 +1907,21 @@ function getDilithium(opts_) {
         keygen: internal.keygen,
         getPublicKey: internal.getPublicKey,
         sign: (msg, secretKey, opts3 = {}) => {
-          validateSigOpts(opts3);
+          opts3 = validateSigOpts(opts3);
           const M = getMessagePrehash(rawHash, msg, opts3.context);
-          const res = internal.sign(M, secretKey, opts3);
+          const res = internal.sign(M, secretKey, {
+            extraEntropy: opts3.extraEntropy,
+            externalMu: false
+          });
           cleanBytes(M);
           return res;
         },
         verify: (sig, msg, publicKey, opts3 = {}) => {
-          validateVerOpts(opts3);
+          opts3 = validateVerOpts(opts3);
           abytesDoc(sig, void 0, "signature");
-          return internal.verify(sig, getMessagePrehash(rawHash, msg, opts3.context), publicKey);
+          return internal.verify(sig, getMessagePrehash(rawHash, msg, opts3.context), publicKey, {
+            externalMu: false
+          });
         }
       });
     }
@@ -2463,6 +2561,8 @@ var sha512 = /* @__PURE__ */ createHasher(
 );
 
 // node_modules/@noble/post-quantum/slh-dsa.js
+var INTERNAL_SIG_OPT_KEYS2 = /* @__PURE__ */ Object.freeze(["extraEntropy"]);
+var INTERNAL_VER_OPT_KEYS2 = /* @__PURE__ */ Object.freeze([]);
 var PARAMS3 = /* @__PURE__ */ (() => Object.freeze({
   "128f": Object.freeze({ W: 16, N: 16, H: 66, D: 22, K: 33, A: 6, securityLevel: 128 }),
   "128s": Object.freeze({ W: 16, N: 16, H: 63, D: 7, K: 14, A: 12, securityLevel: 128 }),
@@ -2533,8 +2633,16 @@ function gen(opts2, hashOpts_) {
     OFFSET_HASH_ADDR += 10;
   }
   const setAddr = (opts3, addr = new Uint8Array(ADDR_BYTES)) => {
-    const { type, height, tree, layer, index, chain, hash, keypair } = opts3;
-    const { subtreeAddr, keypairAddr } = opts3;
+    const type = Object.hasOwn(opts3, "type") ? opts3.type : void 0;
+    const height = Object.hasOwn(opts3, "height") ? opts3.height : void 0;
+    const tree = Object.hasOwn(opts3, "tree") ? opts3.tree : void 0;
+    const layer = Object.hasOwn(opts3, "layer") ? opts3.layer : void 0;
+    const index = Object.hasOwn(opts3, "index") ? opts3.index : void 0;
+    const chain = Object.hasOwn(opts3, "chain") ? opts3.chain : void 0;
+    const hash = Object.hasOwn(opts3, "hash") ? opts3.hash : void 0;
+    const keypair = Object.hasOwn(opts3, "keypair") ? opts3.keypair : void 0;
+    const subtreeAddr = Object.hasOwn(opts3, "subtreeAddr") ? opts3.subtreeAddr : void 0;
+    const keypairAddr = Object.hasOwn(opts3, "keypairAddr") ? opts3.keypairAddr : void 0;
     if (height !== void 0)
       addr[OFFSET_CHAIN_ADDR] = height;
     if (layer !== void 0)
@@ -2735,7 +2843,7 @@ function gen(opts2, hashOpts_) {
       return Uint8Array.from(pk);
     },
     sign: (msg, sk, opts3 = {}) => {
-      validateSigOpts(opts3);
+      opts3 = validateSigOpts(opts3, INTERNAL_SIG_OPT_KEYS2);
       let { extraEntropy: random } = opts3;
       const [skSeed, skPRF, pk] = secretCoder.decode(sk);
       const [pkSeed, _] = publicCoder.decode(pk);
@@ -2793,7 +2901,8 @@ function gen(opts2, hashOpts_) {
       cleanBytes(R, random, treeAddr, wotsAddr, forsLeaf, forsTreeAddr, indices, roots);
       return SIG;
     },
-    verify: (sig, msg, publicKey) => {
+    verify: (sig, msg, publicKey, opts3 = {}) => {
+      validateVerOpts(opts3, INTERNAL_VER_OPT_KEYS2);
       const [pkSeed, pubRoot] = publicCoder.decode(publicKey);
       const pk = publicKey;
       abytesDoc(sig, void 0, "signature");
@@ -2860,14 +2969,14 @@ function gen(opts2, hashOpts_) {
     keygen: internal.keygen,
     getPublicKey: internal.getPublicKey,
     sign: (msg, secretKey, opts3 = {}) => {
-      validateSigOpts(opts3);
+      opts3 = validateSigOpts(opts3);
       const M = getMessage(msg, opts3.context);
-      const res = internal.sign(M, secretKey, opts3);
+      const res = internal.sign(M, secretKey, { extraEntropy: opts3.extraEntropy });
       cleanBytes(M);
       return res;
     },
     verify: (sig, msg, publicKey, opts3 = {}) => {
-      validateVerOpts(opts3);
+      opts3 = validateVerOpts(opts3);
       return internal.verify(sig, getMessage(msg, opts3.context), publicKey);
     },
     prehash: (hash) => {
@@ -2879,14 +2988,14 @@ function gen(opts2, hashOpts_) {
         keygen: internal.keygen,
         getPublicKey: internal.getPublicKey,
         sign: (msg, secretKey, opts3 = {}) => {
-          validateSigOpts(opts3);
+          opts3 = validateSigOpts(opts3);
           const M = getMessagePrehash(rawHash, msg, opts3.context);
-          const res = internal.sign(M, secretKey, opts3);
+          const res = internal.sign(M, secretKey, { extraEntropy: opts3.extraEntropy });
           cleanBytes(M);
           return res;
         },
         verify: (sig, msg, publicKey, opts3 = {}) => {
-          validateVerOpts(opts3);
+          opts3 = validateVerOpts(opts3);
           return internal.verify(sig, getMessagePrehash(rawHash, msg, opts3.context), publicKey);
         }
       });
@@ -2931,7 +3040,7 @@ var genShake2 = () => (opts2) => (pubSeed, skSeed) => {
     }
   };
 };
-var SHAKE_SIMPLE = /* @__PURE__ */ (() => ({ getContext: genShake2() }))();
+var SHAKE_SIMPLE = /* @__PURE__ */ (() => ({ isCompressed: false, getContext: genShake2() }))();
 var slh_dsa_shake_128f = /* @__PURE__ */ (() => gen(PARAMS3["128f"], SHAKE_SIMPLE))();
 var slh_dsa_shake_192f = /* @__PURE__ */ (() => gen(PARAMS3["192f"], SHAKE_SIMPLE))();
 var slh_dsa_shake_256f = /* @__PURE__ */ (() => gen(PARAMS3["256f"], SHAKE_SIMPLE))();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.18.55",
+  "version": "0.18.56",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",