unjwt 0.8.2 → 0.8.4

package/dist/_chunks/_jwt-internal.mjs

@@ -91,7 +91,7 @@ function concatUint8Arrays(...arrays) {
 	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");
+	if (value < 0 || value >= 2 ** 32) throw new JWTError(`value must be >= 0 and <= ${2 ** 32 - 1} (got ${value})`, "ERR_INVALID_OPTION");
 	return new Uint8Array([
 		value >>> 24,
 		value >>> 16,
@@ -142,7 +142,7 @@ function parseDurationSeconds(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");
+		if (!match || !match[1]) throw new JWTError("Duration must be an integer or a string like '10m' or '7D'.", "ERR_INVALID_OPTION");
 		const n = Number.parseInt(match[1], 10);
 		const unit = match[2] || "s";
 		return n * TIME_CONSTANTS[unit];
@@ -155,7 +155,7 @@ function computeDurationInSeconds(duration) {
 	return seconds;
 }
 function expiredClaimMessage(exp) {
-	return `JWT "exp" (Expiration Time) Claim validation failed: Token has expired (exp: ${(/* @__PURE__ */ new Date(exp * 1e3)).toISOString()})`;
+	return `JWT "exp" is in the past (${(/* @__PURE__ */ new Date(exp * 1e3)).toISOString()}).`;
 }
 function validateJwtClaims(jwtClaims, options = {}) {
 	assertClaimValidationOptions(options);
@@ -171,29 +171,29 @@ function validateJwtClaims(jwtClaims, options = {}) {
 		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");
+	_assertNumericDate(jwtClaims.exp, "exp");
+	_assertNumericDate(jwtClaims.nbf, "nbf");
+	_assertNumericDate(jwtClaims.iat, "iat");
 	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 (!jwtClaims.iss || !expectedIssuers.includes(jwtClaims.iss)) throw new JWTError(`Invalid JWT "iss": 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.subject !== void 0 && jwtClaims.sub !== options.subject) throw new JWTError(`Invalid JWT "sub": 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 (!claimAudience.some((aud) => expectedAudiences.includes(aud))) throw new JWTError(`Invalid JWT "aud": 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.nbf === "number" && jwtClaims.nbf > currentTime + clockTolerance) throw new JWTError(`JWT "nbf" is in the future (${(/* @__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", {
+		if (typeof jwtClaims.iat !== "number") throw new JWTError("JWT \"iat\" must be a number when maxTokenAge is set.", "ERR_JWT_CLAIM_INVALID");
+		if (jwtClaims.iat > currentTime + clockTolerance) throw new JWTError(`JWT "iat" is in the future (${(/* @__PURE__ */ new Date(jwtClaims.iat * 1e3)).toISOString()}).`, "ERR_JWT_CLAIM_INVALID");
+		if (jwtClaims.iat < currentTime - computeDurationInSeconds(options.maxTokenAge) - clockTolerance) throw new JWTError(`JWT "iat" is older than maxTokenAge ${options.maxTokenAge}.`, "ERR_JWT_EXPIRED", {
 			jti: jwtClaims.jti,
 			iat: jwtClaims.iat,
 			exp: jwtClaims.exp
@@ -238,10 +238,10 @@ function _assertExpectedValues(value, name) {
 function _isNonEmptyString(value) {
 	return typeof value === "string" && value !== "";
 }
-function _assertNumericDate(value, claim, label) {
+function _assertNumericDate(value, claim) {
 	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");
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new JWTError(`JWT "${claim}" must be a number.`, "ERR_JWT_CLAIM_INVALID");
+	if (value < 0) throw new JWTError(`JWT "${claim}" must be a non-negative NumericDate.`, "ERR_JWT_CLAIM_INVALID");
 }
 function applyTypDefault(header, payload) {
 	const declared = header.typ;
@@ -283,29 +283,32 @@ function getPlaintextBytes(payload) {
 	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 { 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;
-	if (!hasExpHint && !hasNbfHint) return 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);
-	if (!wantsExp && !wantsNbf) return void 0;
+	const wantsIat = hasIatHint && (!("iat" in payload) || payload.iat === void 0);
+	if (!wantsExp && !wantsNbf && !wantsIat) return void 0;
 	const now = Math.round((currentDate ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
 	const claims = { ...payload };
-	claims.iat ||= now;
+	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 = claims.iat + computeDurationInSeconds(expiresIn);
+		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 = claims.iat + offset;
+			claims.nbf = now + offset;
 		}
 	}
 	return claims;
@@ -381,7 +384,7 @@ function validateCriticalHeaders(protectedHeader, options) {
 	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 (!Object.hasOwn(protectedHeader, param)) throw new JWTError(`Critical header parameter "${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: ${param}`, `ERR_${family}_INVALID`);
 	}
 }

package/dist/_chunks/index.d.mts

@@ -210,13 +210,15 @@ export interface JWTClaimValidationOptions {
 }
 /** Time claims a producer computes; a claim already in the payload is kept as given. */
 export interface JWTTimeClaimOptions {
-  /** Reference moment for `iat` and relative durations. @default new Date() */
+  /** The clock: `iat` when written, and the base of `expiresIn` / `notBeforeIn`. @default new Date() */
   currentDate?: Date;
-  /** Duration until `exp`; exclusive with `expiresAt`. */
+  /** Writes `iat` on its own: `true` as `currentDate`, a `Date` as that instant; `false` is unset. `exp`/`nbf` options write it either way. */
+  issuedAt?: boolean | Date;
+  /** Duration from `currentDate` until `exp`; exclusive with `expiresAt`. */
   expiresIn?: ExpiresIn;
   /** Absolute `exp`; exclusive with `expiresIn`. */
   expiresAt?: Date;
-  /** Duration from `iat` until `nbf` (`0` sets `nbf = iat`); exclusive with `notBeforeAt`. */
+  /** Duration from `currentDate` until `nbf` (`0` sets `nbf` to it); exclusive with `notBeforeAt`. */
   notBeforeIn?: ExpiresIn;
   /** Absolute `nbf` (RFC 7519 §4.1.5); exclusive with `notBeforeIn`. */
   notBeforeAt?: Date;

package/dist/_chunks/jwe.d.mts

@@ -49,6 +49,7 @@ export declare function encrypt(payload: JOSEPayload, key: CryptoKey | JWEEncryp
 /**
  * Decrypt a JWE Compact Serialization string; `key` may be a lookup function.
  * The payload type follows `options.payload` (claims `T` by default).
+ * A compact JWE has five sections (RFC 7516 §3).
  */
 export declare function decrypt<T extends object = JWTClaims>(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWEKeyLookup, options?: JWEDecryptOptions<"json"> & {
   forceUint8Array?: false;

package/dist/_chunks/jwe.mjs

@@ -1,7 +1,8 @@
 import { sanitizeObjectCopy, secureRandomBytes, textEncoder } from "./libs/unsecure.mjs";
 import { JWTError, applyTypDefault, base64UrlStringify, computeJwtTimeClaims, getPlaintextBytes, isJWK, isJWKSet, validateCriticalHeadersJWE } from "./_jwt-internal.mjs";
 import { isContentEncryptionAlgorithm, isPBES2Algorithm } from "./digest.mjs";
-import { DEFAULT_PBES2_ITERATIONS, JWE_ALG_CTX, JWE_DIRECT_ALGS, asDecryptionError, asKeyLookupError, assertCompactToken, assertConsumerOptions, assertDirectKeyRole, assertEntryLimit, assertJWEAlgSupported, assertJWEEncSupported, assertJWKSetCandidates, assertNoZipOption, assertOptionEntry, assertPBES2Params, assertProducerCEK, assertProducerConfirmation, assertProducerCrit, assertProducerIV, assertProducerKeyHeaders, assertProtectedOnlyOption, assertSerializationObject, buildECDHAgreementParams, buildJWKSetFilter, buildUnwrapKeyOptions, checkAlgAllowed, checkJWEAlgSupported, checkJWEContentSegments, checkJWEDirectEncryptedKey, checkJWEEncAllowed, checkJWEEncSupported, checkJWEUnprotectedCrit, checkJWEZip, checkProtectedTyp, checkSerializationEntry, createPBES2Budget, decodeJWEPayload, decodeProtectedHeader, decodeSegment, decrypt as decrypt$1, encrypt as encrypt$1, encryptKey, exportReturnedCek, generateCEK, generateIV, getJWKsFromSet, importKey, isJWEAlgSupported, keyMatchesHeader, resolveKeyInput, resolveLimit, resolvePasswordKey, resolvePayloadMode, serializeProtectedHeader, unwrapKey, validateClaimsIfJson } from "./jwk.mjs";
+import { DEFAULT_PBES2_ITERATIONS, JWE_ALG_CTX, JWE_DIRECT_ALGS, asDecryptionError, asKeyLookupError, assertCompactToken, assertConsumerOptions, assertDirectKeyRole, assertEntryLimit, assertJWEAlgSupported, assertJWEEncSupported, assertJWKSetCandidates, assertNoZipOption, assertOptionEntry, assertPBES2Params, assertProducerCEK, assertProducerConfirmation, assertProducerCrit, assertProducerIV, assertProducerKeyHeaders, assertProtectedOnlyOption, assertSerializationObject, buildECDHAgreementParams, buildJWKSetFilter, buildUnwrapKeyOptions, checkAlgAllowed, checkJWEAlgSupported, checkJWEContentSegments, checkJWEDirectEncryptedKey, checkJWEEncAllowed, checkJWEEncSupported, checkJWEUnprotectedCrit, checkJWEZip, checkProtectedTyp, checkSerializationEntry, createPBES2Budget, decodeJWEPayload, decodeProtectedHeader, decodeSegment, decrypt as decrypt$1, encrypt as encrypt$1, encryptKey, exportReturnedCek, generateCEK, generateIV, getJWKsFromSet, importKey, isJWEAlgSupported, keyMatchesHeader, resolveKeyInput, resolveLimit, resolvePasswordKey, resolvePayloadMode, serializeProtectedHeader, validateClaimsIfJson } from "./_import-key.mjs";
+import { unwrapKey } from "../core/jwk.mjs";
 function buildKeyManagementParams(alg, source) {
 	const { keyManagementIV, p2s, p2c, ecdh } = source;
 	const isPBES2 = alg.startsWith("PBES2");
@@ -339,7 +340,7 @@ function _resolveRecipientAlg(key, index) {
 	const declared = key.alg;
 	if (!declared) throw new JWTError(`Cannot infer "alg" for recipient[${index}]: the JWK has no "alg" property.`, "ERR_JWE_RECIPIENT_ALG_INFERENCE");
 	const alg = key.kty === "oct" && isContentEncryptionAlgorithm(declared) ? "dir" : declared;
-	if (JWE_DIRECT_ALGS.has(alg)) throw new JWTError(`Recipient[${index}] resolves to "${alg}", which requires exactly one recipient. Use encrypt() instead.`, "ERR_JWE_ALG_FORBIDDEN_IN_MULTI");
+	if (JWE_DIRECT_ALGS.has(alg)) throw new JWTError(`Recipient[${index}] "${alg}" allows a single recipient, use encrypt().`, "ERR_JWE_ALG_FORBIDDEN_IN_MULTI");
 	assertJWEAlgSupported(alg);
 	return alg;
 }
@@ -357,7 +358,7 @@ function _assertDisjointHeaders(protectedHeader, sharedUnprotected, recipientHea
 	const check = (obj) => {
 		if (!obj) return;
 		for (const k of Object.keys(obj)) {
-			if (seen.has(k)) throw new JWTError(`JWE header parameter "${k}" appears in multiple header tiers; protected, shared unprotected, and per-recipient headers must be disjoint (RFC 7516 §7.2.1).`, "ERR_JWE_HEADER_PARAMS_NOT_DISJOINT");
+			if (seen.has(k)) throw new JWTError(`Invalid JWE: header parameter "${k}" is set in more than one header.`, "ERR_JWE_HEADER_PARAMS_NOT_DISJOINT");
 			seen.add(k);
 		}
 	};
@@ -374,7 +375,7 @@ function _mergeHeaders(protectedHeader, sharedUnprotected, recipientHeader) {
 function _normalizeSerialization(input) {
 	assertSerializationObject(input, "JWE");
 	if ("recipients" in input) {
-		if ("encrypted_key" in input || "header" in input) throw new JWTError("Invalid JWE JSON Serialization: \"recipients\" must not be combined with a top-level \"header\" or \"encrypted_key\".", "ERR_JWE_INVALID_SERIALIZATION");
+		if ("encrypted_key" in input || "header" in input) throw new JWTError("Invalid JWE JSON Serialization: \"recipients\" excludes top-level \"header\" and \"encrypted_key\".", "ERR_JWE_INVALID_SERIALIZATION");
 		return input;
 	}
 	const flattened = input;
@@ -416,7 +417,7 @@ async function encrypt(payload, key, options = {}) {
 		else if (cekRole) alg = "dir";
 		else if (isJWK(key)) alg = key.alg;
 	}
-	if (!alg) throw new JWTError("JWE \"alg\" (Key Management Algorithm) must be provided in options or inferable from the key", "ERR_JWE_ALG_MISSING");
+	if (!alg) throw new JWTError("JWE \"alg\" must be provided in options or inferable from the key", "ERR_JWE_ALG_MISSING");
 	if (!enc) {
 		if (alg === "dir") {
 			enc = cekRole ?? (isJWK(key) ? key.enc : void 0);
@@ -466,7 +467,7 @@ async function decrypt(jwe, key, options = {}) {
 	const keyCandidateLimit = resolveLimit(options.limits, "keyCandidates");
 	const pbes2Budget = createPBES2Budget(resolveLimit(options.limits, "pbes2Iterations"));
 	const parts = jwe.split(".");
-	if (parts.length !== 5) throw new JWTError("Invalid JWE: Must contain five sections (RFC7516, section-3).", "ERR_JWE_INVALID");
+	if (parts.length !== 5) throw new JWTError("Invalid JWE: Must contain five sections.", "ERR_JWE_INVALID");
 	const [protectedHeaderEncoded, encryptedKeyEncoded, ivEncoded, ciphertextEncoded, authTagEncoded] = parts;
 	const protectedHeader = decodeProtectedHeader(protectedHeaderEncoded, "JWE");
 	assertHeaderAlgorithms(protectedHeader);
@@ -550,7 +551,7 @@ function _buildJWEHeader(alg, enc, key, userHeader, keyManagementParams, payload
 	return header;
 }
 function assertHeaderAlgorithms(header) {
-	if (!header.alg || !header.enc) throw new JWTError("Invalid JWE: Protected header must be an object with \"alg\" and \"enc\" properties.", "ERR_JWE_INVALID");
+	if (!header.alg || !header.enc) throw new JWTError("Invalid JWE: Protected header must carry \"alg\" and \"enc\".", "ERR_JWE_INVALID");
 	assertJWEAlgSupported(header.alg);
 	assertJWEEncSupported(header.enc);
 }

package/dist/_chunks/jwk.d.mts

@@ -0,0 +1,205 @@
+import { ContentEncryptionAlgorithm, DeriveJWKOptions, DeriveJWKReturn, DeriveKeyOptions, DeriveKeyReturn, GenerateJWKOptions, GenerateJWKReturn, GenerateKeyAlgorithm, GenerateKeyOptions, GenerateKeyReturn, ImportedKey, ImportedPEMJWK, JWK, JWKAlgorithm, JWKCacheAdapter, JWKMetadata, JWKPEMAlgorithm, JWKSet, JWK_Asymmetric, JWK_ECDH_ES, JWK_EC_Private, JWK_EC_Public, JWK_PBES2, JWK_oct, KeyManagementAlgorithm, PEMType, ToPublicJWKReturn, UnwrapKeyOptions, UnwrapKeyResult, UnwrappingKeyFor, WrapKeyOptions, WrapKeyResult, WrappingKeyFor } from "./index.mjs";
+import "./index2.mjs";
+/**
+ * Default JWK import cache, keyed by JWK object identity: a copied JWK misses it, and a JWK
+ * mutated in place keeps serving the old `CryptoKey`. Rotate by replacing the object.
+ */
+export declare class WeakMapJWKCache implements JWKCacheAdapter {
+  private readonly _map;
+  get(jwk: JWK, alg: JWKAlgorithm): CryptoKey | undefined;
+  set(jwk: JWK, alg: JWKAlgorithm, key: CryptoKey): void;
+}
+/**
+ * Replaces the JWK import cache used by `importKey`, or disables it with `false`.
+ *
+ * A cache shared across JWK objects keys on the RFC 7638 thumbprint, the pair half (`d` present)
+ * and `alg`: the thumbprint covers public members only, and a `kid` may name different keys.
+ * `get` and `set` may return promises.
+ *
+ * @example
+ * ```ts
+ * const cacheKey = async (jwk: JWK, alg: JWKAlgorithm) =>
+ *   `${await thumbprint(jwk)}:${"d" in jwk ? "private" : "public"}:${alg}`;
+ * const map = new Map<string, CryptoKey>();
+ * configureJWKCache({
+ *   get: async (jwk, alg) => map.get(await cacheKey(jwk, alg)),
+ *   set: async (jwk, alg, key) => {
+ *     map.set(await cacheKey(jwk, alg), key);
+ *   },
+ * });
+ * ```
+ */
+export declare function configureJWKCache(cache: JWKCacheAdapter | false): void;
+/** Resets the JWK import cache to a fresh `WeakMapJWKCache`. */
+export declare function clearJWKCache(): void;
+/** Imports the secret of an `oct` JWK as a `CryptoKey` under `algorithm` and `usage`. */
+export declare function importKey(key: JWK_oct, options: {
+  asCryptoKey: true;
+  /** Algorithm to import the key as (e.g. `{ name: "AES-GCM", length: 256 }`). */
+  algorithm: Parameters<typeof crypto.subtle.importKey>[2];
+  usage: KeyUsage[];
+  /** Mark the key as extractable. Defaults to `false`. */
+  extractable?: boolean;
+}): Promise<CryptoKey>;
+/**
+ * Imports key material: a `CryptoKey` or `Uint8Array` is returned as is, an `oct` JWK as its raw
+ * bytes, an asymmetric JWK as a `CryptoKey` under its own `alg` or the hint. A string throws
+ * `ERR_JWK_INVALID`.
+ *
+ * `expect` and `extractable` apply to asymmetric keys only; `expect` rejects the other pair half
+ * with `ERR_JWK_INVALID`. A JWK's `alg` is authoritative (RFC 7517 §4.4): a different requested
+ * `alg` throws `ERR_JWK_INVALID`, except an `oct` JWK declaring a content encryption `alg` under
+ * `"dir"`.
+ */
+export declare function importKey<K extends CryptoKey | JWK | Uint8Array<ArrayBuffer>>(key: K, options?: JWKAlgorithm | {
+  /** Algorithm hint. Required when `key.alg` is absent on an asymmetric JWK. */
+  alg?: JWKAlgorithm;
+  /** Reject on shape mismatch instead of silently importing. */
+  expect?: "public" | "private";
+  /** Defaults to `false` for private, `true` for public material; JWK `ext: false` wins. */
+  extractable?: boolean;
+}): Promise<ImportedKey<K>>;
+/**
+ * Returns the JWKs of a JWK Set, dropping non-JWK entries, optionally narrowed by `filter`.
+ * An invalid set throws `ERR_JWK_INVALID`.
+ */
+export declare function getJWKsFromSet(jwkSet: JWKSet, filter?: (jwk: JWK) => boolean): JWK[];
+/**
+ * Generates a key for a JWA algorithm: a `CryptoKey` for symmetric algorithms, raw bytes for
+ * the `A*CBC-HS*` composites, a `CryptoKeyPair` for asymmetric ones; with `toJWK: true`, a JWK
+ * (or JWK pair) named by the `kid` option or its RFC 7638 thumbprint. PBES2, `"dir"` and `"none"` are refused.
+ *
+ * @param options
+ *   - `extractable?` — defaults to `true`; ignored when `toJWK` is set.
+ *   - `kid?` — with `toJWK`, a string set verbatim or `false` for no `kid`, either skipping the
+ *     thumbprint digest; anything else throws `ERR_INVALID_OPTION`.
+ *   - `keyUsage?` — narrows the usages derived from `alg`; leaving either half of a pair with
+ *     no usage throws `ERR_INVALID_OPTION`.
+ *   - `modulusLength?` — RSA only; defaults to `2048`.
+ *   - `publicExponent?` — RSA only; big-endian bytes, defaults to `0x010001`.
+ *   - `namedCurve?` — EC/OKP only; defaults to `"P-256"` / `"Ed25519"`. One that contradicts
+ *     the curve `ES*` or `Ed25519` names throws `ERR_INVALID_OPTION`.
+ */
+export declare function generateKey<TAlg extends GenerateKeyAlgorithm, ToJWK extends boolean = false, Kid extends string | false = string>(alg: TAlg, options?: GenerateKeyOptions<ToJWK, Kid>): Promise<GenerateKeyReturn<TAlg, GenerateKeyOptions<ToJWK, Kid>>>;
+/**
+ * Generates a JWK (or JWK pair) for a JWA algorithm, its `kid` the caller's, none with
+ * `kid: false`, or else its RFC 7638 thumbprint. PBES2, `"dir"` and `"none"` are refused.
+ *
+ * @param options
+ *   - `keyUsage?`, `modulusLength?` (default `2048`), `publicExponent?` (default `0x010001`),
+ *     `namedCurve?` (default `"P-256"` / `"Ed25519"`); a narrowing that empties a pair half or
+ *     a curve that contradicts `alg` throws `ERR_INVALID_OPTION`.
+ *   - `kid?` — a string set verbatim or `false` for no `kid`, either skipping the thumbprint
+ *     digest; anything else throws `ERR_INVALID_OPTION`.
+ *   - JWK metadata (`use`, `x5c`, `x5t`, `x5t#S256`, `x5u`) is merged onto the result;
+ *     `alg`, `kty`, `key_ops`, `ext` and key-material members are reserved (`ERR_INVALID_OPTION`).
+ */
+export declare function generateJWK<TAlg extends GenerateKeyAlgorithm, Kid extends string | false = string>(alg: TAlg, options?: GenerateJWKOptions<Kid> & Omit<JWKMetadata, "kid">): Promise<GenerateJWKReturn<TAlg, Kid>>;
+/**
+ * Derives an AES-KW key from a password with PBKDF2 per PBES2 (RFC 7518 §4.8).
+ *
+ * @param options
+ *   - `alg` — a PBES2 algorithm; any other throws `ERR_JWK_UNSUPPORTED`.
+ *   - `salt` — PBKDF2 salt (`p2s`), at least 8 octets (RFC 7518 §4.8.1.1).
+ *   - `iterations` — PBKDF2 count (`p2c`), an integer of at least 1000 (RFC 7518 §4.8.1.2);
+ *     anything else throws `ERR_INVALID_OPTION`.
+ *   - `keyUsage?` — defaults to `["wrapKey", "unwrapKey"]`.
+ *   - `extractable?` — defaults to `false`; ignored when `toJWK` is set.
+ *   - `toJWK?` — return a `JWK_oct` carrying the inner AES-KW `alg` instead of a `CryptoKey`.
+ */
+export declare function deriveKeyFromPassword<TOptions extends DeriveKeyOptions>(password: string | Uint8Array<ArrayBuffer>, options: TOptions): Promise<DeriveKeyReturn<TOptions, TOptions["alg"]>>;
+/**
+ * Derives a `JWK_oct` from a password per PBES2 (RFC 7518 §4.8); its `alg` is the inner AES-KW
+ * variant and its `kid` the caller's, none with `kid: false`, or else its RFC 7638 thumbprint.
+ *
+ * @param options
+ *   - `alg` (PBES2 only, else `ERR_JWK_UNSUPPORTED`), `salt` (at least 8 octets), `iterations`
+ *     (integer of at least 1000, else `ERR_INVALID_OPTION`), `keyUsage?` (default
+ *     `["wrapKey", "unwrapKey"]`).
+ *   - `kid?` — a string set verbatim or `false` for no `kid`, either skipping the thumbprint
+ *     digest; anything else throws `ERR_INVALID_OPTION`.
+ *   - JWK metadata (`use`, `x5c`, `x5t`, `x5t#S256`, `x5u`) is merged onto the result;
+ *     `alg`, `kty`, `key_ops`, `ext` and key-material members are reserved (`ERR_INVALID_OPTION`).
+ */
+export declare function deriveJWKFromPassword<TAlg extends JWK_PBES2, Kid extends string | false = string>(password: string | Uint8Array<ArrayBuffer>, options: DeriveJWKOptions<TAlg, Kid> & Omit<JWKMetadata, "kid">): Promise<DeriveJWKReturn<TAlg, Kid>>;
+/**
+ * Exports an extractable `CryptoKey` as a JWK, merging optional `jwkParams` metadata.
+ *
+ * The `alg` is WebCrypto's, which knows no JOSE roles: an AES-GCM key minted for `A128GCMKW`
+ * exports as `A128GCM`, so key-wrapping keys are minted with `generateJWK` instead.
+ *
+ * @throws `ERR_INVALID_OPTION` if `key` is not a `CryptoKey` or `jwkParams` sets a reserved member
+ *   (`alg`, `kty`, `key_ops`, `ext`, key material); `ERR_JWK_INVALID` for a non-extractable key.
+ */
+export declare function exportJWK<T extends JWK = JWK>(key: CryptoKey, jwkParams?: JWKMetadata): Promise<T>;
+/** @deprecated Use `exportJWK`; removed in 0.9.0. */
+export declare function exportKey<T extends JWK = JWK>(key: CryptoKey, jwkParams?: JWKMetadata): Promise<T>;
+/**
+ * Utility to derive the public half of an asymmetric JWK, or throw if the input is not asymmetric.
+ *
+ * @param jwk An asymmetric JWK (EC, OKP, RSA) with a private scalar (`d`).
+ * @throws `ERR_JWK_INVALID` if the input is not an asymmetric JWK.
+ * @returns A JWK with the same public members, without the private scalar.
+ */
+export declare function toPublicJWK<T extends JWK_Asymmetric>(jwk: T): ToPublicJWKReturn<T>;
+/**
+ * Wraps a CEK under a JWA key management algorithm; the result shape follows `alg`.
+ *
+ * @param wrappingKey A `CryptoKey`, a JWK, or for PBES2 a password string or bytes.
+ * @param options `alg` plus its parameters (`p2s`/`p2c` for PBES2, `ecdh` for ECDH-ES, …).
+ */
+export declare function wrapKey<TAlg extends KeyManagementAlgorithm>(keyToWrap: CryptoKey | Uint8Array<ArrayBuffer>, wrappingKey: WrappingKeyFor<TAlg>, options: WrapKeyOptions<TAlg>): Promise<WrapKeyResult<TAlg>>;
+/**
+ * Unwraps a CEK under a JWA key management algorithm.
+ *
+ * @param unwrappingKey A `CryptoKey`, a JWK, or for PBES2 a password string or bytes.
+ * @param options `alg`, `format?` (`"cryptokey"` by default, or `"raw"`), plus the algorithm's
+ *   parameters (`iv`/`tag`, `p2s`/`p2c`, `epk`, …).
+ * @throws `ERR_JWE_DECRYPTION_FAILED` for any failed unwrap, its cause undisclosed (RFC 7516
+ *   §11.5); `ERR_INVALID_OPTION` for a malformed `wrappedKey` or `options`; `ERR_JWE_INVALID` for
+ *   missing or malformed algorithm parameters.
+ */
+export declare function unwrapKey<TOptions extends UnwrapKeyOptions>(wrappedKey: Uint8Array<ArrayBuffer>, unwrappingKey: UnwrappingKeyFor<TOptions["alg"]>, options: TOptions): Promise<UnwrapKeyResult<TOptions>>;
+/**
+ * Imports a PEM key as a JWK carrying `alg`. The type follows the label — `PRIVATE KEY`
+ * (PKCS#8), `PUBLIC KEY` (SPKI), `CERTIFICATE` (X.509, only its SPKI kept) — unless
+ * `options.pemType` overrides it. The JWK holds the key material in plain JavaScript.
+ *
+ * @throws `ERR_JWK_INVALID` if the type cannot be inferred or does not match the label;
+ *   `ERR_JWK_UNSUPPORTED` for an unknown `pemType`; `ERR_INVALID_OPTION` if `jwkParams` sets
+ *   `alg`, `kty`, `key_ops`, `ext` or a key-material member.
+ */
+export declare function importPEM<A extends JWKPEMAlgorithm, Type extends PEMType | undefined = undefined>(pem: string, alg: A, options?: {
+  /** PEM type. Inferred from the PEM label when omitted, which leaves the result public or private. */
+  pemType?: Type;
+  /** Additional JWK properties merged into the exported key (e.g. `kid`). */
+  jwkParams?: JWKMetadata;
+}): Promise<ImportedPEMJWK<A, Type>>;
+/**
+ * Exports an asymmetric JWK as PEM: PKCS#8 when it carries `d`, SPKI otherwise.
+ *
+ * @throws `ERR_JWK_UNSUPPORTED` for `oct` JWKs or an unknown format or algorithm;
+ *   `ERR_JWK_INVALID` for a missing `alg` or a `pemFormat` that contradicts the JWK's half.
+ */
+export declare function exportPEM(jwk: JWK, options?: {
+  /** PEM format. Inferred from the JWK shape when omitted. */
+  pemFormat?: "pkcs8" | "spki";
+  /** Algorithm hint used when `jwk.alg` is absent. */
+  alg?: JWKPEMAlgorithm;
+}): Promise<string>;
+/**
+ * Derives ECDH-ES key material (RFC 7518 §4.6): ECDH followed by the Concat KDF.
+ *
+ * @param publicKey The recipient's static public key (the ephemeral one when decrypting).
+ * @param privateKey The ephemeral private key (the recipient's static one when decrypting).
+ */
+export declare function deriveSharedSecret(publicKey: CryptoKey | JWK_EC_Public, privateKey: CryptoKey | JWK_EC_Private, options: {
+  /** Algorithm identifier fed to the concat KDF as `AlgorithmID`. */
+  enc: JWK_ECDH_ES | ContentEncryptionAlgorithm;
+  /** Derived length in bits. Defaults to `enc`'s length; required for `"ECDH-ES"`. */
+  keyLength?: number;
+  /** Agreement PartyUInfo (apu). */
+  partyUInfo?: Uint8Array<ArrayBuffer>;
+  /** Agreement PartyVInfo (apv). */
+  partyVInfo?: Uint8Array<ArrayBuffer>;
+}): Promise<Uint8Array<ArrayBuffer>>;

package/dist/_chunks/jws.d.mts

@@ -37,7 +37,10 @@ export declare function verifyMultiAll(jws: JWSGeneralSerialization | JWSFlatten
 export declare function verifyMultiAll<Mode extends JOSEPayloadMode = JOSEPayloadMode>(jws: JWSGeneralSerialization | JWSFlattenedSerialization, keyResolver: JWSKeyLookup, options?: JWSMultiVerifyAllOptions<Mode>): Promise<JWSMultiVerifyOutcome<PayloadOf<Mode>>[]>;
 /** Converts a single-signature General JWS to Flattened form (RFC 7515 §7.2.2); otherwise `ERR_JWS_INVALID_SERIALIZATION`. */
 export declare function generalToFlattenedJWS(jws: JWSGeneralSerialization): JWSFlattenedSerialization;
-/** Creates a JWS Compact Serialization; an object payload is JSON-serialized, `alg` is required unless the JWK carries one. */
+/**
+ * Creates a JWS Compact Serialization; an object payload is JSON-serialized, `alg` is required unless the JWK carries one.
+ * An unencoded (`b64: false`) compact payload cannot contain "." (RFC 7797 §5.2).
+ */
 export declare function sign(payload: JOSEPayload, key: JWSSignJWK, options?: JWSSignOptions): Promise<string>;
 export declare function sign(payload: JOSEPayload, key: CryptoKey | Uint8Array<ArrayBuffer>, options: JWSSignOptions & {
   alg: JWSAlgorithm;

package/dist/_chunks/jws.mjs

@@ -1,7 +1,7 @@
 import { sanitizeObjectCopy, textEncoder } from "./libs/unsecure.mjs";
 import { JWTError, applyTypDefault, base64UrlStringify, computeJwtTimeClaims, getPlaintextBytes, isJWK, isJWKSet, parsePayloadText, validateCriticalHeadersJWS } from "./_jwt-internal.mjs";
 import { inferJWSAllowedAlgorithms } from "./digest.mjs";
-import { JWS_ALG_CTX, applyB64Header, asJWTError, asKeyLookupError, asKeyUsageError, assertB64Option, assertCompactToken, assertConsumerOptions, assertEntryLimit, assertJWKSetCandidates, assertJWSAlgSupported, assertNotStringKey, assertOptionEntry, assertProducerConfirmation, assertProducerCrit, assertProducerKeyHeaders, assertProtectedOnlyOption, assertSerializationObject, buildJWKSetFilter, checkAlgAllowed, checkJWSAlgSupported, checkJWSB64, checkProtectedTyp, checkSerializationEntry, decodeJWSPayload, decodeProtectedHeader, decodeSegment, getJWKsFromSet, importKey, keyMatchesHeader, resolveKeyInput, resolveLimit, resolvePayloadMode, resolveSigningKey, serializeProtectedHeader, sign as sign$1, stringKeyError, validateClaimsIfJson, verify as verify$1 } from "./jwk.mjs";
+import { JWS_ALG_CTX, applyB64Header, asJWTError, asKeyLookupError, asKeyUsageError, assertB64Option, assertCompactToken, assertConsumerOptions, assertEntryLimit, assertJWKSetCandidates, assertJWSAlgSupported, assertNotStringKey, assertOptionEntry, assertProducerConfirmation, assertProducerCrit, assertProducerKeyHeaders, assertProtectedOnlyOption, assertSerializationObject, buildJWKSetFilter, checkAlgAllowed, checkJWSAlgSupported, checkJWSB64, checkProtectedTyp, checkSerializationEntry, decodeJWSPayload, decodeProtectedHeader, decodeSegment, getJWKsFromSet, importKey, keyMatchesHeader, resolveKeyInput, resolveLimit, resolvePayloadMode, resolveSigningKey, serializeProtectedHeader, sign as sign$1, stringKeyError, validateClaimsIfJson, verify as verify$1 } from "./_import-key.mjs";
 function buildJWSProtectedHeader(alg, key, userHeader, options) {
 	const safeHeader = sanitizeObjectCopy(userHeader);
 	const header = {};
@@ -256,8 +256,8 @@ const PER_SIGNATURE_ERROR_CODES = /* @__PURE__ */ new Set([
 ]);
 function _checkUnprotectedHeader(header) {
 	if (!header) return void 0;
-	if (Object.hasOwn(header, "crit")) return new JWTError("Invalid JWS: \"crit\" must be integrity protected (RFC 7515 §4.1.11).", "ERR_JWS_INVALID");
-	if (Object.hasOwn(header, "b64")) return new JWTError("Invalid JWS: \"b64\" must occur only within the protected header (RFC 7797 §3).", "ERR_JWS_INVALID");
+	if (Object.hasOwn(header, "crit")) return new JWTError("Invalid JWS: \"crit\" must be integrity protected.", "ERR_JWS_INVALID");
+	if (Object.hasOwn(header, "b64")) return new JWTError("Invalid JWS: \"b64\" must be in the protected header.", "ERR_JWS_INVALID");
 }
 function _readSignatureHeaders(entry, index) {
 	const shapeError = checkSerializationEntry(entry, {
@@ -290,7 +290,7 @@ function _readSignatureHeaders(entry, index) {
 	}
 	const effective = _mergeHeaders(protectedHeader, unprotectedHeader);
 	const alg = effective.alg;
-	if (!alg) return failed(new JWTError(`Invalid JWS: Signature[${index}] has no "alg" in its protected or unprotected header.`, "ERR_JWS_INVALID"));
+	if (!alg) return failed(new JWTError(`Invalid JWS: Signature[${index}] has no "alg" in its headers.`, "ERR_JWS_INVALID"));
 	const algError = checkJWSAlgSupported(alg) ?? checkJWSB64(protectedHeader);
 	if (algError) return failed(algError);
 	return {
@@ -323,13 +323,13 @@ function _resolveB64(signers) {
 		const raw = signers[i].protectedHeader?.b64;
 		if (raw === void 0) continue;
 		if (decided === void 0) decided = raw;
-		else if (decided !== raw) throw new JWTError(`Inconsistent "b64" across signers (RFC 7797 §3 requires all signers use the same b64 value).`, "ERR_JWS_B64_INCONSISTENT");
+		else if (decided !== raw) throw new JWTError("Inconsistent \"b64\" across signers.", "ERR_JWS_B64_INCONSISTENT");
 	}
 	return decided ?? true;
 }
 function _assertDisjointHeaders(protectedHeader, unprotectedHeader) {
 	if (!protectedHeader || !unprotectedHeader) return;
-	for (const k of Object.keys(unprotectedHeader)) if (k in protectedHeader) throw new JWTError(`JWS header parameter "${k}" appears in both protected and unprotected headers of a signature; they must be disjoint (RFC 7515 §7.2.1).`, "ERR_JWS_HEADER_PARAMS_NOT_DISJOINT");
+	for (const k of Object.keys(unprotectedHeader)) if (k in protectedHeader) throw new JWTError(`Invalid JWS: header parameter "${k}" is set in more than one header.`, "ERR_JWS_HEADER_PARAMS_NOT_DISJOINT");
 }
 function _mergeHeaders(protectedHeader, unprotectedHeader) {
 	if (!unprotectedHeader) return protectedHeader;
@@ -350,7 +350,7 @@ function _readGeneralSerialization(input, signatureLimit) {
 function _normalizeSerialization(input) {
 	assertSerializationObject(input, "JWS");
 	if ("signatures" in input && Array.isArray(input.signatures)) {
-		if ("signature" in input || "protected" in input) throw new JWTError("Invalid JWS JSON Serialization: \"signatures\" must not be combined with a top-level \"signature\" or \"protected\".", "ERR_JWS_INVALID_SERIALIZATION");
+		if ("signature" in input || "protected" in input) throw new JWTError("Invalid JWS JSON Serialization: \"signatures\" excludes top-level \"signature\" and \"protected\".", "ERR_JWS_INVALID_SERIALIZATION");
 		return input;
 	}
 	if ("signature" in input) {
@@ -363,7 +363,7 @@ function _normalizeSerialization(input) {
 			signatures: [signature]
 		};
 	}
-	throw new JWTError("Invalid JWS JSON Serialization: missing both signatures[] and flattened signature.", "ERR_JWS_INVALID_SERIALIZATION");
+	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;
@@ -466,7 +466,7 @@ async function sign(payload, key, options = {}) {
 	let { alg } = options;
 	if (!alg) {
 		if (isJWK(key) && key.alg) alg = key.alg;
-		else throw new JWTError("JWS \"alg\" (Algorithm) must be provided in options", "ERR_JWS_ALG_MISSING");
+		else throw new JWTError("JWS \"alg\" must be provided in options", "ERR_JWS_ALG_MISSING");
 	}
 	assertJWSAlgSupported(alg);
 	let signingKey;
@@ -488,7 +488,7 @@ async function sign(payload, key, options = {}) {
 	if (useB64) payloadEncoded = base64UrlStringify(payloadBytes);
 	else {
 		payloadEncoded = parsePayloadText(payloadBytes);
-		if (payloadEncoded.includes(".")) throw new JWTError("Invalid JWS: unencoded compact payload must not contain \".\" (RFC 7797 §5.2).", "ERR_JWS_INVALID");
+		if (payloadEncoded.includes(".")) throw new JWTError("Invalid JWS: unencoded compact payload must not contain \".\".", "ERR_JWS_INVALID");
 	}
 	const signingInputString = `${protectedHeaderEncoded}.${payloadEncoded}`;
 	const signingInputBytes = textEncoder.encode(signingInputString);

package/dist/_chunks/jwt.d.mts

@@ -24,7 +24,8 @@ export declare function getPlaintextBytes(payload: JOSEPayload): Uint8Array<Arra
 export type ComputeJwtTimeClaimsOptions = JWTTimeClaimOptions;
 /**
  * Return a copy of an object payload with `iat` and the requested `exp` / `nbf`, or `undefined` when none applies.
- * Both members of `expiresIn`/`expiresAt` or `notBeforeIn`/`notBeforeAt` throw `ERR_JWT_CLAIM_INVALID`.
+ * `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. */