@workos-inc/node 8.9.0 → 8.10.0

package/lib/{webapi-oTg8yaNv.mjs → webapi-Cj8QQOwM.mjs}

@@ -98,6 +98,127 @@ function encode(input) {
 	return encodeBase64(unencoded).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 }
 //#endregion
+//#region node_modules/jose/dist/webapi/lib/crypto_key.js
+const unusable = (name, prop = "algorithm.name") => /* @__PURE__ */ new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
+const isAlgorithm = (algorithm, name) => algorithm.name === name;
+function getHashLength(hash) {
+	return parseInt(hash.name.slice(4), 10);
+}
+function checkHashLength(algorithm, expected) {
+	if (getHashLength(algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
+}
+function getNamedCurve(alg) {
+	switch (alg) {
+		case "ES256": return "P-256";
+		case "ES384": return "P-384";
+		case "ES512": return "P-521";
+		default: throw new Error("unreachable");
+	}
+}
+function checkUsage(key, usage) {
+	if (usage && !key.usages.includes(usage)) throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
+}
+function checkSigCryptoKey(key, alg, usage) {
+	switch (alg) {
+		case "HS256":
+		case "HS384":
+		case "HS512":
+			if (!isAlgorithm(key.algorithm, "HMAC")) throw unusable("HMAC");
+			checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
+			break;
+		case "RS256":
+		case "RS384":
+		case "RS512":
+			if (!isAlgorithm(key.algorithm, "RSASSA-PKCS1-v1_5")) throw unusable("RSASSA-PKCS1-v1_5");
+			checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
+			break;
+		case "PS256":
+		case "PS384":
+		case "PS512":
+			if (!isAlgorithm(key.algorithm, "RSA-PSS")) throw unusable("RSA-PSS");
+			checkHashLength(key.algorithm, parseInt(alg.slice(2), 10));
+			break;
+		case "Ed25519":
+		case "EdDSA":
+			if (!isAlgorithm(key.algorithm, "Ed25519")) throw unusable("Ed25519");
+			break;
+		case "ML-DSA-44":
+		case "ML-DSA-65":
+		case "ML-DSA-87":
+			if (!isAlgorithm(key.algorithm, alg)) throw unusable(alg);
+			break;
+		case "ES256":
+		case "ES384":
+		case "ES512": {
+			if (!isAlgorithm(key.algorithm, "ECDSA")) throw unusable("ECDSA");
+			const expected = getNamedCurve(alg);
+			if (key.algorithm.namedCurve !== expected) throw unusable(expected, "algorithm.namedCurve");
+			break;
+		}
+		default: throw new TypeError("CryptoKey does not support this operation");
+	}
+	checkUsage(key, usage);
+}
+function checkEncCryptoKey(key, alg, usage) {
+	switch (alg) {
+		case "A128GCM":
+		case "A192GCM":
+		case "A256GCM": {
+			if (!isAlgorithm(key.algorithm, "AES-GCM")) throw unusable("AES-GCM");
+			const expected = parseInt(alg.slice(1, 4), 10);
+			if (key.algorithm.length !== expected) throw unusable(expected, "algorithm.length");
+			break;
+		}
+		case "A128KW":
+		case "A192KW":
+		case "A256KW": {
+			if (!isAlgorithm(key.algorithm, "AES-KW")) throw unusable("AES-KW");
+			const expected = parseInt(alg.slice(1, 4), 10);
+			if (key.algorithm.length !== expected) throw unusable(expected, "algorithm.length");
+			break;
+		}
+		case "ECDH":
+			switch (key.algorithm.name) {
+				case "ECDH":
+				case "X25519": break;
+				default: throw unusable("ECDH or X25519");
+			}
+			break;
+		case "PBES2-HS256+A128KW":
+		case "PBES2-HS384+A192KW":
+		case "PBES2-HS512+A256KW":
+			if (!isAlgorithm(key.algorithm, "PBKDF2")) throw unusable("PBKDF2");
+			break;
+		case "RSA-OAEP":
+		case "RSA-OAEP-256":
+		case "RSA-OAEP-384":
+		case "RSA-OAEP-512":
+			if (!isAlgorithm(key.algorithm, "RSA-OAEP")) throw unusable("RSA-OAEP");
+			checkHashLength(key.algorithm, parseInt(alg.slice(9), 10) || 1);
+			break;
+		default: throw new TypeError("CryptoKey does not support this operation");
+	}
+	checkUsage(key, usage);
+}
+//#endregion
+//#region node_modules/jose/dist/webapi/lib/invalid_key_input.js
+function message(msg, actual, ...types) {
+	types = types.filter(Boolean);
+	if (types.length > 2) {
+		const last = types.pop();
+		msg += `one of type ${types.join(", ")}, or ${last}.`;
+	} else if (types.length === 2) msg += `one of type ${types[0]} or ${types[1]}.`;
+	else msg += `of type ${types[0]}.`;
+	if (actual == null) msg += ` Received ${actual}`;
+	else if (typeof actual === "function" && actual.name) msg += ` Received function ${actual.name}`;
+	else if (typeof actual === "object" && actual != null) {
+		if (actual.constructor?.name) msg += ` Received an instance of ${actual.constructor.name}`;
+	}
+	return msg;
+}
+const invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types);
+const withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
+//#endregion
 //#region node_modules/jose/dist/webapi/util/errors.js
 var errors_exports = /* @__PURE__ */ __exportAll({
 	JOSEAlgNotAllowed: () => JOSEAlgNotAllowed,
@@ -224,8 +345,39 @@ var JWSSignatureVerificationFailed = class extends JOSEError {
 	}
 };
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/iv.js
-function bitLength(alg) {
+//#region node_modules/jose/dist/webapi/lib/is_key_like.js
+function assertCryptoKey(key) {
+	if (!isCryptoKey(key)) throw new Error("CryptoKey instance expected");
+}
+const isCryptoKey = (key) => {
+	if (key?.[Symbol.toStringTag] === "CryptoKey") return true;
+	try {
+		return key instanceof CryptoKey;
+	} catch {
+		return false;
+	}
+};
+const isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject";
+const isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
+//#endregion
+//#region node_modules/jose/dist/webapi/lib/content_encryption.js
+function cekLength(alg) {
+	switch (alg) {
+		case "A128GCM": return 128;
+		case "A192GCM": return 192;
+		case "A256GCM":
+		case "A128CBC-HS256": return 256;
+		case "A192CBC-HS384": return 384;
+		case "A256CBC-HS512": return 512;
+		default: throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
+	}
+}
+const generateCek = (alg) => crypto.getRandomValues(new Uint8Array(cekLength(alg) >> 3));
+function checkCekLength(cek, expected) {
+	const actual = cek.byteLength << 3;
+	if (actual !== expected) throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
+}
+function ivBitLength(alg) {
 	switch (alg) {
 		case "A128GCM":
 		case "A128GCMKW":
@@ -239,200 +391,89 @@ function bitLength(alg) {
 		default: throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
 	}
 }
-const generateIv = (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/check_iv_length.js
+const generateIv = (alg) => crypto.getRandomValues(new Uint8Array(ivBitLength(alg) >> 3));
 function checkIvLength(enc, iv) {
-	if (iv.length << 3 !== bitLength(enc)) throw new JWEInvalid("Invalid Initialization Vector length");
+	if (iv.length << 3 !== ivBitLength(enc)) throw new JWEInvalid("Invalid Initialization Vector length");
 }
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/check_cek_length.js
-function checkCekLength(cek, expected) {
-	const actual = cek.byteLength << 3;
-	if (actual !== expected) throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
+async function cbcKeySetup(enc, cek, usage) {
+	if (!(cek instanceof Uint8Array)) throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
+	const keySize = parseInt(enc.slice(1, 4), 10);
+	return {
+		encKey: await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", false, [usage]),
+		macKey: await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
+			hash: `SHA-${keySize << 1}`,
+			name: "HMAC"
+		}, false, ["sign"]),
+		keySize
+	};
 }
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/crypto_key.js
-const unusable = (name, prop = "algorithm.name") => /* @__PURE__ */ new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-const isAlgorithm = (algorithm, name) => algorithm.name === name;
-function getHashLength(hash) {
-	return parseInt(hash.name.slice(4), 10);
+async function cbcHmacTag(macKey, macData, keySize) {
+	return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3));
 }
-function getNamedCurve(alg) {
-	switch (alg) {
-		case "ES256": return "P-256";
-		case "ES384": return "P-384";
-		case "ES512": return "P-521";
-		default: throw new Error("unreachable");
-	}
+async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
+	const { encKey, macKey, keySize } = await cbcKeySetup(enc, cek, "encrypt");
+	const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+		iv,
+		name: "AES-CBC"
+	}, encKey, plaintext));
+	return {
+		ciphertext,
+		tag: await cbcHmacTag(macKey, concat(aad, iv, ciphertext, uint64be(aad.length << 3)), keySize),
+		iv
+	};
 }
