unjwt 0.8.5 → 0.9.1

package/dist/_chunks/jws.mjs

@@ -1,8 +1,9 @@
 import { textEncoder } from "./libs/unsecure.mjs";
 import { JWTError } from "../error.mjs";
-import { applyTypDefault, base64UrlStringify, computeJwtTimeClaims, getPlaintextBytes, isJWK, isJWKSet, parsePayloadBytes, parsePayloadSegment, parsePayloadText, validateCriticalHeadersJWS } from "./jwt.mjs";
-import { JWS_ALG_CTX, asJWTError, asKeyLookupError, assertCompactToken, assertConsumerOptions, assertEntryLimit, assertJWKSetCandidates, assertOctKeyLength, assertOptionEntry, assertProducerConfirmation, assertProducerCrit, assertProducerKeyHeaders, assertProtectedOnlyOption, assertSerializationObject, buildJWKSetFilter, checkAlgAllowed, checkAlgSupported, checkProtectedTyp, checkSerializationEntry, copyJsonObject, decodeProtectedHeader, decodeSegment, getJWKsFromSet, importKey, keyMatchesHeader, resolveKeyInput, resolveLimit, serializeProtectedHeader, sign as sign$1, stringKeyError, verify as verify$1 } from "./algorithms.mjs";
-import { inferJWSAllowedAlgorithms, isJWSAlgorithm, jwsHashOf, modulusLengthOf } from "./digest.mjs";
+import { base64UrlStringify, isJWK, isJWKSet } from "./jwt.mjs";
+import { applyTypDefault, computeJwtTimeClaims, getPlaintextBytes, parsePayloadBytes, parsePayloadSegment, parsePayloadText, validateCriticalHeadersJWS } from "./jwt2.mjs";
+import { JWS_ALG_CTX, asJWTError, asKeyLookupError, assertCompactToken, assertConsumerOptions, assertEntryLimit, assertJWKSetCandidates, assertOctKeyLength, assertOptionEntry, assertProducerConfirmation, assertProducerCrit, assertProducerKeyHeaders, assertProtectedOnlyOption, assertSerializationObject, buildJWKSetFilter, checkAlgAllowed, checkAlgSupported, checkProtectedTyp, checkSerializationEntry, copyJsonObject, createKeyAttemptBudget, decodeProtectedHeader, decodeSegment, getJWKsFromSet, importKey, keyMatchesHeader, resolveKeyInput, resolveLimit, serializeProtectedHeader, sign as sign$1, stringKeyError, verify as verify$1 } from "./algorithms.mjs";
+import { inferJWSAllowedAlgorithms, isJWSAlgorithm, jwsAlgsFromJWK, jwsHashOf, modulusLengthOf } from "./digest.mjs";
 import { resolvePayloadMode, validateClaimsIfJson } from "./payload.mjs";
 async function resolveSigningKey(alg, key, usage) {
 	if (key instanceof Uint8Array) {
@@ -19,6 +20,9 @@ async function resolveSigningKey(alg, key, usage) {
 	}
 	return key;
 }
+function signingAlgOf(jwk) {
+	return jwk.alg ?? jwsAlgsFromJWK(jwk)?.[0];
+}
 function assertNotStringKey(key) {
 	if (typeof key === "string") throw stringKeyError();
 }
@@ -107,32 +111,33 @@ async function verifyWithKey(alg, rawKeyMaterial, options) {
 	}
 }
 async function verifyWithKeyMaterial(alg, rawKeyMaterial, options) {
-	const { signature, signingInput, kid, allowSymmetric, keyCandidates } = options;
+	const { signature, signingInput, kid, keyCandidates, keyAttempts } = options;
 	if (isJWKSet(rawKeyMaterial)) {
 		const candidates = getJWKsFromSet(rawKeyMaterial, buildJWKSetFilter({
 			kid,
 			alg
-		}, {
-			op: "sig",
-			allowSymmetric
-		}));
+		}, { op: "sig" }));
 		assertJWKSetCandidates(candidates, {
 			limit: keyCandidates,
 			kid
 		});
 		const attempts = [];
