@tickernelz/paperclip-pro-server 2026.1018.0 → 2026.1022.0

package/node_modules/jose/dist/webapi/jwk/thumbprint.js

@@ -19,30 +19,30 @@ async function calculateJwkThumbprint(key, digestAlgorithm) {
     throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
   if (digestAlgorithm ??= "sha256", digestAlgorithm !== "sha256" && digestAlgorithm !== "sha384" && digestAlgorithm !== "sha512")
     throw new TypeError('digestAlgorithm must one of "sha256", "sha384", or "sha512"');
-  let components;
+  let requiredMembers;
   switch (jwk.kty) {
     case "AKP":
-      check(jwk.alg, '"alg" (Algorithm) Parameter'), check(jwk.pub, '"pub" (Public key) Parameter'), components = { alg: jwk.alg, kty: jwk.kty, pub: jwk.pub };
+      check(jwk.alg, '"alg" (Algorithm) Parameter'), check(jwk.pub, '"pub" (Public key) Parameter'), requiredMembers = { alg: jwk.alg, kty: jwk.kty, pub: jwk.pub };
       break;
     case "EC":
-      check(jwk.crv, '"crv" (Curve) Parameter'), check(jwk.x, '"x" (X Coordinate) Parameter'), check(jwk.y, '"y" (Y Coordinate) Parameter'), components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y };
+      check(jwk.crv, '"crv" (Curve) Parameter'), check(jwk.x, '"x" (X Coordinate) Parameter'), check(jwk.y, '"y" (Y Coordinate) Parameter'), requiredMembers = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y };
       break;
     case "OKP":
-      check(jwk.crv, '"crv" (Subtype of Key Pair) Parameter'), check(jwk.x, '"x" (Public Key) Parameter'), components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
+      check(jwk.crv, '"crv" (Subtype of Key Pair) Parameter'), check(jwk.x, '"x" (Public Key) Parameter'), requiredMembers = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
       break;
     case "RSA":
-      check(jwk.e, '"e" (Exponent) Parameter'), check(jwk.n, '"n" (Modulus) Parameter'), components = { e: jwk.e, kty: jwk.kty, n: jwk.n };
+      check(jwk.e, '"e" (Exponent) Parameter'), check(jwk.n, '"n" (Modulus) Parameter'), requiredMembers = { e: jwk.e, kty: jwk.kty, n: jwk.n };
       break;
     case "oct":
       if (typeof jwk.k != "string")
         throw new JWKInvalid('"k" (Key Value) Parameter missing or invalid');
-      components = { k: jwk.k, kty: jwk.kty };
+      requiredMembers = { k: jwk.k, kty: jwk.kty };
       break;
     default:
       throw new JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported');
   }