-function checkUsage(key, usage) {
-	if (usage && !key.usages.includes(usage)) throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
+async function timingSafeEqual(a, b) {
+	if (!(a instanceof Uint8Array)) throw new TypeError("First argument must be a buffer");
+	if (!(b instanceof Uint8Array)) throw new TypeError("Second argument must be a buffer");
+	const algorithm = {
+		name: "HMAC",
+		hash: "SHA-256"
+	};
+	const key = await crypto.subtle.generateKey(algorithm, false, ["sign"]);
+	const aHmac = new Uint8Array(await crypto.subtle.sign(algorithm, key, a));
+	const bHmac = new Uint8Array(await crypto.subtle.sign(algorithm, key, b));
+	let out = 0;
+	let i = -1;
+	while (++i < 32) out |= aHmac[i] ^ bHmac[i];
+	return out === 0;
 }
-function checkSigCryptoKey(key, alg, usage) {
-	switch (alg) {
-		case "HS256":
-		case "HS384":
-		case "HS512": {
-			if (!isAlgorithm(key.algorithm, "HMAC")) throw unusable("HMAC");
-			const expected = parseInt(alg.slice(2), 10);
-			if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
-			break;
-		}
-		case "RS256":
-		case "RS384":
-		case "RS512": {
-			if (!isAlgorithm(key.algorithm, "RSASSA-PKCS1-v1_5")) throw unusable("RSASSA-PKCS1-v1_5");
-			const expected = parseInt(alg.slice(2), 10);
-			if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
-			break;
-		}
-		case "PS256":
-		case "PS384":
-		case "PS512": {
-			if (!isAlgorithm(key.algorithm, "RSA-PSS")) throw unusable("RSA-PSS");
-			const expected = parseInt(alg.slice(2), 10);
-			if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
-			break;
-		}
-		case "Ed25519":
-		case "EdDSA":
-			if (!isAlgorithm(key.algorithm, "Ed25519")) throw unusable("Ed25519");
-			break;
-		case "ML-DSA-44":
-		case "ML-DSA-65":
-		case "ML-DSA-87":
-			if (!isAlgorithm(key.algorithm, alg)) throw unusable(alg);
-			break;
-		case "ES256":
-		case "ES384":
-		case "ES512": {
-			if (!isAlgorithm(key.algorithm, "ECDSA")) throw unusable("ECDSA");
-			const expected = getNamedCurve(alg);
-			if (key.algorithm.namedCurve !== expected) throw unusable(expected, "algorithm.namedCurve");
-			break;
-		}
-		default: throw new TypeError("CryptoKey does not support this operation");
-	}
-	checkUsage(key, usage);
+async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+	const { encKey, macKey, keySize } = await cbcKeySetup(enc, cek, "decrypt");
+	const expectedTag = await cbcHmacTag(macKey, concat(aad, iv, ciphertext, uint64be(aad.length << 3)), keySize);
+	let macCheckPassed;
+	try {
+		macCheckPassed = await timingSafeEqual(tag, expectedTag);
+	} catch {}
+	if (!macCheckPassed) throw new JWEDecryptionFailed();
+	let plaintext;
+	try {
+		plaintext = new Uint8Array(await crypto.subtle.decrypt({
+			iv,
+			name: "AES-CBC"
+		}, encKey, ciphertext));
+	} catch {}
+	if (!plaintext) throw new JWEDecryptionFailed();
+	return plaintext;
 }
-function checkEncCryptoKey(key, alg, usage) {
-	switch (alg) {
-		case "A128GCM":
-		case "A192GCM":
-		case "A256GCM": {
-			if (!isAlgorithm(key.algorithm, "AES-GCM")) throw unusable("AES-GCM");
-			const expected = parseInt(alg.slice(1, 4), 10);
-			if (key.algorithm.length !== expected) throw unusable(expected, "algorithm.length");
-			break;
-		}
-		case "A128KW":
-		case "A192KW":
-		case "A256KW": {
-			if (!isAlgorithm(key.algorithm, "AES-KW")) throw unusable("AES-KW");
-			const expected = parseInt(alg.slice(1, 4), 10);
-			if (key.algorithm.length !== expected) throw unusable(expected, "algorithm.length");
-			break;
-		}
-		case "ECDH":
-			switch (key.algorithm.name) {
-				case "ECDH":
-				case "X25519": break;
-				default: throw unusable("ECDH or X25519");
-			}
-			break;
-		case "PBES2-HS256+A128KW":
-		case "PBES2-HS384+A192KW":
-		case "PBES2-HS512+A256KW":
-			if (!isAlgorithm(key.algorithm, "PBKDF2")) throw unusable("PBKDF2");
-			break;
-		case "RSA-OAEP":
-		case "RSA-OAEP-256":
-		case "RSA-OAEP-384":
-		case "RSA-OAEP-512": {
-			if (!isAlgorithm(key.algorithm, "RSA-OAEP")) throw unusable("RSA-OAEP");
-			const expected = parseInt(alg.slice(9), 10) || 1;
-			if (getHashLength(key.algorithm.hash) !== expected) throw unusable(`SHA-${expected}`, "algorithm.hash");
-			break;
-		}
-		default: throw new TypeError("CryptoKey does not support this operation");
-	}
-	checkUsage(key, usage);
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/invalid_key_input.js
-function message(msg, actual, ...types) {
-	types = types.filter(Boolean);
-	if (types.length > 2) {
-		const last = types.pop();
-		msg += `one of type ${types.join(", ")}, or ${last}.`;
-	} else if (types.length === 2) msg += `one of type ${types[0]} or ${types[1]}.`;
-	else msg += `of type ${types[0]}.`;
-	if (actual == null) msg += ` Received ${actual}`;
-	else if (typeof actual === "function" && actual.name) msg += ` Received function ${actual.name}`;
-	else if (typeof actual === "object" && actual != null) {
-		if (actual.constructor?.name) msg += ` Received an instance of ${actual.constructor.name}`;
-	}
-	return msg;
-}
-const invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types);
-const withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/is_key_like.js
-function assertCryptoKey(key) {
-	if (!isCryptoKey(key)) throw new Error("CryptoKey instance expected");
-}
-const isCryptoKey = (key) => {
-	if (key?.[Symbol.toStringTag] === "CryptoKey") return true;
-	try {
-		return key instanceof CryptoKey;
-	} catch {
-		return false;
+async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
+	let encKey;
+	if (cek instanceof Uint8Array) encKey = await crypto.subtle.importKey("raw", cek, "AES-GCM", false, ["encrypt"]);
+	else {
+		checkEncCryptoKey(cek, enc, "encrypt");
+		encKey = cek;
 	}
-};
-const isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject";
-const isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/decrypt.js
-async function timingSafeEqual(a, b) {
-	if (!(a instanceof Uint8Array)) throw new TypeError("First argument must be a buffer");
-	if (!(b instanceof Uint8Array)) throw new TypeError("Second argument must be a buffer");
-	const algorithm = {
-		name: "HMAC",
-		hash: "SHA-256"
+	const encrypted = new Uint8Array(await crypto.subtle.encrypt({
+		additionalData: aad,
+		iv,
+		name: "AES-GCM",
+		tagLength: 128
+	}, encKey, plaintext));
+	const tag = encrypted.slice(-16);
+	return {
+		ciphertext: encrypted.slice(0, -16),
+		tag,
+		iv
 	};
-	const key = await crypto.subtle.generateKey(algorithm, false, ["sign"]);
-	const aHmac = new Uint8Array(await crypto.subtle.sign(algorithm, key, a));
-	const bHmac = new Uint8Array(await crypto.subtle.sign(algorithm, key, b));
-	let out = 0;
-	let i = -1;
-	while (++i < 32) out |= aHmac[i] ^ bHmac[i];
-	return out === 0;
-}
-async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-	if (!(cek instanceof Uint8Array)) throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
-	const keySize = parseInt(enc.slice(1, 4), 10);
-	const encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", false, ["decrypt"]);
-	const macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
-		hash: `SHA-${keySize << 1}`,
-		name: "HMAC"
-	}, false, ["sign"]);
-	const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
-	const expectedTag = new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3));
-	let macCheckPassed;
-	try {
-		macCheckPassed = await timingSafeEqual(tag, expectedTag);
-	} catch {}
-	if (!macCheckPassed) throw new JWEDecryptionFailed();
-	let plaintext;
-	try {
-		plaintext = new Uint8Array(await crypto.subtle.decrypt({
-			iv,
-			name: "AES-CBC"
-		}, encKey, ciphertext));
-	} catch {}
-	if (!plaintext) throw new JWEDecryptionFailed();
-	return plaintext;
 }
 async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
 	let encKey;
@@ -452,6 +493,25 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
 		throw new JWEDecryptionFailed();
 	}
 }