-		for (const candidate of candidates) try {
-			const verificationKey = await resolveSigningKey(alg, await importKey(candidate, {
-				alg,
-				expect: "public"
-			}), "verify");
-			if (await verify$1(alg, verificationKey, signature, signingInput)) return true;
-			attempts.push(new JWTError("JWS signature verification failed.", "ERR_JWS_SIGNATURE_INVALID"));
-		} catch (error) {
-			attempts.push(asKeyUsageError(error, alg));
+		for (const candidate of candidates) {
+			keyAttempts?.spend();
+			try {
+				const verificationKey = await resolveSigningKey(alg, await importKey(candidate, {
+					alg,
+					expect: "public"
+				}), "verify");
+				if (await verify$1(alg, verificationKey, signature, signingInput)) return true;
+				attempts.push(new JWTError("JWS signature verification failed.", "ERR_JWS_SIGNATURE_INVALID"));
+			} catch (error) {
+				attempts.push(asKeyUsageError(error, alg));
+			}
 		}
 		throw new JWTError("JWS signature verification failed.", "ERR_JWS_SIGNATURE_INVALID", attempts);
 	}
+	keyAttempts?.spend();
 	const verificationKey = await resolveSigningKey(alg, await importKey(rawKeyMaterial, {
 		alg,
 		expect: "public"
@@ -212,8 +217,8 @@ function _resolveSignerAlg(signer, index) {
 }
 function _inferSignerAlg(key, index) {
 	if (isJWK(key)) {
-		const alg = key.alg;
-		if (!alg) throw new JWTError(`Cannot infer "alg" for signer[${index}]: the JWK has no "alg" property.`, "ERR_JWS_SIGNER_ALG_INFERENCE");
+		const alg = signingAlgOf(key);
+		if (!alg) throw new JWTError(`Cannot infer "alg" for signer[${index}]: the JWK has no "alg" property and its key allows more than one.`, "ERR_JWS_SIGNER_ALG_INFERENCE");
 		return alg;
 	}
 	const inferred = inferJWSAllowedAlgorithms(key);
@@ -269,7 +274,7 @@ function _normalizeSerialization(input) {
 	throw new JWTError("Invalid JWS JSON Serialization: missing \"signatures\" or \"signature\".", "ERR_JWS_INVALID_SERIALIZATION");
 }
 async function _verifyOneSignature(payload, entry, index, keyResolver, context) {
-	const { options, payloadMode, keyCandidates } = context;
+	const { options, payloadMode, keyCandidates, keyAttempts } = context;
 	const fail = (error, protectedHeader, signerHeader) => {
 		const outcome = {
 			signerIndex: index,
@@ -301,8 +306,7 @@ async function _verifyOneSignature(payload, entry, index, keyResolver, context)
 	if (typeof rawKeyMaterial === "string") return fail(stringKeyError(), protectedHeader, unprotectedHeader);
 	const algError = checkAlgAllowed(alg, rawKeyMaterial, {
 		ctx: JWS_ALG_CTX,
-		algorithms: options.algorithms,
-		allowSymmetric: options.allowSymmetricJWKSet
+		algorithms: options.algorithms
 	});
 	if (algError) return fail(algError, protectedHeader, unprotectedHeader);
 	let signatureBytes;
@@ -321,10 +325,11 @@ async function _verifyOneSignature(payload, entry, index, keyResolver, context)
 			signature: signatureBytes,
 			signingInput: signingInputBytes,
 			kid: effective.kid,
-			allowSymmetric: options.allowSymmetricJWKSet,
-			keyCandidates
+			keyCandidates,
+			keyAttempts
 		});
 	} catch (err) {
+		if (keyAttempts.exhausted) throw keyAttempts.exhausted;
 		return fail(asJWTError(err, INVALID_SIGNATURE), protectedHeader, unprotectedHeader);
 	}
 	if (!verified) return fail(new JWTError(`JWS signature[${index}] verification failed.`, "ERR_JWS_SIGNATURE_INVALID"), protectedHeader, unprotectedHeader);
@@ -423,13 +428,14 @@ async function verifyMulti(jws, keyOrLookup, options = {}) {
 	const payloadMode = resolvePayloadMode(options);
 	const signatureLimit = resolveLimit(options.limits, "signatures");
 	const keyCandidates = resolveLimit(options.limits, "keyCandidates");
+	const keyAttempts = createKeyAttemptBudget(resolveLimit(options.limits, "keyAttempts"));
 	const general = _readGeneralSerialization(jws, signatureLimit);
-	let lastError;
+	const failures = [];
 	let cryptoAttempted = false;
 	for (let i = 0; i < general.signatures.length; i++) {
 		const read = _readSignatureHeaders(general.signatures[i], i);
 		if (read.error) {
-			lastError = read.error;
+			failures.push(read.error);
 			continue;
 		}
 		const { wireSig, protectedHeader, unprotectedHeader, effective, alg } = read;
@@ -438,7 +444,7 @@ async function verifyMulti(jws, keyOrLookup, options = {}) {
 			label: `signature[${i}]`
 		});
 		if (typError) {
-			lastError = typError;
+			failures.push(typError);
 			continue;
 		}
 		let rawKeyMaterial;
@@ -449,26 +455,25 @@ async function verifyMulti(jws, keyOrLookup, options = {}) {
 				what: `signature[${i}]`
 			});
 		} catch (err) {
-			lastError = asKeyLookupError(err, `signature[${i}]`);
+			failures.push(asKeyLookupError(err, `signature[${i}]`));
 			continue;
 		}
 		if (typeof rawKeyMaterial === "string") {
-			lastError = stringKeyError();
+			failures.push(stringKeyError());
 			continue;
 		}
 		const algError = checkAlgAllowed(alg, rawKeyMaterial, {
 			ctx: JWS_ALG_CTX,
-			algorithms: options.algorithms,
-			allowSymmetric: options.allowSymmetricJWKSet
+			algorithms: options.algorithms
 		});
 		if (algError) {
-			lastError = algError;
+			failures.push(algError);
+			continue;
+		}
+		if (options.strictSignerMatch && !keyMatchesHeader(effective, rawKeyMaterial, { ctx: JWS_ALG_CTX })) {
+			failures.push(new JWTError(`JWS signature[${i}] does not match the key under strictSignerMatch.`, "ERR_JWS_NO_MATCHING_SIGNER"));
 			continue;
 		}
-		if (options.strictSignerMatch && !keyMatchesHeader(effective, rawKeyMaterial, {
-			ctx: JWS_ALG_CTX,
-			allowSymmetric: options.allowSymmetricJWKSet
-		})) continue;
 		let signatureBytes;
 		try {
 			signatureBytes = decodeSegment(wireSig.signature, {
@@ -476,7 +481,7 @@ async function verifyMulti(jws, keyOrLookup, options = {}) {
 				what: "Signature"
 			});
 		} catch (err) {
-			lastError = asJWTError(err, INVALID_JWS);
+			failures.push(asJWTError(err, INVALID_JWS));
 			continue;
 		}
 		const signingInputBytes = textEncoder.encode(`${wireSig.protected ?? ""}.${general.payload}`);
@@ -486,10 +491,10 @@ async function verifyMulti(jws, keyOrLookup, options = {}) {
 				signature: signatureBytes,
 				signingInput: signingInputBytes,
 				kid: effective.kid,
-				allowSymmetric: options.allowSymmetricJWKSet,
-				keyCandidates
+				keyCandidates,
+				keyAttempts
 			})) {
-				lastError = new JWTError("JWS signature verification failed.", "ERR_JWS_SIGNATURE_INVALID");
+				failures.push(new JWTError("JWS signature verification failed.", "ERR_JWS_SIGNATURE_INVALID"));
 				continue;
 			}
 			validateCriticalHeadersJWS(protectedHeader, options.recognizedHeaders);
@@ -504,25 +509,29 @@ async function verifyMulti(jws, keyOrLookup, options = {}) {
 			if (unprotectedHeader) result.signerHeader = unprotectedHeader;
 			return result;
 		} catch (err) {
+			if (keyAttempts.exhausted) throw keyAttempts.exhausted;
 			const error = asJWTError(err, INVALID_SIGNATURE);
 			if (!PER_SIGNATURE_ERROR_CODES.has(error.code)) throw error;
-			lastError = error;
+			failures.push(error);
 		}
 	}
 	if (options.strictSignerMatch && !cryptoAttempted) throw new JWTError("No signature matched the provided key under strictSignerMatch.", "ERR_JWS_NO_MATCHING_SIGNER");
-	throw lastError ?? new JWTError("JWS signature verification failed.", "ERR_JWS_SIGNATURE_INVALID");
+	if (failures.length === 1) throw failures[0];
+	throw new JWTError(INVALID_SIGNATURE.message, INVALID_SIGNATURE.code, failures);
 }
 async function verifyMultiAll(jws, keyResolver, options = {}) {
 	assertConsumerOptions(options);
 	const payloadMode = resolvePayloadMode(options);
 	const signatureLimit = resolveLimit(options.limits, "signatures");
 	const keyCandidates = resolveLimit(options.limits, "keyCandidates");
+	const keyAttempts = createKeyAttemptBudget(resolveLimit(options.limits, "keyAttempts"));
 	const general = _readGeneralSerialization(jws, signatureLimit);
 	const outcomes = [];
 	for (let i = 0; i < general.signatures.length; i++) outcomes.push(await _verifyOneSignature(general.payload, general.signatures[i], i, keyResolver, {
 		options,
 		payloadMode,
-		keyCandidates
+		keyCandidates,
+		keyAttempts
 	}));
 	return outcomes;
 }
