unjwt 0.7.2 → 0.8.0

package/dist/_chunks/_internal.d.mts

@@ -0,0 +1,7 @@
+import { JOSELimits } from "./index.mjs";
+import "./index2.mjs";
+/**
+ * Default per-call work limits: 16 signatures, 16 recipients, 8 JWK Set candidates,
+ * and PBKDF2 iterations for four default-cost PBES2 attempts in total.
+ */
+export declare const DEFAULT_JOSE_LIMITS: Readonly<Required<JOSELimits>>;

package/dist/_chunks/_jwt-internal.mjs

@@ -0,0 +1,388 @@
+import { UnsecureError, base64Parse as base64Parse$1, base64Stringify as base64Stringify$1, safeJsonParse, textEncoder } from "./libs/unsecure.mjs";
+var JWTError = class extends Error {
+	code;
+	cause;
+	constructor(message, code, cause) {
+		super(message);
+		this.name = "JWTError";
+		this.code = code;
+		this.cause = cause;
+	}
+};
+function isJWTError(error, code) {
+	if (!(error instanceof JWTError)) return false;
+	return code === void 0 || error.code === code;
+}
+function isUnsecureError(error, code) {
+	if (!(error instanceof UnsecureError)) return false;
+	return code === void 0 || error.code === code;
+}
+function base64UrlStringify(data) {
+	return base64Stringify$1(data, { alphabet: "base64url" });
+}
+function base64UrlParse(input, options) {
+	const parseOptions = {
+		...options,
+		alphabet: "base64url",
+		padding: false
+	};
+	return typeof input === "string" ? base64Parse$1(input, parseOptions) : base64Parse$1(input, parseOptions);
+}
+function base64Stringify(data) {
+	return base64Stringify$1(data);
+}
+function base64Parse(input, options) {
+	const parseOptions = {
+		...options,
+		alphabet: "base64",
+		padding: true
+	};
+	return typeof input === "string" ? base64Parse$1(input, parseOptions) : base64Parse$1(input, parseOptions);
+}
+const base64UrlEncode = base64UrlStringify;
+const base64UrlDecode = base64UrlParse;
+const base64Encode = base64Stringify;
+const base64Decode = base64Parse;
+function isJWK(key) {
+	return typeof key === "object" && key !== null && "kty" in key && (key.kty === "oct" || key.kty === "RSA" || key.kty === "EC" || key.kty === "OKP");
+}
+function isJWKSet(key) {
+	return typeof key === "object" && key !== null && "keys" in key && Array.isArray(key.keys);
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function assertPlainObject(value, name) {
+	if (!isPlainObject(value)) throw new JWTError(`"${name}" must be an object.`, "ERR_INVALID_OPTION");
+}
+function assertCryptoKey(key) {
+	if (!isCryptoKey(key)) throw new JWTError("CryptoKey instance expected", "ERR_JWK_INVALID");
+}
+function isCryptoKey(key) {
+	return key?.[Symbol.toStringTag] === "CryptoKey";
+}
+const isCryptoKeyPair = (key) => typeof key === "object" && key !== null && "publicKey" in key && "privateKey" in key && isCryptoKey(key.publicKey) && isCryptoKey(key.privateKey);
+function isSymmetricJWK(key) {
+	return isJWK(key) && key.kty === "oct" && typeof key.k === "string";
+}
+function isAsymmetricJWK(key) {
+	return !isSymmetricJWK(key);
+}
+function isPrivateJWK(key) {
+	if (!isJWK(key) || key.kty === "oct") return false;
+	return "d" in key && typeof key.d === "string";
+}
+function isPublicJWK(key) {
+	if (!isJWK(key) || key.kty === "oct" || "d" in key && typeof key.d === "string") return false;
+	if (key.kty === "EC") return typeof key.x === "string" && typeof key.y === "string";
+	if (key.kty === "OKP") return typeof key.x === "string";
+	return typeof key.n === "string" && typeof key.e === "string";
+}
+function concatUint8Arrays(...arrays) {
+	const totalLength = arrays.reduce((length, arr) => length + arr.length, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+}
+function uint32be(value) {
+	if (value < 0 || value >= 2 ** 32) throw new JWTError(`value must be >= 0 and <= ${2 ** 32 - 1}. Received ${value}`, "ERR_INVALID_OPTION");
+	return new Uint8Array([
+		value >>> 24,
+		value >>> 16,
+		value >>> 8,
+		value & 255
+	]);
+}
+function maybeArray(item) {
+	return Array.isArray(item) ? item : [item];
+}
+function isJWTContent(header) {
+	if (!header) return false;
+	const typ = header.typ;
+	if (typeof typ === "string" && typ.toLowerCase().includes("jwt")) return true;
+	const declared = header.cty;
+	if (typeof declared !== "string") return false;
+	const cty = declared.toLowerCase();
+	return cty === "json" || cty === "application/json" || cty.endsWith("+json");
+}
+const TIME_CONSTANTS = Object.freeze({
+	s: 1,
+	second: 1,
+	seconds: 1,
+	m: 60,
+	minute: 60,
+	minutes: 60,
+	h: 3600,
+	hour: 3600,
+	hours: 3600,
+	D: 86400,
+	day: 86400,
+	days: 86400,
+	W: 604800,
+	week: 604800,
+	weeks: 604800,
+	M: 2592e3,
+	month: 2592e3,
+	months: 2592e3,
+	Y: 31536e3,
+	year: 31536e3,
+	years: 31536e3
+});
+const DURATION_REGEX = /^(\d+)(s|second|seconds|m|minute|minutes|h|hour|hours|D|day|days|W|week|weeks|M|month|months|Y|year|years)?$/;
+function parseDurationSeconds(value) {
+	if (typeof value === "number") {
+		if (!Number.isInteger(value)) throw new JWTError("Duration must be an integer number of seconds.", "ERR_INVALID_OPTION");
+		return value;
+	}
+	if (typeof value === "string") {
+		const match = value.match(DURATION_REGEX);
+		if (!match || !match[1]) throw new JWTError("Invalid duration format. Must be an integer or a string like '10m', '2h', '7D', etc.", "ERR_INVALID_OPTION");
+		const n = Number.parseInt(match[1], 10);
+		const unit = match[2] || "s";
+		return n * TIME_CONSTANTS[unit];
+	}
+	throw new JWTError("Duration must be a number or a string representing time.", "ERR_INVALID_OPTION");
+}
+function computeDurationInSeconds(duration) {
+	const seconds = parseDurationSeconds(duration);
+	if (seconds <= 0) throw new JWTError("Duration must be a positive integer number of seconds.", "ERR_INVALID_OPTION");
+	return seconds;
+}
+function expiredClaimMessage(exp) {
+	return `JWT "exp" (Expiration Time) Claim validation failed: Token has expired (exp: ${(/* @__PURE__ */ new Date(exp * 1e3)).toISOString()})`;
+}
+function validateJwtClaims(jwtClaims, options = {}) {
+	assertClaimValidationOptions(options);
+	const clockTolerance = _normalizeClockTolerance(options.clockTolerance);
+	const currentTime = Math.round((options.currentDate ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+	if (options.requiredClaims !== void 0 || options.issuer !== void 0 || options.audience !== void 0 || options.subject !== void 0 || options.maxTokenAge !== void 0) {
+		const allRequiredClaims = new Set(options.requiredClaims);
+		if (options.issuer !== void 0) allRequiredClaims.add("iss");
+		if (options.audience !== void 0) allRequiredClaims.add("aud");
+		if (options.subject !== void 0) allRequiredClaims.add("sub");
+		if (options.maxTokenAge !== void 0) allRequiredClaims.add("iat");
+		const missingClaims = [];
+		for (const claimName of allRequiredClaims) if (!Object.hasOwn(jwtClaims, claimName)) missingClaims.push(claimName);
+		if (missingClaims.length > 0) throw new JWTError(`Missing required JWT Claims: ${missingClaims.join(", ")}`, "ERR_JWT_CLAIM_MISSING");
+	}
+	_assertNumericDate(jwtClaims.exp, "exp", "Expiration Time");
+	_assertNumericDate(jwtClaims.nbf, "nbf", "Not Before");
+	_assertNumericDate(jwtClaims.iat, "iat", "Issued At");
+	if (options.issuer !== void 0) {
+		const expectedIssuers = maybeArray(options.issuer);
+		if (!jwtClaims.iss || !expectedIssuers.includes(jwtClaims.iss)) throw new JWTError(`Invalid JWT "iss" (Issuer) Claim: Expected ${expectedIssuers.join(" or ")}, got ${jwtClaims.iss}`, "ERR_JWT_CLAIM_INVALID");
+	}
+	if (options.subject !== void 0 && jwtClaims.sub !== options.subject) throw new JWTError(`Invalid JWT "sub" (Subject) Claim: Expected ${options.subject}, got ${jwtClaims.sub}`, "ERR_JWT_CLAIM_INVALID");
+	if (options.audience !== void 0) {
+		const expectedAudiences = maybeArray(options.audience);
+		const claimAudience = maybeArray(jwtClaims.aud || []);
+		if (!claimAudience.some((aud) => expectedAudiences.includes(aud))) throw new JWTError(`Invalid JWT "aud" (Audience) Claim: Expected ${expectedAudiences.join(" or ")}, got ${claimAudience.join(", ")}`, "ERR_JWT_CLAIM_INVALID");
+	}
+	if (typeof jwtClaims.nbf === "number" && jwtClaims.nbf > currentTime + clockTolerance) throw new JWTError(`JWT "nbf" (Not Before) Claim validation failed: Token is not yet valid (nbf: ${(/* @__PURE__ */ new Date(jwtClaims.nbf * 1e3)).toISOString()})`, "ERR_JWT_NBF");
+	if (typeof jwtClaims.exp === "number" && jwtClaims.exp <= currentTime - clockTolerance) throw new JWTError(expiredClaimMessage(jwtClaims.exp), "ERR_JWT_EXPIRED", {
+		jti: jwtClaims.jti,
+		iat: jwtClaims.iat,
+		exp: jwtClaims.exp
+	});
+	if (options.maxTokenAge !== void 0) {
+		if (typeof jwtClaims.iat !== "number") throw new JWTError("JWT \"iat\" (Issued At) Claim must be a number when maxTokenAge is set.", "ERR_JWT_CLAIM_INVALID");
+		if (jwtClaims.iat > currentTime + clockTolerance) throw new JWTError(`JWT "iat" (Issued At) Claim validation failed: Token was issued in the future (iat: ${(/* @__PURE__ */ new Date(jwtClaims.iat * 1e3)).toISOString()})`, "ERR_JWT_CLAIM_INVALID");
+		if (jwtClaims.iat < currentTime - computeDurationInSeconds(options.maxTokenAge) - clockTolerance) throw new JWTError(`JWT "iat" (Issued At) Claim validation failed: Token is too old (maxTokenAge: ${options.maxTokenAge}, iat: ${(/* @__PURE__ */ new Date(jwtClaims.iat * 1e3)).toISOString()})`, "ERR_JWT_EXPIRED", {
+			jti: jwtClaims.jti,
+			iat: jwtClaims.iat,
+			exp: jwtClaims.exp
+		});
+	}
+}
+function assertClaimValidationOptions(options) {
+	_assertExpectedValues(options.issuer, "issuer");
+	_assertExpectedValues(options.audience, "audience");
+	const subject = options.subject;
+	if (subject !== void 0 && !_isNonEmptyString(subject)) throw new JWTError("\"subject\" must be a non-empty string.", "ERR_INVALID_OPTION");
+	if (options.maxTokenAge !== void 0) computeDurationInSeconds(options.maxTokenAge);
+	assertStringList(options.requiredClaims, "requiredClaims");
+	_normalizeClockTolerance(options.clockTolerance);
+}
+function assertStringList(value, name) {
+	if (value === void 0) return;
+	if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) return;
+	throw new JWTError(`"${name}" must be an array of strings.`, "ERR_INVALID_OPTION");
+}
+function _normalizeClockTolerance(value) {
+	if (value === void 0) return 0;
+	let seconds;
+	if (typeof value === "number") seconds = value;
+	else if (typeof value === "string") try {
+		seconds = computeDurationInSeconds(value);
+	} catch {
+		throw _invalidClockTolerance();
+	}
+	else throw _invalidClockTolerance();
+	if (!Number.isFinite(seconds) || seconds < 0) throw _invalidClockTolerance();
+	return seconds;
+}
+function _invalidClockTolerance() {
+	return new JWTError("clockTolerance must be a non-negative number of seconds or a Duration.", "ERR_INVALID_OPTION");
+}
+function _assertExpectedValues(value, name) {
+	if (value === void 0 || _isNonEmptyString(value)) return;
+	if (Array.isArray(value) && value.every((entry) => _isNonEmptyString(entry))) return;
+	throw new JWTError(`"${name}" must be a non-empty string or an array of non-empty strings.`, "ERR_INVALID_OPTION");
+}
+function _isNonEmptyString(value) {
+	return typeof value === "string" && value !== "";
+}
+function _assertNumericDate(value, claim, label) {
+	if (value === void 0) return;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new JWTError(`JWT "${claim}" (${label}) Claim must be a number.`, "ERR_JWT_CLAIM_INVALID");
+	if (value < 0) throw new JWTError(`JWT "${claim}" (${label}) Claim must be a non-negative NumericDate.`, "ERR_JWT_CLAIM_INVALID");
+}
+function applyTypDefault(header, payload) {
+	const declared = header.typ;
+	if (declared !== void 0 && typeof declared !== "string") throw new JWTError("\"typ\" must be a string.", "ERR_INVALID_OPTION");
+	if (declared === void 0 && typeof payload === "object" && payload !== null && !(payload instanceof Uint8Array)) header.typ = "JWT";
+	return header;
+}
+function parsePayloadBytes(bytes, options) {
+	const mode = options?.payload ?? "json";
+	if (mode === "bytes") return bytes;
+	const family = options?.family ?? "JWS";
+	const text = parsePayloadText(bytes, { family });
+	if (mode === "string") return text;
+	return _parsePayloadObject(text, family);
+}
+function parsePayloadText(bytes, options) {
+	const family = options?.family ?? "JWS";
+	try {
+		return _utf8Decoder.decode(bytes);
+	} catch (error) {
+		throw new JWTError(`Invalid ${family}: Payload is not valid UTF-8.`, `ERR_${family}_INVALID`, error);
+	}
+}
+function parsePayloadSegment(payloadEncoded, options) {
+	return parsePayloadBytes(base64UrlParse(payloadEncoded, { returnAs: "uint8array" }), options);
+}
+function getPlaintextBytes(payload) {
+	if (payload instanceof Uint8Array) return payload;
+	if (typeof payload === "string") return textEncoder.encode(payload);
+	if (typeof payload === "object" && payload !== null) {
+		let json;
+		try {
+			json = JSON.stringify(payload);
+		} catch (error) {
+			throw new JWTError("Payload is not JSON-serializable.", "ERR_INVALID_OPTION", error);
+		}
+		return textEncoder.encode(json);
+	}
+	throw new JWTError("Plaintext must be a string, Uint8Array, or a JSON-serializable object.", "ERR_INVALID_OPTION");
+}
+function computeJwtTimeClaims(payload, options) {
+	const { currentDate, expiresIn, expiresAt, notBeforeIn, notBeforeAt } = options ?? {};
+	if (expiresIn !== void 0 && expiresAt !== void 0) throw new JWTError("\"expiresIn\" and \"expiresAt\" are mutually exclusive; pass only one.", "ERR_JWT_CLAIM_INVALID");
+	if (notBeforeIn !== void 0 && notBeforeAt !== void 0) throw new JWTError("\"notBeforeIn\" and \"notBeforeAt\" are mutually exclusive; pass only one.", "ERR_JWT_CLAIM_INVALID");
+	const hasExpHint = expiresIn !== void 0 || expiresAt !== void 0;
+	const hasNbfHint = notBeforeIn !== void 0 || notBeforeAt !== void 0;
+	if (!hasExpHint && !hasNbfHint) return void 0;
+	if (!payload || typeof payload !== "object" || payload instanceof Uint8Array) return void 0;
+	const wantsExp = hasExpHint && (!("exp" in payload) || payload.exp === void 0);
+	const wantsNbf = hasNbfHint && (!("nbf" in payload) || payload.nbf === void 0);
+	if (!wantsExp && !wantsNbf) return void 0;
+	const now = Math.round((currentDate ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+	const claims = { ...payload };
+	claims.iat ||= now;
+	if (wantsExp) {
+		if (expiresAt !== void 0) claims.exp = Math.floor(_instantOf(expiresAt, "expiresAt") / 1e3);
+		else if (expiresIn !== void 0) claims.exp = claims.iat + computeDurationInSeconds(expiresIn);
+	}
+	if (wantsNbf) {
+		if (notBeforeAt !== void 0) claims.nbf = Math.floor(_instantOf(notBeforeAt, "notBeforeAt") / 1e3);
+		else if (notBeforeIn !== void 0) {
+			const offset = parseDurationSeconds(notBeforeIn);
+			if (offset < 0) throw new JWTError("\"notBeforeIn\" must be zero or a positive duration.", "ERR_JWT_CLAIM_INVALID");
+			claims.nbf = claims.iat + offset;
+		}
+	}
+	return claims;
+}
+const BASE_PROCESSED = /* @__PURE__ */ Object.freeze({
+	JWS: ["b64"],
+	JWE: []
+});
+function validateCriticalHeadersJWS(protectedHeader, recognizedHeaders) {
+	validateCriticalHeaders(protectedHeader, {
+		family: "JWS",
+		recognizedHeaders
+	});
+}
+function validateCriticalHeadersJWE(protectedHeader, recognizedHeaders) {
+	validateCriticalHeaders(protectedHeader, {
+		family: "JWE",
+		recognizedHeaders
+	});
+}
+const REGISTERED_HEADER_PARAMS = /* @__PURE__ */ new Set([
+	"alg",
+	"enc",
+	"zip",
+	"jku",
+	"jwk",
+	"kid",
+	"x5u",
+	"x5c",
+	"x5t",
+	"x5t#S256",
+	"typ",
+	"cty",
+	"crit",
+	"epk",
+	"apu",
+	"apv",
+	"iv",
+	"tag",
+	"p2s",
+	"p2c"
+]);
+function assertCritShape(crit, options) {
+	const { family } = options;
+	const code = options.code ?? `ERR_${family}_INVALID`;
+	if (!Array.isArray(crit) || crit.length === 0 || crit.some((param) => typeof param !== "string")) throw new JWTError(`Invalid ${family}: "crit" must be a non-empty array of strings.`, code);
+	for (const param of crit) if (REGISTERED_HEADER_PARAMS.has(param)) throw new JWTError(`Invalid ${family}: "crit" must not list registered header parameters.`, code);
+}
+function _instantOf(value, name) {
+	const ms = value instanceof Date ? value.getTime() : NaN;
+	if (!Number.isFinite(ms)) throw new JWTError(`"${name}" must be a valid Date.`, "ERR_INVALID_OPTION");
+	return ms;
+}
+const _utf8Decoder = /* @__PURE__ */ new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+function _parsePayloadObject(text, family) {
+	const code = `ERR_${family}_INVALID`;
+	const message = `Invalid ${family}: Payload is not a JSON object.`;
+	let parsed;
+	try {
+		parsed = safeJsonParse(text);
+	} catch (error) {
+		throw new JWTError(message, code, error);
+	}
+	if (!isPlainObject(parsed)) throw new JWTError(message, code);
+	return parsed;
+}
+function validateCriticalHeaders(protectedHeader, options) {
+	const { crit } = protectedHeader;
+	if (crit === void 0) return;
+	const { family, recognizedHeaders = [] } = options;
+	assertCritShape(crit, { family });
+	for (const param of crit) {
+		if (!Object.hasOwn(protectedHeader, param)) throw new JWTError(`Critical header parameter "${param}" listed in "crit" but not present in the protected header.`, `ERR_${family}_INVALID`);
+		if (!recognizedHeaders.includes(param) && !BASE_PROCESSED[family].includes(param)) throw new JWTError(`Unprocessed critical header parameters: ${param}`, `ERR_${family}_INVALID`);
+	}
+}
+export { JWTError, applyTypDefault, assertClaimValidationOptions, assertCritShape, assertCryptoKey, assertPlainObject, assertStringList, base64Decode, base64Encode, base64Parse, base64Stringify, base64UrlDecode, base64UrlEncode, base64UrlParse, base64UrlStringify, computeDurationInSeconds, computeJwtTimeClaims, concatUint8Arrays, expiredClaimMessage, getPlaintextBytes, isAsymmetricJWK, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet, isJWTContent, isJWTError, isPlainObject, isPrivateJWK, isPublicJWK, isSymmetricJWK, isUnsecureError, maybeArray, parsePayloadBytes, parsePayloadSegment, parsePayloadText, uint32be, validateCriticalHeadersJWE, validateCriticalHeadersJWS, validateJwtClaims };

package/dist/_chunks/algorithms.mjs

@@ -0,0 +1,186 @@
+import { JWTError, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet } from "./_jwt-internal.mjs";
+const ECDSA_CURVES = /* @__PURE__ */ Object.freeze({
+	ES256: "P-256",
+	ES384: "P-384",
+	ES512: "P-521"
+});
+function jwsHashOf(alg) {
+	return `SHA-${alg.slice(-3)}`;
+}
+function rsaOaepHashOf(alg) {
+	return `SHA-${Number.parseInt(alg.slice(9), 10) || 1}`;
+}
+function aesBitsOf(alg) {
+	return Number.parseInt(alg.slice(1, 4), 10);
+}
+function innerKeyWrapAlg(alg) {
+	return alg.slice(-6);
+}
+function namedCurveOf(algorithm) {
+	return "namedCurve" in algorithm && typeof algorithm.namedCurve === "string" ? algorithm.namedCurve : void 0;
+}
+function cryptoKeyCurve(key) {
+	const { algorithm } = key;
+	return namedCurveOf(algorithm) ?? (algorithm.name === "X25519" ? algorithm.name : void 0);
+}
+function hashNameOf(algorithm) {
+	if (!("hash" in algorithm)) return void 0;
+	const { hash } = algorithm;
+	return typeof hash === "object" && hash !== null && "name" in hash && typeof hash.name === "string" ? hash.name : void 0;
+}
+function lengthOf(algorithm) {
+	return "length" in algorithm && typeof algorithm.length === "number" ? algorithm.length : void 0;
+}
+function modulusLengthOf(algorithm) {
+	return "modulusLength" in algorithm && typeof algorithm.modulusLength === "number" ? algorithm.modulusLength : void 0;
+}
+function hashBitsOf(hash) {
+	return Number.parseInt(hash.name.slice(4), 10);
+}
+function isAlgorithm(algorithm, name) {
+	return algorithm.name === name;
+}
+function unusableKey(name, prop = "algorithm.name") {
+	return new JWTError(`CryptoKey does not support this operation, its ${prop} must be ${name}`, "ERR_JWK_INVALID");
+}
+function checkKeyUsage(key, usage) {
+	if (usage && !key.usages.includes(usage)) throw new JWTError(`CryptoKey does not support this operation, its usages must include ${usage}.`, "ERR_JWK_INVALID");
+}
+const PBES2_ALGORITHMS = [
+	"PBES2-HS256+A128KW",
+	"PBES2-HS384+A192KW",
+	"PBES2-HS512+A256KW"
+];
+const ECDH_ES_ALGORITHMS = [
+	"ECDH-ES",
+	"ECDH-ES+A128KW",
+	"ECDH-ES+A192KW",
+	"ECDH-ES+A256KW"
+];
+function inferJWSAllowedAlgorithms(key, options) {
+	if (!key || typeof key === "function") return void 0;
+	if (typeof key === "string" || key instanceof Uint8Array) return void 0;
+	if (typeof key !== "object") return void 0;
+	if (isCryptoKeyPair(key)) return inferJWSAllowedAlgorithms(key.publicKey);
+	if (isJWKSet(key)) return unionFromJWKSet(key.keys, jwsAlgsFromJWK, options);
+	if (isCryptoKey(key)) return jwsAlgsFromCryptoKey(key);
+	if (isJWK(key)) return jwsAlgsFromJWK(key);
+}
+function inferJWEAllowedAlgorithms(key, options) {
+	if (!key || typeof key === "function") return void 0;
+	if (typeof key === "string") return [...PBES2_ALGORITHMS];
+	if (key instanceof Uint8Array) return void 0;
+	if (typeof key !== "object") return void 0;
+	if (isCryptoKeyPair(key)) return inferJWEAllowedAlgorithms(key.privateKey);
+	if (isJWKSet(key)) return unionFromJWKSet(key.keys, jweAlgsFromJWK, options);
+	if (isCryptoKey(key)) return jweAlgsFromCryptoKey(key);
+	if (isJWK(key)) return jweAlgsFromJWK(key);
+}
+function unionFromJWKSet(keys, mapper, options) {
+	const algs = /* @__PURE__ */ new Set();
+	for (const k of keys) {
+		if (!isJWK(k)) continue;
+		if (k.kty === "oct" && !options?.allowSymmetric) continue;
+		const mapped = mapper(k);
+		if (!mapped) continue;
+		for (const a of mapped) algs.add(a);
+	}
+	return algs.size > 0 ? [...algs] : void 0;
+}
+function isEd25519Signature(alg) {
+	return alg === "EdDSA" || alg === "Ed25519";
+}
+function jwsAlgsFromJWK(jwk) {
+	if (jwk.alg && isEd25519Signature(jwk.alg)) return ["EdDSA", "Ed25519"];
+	if (jwk.alg) return declaredAlgorithm(jwk.alg);
+	if (jwk.kty === "EC") {
+		const crv = jwk.crv;
+		if (crv === "P-256") return ["ES256"];
+		if (crv === "P-384") return ["ES384"];
+		if (crv === "P-521") return ["ES512"];
+	}
+	if (jwk.kty === "OKP") {
+		if (jwk.crv === "Ed25519") return ["EdDSA", "Ed25519"];
+	}
+}
+function jweAlgsFromJWK(jwk) {
+	if (jwk.kty === "oct") return jweAlgsFromOctJWK(jwk);
+	if (jwk.alg) return declaredAlgorithm(jwk.alg);
+	if (jwk.kty === "EC") {
+		const crv = jwk.crv;
+		if (crv === "P-256" || crv === "P-384" || crv === "P-521") return [...ECDH_ES_ALGORITHMS];
+	}
+	if (jwk.kty === "OKP") {
+		if (jwk.crv === "X25519") return [...ECDH_ES_ALGORITHMS];
+	}
+}
+function jweAlgsFromOctJWK(jwk) {
+	const alg = jwk.alg;
+	if (!alg) return void 0;
+	if (isContentEncryptionAlgorithm(alg)) return ["dir"];
+	return declaredAlgorithm(alg);
+}
+function isContentEncryptionAlgorithm(alg) {
+	return CONTENT_ENCRYPTION_ALGORITHMS.has(alg);
+}
+const CONTENT_ENCRYPTION_ALGORITHMS = /* @__PURE__ */ new Set([
+	"A128GCM",
+	"A192GCM",
+	"A256GCM",
+	"A128CBC-HS256",
+	"A192CBC-HS384",
+	"A256CBC-HS512"
+]);
+function jwsAlgsFromCryptoKey(key) {
+	const name = key.algorithm.name;
+	const hashBits = jwsHashBits(hashNameOf(key.algorithm));
+	switch (name) {
+		case "HMAC": return hashBits ? [`HS${hashBits}`] : void 0;
+		case "RSASSA-PKCS1-v1_5": return hashBits ? [`RS${hashBits}`] : void 0;
+		case "RSA-PSS": return hashBits ? [`PS${hashBits}`] : void 0;
+		case "ECDSA": {
+			const curve = namedCurveOf(key.algorithm);
+			if (curve === "P-256") return ["ES256"];
+			if (curve === "P-384") return ["ES384"];
+			if (curve === "P-521") return ["ES512"];
+			return;
+		}
+		case "Ed25519": return ["EdDSA", "Ed25519"];
+		default: return;
+	}
+}
+function jweAlgsFromCryptoKey(key) {
+	const name = key.algorithm.name;
+	const hashName = hashNameOf(key.algorithm);
+	const length = lengthOf(key.algorithm);
+	switch (name) {
+		case "AES-KW":
+			if (length === 128) return ["A128KW", "dir"];
+			if (length === 192) return ["A192KW", "dir"];
+			if (length === 256) return ["A256KW", "dir"];
+			return;
+		case "AES-GCM":
+			if (length === 128) return ["A128GCMKW", "dir"];
+			if (length === 192) return ["A192GCMKW", "dir"];
+			if (length === 256) return ["A256GCMKW", "dir"];
+			return;
+		case "RSA-OAEP":
+			if (hashName === "SHA-1") return ["RSA-OAEP"];
+			if (hashName === "SHA-256") return ["RSA-OAEP-256"];
+			if (hashName === "SHA-384") return ["RSA-OAEP-384"];
+			if (hashName === "SHA-512") return ["RSA-OAEP-512"];
+			return;
+		case "ECDH":
+		case "X25519": return [...ECDH_ES_ALGORITHMS];
+		default: return;
+	}
+}
+function jwsHashBits(hashName) {
+	if (hashName === "SHA-256") return "256";
+	if (hashName === "SHA-384") return "384";
+	if (hashName === "SHA-512") return "512";
+}
+function declaredAlgorithm(alg) {
+	return [alg];
+}
+export { ECDSA_CURVES, PBES2_ALGORITHMS, aesBitsOf, checkKeyUsage, cryptoKeyCurve, hashBitsOf, inferJWEAllowedAlgorithms, inferJWSAllowedAlgorithms, innerKeyWrapAlg, isAlgorithm, isContentEncryptionAlgorithm, isEd25519Signature, jwsHashOf, lengthOf, modulusLengthOf, namedCurveOf, rsaOaepHashOf, unusableKey };