+const unsupportedEnc = "Unsupported JWE Content Encryption Algorithm";
+async function encrypt$1(enc, plaintext, cek, iv, aad) {
+	if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
+	if (iv) checkIvLength(enc, iv);
+	else iv = generateIv(enc);
+	switch (enc) {
+		case "A128CBC-HS256":
+		case "A192CBC-HS384":
+		case "A256CBC-HS512":
+			if (cek instanceof Uint8Array) checkCekLength(cek, parseInt(enc.slice(-3), 10));
+			return cbcEncrypt(enc, plaintext, cek, iv, aad);
+		case "A128GCM":
+		case "A192GCM":
+		case "A256GCM":
+			if (cek instanceof Uint8Array) checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
+			return gcmEncrypt(enc, plaintext, cek, iv, aad);
+		default: throw new JOSENotSupported(unsupportedEnc);
+	}
+}
 async function decrypt$1(enc, cek, ciphertext, iv, tag, aad) {
 	if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
 	if (!iv) throw new JWEInvalid("JWE Initialization Vector missing");
@@ -468,11 +528,36 @@ async function decrypt$1(enc, cek, ciphertext, iv, tag, aad) {
 		case "A256GCM":
 			if (cek instanceof Uint8Array) checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
 			return gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
-		default: throw new JOSENotSupported("Unsupported JWE Content Encryption Algorithm");
+		default: throw new JOSENotSupported(unsupportedEnc);
 	}
 }
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/is_disjoint.js
+//#region node_modules/jose/dist/webapi/lib/helpers.js
+const unprotected = Symbol();
+function assertNotSet(value, name) {
+	if (value) throw new TypeError(`${name} can only be called once`);
+}
+function decodeBase64url(value, label, ErrorClass) {
+	try {
+		return decode(value);
+	} catch {
+		throw new ErrorClass(`Failed to base64url decode the ${label}`);
+	}
+}
+async function digest(algorithm, data) {
+	const subtleDigest = `SHA-${algorithm.slice(-3)}`;
+	return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
+}
+//#endregion
+//#region node_modules/jose/dist/webapi/lib/type_checks.js
+const isObjectLike = (value) => typeof value === "object" && value !== null;
+function isObject(input) {
+	if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") return false;
+	if (Object.getPrototypeOf(input) === null) return true;
+	let proto = input;
+	while (Object.getPrototypeOf(proto) !== null) proto = Object.getPrototypeOf(proto);
+	return Object.getPrototypeOf(input) === proto;
+}
 function isDisjoint(...headers) {
 	const sources = headers.filter(Boolean);
 	if (sources.length === 0 || sources.length === 1) return true;
@@ -490,16 +575,10 @@ function isDisjoint(...headers) {
 	}
 	return true;
 }
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/is_object.js
-const isObjectLike = (value) => typeof value === "object" && value !== null;
-function isObject(input) {
-	if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") return false;
-	if (Object.getPrototypeOf(input) === null) return true;
-	let proto = input;
-	while (Object.getPrototypeOf(proto) !== null) proto = Object.getPrototypeOf(proto);
-	return Object.getPrototypeOf(input) === proto;
-}
+const isJWK = (key) => isObject(key) && typeof key.kty === "string";
+const isPrivateJWK = (key) => key.kty !== "oct" && (key.kty === "AKP" && typeof key.priv === "string" || typeof key.d === "string");
+const isPublicJWK = (key) => key.kty !== "oct" && key.d === void 0 && key.priv === void 0;
+const isSecretJWK = (key) => key.kty === "oct" && typeof key.k === "string";
 //#endregion
 //#region node_modules/jose/dist/webapi/lib/aeskw.js
 function checkKeySize(key, alg) {
@@ -529,12 +608,6 @@ async function unwrap$2(alg, key, encryptedKey) {
 	return new Uint8Array(await crypto.subtle.exportKey("raw", cryptoKeyCek));
 }
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/digest.js
-async function digest(algorithm, data) {
-	const subtleDigest = `SHA-${algorithm.slice(-3)}`;
-	return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-}
-//#endregion
 //#region node_modules/jose/dist/webapi/lib/ecdhes.js
 function lengthAndInput(input) {
 	return concat(uint32be(input.length), input);
@@ -609,16 +682,80 @@ async function unwrap$1(alg, key, encryptedKey, p2c, p2s) {
 	return unwrap$2(alg.slice(-6), derived, encryptedKey);
 }
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/check_key_length.js
+//#region node_modules/jose/dist/webapi/lib/signing.js
 function checkKeyLength(alg, key) {
 	if (alg.startsWith("RS") || alg.startsWith("PS")) {
 		const { modulusLength } = key.algorithm;
 		if (typeof modulusLength !== "number" || modulusLength < 2048) throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
 	}
 }
+function subtleAlgorithm$1(alg, algorithm) {
+	const hash = `SHA-${alg.slice(-3)}`;
+	switch (alg) {
+		case "HS256":
+		case "HS384":
+		case "HS512": return {
+			hash,
+			name: "HMAC"
+		};
+		case "PS256":
+		case "PS384":
+		case "PS512": return {
+			hash,
+			name: "RSA-PSS",
+			saltLength: parseInt(alg.slice(-3), 10) >> 3
+		};
+		case "RS256":
+		case "RS384":
+		case "RS512": return {
+			hash,
+			name: "RSASSA-PKCS1-v1_5"
+		};
+		case "ES256":
+		case "ES384":
+		case "ES512": return {
+			hash,
+			name: "ECDSA",
+			namedCurve: algorithm.namedCurve
+		};
+		case "Ed25519":
+		case "EdDSA": return { name: "Ed25519" };
+		case "ML-DSA-44":
+		case "ML-DSA-65":
+		case "ML-DSA-87": return { name: alg };
+		default: throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
+	}
+}
+async function getSigKey(alg, key, usage) {
+	if (key instanceof Uint8Array) {
+		if (!alg.startsWith("HS")) throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
+		return crypto.subtle.importKey("raw", key, {
+			hash: `SHA-${alg.slice(-3)}`,
+			name: "HMAC"
+		}, false, [usage]);
+	}
+	checkSigCryptoKey(key, alg, usage);
+	return key;
+}
+async function sign(alg, key, data) {
+	const cryptoKey = await getSigKey(alg, key, "sign");
+	checkKeyLength(alg, cryptoKey);
+	const signature = await crypto.subtle.sign(subtleAlgorithm$1(alg, cryptoKey.algorithm), cryptoKey, data);
+	return new Uint8Array(signature);
+}
+async function verify(alg, key, signature, data) {
+	const cryptoKey = await getSigKey(alg, key, "verify");
+	checkKeyLength(alg, cryptoKey);
+	const algorithm = subtleAlgorithm$1(alg, cryptoKey.algorithm);
+	try {
+		return await crypto.subtle.verify(algorithm, cryptoKey, signature, data);
+	} catch {
+		return false;
+	}
+}
 //#endregion
 //#region node_modules/jose/dist/webapi/lib/rsaes.js
-const subtleAlgorithm$1 = (alg) => {
+const subtleAlgorithm = (alg) => {
 	switch (alg) {
 		case "RSA-OAEP":
 		case "RSA-OAEP-256":
@@ -627,48 +764,266 @@ const subtleAlgorithm$1 = (alg) => {
 		default: throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
 	}
 };
-async function encrypt$1(alg, key, cek) {
+async function encrypt(alg, key, cek) {
 	checkEncCryptoKey(key, alg, "encrypt");
 	checkKeyLength(alg, key);
-	return new Uint8Array(await crypto.subtle.encrypt(subtleAlgorithm$1(alg), key, cek));
+	return new Uint8Array(await crypto.subtle.encrypt(subtleAlgorithm(alg), key, cek));
 }
 async function decrypt(alg, key, encryptedKey) {
 	checkEncCryptoKey(key, alg, "decrypt");
 	checkKeyLength(alg, key);
-	return new Uint8Array(await crypto.subtle.decrypt(subtleAlgorithm$1(alg), key, encryptedKey));
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/cek.js
-function cekLength(alg) {
-	switch (alg) {
-		case "A128GCM": return 128;
-		case "A192GCM": return 192;
-		case "A256GCM":
-		case "A128CBC-HS256": return 256;
-		case "A192CBC-HS384": return 384;
-		case "A256CBC-HS512": return 512;
-		default: throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
-	}
+	return new Uint8Array(await crypto.subtle.decrypt(subtleAlgorithm(alg), key, encryptedKey));
 }
-const generateCek = (alg) => crypto.getRandomValues(new Uint8Array(cekLength(alg) >> 3));
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/asn1.js
-const formatPEM = (b64, descriptor) => {
-	return `-----BEGIN ${descriptor}-----\n${(b64.match(/.{1,64}/g) || []).join("\n")}\n-----END ${descriptor}-----`;
-};
-const genericExport = async (keyType, keyFormat, key) => {
-	if (isKeyObject(key)) {
-		if (key.type !== keyType) throw new TypeError(`key is not a ${keyType} key`);
-		return key.export({
-			format: "pem",
-			type: keyFormat
-		});
-	}
-	if (!isCryptoKey(key)) throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject"));
-	if (!key.extractable) throw new TypeError("CryptoKey is not extractable");
-	if (key.type !== keyType) throw new TypeError(`key is not a ${keyType} key`);
-	return formatPEM(encodeBase64(new Uint8Array(await crypto.subtle.exportKey(keyFormat, key))), `${keyType.toUpperCase()} KEY`);
-};
+//#region node_modules/jose/dist/webapi/lib/jwk_to_key.js
+const unsupportedAlg = "Invalid or unsupported JWK \"alg\" (Algorithm) Parameter value";
+function subtleMapping(jwk) {
+	let algorithm;
+	let keyUsages;
+	switch (jwk.kty) {
+		case "AKP":
+			switch (jwk.alg) {
+				case "ML-DSA-44":
+				case "ML-DSA-65":
+				case "ML-DSA-87":
+					algorithm = { name: jwk.alg };
+					keyUsages = jwk.priv ? ["sign"] : ["verify"];
+					break;
+				default: throw new JOSENotSupported(unsupportedAlg);
+			}
+			break;
+		case "RSA":
+			switch (jwk.alg) {
+				case "PS256":
+				case "PS384":
+				case "PS512":
+					algorithm = {
+						name: "RSA-PSS",
+						hash: `SHA-${jwk.alg.slice(-3)}`
+					};
+					keyUsages = jwk.d ? ["sign"] : ["verify"];
+					break;
+				case "RS256":
+				case "RS384":
+				case "RS512":
+					algorithm = {
+						name: "RSASSA-PKCS1-v1_5",
+						hash: `SHA-${jwk.alg.slice(-3)}`
+					};
+					keyUsages = jwk.d ? ["sign"] : ["verify"];
+					break;
+				case "RSA-OAEP":
+				case "RSA-OAEP-256":
+				case "RSA-OAEP-384":
+				case "RSA-OAEP-512":
+					algorithm = {
+						name: "RSA-OAEP",
+						hash: `SHA-${parseInt(jwk.alg.slice(-3), 10) || 1}`
+					};
+					keyUsages = jwk.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
+					break;
+				default: throw new JOSENotSupported(unsupportedAlg);
+			}
+			break;
+		case "EC":
+			switch (jwk.alg) {
+				case "ES256":
+				case "ES384":
+				case "ES512":
+					algorithm = {
+						name: "ECDSA",
+						namedCurve: {
+							ES256: "P-256",
+							ES384: "P-384",
+							ES512: "P-521"
+						}[jwk.alg]
+					};
+					keyUsages = jwk.d ? ["sign"] : ["verify"];
+					break;
+				case "ECDH-ES":
+				case "ECDH-ES+A128KW":
+				case "ECDH-ES+A192KW":
+				case "ECDH-ES+A256KW":
+					algorithm = {
+						name: "ECDH",
+						namedCurve: jwk.crv
+					};
+					keyUsages = jwk.d ? ["deriveBits"] : [];
+					break;
+				default: throw new JOSENotSupported(unsupportedAlg);
+			}
+			break;
+		case "OKP":
+			switch (jwk.alg) {
+				case "Ed25519":
+				case "EdDSA":
+					algorithm = { name: "Ed25519" };
+					keyUsages = jwk.d ? ["sign"] : ["verify"];
+					break;
+				case "ECDH-ES":
+				case "ECDH-ES+A128KW":
+				case "ECDH-ES+A192KW":
+				case "ECDH-ES+A256KW":
+					algorithm = { name: jwk.crv };
+					keyUsages = jwk.d ? ["deriveBits"] : [];
+					break;
+				default: throw new JOSENotSupported(unsupportedAlg);
+			}
+			break;
+		default: throw new JOSENotSupported("Invalid or unsupported JWK \"kty\" (Key Type) Parameter value");
+	}
+	return {
+		algorithm,
+		keyUsages
+	};
+}
+async function jwkToKey(jwk) {
+	if (!jwk.alg) throw new TypeError("\"alg\" argument is required when \"jwk.alg\" is not present");
+	const { algorithm, keyUsages } = subtleMapping(jwk);
+	const keyData = { ...jwk };
+	if (keyData.kty !== "AKP") delete keyData.alg;
+	delete keyData.use;
+	return crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? (jwk.d || jwk.priv ? false : true), jwk.key_ops ?? keyUsages);
+}
+//#endregion
+//#region node_modules/jose/dist/webapi/lib/normalize_key.js
+const unusableForAlg = "given KeyObject instance cannot be used for this algorithm";
+let cache;
+const handleJWK = async (key, jwk, alg, freeze = false) => {
+	cache ||= /* @__PURE__ */ new WeakMap();
+	let cached = cache.get(key);
+	if (cached?.[alg]) return cached[alg];
+	const cryptoKey = await jwkToKey({
+		...jwk,
+		alg
+	});
+	if (freeze) Object.freeze(key);
+	if (!cached) cache.set(key, { [alg]: cryptoKey });
+	else cached[alg] = cryptoKey;
+	return cryptoKey;
+};
+const handleKeyObject = (keyObject, alg) => {
+	cache ||= /* @__PURE__ */ new WeakMap();
+	let cached = cache.get(keyObject);
+	if (cached?.[alg]) return cached[alg];
+	const isPublic = keyObject.type === "public";
+	const extractable = isPublic ? true : false;
+	let cryptoKey;
+	if (keyObject.asymmetricKeyType === "x25519") {
+		switch (alg) {
+			case "ECDH-ES":
+			case "ECDH-ES+A128KW":
+			case "ECDH-ES+A192KW":
+			case "ECDH-ES+A256KW": break;
+			default: throw new TypeError(unusableForAlg);
+		}
+		cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, isPublic ? [] : ["deriveBits"]);
+	}
+	if (keyObject.asymmetricKeyType === "ed25519") {
+		if (alg !== "EdDSA" && alg !== "Ed25519") throw new TypeError(unusableForAlg);
+		cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [isPublic ? "verify" : "sign"]);
+	}
+	switch (keyObject.asymmetricKeyType) {
+		case "ml-dsa-44":
+		case "ml-dsa-65":
+		case "ml-dsa-87":
+			if (alg !== keyObject.asymmetricKeyType.toUpperCase()) throw new TypeError(unusableForAlg);
+			cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [isPublic ? "verify" : "sign"]);
+	}
+	if (keyObject.asymmetricKeyType === "rsa") {
+		let hash;
+		switch (alg) {
+			case "RSA-OAEP":
+				hash = "SHA-1";
+				break;
+			case "RS256":
+			case "PS256":
+			case "RSA-OAEP-256":
+				hash = "SHA-256";
+				break;
+			case "RS384":
+			case "PS384":
+			case "RSA-OAEP-384":
+				hash = "SHA-384";
+				break;
+			case "RS512":
+			case "PS512":
+			case "RSA-OAEP-512":
+				hash = "SHA-512";
+				break;
+			default: throw new TypeError(unusableForAlg);
+		}
+		if (alg.startsWith("RSA-OAEP")) return keyObject.toCryptoKey({
+			name: "RSA-OAEP",
+			hash
+		}, extractable, isPublic ? ["encrypt"] : ["decrypt"]);
+		cryptoKey = keyObject.toCryptoKey({
+			name: alg.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
+			hash
+		}, extractable, [isPublic ? "verify" : "sign"]);
+	}
+	if (keyObject.asymmetricKeyType === "ec") {
+		const namedCurve = new Map([
+			["prime256v1", "P-256"],
+			["secp384r1", "P-384"],
+			["secp521r1", "P-521"]
+		]).get(keyObject.asymmetricKeyDetails?.namedCurve);
+		if (!namedCurve) throw new TypeError(unusableForAlg);
+		const expectedCurve = {
+			ES256: "P-256",
+			ES384: "P-384",
+			ES512: "P-521"
+		};
+		if (expectedCurve[alg] && namedCurve === expectedCurve[alg]) cryptoKey = keyObject.toCryptoKey({
+			name: "ECDSA",
+			namedCurve
+		}, extractable, [isPublic ? "verify" : "sign"]);
+		if (alg.startsWith("ECDH-ES")) cryptoKey = keyObject.toCryptoKey({
+			name: "ECDH",
+			namedCurve
+		}, extractable, isPublic ? [] : ["deriveBits"]);
+	}
+	if (!cryptoKey) throw new TypeError(unusableForAlg);
+	if (!cached) cache.set(keyObject, { [alg]: cryptoKey });
+	else cached[alg] = cryptoKey;
+	return cryptoKey;
+};
+async function normalizeKey(key, alg) {
+	if (key instanceof Uint8Array) return key;
+	if (isCryptoKey(key)) return key;
+	if (isKeyObject(key)) {
+		if (key.type === "secret") return key.export();
+		if ("toCryptoKey" in key && typeof key.toCryptoKey === "function") try {
+			return handleKeyObject(key, alg);
+		} catch (err) {
+			if (err instanceof TypeError) throw err;
+		}
+		return handleJWK(key, key.export({ format: "jwk" }), alg);
+	}
+	if (isJWK(key)) {
+		if (key.k) return decode(key.k);
+		return handleJWK(key, key, alg, true);
+	}
+	throw new Error("unreachable");
+}
+//#endregion
+//#region node_modules/jose/dist/webapi/lib/asn1.js
+const formatPEM = (b64, descriptor) => {
+	return `-----BEGIN ${descriptor}-----\n${(b64.match(/.{1,64}/g) || []).join("\n")}\n-----END ${descriptor}-----`;
+};
+const genericExport = async (keyType, keyFormat, key) => {
+	if (isKeyObject(key)) {
+		if (key.type !== keyType) throw new TypeError(`key is not a ${keyType} key`);
+		return key.export({
+			format: "pem",
+			type: keyFormat
+		});
+	}
+	if (!isCryptoKey(key)) throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject"));
+	if (!key.extractable) throw new TypeError("CryptoKey is not extractable");
+	if (key.type !== keyType) throw new TypeError(`key is not a ${keyType} key`);
+	return formatPEM(encodeBase64(new Uint8Array(await crypto.subtle.exportKey(keyFormat, key))), `${keyType.toUpperCase()} KEY`);
+};
 const toSPKI = (key) => genericExport("public", "spki", key);
 const toPKCS8 = (key) => genericExport("private", "pkcs8", key);
 const bytesEqual = (a, b) => {
@@ -920,142 +1275,24 @@ const fromX509 = (pem, alg, options) => {
 	return fromSPKI(formatPEM(encodeBase64(spki), "PUBLIC KEY"), alg, options);
 };
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/jwk_to_key.js
-function subtleMapping(jwk) {
-	let algorithm;
-	let keyUsages;
-	switch (jwk.kty) {
-		case "AKP":
-			switch (jwk.alg) {
-				case "ML-DSA-44":
-				case "ML-DSA-65":
-				case "ML-DSA-87":
-					algorithm = { name: jwk.alg };
-					keyUsages = jwk.priv ? ["sign"] : ["verify"];
-					break;
-				default: throw new JOSENotSupported("Invalid or unsupported JWK \"alg\" (Algorithm) Parameter value");
-			}
-			break;
-		case "RSA":
-			switch (jwk.alg) {
-				case "PS256":
-				case "PS384":
-				case "PS512":
-					algorithm = {
-						name: "RSA-PSS",
-						hash: `SHA-${jwk.alg.slice(-3)}`
-					};
-					keyUsages = jwk.d ? ["sign"] : ["verify"];
-					break;
-				case "RS256":
-				case "RS384":
-				case "RS512":
-					algorithm = {
-						name: "RSASSA-PKCS1-v1_5",
-						hash: `SHA-${jwk.alg.slice(-3)}`
-					};
-					keyUsages = jwk.d ? ["sign"] : ["verify"];
-					break;
-				case "RSA-OAEP":
-				case "RSA-OAEP-256":
-				case "RSA-OAEP-384":
-				case "RSA-OAEP-512":
-					algorithm = {
-						name: "RSA-OAEP",
-						hash: `SHA-${parseInt(jwk.alg.slice(-3), 10) || 1}`
-					};
-					keyUsages = jwk.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
-					break;
-				default: throw new JOSENotSupported("Invalid or unsupported JWK \"alg\" (Algorithm) Parameter value");
-			}
-			break;
-		case "EC":
-			switch (jwk.alg) {
-				case "ES256":
-					algorithm = {
-						name: "ECDSA",
-						namedCurve: "P-256"
-					};
-					keyUsages = jwk.d ? ["sign"] : ["verify"];
-					break;
-				case "ES384":
-					algorithm = {
-						name: "ECDSA",
-						namedCurve: "P-384"
-					};
-					keyUsages = jwk.d ? ["sign"] : ["verify"];
-					break;
-				case "ES512":
-					algorithm = {
-						name: "ECDSA",
-						namedCurve: "P-521"
-					};
-					keyUsages = jwk.d ? ["sign"] : ["verify"];
-					break;
-				case "ECDH-ES":
-				case "ECDH-ES+A128KW":
-				case "ECDH-ES+A192KW":
-				case "ECDH-ES+A256KW":
-					algorithm = {
-						name: "ECDH",
-						namedCurve: jwk.crv
-					};
-					keyUsages = jwk.d ? ["deriveBits"] : [];
-					break;
-				default: throw new JOSENotSupported("Invalid or unsupported JWK \"alg\" (Algorithm) Parameter value");
-			}
-			break;
-		case "OKP":
-			switch (jwk.alg) {
-				case "Ed25519":
-				case "EdDSA":
-					algorithm = { name: "Ed25519" };
-					keyUsages = jwk.d ? ["sign"] : ["verify"];
-					break;
-				case "ECDH-ES":
-				case "ECDH-ES+A128KW":
-				case "ECDH-ES+A192KW":
-				case "ECDH-ES+A256KW":
-					algorithm = { name: jwk.crv };
-					keyUsages = jwk.d ? ["deriveBits"] : [];
-					break;
-				default: throw new JOSENotSupported("Invalid or unsupported JWK \"alg\" (Algorithm) Parameter value");
-			}
-			break;
-		default: throw new JOSENotSupported("Invalid or unsupported JWK \"kty\" (Key Type) Parameter value");
-	}
-	return {
-		algorithm,
-		keyUsages
-	};
-}
-async function jwkToKey(jwk) {
-	if (!jwk.alg) throw new TypeError("\"alg\" argument is required when \"jwk.alg\" is not present");
-	const { algorithm, keyUsages } = subtleMapping(jwk);
-	const keyData = { ...jwk };
-	if (keyData.kty !== "AKP") delete keyData.alg;
-	delete keyData.use;
-	return crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? (jwk.d || jwk.priv ? false : true), jwk.key_ops ?? keyUsages);
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/key/import.js
-async function importSPKI(spki, alg, options) {
-	if (typeof spki !== "string" || spki.indexOf("-----BEGIN PUBLIC KEY-----") !== 0) throw new TypeError("\"spki\" must be SPKI formatted string");
-	return fromSPKI(spki, alg, options);
-}
-async function importX509(x509, alg, options) {
-	if (typeof x509 !== "string" || x509.indexOf("-----BEGIN CERTIFICATE-----") !== 0) throw new TypeError("\"x509\" must be X.509 formatted string");
-	return fromX509(x509, alg, options);
-}
-async function importPKCS8(pkcs8, alg, options) {
-	if (typeof pkcs8 !== "string" || pkcs8.indexOf("-----BEGIN PRIVATE KEY-----") !== 0) throw new TypeError("\"pkcs8\" must be PKCS#8 formatted string");
-	return fromPKCS8(pkcs8, alg, options);
-}
-async function importJWK(jwk, alg, options) {
-	if (!isObject(jwk)) throw new TypeError("JWK must be an object");
-	let ext;
-	alg ??= jwk.alg;
-	ext ??= options?.extractable ?? jwk.ext;
+//#region node_modules/jose/dist/webapi/key/import.js
+async function importSPKI(spki, alg, options) {
+	if (typeof spki !== "string" || spki.indexOf("-----BEGIN PUBLIC KEY-----") !== 0) throw new TypeError("\"spki\" must be SPKI formatted string");
+	return fromSPKI(spki, alg, options);
+}
+async function importX509(x509, alg, options) {
+	if (typeof x509 !== "string" || x509.indexOf("-----BEGIN CERTIFICATE-----") !== 0) throw new TypeError("\"x509\" must be X.509 formatted string");
+	return fromX509(x509, alg, options);
+}
+async function importPKCS8(pkcs8, alg, options) {
+	if (typeof pkcs8 !== "string" || pkcs8.indexOf("-----BEGIN PRIVATE KEY-----") !== 0) throw new TypeError("\"pkcs8\" must be PKCS#8 formatted string");
+	return fromPKCS8(pkcs8, alg, options);
+}
+async function importJWK(jwk, alg, options) {
+	if (!isObject(jwk)) throw new TypeError("JWK must be an object");
+	let ext;
+	alg ??= jwk.alg;
+	ext ??= options?.extractable ?? jwk.ext;
 	switch (jwk.kty) {
 		case "oct":
 			if (typeof jwk.k !== "string" || !jwk.k) throw new TypeError("missing \"k\" (Key Value) Parameter value");
@@ -1084,68 +1321,35 @@ async function importJWK(jwk, alg, options) {
 	}
 }
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/encrypt.js
-async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-	if (!(cek instanceof Uint8Array)) throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
-	const keySize = parseInt(enc.slice(1, 4), 10);
-	const encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", false, ["encrypt"]);
-	const macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
-		hash: `SHA-${keySize << 1}`,
-		name: "HMAC"
-	}, false, ["sign"]);
-	const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-		iv,
-		name: "AES-CBC"
-	}, encKey, plaintext));
-	const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
-	return {
-		ciphertext,
-		tag: new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3)),
-		iv
+//#region node_modules/jose/dist/webapi/lib/key_to_jwk.js
+async function keyToJWK(key) {
+	if (isKeyObject(key)) if (key.type === "secret") key = key.export();
+	else return key.export({ format: "jwk" });
+	if (key instanceof Uint8Array) return {
+		kty: "oct",
+		k: encode(key)
 	};
+	if (!isCryptoKey(key)) throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "Uint8Array"));
+	if (!key.extractable) throw new TypeError("non-extractable CryptoKey cannot be exported as a JWK");
+	const { ext, key_ops, alg, use, ...jwk } = await crypto.subtle.exportKey("jwk", key);
+	if (jwk.kty === "AKP") jwk.alg = alg;
+	return jwk;
 }