-  const data = encode(JSON.stringify(components));
-  return b64u(await digest(digestAlgorithm, data));
+  const thumbprintInput = encode(JSON.stringify(requiredMembers));
+  return b64u(await digest(digestAlgorithm, thumbprintInput));
 }
 async function calculateJwkThumbprintUri(key, digestAlgorithm) {
   digestAlgorithm ??= "sha256";

package/node_modules/jose/dist/webapi/jwks/local.js

@@ -24,7 +24,8 @@ function createLocalJWKSet(jwks) {
   let snapshot;
   try {
     snapshot = structuredClone(jwks);
-  } catch {
+  } catch (cause) {
+    throw new JWKSInvalid("JSON Web Key Set malformed", { cause });
   }
   if (!isJwkSet(snapshot))
     throw new JWKSInvalid("JSON Web Key Set malformed");

package/node_modules/jose/dist/webapi/jwks/remote.js

@@ -5,7 +5,7 @@ function isCloudflareWorkers() {
   return typeof WebSocketPair < "u" || typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime < "u" && EdgeRuntime === "vercel";
 }
 let USER_AGENT;
-(typeof navigator > "u" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) && (USER_AGENT = "jose/v6.2.12");
+(typeof navigator > "u" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) && (USER_AGENT = "jose/v6.2.13");
 const customFetch = /* @__PURE__ */ Symbol();
 async function fetchJwks(url, headers, signal, fetchImpl = fetch) {
   const response = await fetchImpl(url, {
@@ -14,14 +14,14 @@ async function fetchJwks(url, headers, signal, fetchImpl = fetch) {
     redirect: "manual",
     headers
   }).catch((err) => {
-    throw err.name === "TimeoutError" ? new JWKSTimeout() : err;
+    throw err.name === "TimeoutError" ? new JWKSTimeout(void 0, { cause: err }) : err;
   });
   if (response.status !== 200)
     throw new JOSEError("Expected 200 OK from the JSON Web Key Set HTTP response");
   try {
     return await response.json();
-  } catch {
-    throw new JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON");
+  } catch (cause) {
+    throw new JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON", { cause });
   }
 }
 const jwksCache = /* @__PURE__ */ Symbol();

package/node_modules/jose/dist/webapi/jws/general/sign.js

@@ -40,15 +40,15 @@ class GeneralSign {
     const jws = {
       signatures: [],
       payload: ""
-    }, encoded = [];
+    }, encodedPayloadCache = [];
     let b64;
     for (const signature of this.#signatures) {
-      const [protectedHeader, unprotectedHeader, key, crit] = signature.state, [{ payload, ...rest }, signatureB64] = await createSignature([this.#payload, protectedHeader, unprotectedHeader, crit, encoded], key);
+      const [protectedHeader, unprotectedHeader, key, crit] = signature.state, [{ payload, ...signatureMembers }, signatureB64] = await createSignature([this.#payload, protectedHeader, unprotectedHeader, crit, encodedPayloadCache], key);
       if (b64 === void 0)
         b64 = signatureB64, jws.payload = payload;
       else if (b64 !== signatureB64)
         throw new JWSInvalid("inconsistent use of JWS Unencoded Payload (RFC7797)");
-      jws.signatures.push(rest);
+      jws.signatures.push(signatureMembers);
     }
     return jws;
   }

package/node_modules/jose/dist/webapi/jws/general/verify.js

@@ -31,9 +31,9 @@ async function generalVerify(jws, key, options) {
     throw new JWSSignatureVerificationFailed();
   }
   const payload = inputPayload instanceof Uint8Array ? new Uint8Array(inputPayload) : inputPayload, candidates = signatureEntries.map((signature) => snapshotSignature(signature, payload)).filter((candidate) => candidate !== void 0);
-  let modes = 0;
-  for (const [, , mode] of candidates)
-    if (modes |= mode, modes === 3)
+  let payloadEncodings = 0;
+  for (const [, , payloadEncoding] of candidates)
+    if (payloadEncodings |= payloadEncoding, payloadEncodings === 3)
       throw new JWSInvalid("inconsistent use of JWS Unencoded Payload (RFC7797)");
   for (const candidate of candidates)
     try {

package/node_modules/jose/dist/webapi/jwt/encrypt.js

@@ -1,5 +1,5 @@
 import { compactJWE, createJWE } from "../lib/jwe_encrypt.js";
-import { JWTClaimsBuilder, jwtClaim, jwtData } from "../lib/jwt_claims_set.js";
+import { JWTClaimsBuilder, jwtClaim, jwtClaimsSetBytes } from "../lib/jwt_claims_set.js";
 import { assertNotSet } from "../lib/validate.js";
 const EncryptJWT_base = JWTClaimsBuilder;
 class EncryptJWT extends EncryptJWT_base {
@@ -29,7 +29,7 @@ class EncryptJWT extends EncryptJWT_base {
     return this.#replicateAudienceAsHeader = !0, this;
   }
   async encrypt(key, options) {
-    const plaintext = jwtData(this);
+    const plaintext = jwtClaimsSetBytes(this);
     this.#input[1] && (this.#replicateIssuerAsHeader || this.#replicateSubjectAsHeader || this.#replicateAudienceAsHeader) && (this.#input[1] = {
       ...this.#input[1],
       iss: this.#replicateIssuerAsHeader ? jwtClaim(this, "iss") : void 0,

package/node_modules/jose/dist/webapi/jwt/sign.js

@@ -1,6 +1,6 @@
 import { createCompactSignature } from "../lib/jws_sign.js";
 import { JWTInvalid } from "../util/errors.js";
-import { JWTClaimsBuilder, jwtData } from "../lib/jwt_claims_set.js";
+import { JWTClaimsBuilder, jwtClaimsSetBytes } from "../lib/jwt_claims_set.js";
 import { assertNotSet } from "../lib/validate.js";
 const SignJWT_base = JWTClaimsBuilder;
 class SignJWT extends SignJWT_base {
@@ -9,7 +9,7 @@ class SignJWT extends SignJWT_base {
     return assertNotSet(this.#protectedHeader, "setProtectedHeader"), this.#protectedHeader = protectedHeader, this;
   }
   async sign(key, options) {
-    return createCompactSignature(jwtData(this), this.#protectedHeader, options?.crit, key, () => {
+    return createCompactSignature(jwtClaimsSetBytes(this), this.#protectedHeader, options?.crit, key, () => {
       throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
     });
   }

package/node_modules/jose/dist/webapi/jwt/unsecured.js

@@ -1,12 +1,12 @@
 import * as b64u from "../util/base64url.js";
 import { decodeBase64url, parseJoseHeader, JWS_RECOGNIZED, validateB64, validateCrit } from "../lib/validate.js";
 import { JWSInvalid, JWTInvalid } from "../util/errors.js";
-import { validateClaimsSet, JWTClaimsBuilder, jwtData } from "../lib/jwt_claims_set.js";
+import { validateClaimsSet, JWTClaimsBuilder, jwtClaimsSetBytes } from "../lib/jwt_claims_set.js";
 const UnsecuredJWT_base = JWTClaimsBuilder;
 class UnsecuredJWT extends UnsecuredJWT_base {
   encode() {
-    const header = b64u.encode(JSON.stringify({ alg: "none" })), payload = b64u.encode(jwtData(this));
-    return `${header}.${payload}.`;
+    const encodedProtectedHeader = b64u.encode(JSON.stringify({ alg: "none" })), encodedPayload = b64u.encode(jwtClaimsSetBytes(this));
+    return `${encodedProtectedHeader}.${encodedPayload}.`;
   }
   static decode(jwt, options) {
     if (typeof jwt != "string")

package/node_modules/jose/dist/webapi/key/generate_secret.js

@@ -2,12 +2,12 @@ import { unsupportedAlg, algArgument } from "../lib/key_algorithm.js";
 import { validateExtractableOption } from "../lib/key.js";
 async function generateSecret(alg, options) {
   const extractable = validateExtractableOption(options?.extractable);
-  let length, algorithm, keyUsages;
+  let keyLengthBits, algorithm, keyUsages;
   switch (alg) {
     case "HS256":
     case "HS384":
     case "HS512":
-      length = +alg.slice(-3), algorithm = { name: "HMAC", hash: `SHA-${length}`, length }, keyUsages = ["sign", "verify"];
+      keyLengthBits = +alg.slice(-3), algorithm = { name: "HMAC", hash: `SHA-${keyLengthBits}`, length: keyLengthBits }, keyUsages = ["sign", "verify"];
       break;
     case "A128CBC-HS256":
     case "A192CBC-HS384":
@@ -16,7 +16,7 @@ async function generateSecret(alg, options) {
     case "A128KW":
     case "A192KW":
     case "A256KW":
-      length = +alg.slice(1, 4), algorithm = { name: "AES-KW", length }, keyUsages = ["wrapKey", "unwrapKey"];
+      keyLengthBits = +alg.slice(1, 4), algorithm = { name: "AES-KW", length: keyLengthBits }, keyUsages = ["wrapKey", "unwrapKey"];
       break;
     case "A128GCMKW":
     case "A192GCMKW":
@@ -24,7 +24,7 @@ async function generateSecret(alg, options) {
     case "A128GCM":
     case "A192GCM":
     case "A256GCM":
-      length = +alg.slice(1, 4), algorithm = { name: "AES-GCM", length }, keyUsages = ["encrypt", "decrypt"];
+      keyLengthBits = +alg.slice(1, 4), algorithm = { name: "AES-GCM", length: keyLengthBits }, keyUsages = ["encrypt", "decrypt"];
       break;
     default:
       unsupportedAlg(algArgument);

package/node_modules/jose/dist/webapi/lib/asn1.js

@@ -94,8 +94,8 @@ const parseECAlgorithmIdentifier = (state) => {
     try {
       const state = createASN1State(keyData);
       parseKeyHeader(state, keyFormat), algorithm = entry.resolve({ crv: parseECAlgorithmIdentifier(state) });
-    } catch {
-      throw new JOSENotSupported("Invalid or unsupported key format");
+    } catch (cause) {
+      throw new JOSENotSupported("Invalid or unsupported key format", { cause });
     }
   else
     algorithm = entry.subtle;

package/node_modules/jose/dist/webapi/lib/buffer_utils.js

@@ -1,4 +1,4 @@
-const encoder = new TextEncoder(), decoder = new TextDecoder(), strictDecoder = new TextDecoder("utf-8", { fatal: !0 }), MAX_INT32 = 2 ** 32;
+const encoder = new TextEncoder(), decoder = new TextDecoder(), strictDecoder = new TextDecoder("utf-8", { fatal: !0 }), UINT32_RANGE = 2 ** 32;
 function concat(...buffers) {
   const size = buffers.reduce((acc, { length }) => acc + length, 0), buf = new Uint8Array(size);
   let i = 0;
@@ -7,12 +7,12 @@ function concat(...buffers) {
   return buf;
 }
 function writeUInt32BE(buf, value, offset) {
-  if (value < 0 || value >= MAX_INT32)
-    throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);
+  if (value < 0 || value >= UINT32_RANGE)
+    throw new RangeError(`value must be >= 0 and <= ${UINT32_RANGE - 1}. Received ${value}`);
   buf.set([value >>> 24, value >>> 16, value >>> 8, value & 255], offset);
 }
 function uint64be(value) {
-  const high = Math.floor(value / MAX_INT32), low = value % MAX_INT32, buf = new Uint8Array(8);
+  const high = Math.floor(value / UINT32_RANGE), low = value % UINT32_RANGE, buf = new Uint8Array(8);
   return writeUInt32BE(buf, high, 0), writeUInt32BE(buf, low, 4), buf;
 }
 function uint32be(value) {

package/node_modules/jose/dist/webapi/lib/content_encryption.js

@@ -15,20 +15,20 @@ function checkIvLength(enc, iv) {
 async function cbcKeySetup(enc, cek, usage) {
   if (!(cek instanceof Uint8Array))
     throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
-  const keySize = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
-    hash: `SHA-${keySize << 1}`,
+  const keyLengthBits = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keyLengthBits >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keyLengthBits >> 3), {
+    hash: `SHA-${keyLengthBits << 1}`,
     name: "HMAC"
   }, !1, ["sign"]);
-  return [encKey, macKey, keySize];
+  return [encKey, macKey, keyLengthBits];
 }
-async function cbcHmacTag(macKey, macData, keySize) {
-  return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3));
+async function cbcHmacTag(macKey, macData, keyLengthBits) {
+  return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keyLengthBits >> 3));
 }
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+  const [encKey, macKey, keyLengthBits] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({
     iv,
     name: "AES-CBC"
-  }, encKey, plaintext)), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), tag = await cbcHmacTag(macKey, macData, keySize);
+  }, encKey, plaintext)), al = uint64be(aad.length * 8), macData = concat(aad, iv, ciphertext, al), tag = await cbcHmacTag(macKey, macData, keyLengthBits);
   return { ciphertext, tag, iv };
 }
 async function timingSafeEqual(a, b) {
@@ -36,7 +36,7 @@ async function timingSafeEqual(a, b) {
   return crypto.subtle.verify(algorithm, key, aHmac, b);
 }
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "decrypt"), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), expectedTag = await cbcHmacTag(macKey, macData, keySize);
+  const [encKey, macKey, keyLengthBits] = await cbcKeySetup(enc, cek, "decrypt"), al = uint64be(aad.length * 8), macData = concat(aad, iv, ciphertext, al), expectedTag = await cbcHmacTag(macKey, macData, keyLengthBits);
   try {
     if (await timingSafeEqual(tag, expectedTag))
       return new Uint8Array(await crypto.subtle.decrypt({ iv, name: "AES-CBC" }, encKey, ciphertext));

package/node_modules/jose/dist/webapi/lib/jwe_decrypt.js

@@ -1,5 +1,5 @@
 import { decrypt, generateCek } from "./content_encryption.js";
-import { decodeBase64url, encodeBase64url, parseJoseHeader, isDisjoint, isObject, validateCrit, validateAlgorithms, JWE_RECOGNIZED } from "./validate.js";
+import { decodeBase64url, encodeAsciiMember, parseJoseHeader, isDisjoint, isObject, validateCrit, validateAlgorithms, JWE_RECOGNIZED } from "./validate.js";
 import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from "../util/errors.js";
 import { decryptKeyManagement } from "./key_management.js";
 import { decoder } from "./buffer_utils.js";
@@ -59,13 +59,13 @@ function checkRecipient(jwe) {
 }
 function shareJWE(jwe) {
   const { protected: encodedProtected, ciphertext, iv, tag, aad } = jwe;
-  let parsedProt;
-  return encodedProtected !== void 0 && (parsedProt = parseJoseHeader(encodedProtected, JWEInvalid, "JWE Protected Header is invalid")), [
-    parsedProt,
+  let protectedHeader;
+  return encodedProtected !== void 0 && (protectedHeader = parseJoseHeader(encodedProtected, JWEInvalid, "JWE Protected Header is invalid")), [
+    protectedHeader,
     decodeBase64url(ciphertext, "ciphertext", JWEInvalid),
     iv !== void 0 ? decodeBase64url(iv, "iv", JWEInvalid) : void 0,
     tag !== void 0 ? decodeBase64url(tag, "tag", JWEInvalid) : void 0,
-    encodeBase64url((encodedProtected ?? "") + (aad !== void 0 ? `.${aad}` : ""), "aad", JWEInvalid)
+    encodeAsciiMember((encodedProtected ?? "") + (aad !== void 0 ? `.${aad}` : ""), "aad", JWEInvalid)
   ];
 }
 function prepareDecrypt(options) {
@@ -78,16 +78,16 @@ function prepareDecrypt(options) {
   ];
 }
 async function decryptJWE(jwe, shared, key, token = shareJWE(jwe)) {
-  const [parsedProt, ciphertext, iv, tag, additionalData] = token, { header, unprotected, aad } = jwe;
+  const [protectedHeader, ciphertext, iv, tag, additionalAuthenticatedData] = token, { header, unprotected, aad } = jwe;
   let joseHeader;
   if (header !== void 0 || unprotected !== void 0) {
-    if (!isDisjoint(parsedProt, header, unprotected))
+    if (!isDisjoint(protectedHeader, header, unprotected))
       throw new JWEInvalid("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");
-    joseHeader = { ...parsedProt, ...header, ...unprotected };
+    joseHeader = { ...protectedHeader, ...header, ...unprotected };
   } else
-    joseHeader = parsedProt ?? {};
+    joseHeader = protectedHeader ?? {};
   const [keyManagementAlgorithms, contentEncryptionAlgorithms, crit, maxPBES2Count, maxDecompressedLength] = shared, { encrypted_key: encodedKey } = jwe;
-  validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, parsedProt, joseHeader), validateZip(joseHeader, parsedProt);
+  validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, protectedHeader, joseHeader), validateZip(joseHeader, protectedHeader);
   const { alg, enc } = joseHeader;
   if (typeof alg != "string" || !alg)
     throw new JWEInvalid("missing JWE Algorithm (alg) in JWE Header");
@@ -122,13 +122,13 @@ async function decryptJWE(jwe, shared, key, token = shareJWE(jwe)) {
       encryptedKey = new Uint8Array();
     }
   let resolvedKey = !1;
-  typeof key == "function" && (key = await key(parsedProt, jwe), resolvedKey = !0);
+  typeof key == "function" && (key = await key(protectedHeader, jwe), resolvedKey = !0);
   const algEntry = selected ?? jweAlgorithm(alg);
   isJWECEKTransport(algEntry) && encryptedKey === void 0 && (encryptedKey = new Uint8Array());
   const k = await prepareKey(algEntry.mode === "direct-encryption" ? encEntry : algEntry, key, "decrypt");
   let plaintext;
   if (algEntry.mode === "integrated-encryption")
-    plaintext = await algEntry.decrypt(k, encryptedKey, ciphertext, additionalData, parsedProt, joseHeader);
+    plaintext = await algEntry.decrypt(k, encryptedKey, ciphertext, additionalAuthenticatedData, protectedHeader, joseHeader);
   else {
     const encryption = encEntry;
     let cek;
@@ -139,7 +139,7 @@ async function decryptJWE(jwe, shared, key, token = shareJWE(jwe)) {
         throw err;
       cek = generateCek(encryption);
     }
-    plaintext = await decrypt(encryption, cek, ciphertext, iv, tag, additionalData);
+    plaintext = await decrypt(encryption, cek, ciphertext, iv, tag, additionalAuthenticatedData);
   }
   if (joseHeader.zip === "DEF") {
     const decompressionLimit = maxDecompressedLength ?? 25e4;
@@ -153,7 +153,7 @@ async function decryptJWE(jwe, shared, key, token = shareJWE(jwe)) {
   }
   return {
     plaintext,
-    ...parsedProt && { protectedHeader: parsedProt },
+    ...protectedHeader && { protectedHeader },
     ...aad !== void 0 && {
       additionalAuthenticatedData: decodeBase64url(aad, "aad", JWEInvalid)
     },

package/node_modules/jose/dist/webapi/lib/jwe_encrypt.js

@@ -48,17 +48,17 @@ async function encryptJWE(input, checked, key) {
   const algEntry = selected ?? jweAlgorithm(joseHeader.alg);
   let encryptedKey, parameters, cek;
   algEntry.mode === "integrated-encryption" ? cek = await prepareKey(algEntry, key, "encrypt") : [cek, encryptedKey, parameters] = await encryptKeyManagement(algEntry, encEntry, key, joseHeader, providedCek, keyManagementParameters), parameters && (unprotectedParameters ? unprotectedHeader = unprotectedHeader ? { ...unprotectedHeader, ...parameters } : parameters : protectedHeader = protectedHeader ? { ...protectedHeader, ...parameters } : parameters, checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader));
-  const protectedHeaderS = protectedHeader ? b64u(JSON.stringify(protectedHeader)) : "", aadMember = aad?.byteLength ? b64u(aad) : void 0, additionalData = encode(aadMember ? `${protectedHeaderS}.${aadMember}` : protectedHeaderS);
+  const encodedProtectedHeader = protectedHeader ? b64u(JSON.stringify(protectedHeader)) : "", encodedAad = aad?.byteLength ? b64u(aad) : void 0, additionalAuthenticatedData = encode(encodedAad ? `${encodedProtectedHeader}.${encodedAad}` : encodedProtectedHeader);
   let plaintext = inputPlaintext;
   joseHeader.zip === "DEF" && (plaintext = await compress(plaintext).catch((cause) => {
     throw new JWEInvalid("Failed to compress plaintext", { cause });
   }));
   let ciphertext, tag, iv;
-  algEntry.mode === "integrated-encryption" ? [encryptedKey, ciphertext] = await algEntry.encrypt(cek, plaintext, additionalData, protectedHeader, joseHeader, keyManagementParameters) : { ciphertext, tag, iv } = await encrypt(encEntry, plaintext, cek, inputIv, additionalData);
+  algEntry.mode === "integrated-encryption" ? [encryptedKey, ciphertext] = await algEntry.encrypt(cek, plaintext, additionalAuthenticatedData, protectedHeader, joseHeader, keyManagementParameters) : { ciphertext, tag, iv } = await encrypt(encEntry, plaintext, cek, inputIv, additionalAuthenticatedData);
   const jwe = {
     ciphertext: b64u(ciphertext)
   };
-  return iv && (jwe.iv = b64u(iv)), tag && (jwe.tag = b64u(tag)), encryptedKey?.byteLength && (jwe.encrypted_key = b64u(encryptedKey)), aadMember && (jwe.aad = aadMember), protectedHeader && (jwe.protected = protectedHeaderS), sharedUnprotectedHeader && (jwe.unprotected = sharedUnprotectedHeader), unprotectedHeader && (jwe.header = unprotectedHeader), jwe;
+  return iv && (jwe.iv = b64u(iv)), tag && (jwe.tag = b64u(tag)), encryptedKey?.byteLength && (jwe.encrypted_key = b64u(encryptedKey)), encodedAad && (jwe.aad = encodedAad), protectedHeader && (jwe.protected = encodedProtectedHeader), sharedUnprotectedHeader && (jwe.unprotected = sharedUnprotectedHeader), unprotectedHeader && (jwe.header = unprotectedHeader), jwe;
 }
 async function createJWE(input, key, options) {
   return encryptJWE(input, checkEncryptHeaders(input, options), key);

package/node_modules/jose/dist/webapi/lib/jws_algorithms.js

@@ -34,8 +34,8 @@ function eddsa() {
     usages: sig
   };
 }
-function mldsa(bits) {
-  const subtle = { name: `ML-DSA-${bits}` };
+function mldsa(parameterSet) {
+  const subtle = { name: `ML-DSA-${parameterSet}` };
   return {
     kty: ["AKP"],
     subtle,

package/node_modules/jose/dist/webapi/lib/jws_sign.js

@@ -5,10 +5,10 @@ import { JWSInvalid } from "../util/errors.js";
 import { concat, encode, encoder } from "./buffer_utils.js";
 import { prepareKey, rawKey, checkModulusLength } from "./key.js";
 async function createSignature(input, key, rejectUnencoded) {
-  let [payload, protectedHeader, unprotectedHeader, crit] = input, protectedHeaderString = "";
+  let [payload, protectedHeader, unprotectedHeader, crit] = input, encodedProtectedHeader = "";
   if (protectedHeader !== void 0) {
     const normalized = serializeJoseHeader(JWSInvalid, protectedHeader);
-    protectedHeader = normalized[0], protectedHeaderString = b64u(normalized[1]);
+    protectedHeader = normalized[0], encodedProtectedHeader = b64u(normalized[1]);
   }
   if (unprotectedHeader !== void 0 && (unprotectedHeader = serializeJoseHeader(JWSInvalid, unprotectedHeader)[0]), !protectedHeader && !unprotectedHeader)
     throw new JWSInvalid("either setProtectedHeader or setUnprotectedHeader must be called before #sign()");
@@ -22,19 +22,19 @@ async function createSignature(input, key, rejectUnencoded) {
   if (typeof alg != "string" || !alg)
     throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
   const entry = jwsAlgorithm(alg);
-  let payloadS = "", payloadB = payload, data;
+  let encodedPayload = "", signingPayload = payload, signingInput;
   if (b64) {
-    const encoded = input[4];
-    encoded ? (payloadS = encoded[0] ??= b64u(payload), payloadB = encoded[1] ??= encode(payloadS)) : (payloadS = b64u(payload), data = encoder.encode(`${protectedHeaderString}.${payloadS}`));
+    const encodedPayloadCache = input[4];
+    encodedPayloadCache ? (encodedPayload = encodedPayloadCache[0] ??= b64u(payload), signingPayload = encodedPayloadCache[1] ??= encode(encodedPayload)) : (encodedPayload = b64u(payload), signingInput = encoder.encode(`${encodedProtectedHeader}.${encodedPayload}`));
   }
-  data ??= concat(encode(protectedHeaderString), encode("."), payloadB);
-  const k = await rawKey(await prepareKey(entry, key, "sign"), entry.subtle, "sign");
-  entry.minRsaBits && checkModulusLength(entry.alg, k);
+  signingInput ??= concat(encode(encodedProtectedHeader), encode("."), signingPayload);
+  const signingKey = await rawKey(await prepareKey(entry, key, "sign"), entry.subtle, "sign");
+  entry.minRsaBits && checkModulusLength(entry.alg, signingKey);
   const jws = {
-    signature: b64u(new Uint8Array(await crypto.subtle.sign(entry.signing, k, data))),
-    payload: payloadS
+    signature: b64u(new Uint8Array(await crypto.subtle.sign(entry.signing, signingKey, signingInput))),
+    payload: encodedPayload
   };
-  return protectedHeader && (jws.protected = protectedHeaderString), unprotectedHeader && (jws.header = unprotectedHeader), [jws, b64];
+  return protectedHeader && (jws.protected = encodedProtectedHeader), unprotectedHeader && (jws.header = unprotectedHeader), [jws, b64];
 }
 async function createCompactSignature(payload, protectedHeader, crit, key, rejectUnencoded) {
   const [jws] = await createSignature([payload, protectedHeader, void 0, crit], key, rejectUnencoded);

package/node_modules/jose/dist/webapi/lib/jws_verify.js

@@ -1,16 +1,16 @@
 import { jwsAlgorithm } from "./jws_algorithms.js";
 import { JOSEAlgNotAllowed, JWSInvalid, JWSSignatureVerificationFailed } from "../util/errors.js";
 import { concat, decoder, encoder, encode } from "./buffer_utils.js";
-import { decodeBase64url, encodeBase64url, parseJoseHeader, isDisjoint, isObject, validateB64, validateCrit, validateAlgorithms, JWS_RECOGNIZED } from "./validate.js";
+import { decodeBase64url, encodeAsciiMember, parseJoseHeader, isDisjoint, isObject, validateB64, validateCrit, validateAlgorithms, JWS_RECOGNIZED } from "./validate.js";
 import { prepareKey, rawKey, checkModulusLength } from "./key.js";
 function snapshotJws(jws, sharedPayload) {
-  const encodedProtected = jws.protected, inputHeader = jws.header, header = isObject(inputHeader) ? { ...inputHeader } : inputHeader;
+  const encodedProtectedHeader = jws.protected, inputHeader = jws.header, header = isObject(inputHeader) ? { ...inputHeader } : inputHeader;
   let payload = sharedPayload ? sharedPayload[0] : jws.payload;
   !sharedPayload && payload instanceof Uint8Array && (payload = new Uint8Array(payload));
   const signature = jws.signature, snapshot = { payload, signature };
-  if (encodedProtected !== void 0 && (snapshot.protected = encodedProtected), inputHeader !== void 0 && (snapshot.header = header), encodedProtected === void 0 && header === void 0)
+  if (encodedProtectedHeader !== void 0 && (snapshot.protected = encodedProtectedHeader), inputHeader !== void 0 && (snapshot.header = header), encodedProtectedHeader === void 0 && header === void 0)
     throw new JWSInvalid('Flattened JWS must have either of the "protected" or "header" members');
-  if (encodedProtected !== void 0 && typeof encodedProtected != "string")
+  if (encodedProtectedHeader !== void 0 && typeof encodedProtectedHeader != "string")
     throw new JWSInvalid("JWS Protected Header incorrect type");
   if (payload === void 0)
     throw new JWSInvalid("JWS Payload missing");
@@ -23,8 +23,8 @@ function snapshotJws(jws, sharedPayload) {
 function prepareVerify(options) {
   return [options && validateAlgorithms("algorithms", options.algorithms), options?.crit];
 }
-function parseProtectedHeader(encodedProtected) {
-  return encodedProtected === void 0 ? {} : parseJoseHeader(encodedProtected, JWSInvalid, "JWS Protected Header is invalid");
+function parseProtectedHeader(encodedProtectedHeader) {
+  return encodedProtectedHeader === void 0 ? {} : parseJoseHeader(encodedProtectedHeader, JWSInvalid, "JWS Protected Header is invalid");
 }
 function encodeJsonUnencodedPayload(payload) {
   const invalid = /[\p{Cs}\p{Cn}]/u.exec(payload)?.[0];
@@ -35,15 +35,17 @@ function encodeJsonUnencodedPayload(payload) {
 function encodeCompactUnencodedPayload(payload) {
   try {
     return encode(payload);
-  } catch {
-    throw new JWSInvalid("JWS Compact Serialization payload must use only ASCII characters");
+  } catch (cause) {
+    throw new JWSInvalid("JWS Compact Serialization payload must use only ASCII characters", {
+      cause
+    });
   }
 }
 async function verifySignature(jws, shared, key, encodeUnencodedPayload, parsedProtected) {
-  const { protected: encodedProtected, header, payload: inputPayload } = jws, parsedProt = parsedProtected ?? parseProtectedHeader(encodedProtected);
-  if (!isDisjoint(parsedProt, header))
+  const { protected: encodedProtectedHeader, header, payload: inputPayload } = jws, protectedHeader = parsedProtected ?? parseProtectedHeader(encodedProtectedHeader);
+  if (!isDisjoint(protectedHeader, header))
     throw new JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
-  const joseHeader = { ...parsedProt, ...header }, b64 = validateB64(parsedProt, validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader)), { alg } = joseHeader;
+  const joseHeader = { ...protectedHeader, ...header }, b64 = validateB64(protectedHeader, validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], protectedHeader, joseHeader)), { alg } = joseHeader;
   if (typeof alg != "string" || !alg)
     throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
   if (shared[0] && !shared[0].has(alg))
@@ -55,18 +57,19 @@ async function verifySignature(jws, shared, key, encodeUnencodedPayload, parsedP
     throw new JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
   const signingPayload = b64 || typeof inputPayload != "string" ? inputPayload : encodeUnencodedPayload(inputPayload);
   let resolvedKey = !1;
-  typeof key == "function" && (key = await key(parsedProt, jws), resolvedKey = !0);
-  const entry = jwsAlgorithm(alg), data = concat(encodedProtected !== void 0 ? encode(encodedProtected) : new Uint8Array(), encode("."), typeof signingPayload == "string" ? shared[2] ??= encodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload), signature = decodeBase64url(jws.signature, "signature", JWSInvalid), k = await prepareKey(entry, key, "verify"), cryptoKey = await rawKey(k, entry.subtle, "verify");
+  typeof key == "function" && (key = await key(protectedHeader, jws), resolvedKey = !0);
+  const entry = jwsAlgorithm(alg), signingInput = concat(encodedProtectedHeader !== void 0 ? encode(encodedProtectedHeader) : new Uint8Array(), encode("."), typeof signingPayload == "string" ? shared[2] ??= encodeAsciiMember(signingPayload, "payload", JWSInvalid) : signingPayload), signature = decodeBase64url(jws.signature, "signature", JWSInvalid), verificationKey = await prepareKey(entry, key, "verify"), cryptoKey = await rawKey(verificationKey, entry.subtle, "verify");
   entry.minRsaBits && checkModulusLength(entry.alg, cryptoKey);
   let verified = !1;
   try {
-    verified = await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
-  } catch {
+    verified = await crypto.subtle.verify(entry.signing, cryptoKey, signature, signingInput);
+  } catch (cause) {
+    throw new JWSSignatureVerificationFailed(void 0, { cause });
   }
   if (!verified)
     throw new JWSSignatureVerificationFailed();
   const result = { payload: typeof signingPayload == "string" ? decodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload };
-  return encodedProtected !== void 0 && (result.protectedHeader = parsedProt), header !== void 0 && (result.unprotectedHeader = header), resolvedKey ? [{ ...result, key: k }, b64] : [result, b64];
+  return encodedProtectedHeader !== void 0 && (result.protectedHeader = protectedHeader), header !== void 0 && (result.unprotectedHeader = header), resolvedKey ? [{ ...result, key: verificationKey }, b64] : [result, b64];
 }
 async function verifyCompact(jws, shared, key) {
   if (jws instanceof Uint8Array && (jws = decoder.decode(jws)), typeof jws != "string")