@@ -552,10 +561,8 @@ async function sign(payload, key, options = {}) {
 	});
 	assertProducerConfirmation(payload);
 	let { alg } = options;
-	if (!alg) {
-		if (isJWK(key) && key.alg) alg = key.alg;
-		else throw new JWTError("JWS \"alg\" must be provided in options", "ERR_JWS_ALG_MISSING");
-	}
+	alg ??= isJWK(key) ? signingAlgOf(key) : void 0;
+	if (!alg) throw new JWTError("JWS \"alg\" must be provided in options or inferable from the key", "ERR_JWS_ALG_MISSING");
 	assertJWSAlgSupported(alg);
 	let signingKey;
 	try {
@@ -614,15 +621,13 @@ async function verify(jws, key, options = {}) {
 	assertNotStringKey(keyInput);
 	const algError = checkAlgAllowed(alg, keyInput, {
 		ctx: JWS_ALG_CTX,
-		algorithms: options.algorithms,
-		allowSymmetric: options.allowSymmetricJWKSet
+		algorithms: options.algorithms
 	});
 	if (algError) throw algError;
 	if (!await verifyWithKey(alg, keyInput, {
 		signature: signatureBytes,
 		signingInput: textEncoder.encode(`${protectedHeaderEncoded}.${payloadEncoded}`),
 		kid: protectedHeader.kid,
-		allowSymmetric: options.allowSymmetricJWKSet,
 		keyCandidates: keyCandidateLimit
 	})) throw new JWTError("JWS signature verification failed.", "ERR_JWS_SIGNATURE_INVALID");
 	validateCriticalHeadersJWS(protectedHeader, options.recognizedHeaders);

package/dist/_chunks/jwt.d.mts

@@ -1,58 +1,22 @@
-import { JWTErrorCode } from "./error.mjs";
-import { Duration, JOSEPayload, JOSEPayloadMode, JWTClaimValidationOptions, JWTClaims, JWTTimeClaimOptions, PayloadOf } from "./index.mjs";
-/** Set `typ: "JWT"` on a header without `typ` when the payload is an object (not a `Uint8Array`). */
-export declare function applyTypDefault<T extends {
-  typ?: string;
-}>(header: T, payload: unknown): T;
-/** Options for {@link parsePayloadBytes} and {@link parsePayloadSegment}. */
-export interface ParsePayloadOptions<Mode extends JOSEPayloadMode = JOSEPayloadMode> {
-  /** How to interpret the payload bytes; the return type follows it. @default "json" */
-  payload?: Mode;
-  /** Family the rejection is reported under (`ERR_JWS_INVALID` / `ERR_JWE_INVALID`). @default "JWS" */
-  family?: "JWS" | "JWE";
-}
-/** Parse payload bytes under the declared mode: `"json"` needs a UTF-8 JSON object, `"string"` UTF-8; throws `ERR_JWS_INVALID` / `ERR_JWE_INVALID`. */
-export declare function parsePayloadBytes<T = JWTClaims>(bytes: Uint8Array<ArrayBuffer>, options?: ParsePayloadOptions<"json">): T;
-export declare function parsePayloadBytes<Mode extends JOSEPayloadMode = JOSEPayloadMode>(bytes: Uint8Array<ArrayBuffer>, options?: ParsePayloadOptions<Mode>): PayloadOf<Mode>;
-/** Decode payload bytes as UTF-8; throws `ERR_JWS_INVALID` / `ERR_JWE_INVALID` otherwise. */
-export declare function parsePayloadText(bytes: Uint8Array<ArrayBuffer>, options?: Pick<ParsePayloadOptions, "family">): string;
-/** {@link parsePayloadBytes} over a Base64URL-encoded payload segment. */
-export declare function parsePayloadSegment<T = JWTClaims>(payloadEncoded: string, options?: ParsePayloadOptions<"json">): T;
-export declare function parsePayloadSegment<Mode extends JOSEPayloadMode = JOSEPayloadMode>(payloadEncoded: string, options?: ParsePayloadOptions<Mode>): PayloadOf<Mode>;
-/** Encode a payload to bytes; a non-serializable one throws `ERR_INVALID_OPTION`. */
-export declare function getPlaintextBytes(payload: JOSEPayload): Uint8Array<ArrayBuffer>;
-/** Options for {@link computeJwtTimeClaims}. */
-export type ComputeJwtTimeClaimsOptions = JWTTimeClaimOptions;
-/**
- * Return a copy of an object payload with `iat` and the requested `exp` / `nbf`, or `undefined` when none applies.
- * `currentDate` is the clock: `iat` when written, and the base of `expiresIn` / `notBeforeIn`;
- * `issuedAt` writes `iat` alone, a `Date` as that instant. Both members of `expiresIn`/`expiresAt` or `notBeforeIn`/`notBeforeAt` throw `ERR_JWT_CLAIM_INVALID`.
- */
-export declare function computeJwtTimeClaims(payload: unknown, options?: ComputeJwtTimeClaimsOptions): JWTClaims | undefined;
-/** Validate critical headers in JWS semantics. */
-export declare function validateCriticalHeadersJWS(protectedHeader: {
-  crit?: string[];
-} & Record<string, unknown>, recognizedHeaders?: string[]): void;
-/** Validate critical headers in JWE semantics. */
-export declare function validateCriticalHeadersJWE(protectedHeader: {
-  crit?: string[];
-} & Record<string, unknown>, recognizedHeaders?: string[]): void;
-/** Assert `crit` is a non-empty string array with no registered header name (RFC 7515 §4.1.11 / RFC 7516 §4.1.13). */
-export declare function assertCritShape(crit: unknown, options: {
-  family: "JWS" | "JWE";
-  code?: JWTErrorCode;
-}): asserts crit is string[];
-/** Whether headers declare JSON content: a string `typ` naming JWT, or a JSON `cty`. */
+import { Duration, JWTClaimValidationOptions, JWTClaims } from "./index.mjs";
+/** Whether the header declares JSON content: a `typ` containing `jwt` in any case, or a JSON `cty`. */
 export declare function isJWTContent(header: {
   typ?: string;
   cty?: string;
 } | undefined): boolean;
-/** Parse a `Duration` (e.g. `3600` or `"10m"`) into positive integer seconds; else `ERR_INVALID_OPTION`. */
+/**
+ * Parses a `Duration` (`3600`, `"10m"`, `"7D"`) into positive integer seconds.
+ * @throws `ERR_INVALID_OPTION` if `duration` is malformed or not positive.
+ */
 export declare function computeDurationInSeconds(duration: Duration): number;
-/** The `ERR_JWT_EXPIRED` message for a token whose `exp` (NumericDate seconds) has passed. */
+/** The `ERR_JWT_EXPIRED` message for an `exp` (NumericDate seconds) in the past. */
 export declare function expiredClaimMessage(exp: number): string;
 /**
- * Validate JWT claims against the set expectations. A malformed expectation throws
- * `ERR_INVALID_OPTION`; an empty `audience` or `issuer` list matches no token.
+ * Checks `jwtClaims` against `options`. An empty `audience` or `issuer` list matches no token.
+ * @throws `ERR_INVALID_OPTION` if an option is malformed.
+ * @throws `ERR_JWT_CLAIM_MISSING` if a claim that `requiredClaims` or a claim option names is absent.
+ * @throws `ERR_JWT_CLAIM_INVALID` if a claim does not match or a time claim is not a NumericDate.
+ * @throws `ERR_JWT_NBF` if `nbf` is in the future.
+ * @throws `ERR_JWT_EXPIRED` if `exp` has passed or `iat` is older than `maxTokenAge`.
  */
 export declare function validateJwtClaims(jwtClaims: JWTClaims, options?: JWTClaimValidationOptions): void;

package/dist/_chunks/jwt.mjs

@@ -1,4 +1,4 @@
-import { UnsecureError, safeJsonParse, textEncoder } from "./libs/unsecure.mjs";
+import { UnsecureError, textEncoder } from "./libs/unsecure.mjs";
 import { JWTError } from "../error.mjs";
 function base64UrlStringify(data) {
 	return encode(bytesOf(data, "Base64Url"), "base64url");
@@ -82,10 +82,6 @@ function parse(text, alphabet, padded, label, options) {
 function malformed(label, detail) {
 	return new UnsecureError("MALFORMED", `${label}.parse: ${detail}`);
 }
-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");
 }
@@ -124,13 +120,8 @@ function isPublicJWK(key) {
 	if (key.kty === "OKP") return typeof key.x === "string";
 	return typeof key.n === "string" && typeof key.e === "string";
 }
-function hasSymmetricSecret(key) {
-	return key.kty === "oct" || Object.hasOwn(key, "k");
-}
-const MAX_QUOTED_VALUE = 64;
-function quoteTokenValue(value) {
-	const text = String(value);
-	return JSON.stringify(text.length > MAX_QUOTED_VALUE ? `${text.slice(0, MAX_QUOTED_VALUE)}…` : text);
+function hasMisplacedSecret(key) {
+	return key.kty !== "oct" && Object.hasOwn(key, "k");
 }
 function concatUint8Arrays(...arrays) {
 	const totalLength = arrays.reduce((length, arr) => length + arr.length, 0);
@@ -299,149 +290,4 @@ function _expiredCause(claims) {
 		exp
 	};
 }
-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, issuedAt, expiresIn, expiresAt, notBeforeIn, notBeforeAt } = options ?? {};
-	if (issuedAt !== void 0 && typeof issuedAt !== "boolean" && !(issuedAt instanceof Date)) throw new JWTError("\"issuedAt\" must be a boolean or a Date.", "ERR_INVALID_OPTION");
-	if (expiresIn !== void 0 && expiresAt !== void 0) throw new JWTError("\"expiresIn\" and \"expiresAt\" are mutually exclusive.", "ERR_JWT_CLAIM_INVALID");
-	if (notBeforeIn !== void 0 && notBeforeAt !== void 0) throw new JWTError("\"notBeforeIn\" and \"notBeforeAt\" are mutually exclusive.", "ERR_JWT_CLAIM_INVALID");
-	const hasExpHint = expiresIn !== void 0 || expiresAt !== void 0;
-	const hasNbfHint = notBeforeIn !== void 0 || notBeforeAt !== void 0;
-	const hasIatHint = issuedAt === true || issuedAt instanceof Date;
-	if (!hasExpHint && !hasNbfHint && !hasIatHint) 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);
-	const wantsIat = hasIatHint && (!("iat" in payload) || payload.iat === void 0);
-	if (!wantsExp && !wantsNbf && !wantsIat) return void 0;
-	const now = Math.floor((currentDate ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
-	const claims = { ...payload };
-	claims.iat ||= issuedAt instanceof Date ? Math.floor(_instantOf(issuedAt, "issuedAt") / 1e3) : now;
-	if (wantsExp) {
-		if (expiresAt !== void 0) claims.exp = Math.floor(_instantOf(expiresAt, "expiresAt") / 1e3);
-		else if (expiresIn !== void 0) claims.exp = now + 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 = now + 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 ${quoteTokenValue(param)} is missing from the protected header.`, `ERR_${family}_INVALID`);
-		if (!recognizedHeaders.includes(param) && !BASE_PROCESSED[family].includes(param)) throw new JWTError(`Unprocessed critical header parameters: ${quoteTokenValue(param)}`, `ERR_${family}_INVALID`);
-	}
-}
-export { applyTypDefault, assertClaimValidationOptions, assertCritShape, assertCryptoKey, assertPlainObject, assertStringList, base64Decode, base64Encode, base64Parse, base64Stringify, base64UrlDecode, base64UrlEncode, base64UrlParse, base64UrlStringify, computeDurationInSeconds, computeJwtTimeClaims, concatUint8Arrays, expiredClaimMessage, getPlaintextBytes, hasSymmetricSecret, isAsymmetricJWK, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet, isJWTContent, isPlainObject, isPrivateJWK, isPublicJWK, isSymmetricJWK, maybeArray, parsePayloadBytes, parsePayloadSegment, parsePayloadText, quoteTokenValue, uint32be, validateCriticalHeadersJWE, validateCriticalHeadersJWS, validateJwtClaims };
+export { assertClaimValidationOptions, assertCryptoKey, assertPlainObject, assertStringList, base64Parse, base64Stringify, base64UrlParse, base64UrlStringify, computeDurationInSeconds, concatUint8Arrays, expiredClaimMessage, hasMisplacedSecret, isAsymmetricJWK, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet, isJWTContent, isPlainObject, isPrivateJWK, isPublicJWK, isSymmetricJWK, maybeArray, parseDurationSeconds, uint32be, validateJwtClaims };