-async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
-	let encKey;
-	if (cek instanceof Uint8Array) encKey = await crypto.subtle.importKey("raw", cek, "AES-GCM", false, ["encrypt"]);
-	else {
-		checkEncCryptoKey(cek, enc, "encrypt");
-		encKey = cek;
-	}
-	const encrypted = new Uint8Array(await crypto.subtle.encrypt({
-		additionalData: aad,
-		iv,
-		name: "AES-GCM",
-		tagLength: 128
-	}, encKey, plaintext));
-	const tag = encrypted.slice(-16);
-	return {
-		ciphertext: encrypted.slice(0, -16),
-		tag,
-		iv
-	};
+//#endregion
+//#region node_modules/jose/dist/webapi/key/export.js
+async function exportSPKI(key) {
+	return toSPKI(key);
 }
-async function encrypt(enc, plaintext, cek, iv, aad) {
-	if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
-	if (iv) checkIvLength(enc, iv);
-	else iv = generateIv(enc);
-	switch (enc) {
-		case "A128CBC-HS256":
-		case "A192CBC-HS384":
-		case "A256CBC-HS512":
-			if (cek instanceof Uint8Array) checkCekLength(cek, parseInt(enc.slice(-3), 10));
-			return cbcEncrypt(enc, plaintext, cek, iv, aad);
-		case "A128GCM":
-		case "A192GCM":
-		case "A256GCM":
-			if (cek instanceof Uint8Array) checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
-			return gcmEncrypt(enc, plaintext, cek, iv, aad);
-		default: throw new JOSENotSupported("Unsupported JWE Content Encryption Algorithm");
-	}
+async function exportPKCS8(key) {
+	return toPKCS8(key);
+}
+async function exportJWK(key) {
+	return keyToJWK(key);
 }
 //#endregion
 //#region node_modules/jose/dist/webapi/lib/aesgcmkw.js
 async function wrap(alg, key, cek, iv) {
-	const wrapped = await encrypt(alg.slice(0, 7), cek, key, iv, new Uint8Array());
+	const wrapped = await encrypt$1(alg.slice(0, 7), cek, key, iv, new Uint8Array());
 	return {
 		encryptedKey: wrapped.ciphertext,
 		iv: encode(wrapped.iv),
@@ -1156,7 +1360,11 @@ async function unwrap(alg, key, encryptedKey, iv, tag) {
 	return decrypt$1(alg.slice(0, 7), key, encryptedKey, iv, tag, new Uint8Array());
 }
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/decrypt_key_management.js
+//#region node_modules/jose/dist/webapi/lib/key_management.js
+const unsupportedAlgHeader = "Invalid or unsupported \"alg\" (JWE Algorithm) header value";
+function assertEncryptedKey(encryptedKey) {
+	if (encryptedKey === void 0) throw new JWEInvalid("JWE Encrypted Key missing");
+}
 async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options) {
 	switch (alg) {
 		case "dir":
@@ -1175,227 +1383,152 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options)
 			let partyVInfo;
 			if (joseHeader.apu !== void 0) {
 				if (typeof joseHeader.apu !== "string") throw new JWEInvalid(`JOSE Header "apu" (Agreement PartyUInfo) invalid`);
-				try {
-					partyUInfo = decode(joseHeader.apu);
-				} catch {
-					throw new JWEInvalid("Failed to base64url decode the apu");
-				}
+				partyUInfo = decodeBase64url(joseHeader.apu, "apu", JWEInvalid);
 			}
 			if (joseHeader.apv !== void 0) {
 				if (typeof joseHeader.apv !== "string") throw new JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`);
-				try {
-					partyVInfo = decode(joseHeader.apv);
-				} catch {
-					throw new JWEInvalid("Failed to base64url decode the apv");
-				}
+				partyVInfo = decodeBase64url(joseHeader.apv, "apv", JWEInvalid);
 			}
 			const sharedSecret = await deriveKey$1(epk, key, alg === "ECDH-ES" ? joseHeader.enc : alg, alg === "ECDH-ES" ? cekLength(joseHeader.enc) : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
 			if (alg === "ECDH-ES") return sharedSecret;
-			if (encryptedKey === void 0) throw new JWEInvalid("JWE Encrypted Key missing");
+			assertEncryptedKey(encryptedKey);
 			return unwrap$2(alg.slice(-6), sharedSecret, encryptedKey);
 		}
 		case "RSA-OAEP":
 		case "RSA-OAEP-256":
 		case "RSA-OAEP-384":
 		case "RSA-OAEP-512":
-			if (encryptedKey === void 0) throw new JWEInvalid("JWE Encrypted Key missing");
+			assertEncryptedKey(encryptedKey);
 			assertCryptoKey(key);
 			return decrypt(alg, key, encryptedKey);
 		case "PBES2-HS256+A128KW":
 		case "PBES2-HS384+A192KW":
 		case "PBES2-HS512+A256KW": {
-			if (encryptedKey === void 0) throw new JWEInvalid("JWE Encrypted Key missing");
+			assertEncryptedKey(encryptedKey);
 			if (typeof joseHeader.p2c !== "number") throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`);
 			const p2cLimit = options?.maxPBES2Count || 1e4;
 			if (joseHeader.p2c > p2cLimit) throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds`);
 			if (typeof joseHeader.p2s !== "string") throw new JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`);
 			let p2s;
-			try {
-				p2s = decode(joseHeader.p2s);
-			} catch {
-				throw new JWEInvalid("Failed to base64url decode the p2s");
-			}
+			p2s = decodeBase64url(joseHeader.p2s, "p2s", JWEInvalid);
 			return unwrap$1(alg, key, encryptedKey, joseHeader.p2c, p2s);
 		}
 		case "A128KW":
 		case "A192KW":
 		case "A256KW":
-			if (encryptedKey === void 0) throw new JWEInvalid("JWE Encrypted Key missing");
+			assertEncryptedKey(encryptedKey);
 			return unwrap$2(alg, key, encryptedKey);
 		case "A128GCMKW":
 		case "A192GCMKW":
 		case "A256GCMKW": {
-			if (encryptedKey === void 0) throw new JWEInvalid("JWE Encrypted Key missing");
+			assertEncryptedKey(encryptedKey);
 			if (typeof joseHeader.iv !== "string") throw new JWEInvalid(`JOSE Header "iv" (Initialization Vector) missing or invalid`);
 			if (typeof joseHeader.tag !== "string") throw new JWEInvalid(`JOSE Header "tag" (Authentication Tag) missing or invalid`);
 			let iv;
-			try {
-				iv = decode(joseHeader.iv);
-			} catch {
-				throw new JWEInvalid("Failed to base64url decode the iv");
-			}
+			iv = decodeBase64url(joseHeader.iv, "iv", JWEInvalid);
 			let tag;
-			try {
-				tag = decode(joseHeader.tag);
-			} catch {
-				throw new JWEInvalid("Failed to base64url decode the tag");
-			}
+			tag = decodeBase64url(joseHeader.tag, "tag", JWEInvalid);
 			return unwrap(alg, key, encryptedKey, iv, tag);
 		}
-		default: throw new JOSENotSupported("Invalid or unsupported \"alg\" (JWE Algorithm) header value");
-	}
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/validate_crit.js
-function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
-	if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) throw new Err("\"crit\" (Critical) Header Parameter MUST be integrity protected");
-	if (!protectedHeader || protectedHeader.crit === void 0) return /* @__PURE__ */ new Set();
-	if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input !== "string" || input.length === 0)) throw new Err("\"crit\" (Critical) Header Parameter MUST be an array of non-empty strings when present");
-	let recognized;
-	if (recognizedOption !== void 0) recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-	else recognized = recognizedDefault;
-	for (const parameter of protectedHeader.crit) {
-		if (!recognized.has(parameter)) throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-		if (joseHeader[parameter] === void 0) throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-		if (recognized.get(parameter) && protectedHeader[parameter] === void 0) throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
+		default: throw new JOSENotSupported(unsupportedAlgHeader);
 	}
-	return new Set(protectedHeader.crit);
 }
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/validate_algorithms.js
-function validateAlgorithms(option, algorithms) {
-	if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== "string"))) throw new TypeError(`"${option}" option must be an array of strings`);
-	if (!algorithms) return;
-	return new Set(algorithms);
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/is_jwk.js
-const isJWK = (key) => isObject(key) && typeof key.kty === "string";
-const isPrivateJWK = (key) => key.kty !== "oct" && (key.kty === "AKP" && typeof key.priv === "string" || typeof key.d === "string");
-const isPublicJWK = (key) => key.kty !== "oct" && key.d === void 0 && key.priv === void 0;
-const isSecretJWK = (key) => key.kty === "oct" && typeof key.k === "string";
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/normalize_key.js
-let cache;
-const handleJWK = async (key, jwk, alg, freeze = false) => {
-	cache ||= /* @__PURE__ */ new WeakMap();
-	let cached = cache.get(key);
-	if (cached?.[alg]) return cached[alg];
-	const cryptoKey = await jwkToKey({
-		...jwk,
-		alg
-	});
-	if (freeze) Object.freeze(key);
-	if (!cached) cache.set(key, { [alg]: cryptoKey });
-	else cached[alg] = cryptoKey;
-	return cryptoKey;
-};
-const handleKeyObject = (keyObject, alg) => {
-	cache ||= /* @__PURE__ */ new WeakMap();
-	let cached = cache.get(keyObject);
-	if (cached?.[alg]) return cached[alg];
-	const isPublic = keyObject.type === "public";
-	const extractable = isPublic ? true : false;
-	let cryptoKey;
-	if (keyObject.asymmetricKeyType === "x25519") {
-		switch (alg) {
-			case "ECDH-ES":
-			case "ECDH-ES+A128KW":
-			case "ECDH-ES+A192KW":
-			case "ECDH-ES+A256KW": break;
-			default: throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-		}
-		cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, isPublic ? [] : ["deriveBits"]);
-	}
-	if (keyObject.asymmetricKeyType === "ed25519") {
-		if (alg !== "EdDSA" && alg !== "Ed25519") throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-		cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [isPublic ? "verify" : "sign"]);
-	}
-	switch (keyObject.asymmetricKeyType) {
-		case "ml-dsa-44":
-		case "ml-dsa-65":
-		case "ml-dsa-87":
-			if (alg !== keyObject.asymmetricKeyType.toUpperCase()) throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-			cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [isPublic ? "verify" : "sign"]);
-	}
-	if (keyObject.asymmetricKeyType === "rsa") {
-		let hash;
-		switch (alg) {
-			case "RSA-OAEP":
-				hash = "SHA-1";
-				break;
-			case "RS256":
-			case "PS256":
-			case "RSA-OAEP-256":
-				hash = "SHA-256";
-				break;
-			case "RS384":
-			case "PS384":
-			case "RSA-OAEP-384":
-				hash = "SHA-384";
-				break;
-			case "RS512":
-			case "PS512":
-			case "RSA-OAEP-512":
-				hash = "SHA-512";
-				break;
-			default: throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-		}
-		if (alg.startsWith("RSA-OAEP")) return keyObject.toCryptoKey({
-			name: "RSA-OAEP",
-			hash
-		}, extractable, isPublic ? ["encrypt"] : ["decrypt"]);
-		cryptoKey = keyObject.toCryptoKey({
-			name: alg.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
-			hash
-		}, extractable, [isPublic ? "verify" : "sign"]);
-	}
-	if (keyObject.asymmetricKeyType === "ec") {
-		const namedCurve = new Map([
-			["prime256v1", "P-256"],
-			["secp384r1", "P-384"],
-			["secp521r1", "P-521"]
-		]).get(keyObject.asymmetricKeyDetails?.namedCurve);
-		if (!namedCurve) throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-		if (alg === "ES256" && namedCurve === "P-256") cryptoKey = keyObject.toCryptoKey({
-			name: "ECDSA",
-			namedCurve
-		}, extractable, [isPublic ? "verify" : "sign"]);
-		if (alg === "ES384" && namedCurve === "P-384") cryptoKey = keyObject.toCryptoKey({
-			name: "ECDSA",
-			namedCurve
-		}, extractable, [isPublic ? "verify" : "sign"]);
-		if (alg === "ES512" && namedCurve === "P-521") cryptoKey = keyObject.toCryptoKey({
-			name: "ECDSA",
-			namedCurve
-		}, extractable, [isPublic ? "verify" : "sign"]);
-		if (alg.startsWith("ECDH-ES")) cryptoKey = keyObject.toCryptoKey({
-			name: "ECDH",
-			namedCurve
-		}, extractable, isPublic ? [] : ["deriveBits"]);
-	}
-	if (!cryptoKey) throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-	if (!cached) cache.set(keyObject, { [alg]: cryptoKey });
-	else cached[alg] = cryptoKey;
-	return cryptoKey;
-};
-async function normalizeKey(key, alg) {
-	if (key instanceof Uint8Array) return key;
-	if (isCryptoKey(key)) return key;
-	if (isKeyObject(key)) {
-		if (key.type === "secret") return key.export();
-		if ("toCryptoKey" in key && typeof key.toCryptoKey === "function") try {
-			return handleKeyObject(key, alg);
-		} catch (err) {
-			if (err instanceof TypeError) throw err;
+async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
+	let encryptedKey;
+	let parameters;
+	let cek;
+	switch (alg) {
+		case "dir":
+			cek = key;
+			break;
+		case "ECDH-ES":
+		case "ECDH-ES+A128KW":
+		case "ECDH-ES+A192KW":
+		case "ECDH-ES+A256KW": {
+			assertCryptoKey(key);
+			if (!allowed(key)) throw new JOSENotSupported("ECDH with the provided key is not allowed or not supported by your javascript runtime");
+			const { apu, apv } = providedParameters;
+			let ephemeralKey;
+			if (providedParameters.epk) ephemeralKey = await normalizeKey(providedParameters.epk, alg);
+			else ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, true, ["deriveBits"])).privateKey;
+			const { x, y, crv, kty } = await exportJWK(ephemeralKey);
+			const sharedSecret = await deriveKey$1(key, ephemeralKey, alg === "ECDH-ES" ? enc : alg, alg === "ECDH-ES" ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
+			parameters = { epk: {
+				x,
+				crv,
+				kty
+			} };
+			if (kty === "EC") parameters.epk.y = y;
+			if (apu) parameters.apu = encode(apu);
+			if (apv) parameters.apv = encode(apv);
+			if (alg === "ECDH-ES") {
+				cek = sharedSecret;
+				break;
+			}
+			cek = providedCek || generateCek(enc);
+			encryptedKey = await wrap$2(alg.slice(-6), sharedSecret, cek);
+			break;
 		}
-		return handleJWK(key, key.export({ format: "jwk" }), alg);
+		case "RSA-OAEP":
+		case "RSA-OAEP-256":
+		case "RSA-OAEP-384":
+		case "RSA-OAEP-512":
+			cek = providedCek || generateCek(enc);
+			assertCryptoKey(key);
+			encryptedKey = await encrypt(alg, key, cek);
+			break;
+		case "PBES2-HS256+A128KW":
+		case "PBES2-HS384+A192KW":
+		case "PBES2-HS512+A256KW": {
+			cek = providedCek || generateCek(enc);
+			const { p2c, p2s } = providedParameters;
+			({encryptedKey, ...parameters} = await wrap$1(alg, key, cek, p2c, p2s));
+			break;
+		}
+		case "A128KW":
+		case "A192KW":
+		case "A256KW":
+			cek = providedCek || generateCek(enc);
+			encryptedKey = await wrap$2(alg, key, cek);
+			break;
+		case "A128GCMKW":
+		case "A192GCMKW":
+		case "A256GCMKW": {
+			cek = providedCek || generateCek(enc);
+			const { iv } = providedParameters;
+			({encryptedKey, ...parameters} = await wrap(alg, key, cek, iv));
+			break;
+		}
+		default: throw new JOSENotSupported(unsupportedAlgHeader);
 	}
-	if (isJWK(key)) {
-		if (key.k) return decode(key.k);
-		return handleJWK(key, key, alg, true);
+	return {
+		cek,
+		encryptedKey,
+		parameters
+	};
+}
+//#endregion
+//#region node_modules/jose/dist/webapi/lib/validate_crit.js
+function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
+	if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) throw new Err("\"crit\" (Critical) Header Parameter MUST be integrity protected");
+	if (!protectedHeader || protectedHeader.crit === void 0) return /* @__PURE__ */ new Set();
+	if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input !== "string" || input.length === 0)) throw new Err("\"crit\" (Critical) Header Parameter MUST be an array of non-empty strings when present");
+	let recognized;
+	if (recognizedOption !== void 0) recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
+	else recognized = recognizedDefault;
+	for (const parameter of protectedHeader.crit) {
+		if (!recognized.has(parameter)) throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
+		if (joseHeader[parameter] === void 0) throw new Err(`Extension Header Parameter "${parameter}" is missing`);
+		if (recognized.get(parameter) && protectedHeader[parameter] === void 0) throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
 	}
-	throw new Error("unreachable");
+	return new Set(protectedHeader.crit);
+}
+//#endregion
+//#region node_modules/jose/dist/webapi/lib/validate_algorithms.js
+function validateAlgorithms(option, algorithms) {
+	if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== "string"))) throw new TypeError(`"${option}" option must be an array of strings`);
+	if (!algorithms) return;
+	return new Set(algorithms);
 }
 //#endregion
 //#region node_modules/jose/dist/webapi/lib/check_key_type.js
@@ -1560,11 +1693,7 @@ async function flattenedDecrypt(jwe, key, options) {
 	if (keyManagementAlgorithms && !keyManagementAlgorithms.has(alg) || !keyManagementAlgorithms && alg.startsWith("PBES2")) throw new JOSEAlgNotAllowed("\"alg\" (Algorithm) Header Parameter value not allowed");
 	if (contentEncryptionAlgorithms && !contentEncryptionAlgorithms.has(enc)) throw new JOSEAlgNotAllowed("\"enc\" (Encryption Algorithm) Header Parameter value not allowed");
 	let encryptedKey;
-	if (jwe.encrypted_key !== void 0) try {
-		encryptedKey = decode(jwe.encrypted_key);
-	} catch {
-		throw new JWEInvalid("Failed to base64url decode the encrypted_key");
-	}
+	if (jwe.encrypted_key !== void 0) encryptedKey = decodeBase64url(jwe.encrypted_key, "encrypted_key", JWEInvalid);
 	let resolvedKey = false;
 	if (typeof key === "function") {
 		key = await key(parsedProt, jwe);
@@ -1581,26 +1710,13 @@ async function flattenedDecrypt(jwe, key, options) {
 	}
 	let iv;
 	let tag;
-	if (jwe.iv !== void 0) try {
-		iv = decode(jwe.iv);
-	} catch {
-		throw new JWEInvalid("Failed to base64url decode the iv");
-	}
-	if (jwe.tag !== void 0) try {
-		tag = decode(jwe.tag);
-	} catch {
-		throw new JWEInvalid("Failed to base64url decode the tag");
-	}
+	if (jwe.iv !== void 0) iv = decodeBase64url(jwe.iv, "iv", JWEInvalid);
+	if (jwe.tag !== void 0) tag = decodeBase64url(jwe.tag, "tag", JWEInvalid);
 	const protectedHeader = jwe.protected !== void 0 ? encode$1(jwe.protected) : new Uint8Array();
 	let additionalData;
 	if (jwe.aad !== void 0) additionalData = concat(protectedHeader, encode$1("."), encode$1(jwe.aad));
 	else additionalData = protectedHeader;
-	let ciphertext;
-	try {
-		ciphertext = decode(jwe.ciphertext);
-	} catch {
-		throw new JWEInvalid("Failed to base64url decode the ciphertext");
-	}
+	const ciphertext = decodeBase64url(jwe.ciphertext, "ciphertext", JWEInvalid);
 	const plaintext = await decrypt$1(enc, cek, ciphertext, iv, tag, additionalData);
 	const result = { plaintext };
 	if (joseHeader.zip === "DEF") {
@@ -1610,11 +1726,7 @@ async function flattenedDecrypt(jwe, key, options) {
 		result.plaintext = await decompress(plaintext, maxDecompressedLength);
 	}
 	if (jwe.protected !== void 0) result.protectedHeader = parsedProt;
-	if (jwe.aad !== void 0) try {
-		result.additionalAuthenticatedData = decode(jwe.aad);
-	} catch {
-		throw new JWEInvalid("Failed to base64url decode the aad");
-	}
+	if (jwe.aad !== void 0) result.additionalAuthenticatedData = decodeBase64url(jwe.aad, "aad", JWEInvalid);
 	if (jwe.unprotected !== void 0) result.sharedUnprotectedHeader = jwe.unprotected;
 	if (jwe.header !== void 0) result.unprotectedHeader = jwe.header;
 	if (resolvedKey) return {
@@ -1668,111 +1780,6 @@ async function generalDecrypt(jwe, key, options) {
 	throw new JWEDecryptionFailed();
 }
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/private_symbols.js
-const unprotected = Symbol();
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/key_to_jwk.js
-async function keyToJWK(key) {
-	if (isKeyObject(key)) if (key.type === "secret") key = key.export();
-	else return key.export({ format: "jwk" });
-	if (key instanceof Uint8Array) return {
-		kty: "oct",
-		k: encode(key)
-	};
-	if (!isCryptoKey(key)) throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "Uint8Array"));
-	if (!key.extractable) throw new TypeError("non-extractable CryptoKey cannot be exported as a JWK");
-	const { ext, key_ops, alg, use, ...jwk } = await crypto.subtle.exportKey("jwk", key);
-	if (jwk.kty === "AKP") jwk.alg = alg;
-	return jwk;
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/key/export.js
-async function exportSPKI(key) {
-	return toSPKI(key);
-}
-async function exportPKCS8(key) {
-	return toPKCS8(key);
-}
-async function exportJWK(key) {
-	return keyToJWK(key);
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/encrypt_key_management.js
-async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
-	let encryptedKey;
-	let parameters;
-	let cek;
-	switch (alg) {
-		case "dir":
-			cek = key;
-			break;
-		case "ECDH-ES":
-		case "ECDH-ES+A128KW":
-		case "ECDH-ES+A192KW":
-		case "ECDH-ES+A256KW": {
-			assertCryptoKey(key);
-			if (!allowed(key)) throw new JOSENotSupported("ECDH with the provided key is not allowed or not supported by your javascript runtime");
-			const { apu, apv } = providedParameters;
-			let ephemeralKey;
-			if (providedParameters.epk) ephemeralKey = await normalizeKey(providedParameters.epk, alg);
-			else ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, true, ["deriveBits"])).privateKey;
-			const { x, y, crv, kty } = await exportJWK(ephemeralKey);
-			const sharedSecret = await deriveKey$1(key, ephemeralKey, alg === "ECDH-ES" ? enc : alg, alg === "ECDH-ES" ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
-			parameters = { epk: {
-				x,
-				crv,
-				kty
-			} };
-			if (kty === "EC") parameters.epk.y = y;
-			if (apu) parameters.apu = encode(apu);
-			if (apv) parameters.apv = encode(apv);
-			if (alg === "ECDH-ES") {
-				cek = sharedSecret;
-				break;
-			}
-			cek = providedCek || generateCek(enc);
-			encryptedKey = await wrap$2(alg.slice(-6), sharedSecret, cek);
-			break;
-		}
-		case "RSA-OAEP":
-		case "RSA-OAEP-256":
-		case "RSA-OAEP-384":
-		case "RSA-OAEP-512":
-			cek = providedCek || generateCek(enc);
-			assertCryptoKey(key);
-			encryptedKey = await encrypt$1(alg, key, cek);
-			break;
-		case "PBES2-HS256+A128KW":
-		case "PBES2-HS384+A192KW":
-		case "PBES2-HS512+A256KW": {
-			cek = providedCek || generateCek(enc);
-			const { p2c, p2s } = providedParameters;
-			({encryptedKey, ...parameters} = await wrap$1(alg, key, cek, p2c, p2s));
-			break;
-		}
-		case "A128KW":
-		case "A192KW":
-		case "A256KW":
-			cek = providedCek || generateCek(enc);
-			encryptedKey = await wrap$2(alg, key, cek);
-			break;
-		case "A128GCMKW":
-		case "A192GCMKW":
-		case "A256GCMKW": {
-			cek = providedCek || generateCek(enc);
-			const { iv } = providedParameters;
-			({encryptedKey, ...parameters} = await wrap(alg, key, cek, iv));
-			break;
-		}
-		default: throw new JOSENotSupported("Invalid or unsupported \"alg\" (JWE Algorithm) header value");
-	}
-	return {
-		cek,
-		encryptedKey,
-		parameters
-	};
-}
-//#endregion
 //#region node_modules/jose/dist/webapi/jwe/flattened/encrypt.js
 var FlattenedEncrypt = class {
 	#plaintext;
@@ -1788,22 +1795,22 @@ var FlattenedEncrypt = class {
 		this.#plaintext = plaintext;
 	}
 	setKeyManagementParameters(parameters) {
-		if (this.#keyManagementParameters) throw new TypeError("setKeyManagementParameters can only be called once");
+		assertNotSet(this.#keyManagementParameters, "setKeyManagementParameters");
 		this.#keyManagementParameters = parameters;
 		return this;
 	}
 	setProtectedHeader(protectedHeader) {
-		if (this.#protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
+		assertNotSet(this.#protectedHeader, "setProtectedHeader");
 		this.#protectedHeader = protectedHeader;
 		return this;
 	}
 	setSharedUnprotectedHeader(sharedUnprotectedHeader) {
-		if (this.#sharedUnprotectedHeader) throw new TypeError("setSharedUnprotectedHeader can only be called once");
+		assertNotSet(this.#sharedUnprotectedHeader, "setSharedUnprotectedHeader");
 		this.#sharedUnprotectedHeader = sharedUnprotectedHeader;
 		return this;
 	}
 	setUnprotectedHeader(unprotectedHeader) {
-		if (this.#unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
+		assertNotSet(this.#unprotectedHeader, "setUnprotectedHeader");
 		this.#unprotectedHeader = unprotectedHeader;
 		return this;
 	}
@@ -1812,12 +1819,12 @@ var FlattenedEncrypt = class {
 		return this;
 	}
 	setContentEncryptionKey(cek) {
-		if (this.#cek) throw new TypeError("setContentEncryptionKey can only be called once");
+		assertNotSet(this.#cek, "setContentEncryptionKey");
 		this.#cek = cek;
 		return this;
 	}
 	setInitializationVector(iv) {
-		if (this.#iv) throw new TypeError("setInitializationVector can only be called once");
+		assertNotSet(this.#iv, "setInitializationVector");
 		this.#iv = iv;
 		return this;
 	}
@@ -1872,7 +1879,7 @@ var FlattenedEncrypt = class {
 		} else additionalData = protectedHeaderB;
 		let plaintext = this.#plaintext;
 		if (joseHeader.zip === "DEF") plaintext = await compress(plaintext);
-		const { ciphertext, tag, iv } = await encrypt(enc, plaintext, cek, this.#iv, additionalData);
+		const { ciphertext, tag, iv } = await encrypt$1(enc, plaintext, cek, this.#iv, additionalData);
 		const jwe = { ciphertext: encode(ciphertext) };
 		if (iv) jwe.iv = encode(iv);
 		if (tag) jwe.tag = encode(tag);
@@ -1898,12 +1905,12 @@ var IndividualRecipient = class {
 		this.options = options;
 	}
 	setUnprotectedHeader(unprotectedHeader) {
-		if (this.unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
+		assertNotSet(this.unprotectedHeader, "setUnprotectedHeader");
 		this.unprotectedHeader = unprotectedHeader;
 		return this;
 	}
 	setKeyManagementParameters(parameters) {
-		if (this.keyManagementParameters) throw new TypeError("setKeyManagementParameters can only be called once");
+		assertNotSet(this.keyManagementParameters, "setKeyManagementParameters");
 		this.keyManagementParameters = parameters;
 		return this;
 	}
@@ -1932,12 +1939,12 @@ var GeneralEncrypt = class {
 		return recipient;
 	}
 	setProtectedHeader(protectedHeader) {
-		if (this.#protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
+		assertNotSet(this.#protectedHeader, "setProtectedHeader");
 		this.#protectedHeader = protectedHeader;
 		return this;
 	}
 	setSharedUnprotectedHeader(sharedUnprotectedHeader) {
-		if (this.#unprotectedHeader) throw new TypeError("setSharedUnprotectedHeader can only be called once");
+		assertNotSet(this.#unprotectedHeader, "setSharedUnprotectedHeader");
 		this.#unprotectedHeader = sharedUnprotectedHeader;
 		return this;
 	}
@@ -2020,70 +2027,6 @@ var GeneralEncrypt = class {
 	}
 };
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/subtle_dsa.js
-function subtleAlgorithm(alg, algorithm) {
-	const hash = `SHA-${alg.slice(-3)}`;
-	switch (alg) {
-		case "HS256":
-		case "HS384":
-		case "HS512": return {
-			hash,
-			name: "HMAC"
-		};
-		case "PS256":
-		case "PS384":
-		case "PS512": return {
-			hash,
-			name: "RSA-PSS",
-			saltLength: parseInt(alg.slice(-3), 10) >> 3
-		};
-		case "RS256":
-		case "RS384":
-		case "RS512": return {
-			hash,
-			name: "RSASSA-PKCS1-v1_5"
-		};
-		case "ES256":
-		case "ES384":
-		case "ES512": return {
-			hash,
-			name: "ECDSA",
-			namedCurve: algorithm.namedCurve
-		};
-		case "Ed25519":
-		case "EdDSA": return { name: "Ed25519" };
-		case "ML-DSA-44":
-		case "ML-DSA-65":
-		case "ML-DSA-87": return { name: alg };
-		default: throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-	}
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/get_sign_verify_key.js
-async function getSigKey(alg, key, usage) {
-	if (key instanceof Uint8Array) {
-		if (!alg.startsWith("HS")) throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
-		return crypto.subtle.importKey("raw", key, {
-			hash: `SHA-${alg.slice(-3)}`,
-			name: "HMAC"
-		}, false, [usage]);
-	}
-	checkSigCryptoKey(key, alg, usage);
-	return key;
-}
-//#endregion
-//#region node_modules/jose/dist/webapi/lib/verify.js
-async function verify(alg, key, signature, data) {
-	const cryptoKey = await getSigKey(alg, key, "verify");
-	checkKeyLength(alg, cryptoKey);
-	const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm);
-	try {
-		return await crypto.subtle.verify(algorithm, cryptoKey, signature, data);
-	} catch {
-		return false;
-	}
-}
-//#endregion
 //#region node_modules/jose/dist/webapi/jws/flattened/verify.js
 async function flattenedVerify(jws, key, options) {
 	if (!isObject(jws)) throw new JWSInvalid("Flattened JWS must be an object");
@@ -2124,20 +2067,11 @@ async function flattenedVerify(jws, key, options) {
 	}
 	checkKeyType(alg, key, "verify");
 	const data = concat(jws.protected !== void 0 ? encode$1(jws.protected) : new Uint8Array(), encode$1("."), typeof jws.payload === "string" ? b64 ? encode$1(jws.payload) : encoder.encode(jws.payload) : jws.payload);
-	let signature;
-	try {
-		signature = decode(jws.signature);
-	} catch {
-		throw new JWSInvalid("Failed to base64url decode the signature");
-	}
+	const signature = decodeBase64url(jws.signature, "signature", JWSInvalid);
 	const k = await normalizeKey(key, alg);
 	if (!await verify(alg, k, signature, data)) throw new JWSSignatureVerificationFailed();
 	let payload;
-	if (b64) try {
-		payload = decode(jws.payload);
-	} catch {
-		throw new JWSInvalid("Failed to base64url decode the payload");
-	}
+	if (b64) payload = decodeBase64url(jws.payload, "payload", JWSInvalid);
 	else if (typeof jws.payload === "string") payload = encoder.encode(jws.payload);
 	else payload = jws.payload;
 	const result = { payload };
@@ -2419,14 +2353,6 @@ var CompactEncrypt = class {
 	}
 };
 //#endregion
-//#region node_modules/jose/dist/webapi/lib/sign.js
-async function sign(alg, key, data) {
-	const cryptoKey = await getSigKey(alg, key, "sign");
-	checkKeyLength(alg, cryptoKey);
-	const signature = await crypto.subtle.sign(subtleAlgorithm(alg, cryptoKey.algorithm), cryptoKey, data);
-	return new Uint8Array(signature);
-}
-//#endregion
 //#region node_modules/jose/dist/webapi/jws/flattened/sign.js
 var FlattenedSign = class {
 	#payload;
@@ -2437,12 +2363,12 @@ var FlattenedSign = class {
 		this.#payload = payload;
 	}
 	setProtectedHeader(protectedHeader) {
-		if (this.#protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
+		assertNotSet(this.#protectedHeader, "setProtectedHeader");
 		this.#protectedHeader = protectedHeader;
 		return this;
 	}
 	setUnprotectedHeader(unprotectedHeader) {
-		if (this.#unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
+		assertNotSet(this.#unprotectedHeader, "setUnprotectedHeader");
 		this.#unprotectedHeader = unprotectedHeader;
 		return this;
 	}
@@ -2521,12 +2447,12 @@ var IndividualSignature = class {
 		this.options = options;
 	}
 	setProtectedHeader(protectedHeader) {
-		if (this.protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
+		assertNotSet(this.protectedHeader, "setProtectedHeader");
 		this.protectedHeader = protectedHeader;
 		return this;
 	}
 	setUnprotectedHeader(unprotectedHeader) {
-		if (this.unprotectedHeader) throw new TypeError("setUnprotectedHeader can only be called once");
+		assertNotSet(this.unprotectedHeader, "setUnprotectedHeader");
 		this.unprotectedHeader = unprotectedHeader;
 		return this;
 	}
@@ -2660,22 +2586,22 @@ var EncryptJWT = class {
 		return this;
 	}
 	setProtectedHeader(protectedHeader) {
-		if (this.#protectedHeader) throw new TypeError("setProtectedHeader can only be called once");
+		assertNotSet(this.#protectedHeader, "setProtectedHeader");
 		this.#protectedHeader = protectedHeader;
 		return this;
 	}
 	setKeyManagementParameters(parameters) {
-		if (this.#keyManagementParameters) throw new TypeError("setKeyManagementParameters can only be called once");
+		assertNotSet(this.#keyManagementParameters, "setKeyManagementParameters");
 		this.#keyManagementParameters = parameters;
 		return this;
 	}
 	setContentEncryptionKey(cek) {
-		if (this.#cek) throw new TypeError("setContentEncryptionKey can only be called once");
+		assertNotSet(this.#cek, "setContentEncryptionKey");
 		this.#cek = cek;
 		return this;
 	}
 	setInitializationVector(iv) {
-		if (this.#iv) throw new TypeError("setInitializationVector can only be called once");
+		assertNotSet(this.#iv, "setInitializationVector");
 		this.#iv = iv;
 		return this;
 	}
@@ -2891,7 +2817,7 @@ function isCloudflareWorkers() {
 	return typeof WebSocketPair !== "undefined" || typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime !== "undefined" && EdgeRuntime === "vercel";
 }
 let USER_AGENT;
-if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) USER_AGENT = `jose/v6.2.0`;
+if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) USER_AGENT = `jose/v6.2.1`;
 const customFetch = Symbol();
 async function fetchJwks(url, headers, signal, fetchImpl = fetch) {
 	const response = await fetchImpl(url, {
@@ -3286,4 +3212,4 @@ const cryptoRuntime = "WebCryptoAPI";
 //#endregion
 export { CompactEncrypt, CompactSign, EmbeddedJWK, EncryptJWT, FlattenedEncrypt, FlattenedSign, GeneralEncrypt, GeneralSign, SignJWT, UnsecuredJWT, base64url_exports as base64url, calculateJwkThumbprint, calculateJwkThumbprintUri, compactDecrypt, compactVerify, createLocalJWKSet, createRemoteJWKSet, cryptoRuntime, customFetch, decodeJwt, decodeProtectedHeader, errors_exports as errors, exportJWK, exportPKCS8, exportSPKI, flattenedDecrypt, flattenedVerify, generalDecrypt, generalVerify, generateKeyPair, generateSecret, importJWK, importPKCS8, importSPKI, importX509, jwksCache, jwtDecrypt, jwtVerify };
 
-//# sourceMappingURL=webapi-oTg8yaNv.mjs.map
+//# sourceMappingURL=webapi-Cj8QQOwM.mjs.map