unjwt 0.7.1 → 0.7.3

package/dist/_chunks/_internal.mjs

@@ -1,5 +1,6 @@
-import { D as JWTError, E as inferJWSAllowedAlgorithms, T as inferJWEAllowedAlgorithms, a as isCryptoKeyPair, i as isCryptoKey, o as isJWK, v as decodePayloadFromB64UrlSegment, w as validateJwtClaims } from "./utils.mjs";
-import { c as safeJsonParse, i as base64UrlDecode, s as textEncoder } from "./libs/unsecure.mjs";
+import { JWTError, decodePayloadFromB64UrlSegment, inferJWEAllowedAlgorithms, inferJWSAllowedAlgorithms, isCryptoKey, isCryptoKeyPair, isJWK, validateJwtClaims } from "./utils.mjs";
+import { base64UrlDecode, safeJsonParse, textEncoder } from "./libs/unsecure.mjs";
+import { assertOctKeyLength } from "./jwk.mjs";
 function buildJWKSetFilter(header) {
 	const kid = header?.kid;
 	const alg = header?.alg;
@@ -35,8 +36,7 @@ function parseEphemeralKey(ephemeralKey) {
 }
 async function resolveSigningKey(alg, key, usage) {
 	if (key instanceof Uint8Array) {
-		const minBytes = Number.parseInt(alg.slice(2), 10) / 8;
-		if (key.length < minBytes) throw new JWTError(`${alg} requires a key of at least ${minBytes} bytes`, "ERR_JWK_INVALID");
+		assertOctKeyLength(key, alg);
 		return crypto.subtle.importKey("raw", key, {
 			name: "HMAC",
 			hash: `SHA-${alg.slice(-3)}`
@@ -85,4 +85,4 @@ function decodeJWSPayload(payloadSegment, useB64, forceUint8Array) {
 	if (useB64) return decodePayloadFromB64UrlSegment(payloadSegment, forceUint8Array);
 	return forceUint8Array ? textEncoder.encode(payloadSegment) : payloadSegment;
 }
-export { decodeJWSPayload as a, resolveSigningKey as c, checkAlgAllowed as i, validateJwtClaimsIfJsonPayload as l, JWS_ALG_CTX as n, decodeProtectedHeader as o, buildJWKSetFilter as r, parseEphemeralKey as s, JWE_ALG_CTX as t };
+export { JWE_ALG_CTX, JWS_ALG_CTX, buildJWKSetFilter, checkAlgAllowed, decodeJWSPayload, decodeProtectedHeader, parseEphemeralKey, resolveSigningKey, validateJwtClaimsIfJsonPayload };

package/dist/_chunks/index.d.mts

@@ -66,7 +66,12 @@ type GenerateKeyAlgorithm = Exclude<JWKAlgorithm, "none" | "dir" | JWK_PBES2>;
 interface GenerateKeyOptions {
   /** Key usages for the generated key(s). Note: For composite keys (CBC), default usages are applied separately. */
   keyUsage?: KeyUsage[];
-  /** Mark the key(s) as extractable. Defaults to true. */
+  /**
+  * Mark the key(s) as extractable. Defaults to true. Ignored when `toJWK` is set —
+  * the JWK output requires exporting the intermediate key. For long-lived asymmetric
+  * private keys that should never leave the runtime, prefer `false` (and omit `toJWK`):
+  * the key still signs/decrypts but its material cannot be exported.
+  */
   extractable?: boolean;
   /** RSA modulus length. Defaults to 2048. */
   modulusLength?: number;
@@ -84,7 +89,7 @@ interface GenerateKeyOptions {
 type GenerateKeyReturnJWK<TAlg extends GenerateKeyAlgorithm> = TAlg extends JWK_Asymmetric_Algorithm ? JWK_Pair<TAlg> : TAlg extends JWK_AES_CBC_HMAC | JWK_Symmetric_Algorithm ? JWK_oct<TAlg> : never;
 type GenerateKeyReturnCrypto<TAlg extends GenerateKeyAlgorithm> = TAlg extends JWK_AES_CBC_HMAC ? Uint8Array<ArrayBuffer> : TAlg extends JWK_Asymmetric_Algorithm ? CryptoKeyPair : CryptoKey;
 type GenerateKeyReturn<TAlg extends GenerateKeyAlgorithm, TOptions extends GenerateKeyOptions> = TOptions["toJWK"] extends true ? GenerateKeyReturnJWK<TAlg> : GenerateKeyReturnCrypto<TAlg>;
-type GenerateJWKOptions = Omit<GenerateKeyOptions, "toJWK">;
+type GenerateJWKOptions = Omit<GenerateKeyOptions, "toJWK" | "extractable">;
 type GenerateJWKReturn<TAlg extends GenerateKeyAlgorithm> = GenerateKeyReturnJWK<TAlg>;
 /** Options for the deriveKeyFromPassword function. */
 interface DeriveKeyOptions {
@@ -94,7 +99,7 @@ interface DeriveKeyOptions {
   iterations: number;
   /** Key usages for the derived key. Defaults to ["wrapKey", "unwrapKey"]. */
   keyUsage?: KeyUsage[];
-  /** Mark the derived key as extractable. Defaults to false. */
+  /** Mark the derived key as extractable. Defaults to false. Ignored when `toJWK` is set — the JWK output requires exporting the derived key. */
   extractable?: boolean;
   /**
   * Export the derived key as JWK_oct. When `true`, returns the derived key in
@@ -126,7 +131,15 @@ type WrappingKeyFor<A extends KeyManagementAlgorithm> = A extends JWK_RSA_ENC ?
 type UnwrappingKeyFor<A extends KeyManagementAlgorithm> = A extends JWK_RSA_ENC ? CryptoKey | JWK_RSA_Private<A> : A extends JWK_ECDH_ES ? CryptoKey | JWK_EC_Private<A> | JWK_OKP_Private<A> : A extends JWK_PBES2 ? string | Uint8Array<ArrayBuffer> | JWK_oct<A> : A extends JWK_AES_KW ? CryptoKey | JWK_oct<A> : A extends JWK_AES_GCM_KW ? CryptoKey | JWK_oct<A | `A${"128" | "192" | "256"}GCM`> : A extends "dir" ? CryptoKey | JWK_oct | Uint8Array<ArrayBuffer> : never;
 /** Options for the wrapKey function. */
 interface WrapKeyOptions {
-  /** Initialization Vector for AES-GCMKW. Generated if not provided. */
+  /**
+  * Initialization Vector for AES-GCMKW. A fresh random IV is generated when
+  * not provided — production code should always omit this option.
+  *
+  * **Never reuse an IV and never derive it from external input.** A single
+  * IV reused under the same wrapping key breaks AES-GCM entirely (plaintext
+  * recovery and forgery). Provided only for tests and reproduction of known
+  * vectors in security research.
+  */
   iv?: Uint8Array<ArrayBuffer>;
   /** PBES2 Salt value (p2s). Required for PBES2 algorithms. */
   p2s?: Uint8Array<ArrayBuffer>;
@@ -228,35 +241,35 @@ interface UnwrapKeyOptions {
 */
 interface JWKParameters<Alg extends string = string> {
   /** JWK "kty" (Key Type) Parameter */
-  kty: string;
+  "kty": string;
   /**
   * JWK "alg" (Algorithm) Parameter
   *
   * @see {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}
   */
-  alg?: Alg;
+  "alg"?: Alg;
   /** JWK "key_ops" (Key Operations) Parameter */
-  key_ops?: KeyUsage[];
+  "key_ops"?: KeyUsage[];
   /** JWK "ext" (Extractable) Parameter */
-  ext?: boolean;
+  "ext"?: boolean;
   /** JWK "use" (Public Key Use) Parameter */
-  use?: string;
+  "use"?: string;
   /** JWK "x5c" (X.509 Certificate Chain) Parameter */
-  x5c?: string[];
+  "x5c"?: string[];
   /** JWK "x5t" (X.509 Certificate SHA-1 Thumbprint) Parameter */
-  x5t?: string;
+  "x5t"?: string;
   /** JWK "x5t#S256" (X.509 Certificate SHA-256 Thumbprint) Parameter */
   "x5t#S256"?: string;
   /** JWK "x5u" (X.509 URL) Parameter */
-  x5u?: string;
+  "x5u"?: string;
   /** JWK "kid" (Key ID) Parameter */
-  kid?: string;
+  "kid"?: string;
   /**
   * Non-standard JWK content encryption algorithm hint.
   * When `alg` is `"dir"`, the library reads this field to infer the
   * content encryption algorithm (`enc`) when it is not provided in options.
   */
-  enc?: ContentEncryptionAlgorithm;
+  "enc"?: ContentEncryptionAlgorithm;
 }
 /** Public EC JSON Web Keys */
 interface JWK_EC_Public<Alg extends JWK_ECDSA | JWK_ECDH_ES | (string & {}) = string> extends JWKParameters<Alg> {
@@ -321,6 +334,8 @@ interface JWK_OKP_Private<Alg extends JWK_OKP_SIGN | JWK_ECDH_ES | (string & {})
 type JWK_OKP<Alg extends JWK_OKP_SIGN | JWK_ECDH_ES | (string & {}) = string> = JWK_OKP_Public<Alg> | JWK_OKP_Private<Alg>;
 /** oct JSON Web Keys */
 interface JWK_oct<Alg extends JWK_HMAC | JWK_AES_KW | JWK_AES_GCM | JWK_AES_GCM_KW | JWK_AES_CBC_HMAC | JWK_PBES2 | "dir" | (string & {}) = string> extends JWKParameters<Alg> {
+  /** Oct JWK "kty" (Key Type) Parameter */
+  kty: "oct";
   /** Oct JWK "k" (Key Value) Parameter */
   k: string;
 }
@@ -654,7 +669,12 @@ interface JWSVerifyResult<T extends JOSEPayload = JOSEPayload> {
 }
 /** Options for JWS verification */
 interface JWSVerifyOptions extends JWTClaimValidationOptions {
-  /** List of allowed algorithms. If provided, the JWS `alg` must be in this list. */
+  /**
+  * List of allowed algorithms. If provided, the JWS `alg` must be in this list.
+  * When omitted, the allowlist is inferred from the key's shape — keys without
+  * usable metadata (raw `Uint8Array`/string, alg-less JWKs, lookup functions)
+  * cannot be inferred and require this option explicitly.
+  */
   algorithms?: JWSAlgorithm[];
   /** If true, forces the payload to be returned as a Uint8Array, otherwise type is inferred. */
   forceUint8Array?: boolean;
@@ -949,7 +969,12 @@ interface JWEEncryptOptions {
 * JWE (JSON Web Encryption) decryption options
 */
 interface JWEDecryptOptions extends JWTClaimValidationOptions {
-  /** A list of allowed JWE "alg" (Algorithm) Header Parameter values for key management. */
+  /**
+  * A list of allowed JWE "alg" (Algorithm) Header Parameter values for key management.
+  * When omitted, the allowlist is inferred from the key's shape — password strings
+  * and raw `Uint8Array` keys infer the PBES2 family plus `dir`; lookup functions
+  * cannot be inferred and require this option explicitly.
+  */
   algorithms?: KeyManagementAlgorithm[];
   /** A list of allowed JWE "enc" (Encryption Algorithm) Header Parameter values for content encryption. */
   encryptionAlgorithms?: ContentEncryptionAlgorithm[];
@@ -1116,4 +1141,4 @@ type ExpiresIn = Duration;
 type NotBeforeIn = Duration;
 /** Duration for `maxTokenAge` validation on {@link verify} / {@link decrypt}. */
 type MaxTokenAge = Duration;
-export { DeriveKeyOptions as $, JWSMultiSigner as A, JWK_PBES2 as At, JWSVerifyResult as B, JWK_Symmetric as Bt, JWSAsymmetricPrivateJWK as C, JWK_EC_Private as Ct, JWSGeneralSignature as D, JWK_OKP_Private as Dt, JWSGeneralSerialization as E, JWK_OKP as Et, JWSProtectedHeader as F, JWK_RSA_ENC as Ft, isJWTError as G, UnwrappingKeyFor as Gt, JWTError as H, JWK_oct as Ht, JWSSignJWK as I, JWK_RSA_PSS as It, JWTClaimValidationOptions as J, WrappingKeyFor as Jt, JOSEPayload as K, WrapKeyOptions as Kt, JWSSignOptions as L, JWK_RSA_Private as Lt, JWSMultiVerifyOptions as M, JWK_Private as Mt, JWSMultiVerifyOutcome as N, JWK_Public as Nt, JWSHeaderParameters as O, JWK_OKP_Public as Ot, JWSMultiVerifyResult as P, JWK_RSA as Pt, ContentEncryptionAlgorithm as Q, JWSVerifyJWK as R, JWK_RSA_Public as Rt, JWSAlgorithm as S, JWK_ECDSA as St, JWSFlattenedSerialization as T, JWK_HMAC as Tt, JWTErrorCauseMap as U, KeyManagementAlgorithm as Ut, StrictOmit as V, JWK_Symmetric_Algorithm as Vt, JWTErrorCode as W, UnwrapKeyOptions as Wt, JoseHeaderParameters as X, JWTClaims as Y, CompositeKey as Z, JWEMultiDecryptOptions as _, JWK_AES_KW as _t, JWEAsymmetricPrivateJWK as a, GenerateKeyReturn as at, JWEMultiRecipient as b, JWK_EC as bt, JWEDecryptOptions as c, JWKCacheAdapter as ct, JWEEncryptOptions as d, JWKPEMAlgorithm as dt, DeriveKeyReturn as et, JWEFlattenedSerialization as f, JWKParameters as ft, JWEKeyManagementHeaderParameters as g, JWK_AES_GCM_KW as gt, JWEHeaderParameters as h, JWK_AES_GCM as ht, NotBeforeIn as i, GenerateKeyOptions as it, JWSMultiVerifyAllOptions as j, JWK_Pair as jt, JWSMultiSignOptions as k, JWK_OKP_SIGN as kt, JWEDecryptResult as l, JWKLookupFunction as lt, JWEGeneralSerialization as m, JWK_AES_CBC_HMAC as mt, ExpiresIn as n, GenerateJWKReturn as nt, JWEAsymmetricPublicJWK as o, JWK as ot, JWEGeneralRecipient as p, JWKSet as pt, JWT as q, WrapKeyResult as qt, MaxTokenAge as r, GenerateKeyAlgorithm as rt, JWEDecryptJWK as s, JWKAlgorithm as st, Duration as t, GenerateJWKOptions as tt, JWEEncryptJWK as u, JWKLookupFunctionHeader as ut, JWEMultiDecryptResult as v, JWK_Asymmetric as vt, JWSAsymmetricPublicJWK as w, JWK_EC_Public as wt, JWEProtectedHeader as x, JWK_ECDH_ES as xt, JWEMultiEncryptOptions as y, JWK_Asymmetric_Algorithm as yt, JWSVerifyOptions as z, JWK_RSA_SIGN as zt };
+export { CompositeKey, ContentEncryptionAlgorithm, DeriveKeyOptions, DeriveKeyReturn, Duration, ExpiresIn, GenerateJWKOptions, GenerateJWKReturn, GenerateKeyAlgorithm, GenerateKeyOptions, GenerateKeyReturn, JOSEPayload, JWEAsymmetricPrivateJWK, JWEAsymmetricPublicJWK, JWEDecryptJWK, JWEDecryptOptions, JWEDecryptResult, JWEEncryptJWK, JWEEncryptOptions, JWEFlattenedSerialization, JWEGeneralRecipient, JWEGeneralSerialization, JWEHeaderParameters, JWEKeyManagementHeaderParameters, JWEMultiDecryptOptions, JWEMultiDecryptResult, JWEMultiEncryptOptions, JWEMultiRecipient, JWEProtectedHeader, JWK, JWKAlgorithm, JWKCacheAdapter, JWKLookupFunction, JWKLookupFunctionHeader, JWKPEMAlgorithm, JWKParameters, JWKSet, JWK_AES_CBC_HMAC, JWK_AES_GCM, JWK_AES_GCM_KW, JWK_AES_KW, JWK_Asymmetric, JWK_Asymmetric_Algorithm, JWK_EC, JWK_ECDH_ES, JWK_ECDSA, JWK_EC_Private, JWK_EC_Public, JWK_HMAC, JWK_OKP, JWK_OKP_Private, JWK_OKP_Public, JWK_OKP_SIGN, JWK_PBES2, JWK_Pair, JWK_Private, JWK_Public, JWK_RSA, JWK_RSA_ENC, JWK_RSA_PSS, JWK_RSA_Private, JWK_RSA_Public, JWK_RSA_SIGN, JWK_Symmetric, JWK_Symmetric_Algorithm, JWK_oct, JWSAlgorithm, JWSAsymmetricPrivateJWK, JWSAsymmetricPublicJWK, JWSFlattenedSerialization, JWSGeneralSerialization, JWSGeneralSignature, JWSHeaderParameters, JWSMultiSignOptions, JWSMultiSigner, JWSMultiVerifyAllOptions, JWSMultiVerifyOptions, JWSMultiVerifyOutcome, JWSMultiVerifyResult, JWSProtectedHeader, JWSSignJWK, JWSSignOptions, JWSVerifyJWK, JWSVerifyOptions, JWSVerifyResult, JWT, JWTClaimValidationOptions, JWTClaims, JWTError, JWTErrorCauseMap, JWTErrorCode, JoseHeaderParameters, KeyManagementAlgorithm, MaxTokenAge, NotBeforeIn, StrictOmit, UnwrapKeyOptions, UnwrappingKeyFor, WrapKeyOptions, WrapKeyResult, WrappingKeyFor, isJWTError };

package/dist/_chunks/jwe.d.mts

@@ -1,4 +1,4 @@
-import { K as JOSEPayload, Q as ContentEncryptionAlgorithm, Ut as KeyManagementAlgorithm, _ as JWEMultiDecryptOptions, b as JWEMultiRecipient, c as JWEDecryptOptions, d as JWEEncryptOptions, f as JWEFlattenedSerialization, l as JWEDecryptResult, lt as JWKLookupFunction, m as JWEGeneralSerialization, pt as JWKSet, s as JWEDecryptJWK, u as JWEEncryptJWK, v as JWEMultiDecryptResult, y as JWEMultiEncryptOptions } from "./index.mjs";
+import { ContentEncryptionAlgorithm, JOSEPayload, JWEDecryptJWK, JWEDecryptOptions, JWEDecryptResult, JWEEncryptJWK, JWEEncryptOptions, JWEFlattenedSerialization, JWEGeneralSerialization, JWEMultiDecryptOptions, JWEMultiDecryptResult, JWEMultiEncryptOptions, JWEMultiRecipient, JWKLookupFunction, JWKSet, KeyManagementAlgorithm } from "./index.mjs";
 /**
 * Encrypt a payload to multiple recipients using JWE General JSON Serialization
 * (RFC 7516 §7.2.1).
@@ -81,4 +81,4 @@ declare function decrypt<T extends JOSEPayload>(jwe: string, key: CryptoKey | JW
 declare function decrypt(jwe: string, key: CryptoKey | JWKSet | JWEDecryptJWK | string | Uint8Array<ArrayBuffer> | JWKLookupFunction, options: JWEDecryptOptions & {
   forceUint8Array: true;
 }): Promise<JWEDecryptResult<Uint8Array<ArrayBuffer>>>;
-export { generalToFlattened as a, encryptMulti as i, encrypt as n, decryptMulti as r, decrypt as t };
+export { decrypt, decryptMulti, encrypt, encryptMulti, generalToFlattened };

package/dist/_chunks/jwe.mjs

@@ -1,7 +1,7 @@
-import { D as JWTError, S as validateCriticalHeadersJWE, b as getPlaintextBytes, f as applyTypCtyDefaults, h as computeJwtTimeClaims, i as isCryptoKey, o as isJWK, s as isJWKSet, y as decodePayloadFromBytes } from "./utils.mjs";
-import { a as base64UrlEncode, i as base64UrlDecode, s as textEncoder, t as secureRandomBytes, u as sanitizeObjectCopy } from "./libs/unsecure.mjs";
-import { C as generateIV, S as generateCEK, _ as unwrapKey, b as decrypt$1, h as importKey, p as getJWKsFromSet, x as encrypt$1, y as encryptKey } from "./jwk.mjs";
-import { i as checkAlgAllowed, l as validateJwtClaimsIfJsonPayload, o as decodeProtectedHeader, r as buildJWKSetFilter, s as parseEphemeralKey, t as JWE_ALG_CTX } from "./_internal.mjs";
+import { JWTError, applyTypCtyDefaults, computeJwtTimeClaims, decodePayloadFromBytes, getPlaintextBytes, isCryptoKey, isJWK, isJWKSet, validateCriticalHeadersJWE } from "./utils.mjs";
+import { base64UrlDecode, base64UrlEncode, sanitizeObjectCopy, secureRandomBytes, textEncoder } from "./libs/unsecure.mjs";
+import { decrypt as decrypt$1, encrypt as encrypt$1, encryptKey, generateCEK, generateIV, getJWKsFromSet, importKey, unwrapKey } from "./jwk.mjs";
+import { JWE_ALG_CTX, buildJWKSetFilter, checkAlgAllowed, decodeProtectedHeader, parseEphemeralKey, validateJwtClaimsIfJsonPayload } from "./_internal.mjs";
 const DIRECT_ALGS = /* @__PURE__ */ new Set(["dir", "ECDH-ES"]);
 async function encryptMulti(payload, recipients, options = {}) {
 	if (!Array.isArray(recipients) || recipients.length === 0) throw new JWTError("encryptMulti requires at least one recipient.", "ERR_JWE_INVALID");
@@ -404,4 +404,4 @@ function _buildJWEHeader(alg, enc, key, userHeader, keyManagementParams, payload
 	header.enc = enc;
 	return applyTypCtyDefaults(header, payload);
 }
-export { generalToFlattened as a, encryptMulti as i, encrypt as n, decryptMulti as r, decrypt as t };
+export { decrypt, decryptMulti, encrypt, encryptMulti, generalToFlattened };

package/dist/_chunks/jwk.mjs

@@ -1,5 +1,5 @@
-import { D as JWTError, a as isCryptoKeyPair, i as isCryptoKey, n as concatUint8Arrays, o as isJWK, r as isAsymmetricJWK, s as isJWKSet, t as assertCryptoKey } from "./utils.mjs";
-import { a as base64UrlEncode, i as base64UrlDecode, n as base64Decode, r as base64Encode, s as textEncoder, t as secureRandomBytes, u as sanitizeObjectCopy } from "./libs/unsecure.mjs";
+import { JWTError, assertCryptoKey, concatUint8Arrays, isAsymmetricJWK, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet } from "./utils.mjs";
+import { base64Decode, base64Encode, base64UrlDecode, base64UrlEncode, sanitizeObjectCopy, secureRandomBytes, textEncoder } from "./libs/unsecure.mjs";
 async function sign(alg, key, data) {
 	checkSigCryptoKey(key, alg, "sign");
 	const signature = await crypto.subtle.sign(subtleAlgorithm(alg, key.algorithm), key, data);
@@ -110,20 +110,20 @@ function checkUsage$4(key, usage) {
 	if (usage && !key.usages.includes(usage)) throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
 }
 const IV_BIT_LENGTHS = {
-	A128GCM: 96,
-	A128GCMKW: 96,
-	A192GCM: 96,
-	A192GCMKW: 96,
-	A256GCM: 96,
-	A256GCMKW: 96,
+	"A128GCM": 96,
+	"A128GCMKW": 96,
+	"A192GCM": 96,
+	"A192GCMKW": 96,
+	"A256GCM": 96,
+	"A256GCMKW": 96,
 	"A128CBC-HS256": 128,
 	"A192CBC-HS384": 128,
 	"A256CBC-HS512": 128
 };
 const CEK_BIT_LENGTHS = {
-	A128GCM: 128,
-	A192GCM: 192,
-	A256GCM: 256,
+	"A128GCM": 128,
+	"A192GCM": 192,
+	"A256GCM": 256,
 	"A128CBC-HS256": 256,
 	"A192CBC-HS384": 384,
 	"A256CBC-HS512": 512
@@ -151,6 +151,16 @@ function checkCEKLength(cek, expected) {
 	const actual = cek.byteLength << 3;
 	if (actual !== expected) throw new Error(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
 }
+function assertOctKeyLength(bytes, alg) {
+	if (!alg) return;
+	if (alg === "HS256" || alg === "HS384" || alg === "HS512") {
+		const minBytes = Number.parseInt(alg.slice(2), 10) >> 3;
+		if (bytes.length < minBytes) throw new JWTError(`${alg} requires a key of at least ${minBytes} bytes (got ${bytes.length})`, "ERR_JWK_INVALID");
+		return;
+	}
+	const exactBits = /^A(128|192|256)(GCM)?KW$/.test(alg) ? Number.parseInt(alg.slice(1, 4), 10) : CEK_BIT_LENGTHS[alg];
+	if (exactBits !== void 0 && bytes.length << 3 !== exactBits) throw new JWTError(`${alg} requires a key of exactly ${exactBits >> 3} bytes (got ${bytes.length})`, "ERR_JWK_INVALID");
+}
 function checkAESCryptoKey(key, alg, usage) {
 	switch (alg) {
 		case "A128GCM":
@@ -192,7 +202,7 @@ async function aesKwUnwrap(alg, key, encryptedKey) {
 	return new Uint8Array(await crypto.subtle.exportKey("raw", cryptoKeyCek));
 }
 async function gcmkwEncrypt(alg, key, plaintext, iv) {
-	const wrapped = await encrypt(alg.slice(0, 7), plaintext, key, iv, new Uint8Array(0));
+	const wrapped = await encrypt(alg.slice(0, 7), plaintext, key, iv, /* @__PURE__ */ new Uint8Array(0));
 	return {
 		encryptedKey: wrapped.ciphertext,
 		iv: base64UrlEncode(wrapped.iv),
@@ -200,7 +210,7 @@ async function gcmkwEncrypt(alg, key, plaintext, iv) {
 	};
 }
 async function gcmkwDecrypt(alg, key, ciphertext, iv, tag) {
-	return decrypt(alg.slice(0, 7), key, ciphertext, iv, tag, new Uint8Array(0));
+	return decrypt(alg.slice(0, 7), key, ciphertext, iv, tag, /* @__PURE__ */ new Uint8Array(0));
 }
 async function encrypt(enc, plaintext, cek, iv, aad) {
 	if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) throw new TypeError("Key must be one of type: CryptoKey or Uint8Array");
@@ -379,7 +389,7 @@ function writeUInt32BE$1(buf, value, offset) {
 function uint64be(value) {
 	const high = Math.floor(value / 2 ** 32);
 	const low = value % 2 ** 32;
-	const buf = new Uint8Array(8);
+	const buf = /* @__PURE__ */ new Uint8Array(8);
 	writeUInt32BE$1(buf, high, 0);
 	writeUInt32BE$1(buf, low, 4);
 	return buf;
@@ -529,7 +539,7 @@ function getHashLength(hash) {
 function checkUsage$2(key, usage) {
 	if (usage && !key.usages.includes(usage)) throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
 }
-async function deriveECDHESKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
+async function deriveECDHESKey(publicKey, privateKey, algorithm, keyLength, apu = /* @__PURE__ */ new Uint8Array(0), apv = /* @__PURE__ */ new Uint8Array(0)) {
 	checkECDHCryptoKey(publicKey, "ECDH");
 	checkECDHCryptoKey(privateKey, "ECDH", "deriveBits");
 	const value = concatUint8Arrays(lengthAndInput(textEncoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
@@ -589,7 +599,7 @@ function writeUInt32BE(buf, value, offset) {
 	], offset);
 }
 function uint32be(value) {
-	const buf = new Uint8Array(4);
+	const buf = /* @__PURE__ */ new Uint8Array(4);
 	writeUInt32BE(buf, value, 0);
 	return buf;
 }
@@ -642,7 +652,7 @@ async function getPBKDF2CryptoKey(key, alg, options = {}) {
 	checkPBES2CryptoKey(key, alg, usage);
 	return key;
 }
-const PUBLIC_EPK_FIELDS = new Set([
+const PUBLIC_EPK_FIELDS = /* @__PURE__ */ new Set([
 	"kty",
 	"crv",
 	"x",
@@ -813,7 +823,7 @@ const assertPEMLabel = (pem, descriptor) => {
 	}
 };
 const genericExport = async (keyType, keyFormat, key) => {
-	if (!isCryptoKey(key)) throw new TypeError(`Key must be ${key} of type CryptoKey`);
+	if (!isCryptoKey(key)) throw new TypeError(`Key must be of type CryptoKey, got ${typeof key}`);
 	if (!key.extractable) throw new TypeError("CryptoKey is not extractable");
 	if (key.type !== keyType) throw new TypeError(`key is not a ${keyType} key`);
 	return formatPEM(base64Encode(new Uint8Array(await crypto.subtle.exportKey(keyFormat, key))), `${keyType.toUpperCase()} KEY`);
@@ -1007,11 +1017,12 @@ const getSPKI = (x509) => {
 			type: "spki"
 		});
 	} catch {}
-	return formatPEM(spkiFromX509(base64Decode(x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, ""), { returnAs: "uint8array" })), "PUBLIC KEY");
+	const raw = base64Decode(x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, ""), { returnAs: "uint8array" });
+	return formatPEM(spkiFromX509(raw), "PUBLIC KEY");
 };
 async function generateKey(alg, options = {}) {
 	const exportToJWK = options.toJWK !== void 0 && options.toJWK !== false;
-	const defaultExtractable = options.extractable !== false;
+	const defaultExtractable = exportToJWK || options.extractable !== false;
 	if (alg === "A128CBC-HS256" || alg === "A192CBC-HS384" || alg === "A256CBC-HS512") {
 		const keyBytes = secureRandomBytes(bitLengthCEK(alg) >> 3);
 		if (exportToJWK) return keyToJWK(keyBytes);
@@ -1039,7 +1050,7 @@ async function generateKey(alg, options = {}) {
 	return key;
 }
 async function generateJWK(alg, options) {
-	const { keyUsage, extractable, modulusLength, publicExponent, namedCurve, ...jwkParams } = options ?? {};
+	const { keyUsage, modulusLength, publicExponent, namedCurve, ...jwkParams } = options ?? {};
 	const kid = typeof jwkParams.kid === "string" ? jwkParams.kid : crypto.randomUUID();
 	const extraParams = {
 		...jwkParams,
@@ -1047,7 +1058,6 @@ async function generateJWK(alg, options) {
 	};
 	const result = await generateKey(alg, {
 		keyUsage,
-		extractable,
 		modulusLength,
 		publicExponent,
 		namedCurve,
@@ -1089,12 +1099,11 @@ async function deriveKeyFromPassword(password, alg, options) {
 	return derivedKey;
 }
 async function deriveJWKFromPassword(password, alg, options) {
-	const { salt, iterations, keyUsage, extractable, ...jwkParams } = options;
+	const { salt, iterations, keyUsage, ...jwkParams } = options;
 	const result = await deriveKeyFromPassword(password, alg, {
 		salt,
 		iterations,
 		keyUsage,
-		extractable,
 		toJWK: true
 	});
 	return Object.keys(jwkParams).length > 0 ? {
@@ -1131,9 +1140,16 @@ async function importKey(key, algOrOptions) {
 	}
 	if (isJWK(key)) if ("k" in key && typeof key.k === "string") {
 		const rawBytes = base64UrlDecode(key.k, { returnAs: "uint8array" });
+		assertOctKeyLength(rawBytes, key.alg || alg);
 		if (typeof algOrOptions === "object" && algOrOptions.asCryptoKey) {
 			const { algorithm, usage, extractable = false } = algOrOptions;
 			if (!algorithm || !usage) throw new JWTError("asCryptoKey option requires `algorithm` and `usage` to be provided.", "ERR_JWK_INVALID");
+			if (typeof algorithm === "object" && algorithm.name === "HMAC") {
+				const hash = algorithm.hash;
+				const hashName = typeof hash === "string" ? hash : hash?.name;
+				const minBytes = Number.parseInt(hashName?.slice(-3) ?? "", 10) / 8;
+				if (minBytes && rawBytes.length < minBytes) throw new JWTError(`HMAC with ${hashName} requires a key of at least ${minBytes} bytes (got ${rawBytes.length})`, "ERR_JWK_INVALID");
+			}
 			return crypto.subtle.importKey("raw", rawBytes, algorithm, extractable, usage);
 		}
 		return rawBytes;
@@ -1186,7 +1202,7 @@ async function wrapKey(alg, keyToWrap, wrappingKey, options = {}) {
 	const cekBytes = keyToWrap instanceof Uint8Array ? keyToWrap : new Uint8Array(await crypto.subtle.exportKey("raw", keyToWrap));
 	const importedWrappingKey = await resolveWrappingKey(alg, wrappingKey, "public");
 	switch (alg) {
-		case "dir": return { encryptedKey: new Uint8Array(0) };
+		case "dir": return { encryptedKey: /* @__PURE__ */ new Uint8Array(0) };
 		case "A128KW":
 		case "A192KW":
 		case "A256KW": return { encryptedKey: await aesKwWrap(alg, importedWrappingKey, cekBytes) };
@@ -1217,8 +1233,8 @@ async function wrapKey(alg, keyToWrap, wrappingKey, options = {}) {
 		case "ECDH-ES+A256KW": {
 			if (!(importedWrappingKey instanceof CryptoKey)) throw new TypeError("ECDH-ES requires the wrapping key to be a CryptoKey (recipient's public key)");
 			if (!isECDHKeyAllowed(importedWrappingKey)) throw new JWTError("ECDH with the provided key is not allowed or not supported", "ERR_JWK_INVALID");
-			const apu = options.ecdh?.partyUInfo ?? new Uint8Array(0);
-			const apv = options.ecdh?.partyVInfo ?? new Uint8Array(0);
+			const apu = options.ecdh?.partyUInfo ?? /* @__PURE__ */ new Uint8Array(0);
+			const apv = options.ecdh?.partyVInfo ?? /* @__PURE__ */ new Uint8Array(0);
 			const { ephemeralPrivateKey, epkJwk } = await resolveECDHEphemeralPair(importedWrappingKey, options.ecdh?.ephemeralKey);
 			const infoAlg = alg === "ECDH-ES" ? (() => {
 				if (!options.ecdh?.enc) throw new JWTError("ECDH-ES direct key agreement requires options.ecdh.enc (the target content encryption algorithm)", "ERR_JWK_INVALID");
@@ -1226,7 +1242,7 @@ async function wrapKey(alg, keyToWrap, wrappingKey, options = {}) {
 			})() : alg;
 			const sharedSecret = await deriveECDHESKey(importedWrappingKey, ephemeralPrivateKey, infoAlg, alg === "ECDH-ES" ? bitLengthCEK(infoAlg) : Number.parseInt(alg.slice(-5, -2), 10), apu, apv);
 			const wrapResult = {
-				encryptedKey: new Uint8Array(0),
+				encryptedKey: /* @__PURE__ */ new Uint8Array(0),
 				epk: epkJwk
 			};
 			if (apu.length > 0) wrapResult.apu = base64UrlEncode(apu);
@@ -1291,8 +1307,8 @@ async function unwrapKey(alg, wrappedKey, unwrappingKey, options = {}) {
 			if (!isECDHKeyAllowed(importedUnwrappingKey)) throw new JWTError("ECDH with the provided key is not allowed or not supported", "ERR_JWK_INVALID");
 			const epkCandidate = options.epk instanceof CryptoKey ? options.epk : await normalizeKey(options.epk, alg);
 			if (!(epkCandidate instanceof CryptoKey)) throw new JWTError("Failed to normalize ECDH ephemeral public key", "ERR_JWK_INVALID");
-			const apuBytes = typeof options.apu === "string" ? base64UrlDecode(options.apu, { returnAs: "uint8array" }) : options.apu ?? new Uint8Array(0);
-			const apvBytes = typeof options.apv === "string" ? base64UrlDecode(options.apv, { returnAs: "uint8array" }) : options.apv ?? new Uint8Array(0);
+			const apuBytes = typeof options.apu === "string" ? base64UrlDecode(options.apu, { returnAs: "uint8array" }) : options.apu ?? /* @__PURE__ */ new Uint8Array(0);
+			const apvBytes = typeof options.apv === "string" ? base64UrlDecode(options.apv, { returnAs: "uint8array" }) : options.apv ?? /* @__PURE__ */ new Uint8Array(0);
 			const infoAlg = alg === "ECDH-ES" ? options.enc : alg;
 			if (!infoAlg) throw new JWTError("ECDH-ES requires content encryption algorithm ('enc') to derive the shared secret", "ERR_JWE_INVALID");
 			const sharedSecret = await deriveECDHESKey(epkCandidate, importedUnwrappingKey, infoAlg, alg === "ECDH-ES" ? bitLengthCEK(infoAlg) : Number.parseInt(alg.slice(-5, -2), 10), apuBytes, apvBytes);
@@ -1310,7 +1326,7 @@ async function unwrapKey(alg, wrappedKey, unwrappingKey, options = {}) {
 	return await crypto.subtle.importKey("raw", unwrappedCekBytes, options.unwrappedKeyAlgorithm || { name: "AES-GCM" }, defaultExtractable, options.keyUsage || ["encrypt", "decrypt"]);
 }
 async function importPEM(pem, alg, options) {
-	const extractable = options?.extractable !== false;
+	const extractable = true;
 	const pemType = options?.pemType ?? inferPEMType(pem);
 	if (!pemType) throw new JWTError("Cannot infer PEM type from the input; pass \"options.pemType\" explicitly.", "ERR_JWK_INVALID");
 	let cryptoKey;
@@ -1324,7 +1340,7 @@ async function importPEM(pem, alg, options) {
 		case "x509":
 			cryptoKey = await fromX509(pem, alg, { extractable });
 			break;
-		default: throw new JWTError(`Unsupported PEM type: ${pemType}`, "ERR_JWK_UNSUPPORTED");
+		default: throw new JWTError(`Unsupported PEM type: ${String(pemType)}`, "ERR_JWK_UNSUPPORTED");
 	}
 	return {
 		...await exportKey(cryptoKey, options?.jwkParams),
@@ -1358,7 +1374,7 @@ async function exportPEM(jwk, options) {
 		case "spki":
 			if (cryptoKey.type !== "public") throw new JWTError(`Only 'public' type CryptoKeys can be exported to SPKI PEM format. Key type is '${cryptoKey.type}'.`, "ERR_JWK_INVALID");
 			return toSPKI(cryptoKey);
-		default: throw new JWTError(`Unsupported PEM format: ${pemFormat}`, "ERR_JWK_UNSUPPORTED");
+		default: throw new JWTError(`Unsupported PEM format: ${String(pemFormat)}`, "ERR_JWK_UNSUPPORTED");
 	}
 }
 async function exportToPEM(jwk, pemFormat, algForCryptoKeyImport) {
@@ -1386,7 +1402,7 @@ async function deriveSharedSecret(publicKey, privateKey, alg, options) {
 	else if (alg === "ECDH-ES") throw new JWTError("deriveSharedSecret with alg \"ECDH-ES\" requires an explicit keyLength in options", "ERR_JWK_INVALID");
 	else if (alg.startsWith("ECDH-ES+")) keyLength = Number.parseInt(alg.slice(-5, -2), 10);
 	else keyLength = bitLengthCEK(alg);
-	return deriveECDHESKey(pubCryptoKey, privCryptoKey, alg, keyLength, options?.partyUInfo ?? new Uint8Array(0), options?.partyVInfo ?? new Uint8Array(0));
+	return deriveECDHESKey(pubCryptoKey, privCryptoKey, alg, keyLength, options?.partyUInfo ?? /* @__PURE__ */ new Uint8Array(0), options?.partyVInfo ?? /* @__PURE__ */ new Uint8Array(0));
 }
 function getJWKFromSet(jwkSet, kidOrProtectedHeader) {
 	if (!jwkSet || !isJWKSet(jwkSet)) throw new JWTError("Invalid JWK Set provided", "ERR_JWK_INVALID");
@@ -1622,4 +1638,4 @@ function inferAesImportAlgorithm(enc, cekLengthBytes) {
 		length: bitLength
 	};
 }
-export { generateIV as C, generateCEK as S, verify as T, unwrapKey as _, deriveKeyFromPassword as a, decrypt as b, exportPEM as c, generateKey as d, getJWKFromSet as f, importPEM as g, importKey as h, deriveJWKFromPassword as i, exportToPEM as l, importFromPEM as m, clearJWKCache as n, deriveSharedSecret as o, getJWKsFromSet as p, configureJWKCache as r, exportKey as s, WeakMapJWKCache as t, generateJWK as u, wrapKey as v, sign as w, encrypt as x, encryptKey as y };
+export { WeakMapJWKCache, assertOctKeyLength, clearJWKCache, configureJWKCache, decrypt, deriveJWKFromPassword, deriveKeyFromPassword, deriveSharedSecret, encrypt, encryptKey, exportKey, exportPEM, exportToPEM, generateCEK, generateIV, generateJWK, generateKey, getJWKFromSet, getJWKsFromSet, importFromPEM, importKey, importPEM, sign, unwrapKey, verify, wrapKey };

package/dist/_chunks/jws.d.mts

@@ -1,4 +1,4 @@
-import { A as JWSMultiSigner, B as JWSVerifyResult, E as JWSGeneralSerialization, I as JWSSignJWK, K as JOSEPayload, L as JWSSignOptions, M as JWSMultiVerifyOptions, N as JWSMultiVerifyOutcome, P as JWSMultiVerifyResult, R as JWSVerifyJWK, S as JWSAlgorithm, T as JWSFlattenedSerialization, j as JWSMultiVerifyAllOptions, k as JWSMultiSignOptions, lt as JWKLookupFunction, pt as JWKSet, z as JWSVerifyOptions } from "./index.mjs";
+import { JOSEPayload, JWKLookupFunction, JWKSet, JWSAlgorithm, JWSFlattenedSerialization, JWSGeneralSerialization, JWSMultiSignOptions, JWSMultiSigner, JWSMultiVerifyAllOptions, JWSMultiVerifyOptions, JWSMultiVerifyOutcome, JWSMultiVerifyResult, JWSSignJWK, JWSSignOptions, JWSVerifyJWK, JWSVerifyOptions, JWSVerifyResult } from "./index.mjs";
 /**
 * Sign a payload with multiple signers using JWS General JSON Serialization
 * (RFC 7515 §7.2.1).
@@ -108,4 +108,4 @@ declare function verify<T extends JOSEPayload>(jws: string, key: CryptoKey | JWK
 declare function verify(jws: string, key: CryptoKey | JWKSet | JWSVerifyJWK | Uint8Array<ArrayBuffer> | JWKLookupFunction, options: JWSVerifyOptions & {
   forceUint8Array: true;
 }): Promise<JWSVerifyResult<Uint8Array<ArrayBuffer>>>;
-export { verifyMulti as a, signMulti as i, verify as n, verifyMultiAll as o, generalToFlattenedJWS as r, sign as t };
+export { generalToFlattenedJWS, sign, signMulti, verify, verifyMulti, verifyMultiAll };

package/dist/_chunks/jws.mjs

@@ -1,7 +1,7 @@
-import { C as validateCriticalHeadersJWS, D as JWTError, b as getPlaintextBytes, f as applyTypCtyDefaults, h as computeJwtTimeClaims, o as isJWK, s as isJWKSet } from "./utils.mjs";
-import { a as base64UrlEncode, i as base64UrlDecode, o as textDecoder, s as textEncoder, u as sanitizeObjectCopy } from "./libs/unsecure.mjs";
-import { T as verify$1, h as importKey, p as getJWKsFromSet, w as sign$1 } from "./jwk.mjs";
-import { a as decodeJWSPayload, c as resolveSigningKey, i as checkAlgAllowed, l as validateJwtClaimsIfJsonPayload, n as JWS_ALG_CTX, o as decodeProtectedHeader, r as buildJWKSetFilter } from "./_internal.mjs";
+import { JWTError, applyTypCtyDefaults, computeJwtTimeClaims, getPlaintextBytes, isJWK, isJWKSet, validateCriticalHeadersJWS } from "./utils.mjs";
+import { base64UrlDecode, base64UrlEncode, sanitizeObjectCopy, textDecoder, textEncoder } from "./libs/unsecure.mjs";
+import { getJWKsFromSet, importKey, sign as sign$1, verify as verify$1 } from "./jwk.mjs";
+import { JWS_ALG_CTX, buildJWKSetFilter, checkAlgAllowed, decodeJWSPayload, decodeProtectedHeader, resolveSigningKey, validateJwtClaimsIfJsonPayload } from "./_internal.mjs";
 async function signMulti(payload, signers, options = {}) {
 	if (!Array.isArray(signers) || signers.length === 0) throw new JWTError("signMulti requires at least one signer.", "ERR_JWS_INVALID");
 	const resolvedAlgs = signers.map((s, i) => _resolveSignerAlg(s.key, i));
@@ -327,7 +327,7 @@ async function verify(jws, key, options = {}) {
 	try {
 		payload = decodeJWSPayload(payloadEncoded, useB64, options.forceUint8Array);
 	} catch (error_) {
-		throw new JWTError(`Invalid JWS: Payload decoding failed (${error_ instanceof Error ? error_.message : error_})`, "ERR_JWS_INVALID");
+		throw new JWTError(`Invalid JWS: Payload decoding failed (${error_ instanceof Error ? error_.message : String(error_)})`, "ERR_JWS_INVALID");
 	}
 	validateCriticalHeadersJWS(protectedHeader, options.recognizedHeaders);
 	validateJwtClaimsIfJsonPayload(payload, options);
@@ -346,4 +346,4 @@ function _buildJWSHeader(alg, key, userHeader, payload) {
 	if (header.b64 === true) delete header.b64;
 	return header;
 }
-export { verifyMulti as a, signMulti as i, verify as n, verifyMultiAll as o, generalToFlattenedJWS as r, sign as t };
+export { generalToFlattenedJWS, sign, signMulti, verify, verifyMulti, verifyMultiAll };

package/dist/_chunks/libs/unsecure.d.mts

@@ -91,4 +91,4 @@ declare function base64UrlDecode(data: Uint8Array): Uint8Array<ArrayBuffer>;
 type DecodeReturnAs = "string" | "uint8array" | "bytes";
 declare const textEncoder: TextEncoder;
 declare const textDecoder: TextDecoder;
-export { textDecoder as a, sanitizeObject as c, base64UrlEncode as i, sanitizeObjectCopy as l, base64Encode as n, textEncoder as o, base64UrlDecode as r, safeJsonParse as s, base64Decode as t, secureRandomBytes as u };
+export { base64Decode, base64Encode, base64UrlDecode, base64UrlEncode, safeJsonParse, sanitizeObject, sanitizeObjectCopy, secureRandomBytes, textDecoder, textEncoder };

package/dist/_chunks/libs/unsecure.mjs

@@ -106,7 +106,7 @@ function base64Decode(data, options) {
 	const isBufferInput = data instanceof Uint8Array;
 	const str = isBufferInput ? textDecoder.decode(data) : data;
 	const decodeToString = (options?.returnAs ?? (isBufferInput ? "uint8array" : "string")) === "string";
-	if (!str) return decodeToString ? "" : new Uint8Array(0);
+	if (!str) return decodeToString ? "" : /* @__PURE__ */ new Uint8Array(0);
 	if (_hasBuffer) {
 		const buf = _Buffer.from(str, "base64");
 		return decodeToString ? buf.toString("utf8") : new Uint8Array(buf);
@@ -119,7 +119,7 @@ function base64UrlDecode(data, options) {
 	const isBufferInput = data instanceof Uint8Array;
 	let str = isBufferInput ? textDecoder.decode(data) : data;
 	const decodeToString = (options?.returnAs ?? (isBufferInput ? "uint8array" : "string")) === "string";
-	if (!str) return decodeToString ? "" : new Uint8Array(0);
+	if (!str) return decodeToString ? "" : /* @__PURE__ */ new Uint8Array(0);
 	if (_hasBuffer) {
 		const buf = _Buffer.from(str, "base64url");
 		return decodeToString ? buf.toString("utf8") : new Uint8Array(buf);
@@ -146,4 +146,4 @@ function secureRandomBytes(length) {
 	}
 	return bytes;
 }
-export { base64UrlEncode as a, safeJsonParse as c, base64UrlDecode as i, sanitizeObject as l, base64Decode as n, textDecoder as o, base64Encode as r, textEncoder as s, secureRandomBytes as t, sanitizeObjectCopy as u };
+export { base64Decode, base64Encode, base64UrlDecode, base64UrlEncode, safeJsonParse, sanitizeObject, sanitizeObjectCopy, secureRandomBytes, textDecoder, textEncoder };

package/dist/_chunks/utils.mjs

@@ -1,4 +1,4 @@
-import { c as safeJsonParse, i as base64UrlDecode, o as textDecoder, s as textEncoder } from "./libs/unsecure.mjs";
+import { base64UrlDecode, safeJsonParse, textDecoder, textEncoder } from "./libs/unsecure.mjs";
 var JWTError = class extends Error {
 	code;
 	cause;
@@ -209,7 +209,9 @@ function _parseDurationSeconds(value) {
 	if (typeof value === "string") {
 		const match = value.match(DURATION_REGEX);
 		if (!match || !match[1]) throw new TypeError("Invalid duration format. Must be an integer or a string like '10m', '2h', '7D', etc.");
-		return Number.parseInt(match[1], 10) * TIME_CONSTANTS[match[2] || "s"];
+		const n = Number.parseInt(match[1], 10);
+		const unit = match[2] || "s";
+		return n * TIME_CONSTANTS[unit];
 	}
 	throw new TypeError("Duration must be a number or a string representing time.");
 }
@@ -317,7 +319,7 @@ const BASE_PROCESSED_JWE = [
 function validateCriticalHeadersJWS(protectedHeader, recognizedHeaders = []) {
 	if (!protectedHeader.crit) return;
 	const missingHeaderParams = /* @__PURE__ */ new Set();
-	const recognizedParams = new Set([...recognizedHeaders, ...BASE_PROCESSED_JWS]);
+	const recognizedParams = /* @__PURE__ */ new Set([...recognizedHeaders, ...BASE_PROCESSED_JWS]);
 	for (const param of protectedHeader.crit) {
 		if (recognizedParams.has(param) && (param in protectedHeader || param === "b64")) continue;
 		missingHeaderParams.add(param);
@@ -326,7 +328,7 @@ function validateCriticalHeadersJWS(protectedHeader, recognizedHeaders = []) {
 }
 function validateCriticalHeadersJWE(protectedHeader, recognizedHeaders) {
 	if (!protectedHeader.crit) return;
-	const understoodParams = new Set([...recognizedHeaders || [], ...BASE_PROCESSED_JWE]);
+	const understoodParams = /* @__PURE__ */ new Set([...recognizedHeaders || [], ...BASE_PROCESSED_JWE]);
 	for (const critParam of protectedHeader.crit) {
 		if (!Object.prototype.hasOwnProperty.call(protectedHeader, critParam)) throw new JWTError(`Critical header parameter "${critParam}" listed in "crit" but not present in the protected header.`, "ERR_JWE_INVALID");
 		if (!understoodParams.has(critParam)) throw new JWTError(`Unprocessed critical header parameters: ${critParam}`, "ERR_JWE_INVALID");
@@ -346,7 +348,7 @@ function maybeArray(item) {
 	return Array.isArray(item) ? item : [item];
 }
 function isJWK(key) {
-	return typeof key === "object" && key !== null && "kty" in key && typeof key.kty === "string";
+	return typeof key === "object" && key !== null && (key.kty === "oct" || key.kty === "RSA" || key.kty === "EC" || key.kty === "OKP");
 }
 function isJWKSet(key) {
 	return key && typeof key === "object" && "keys" in key && Array.isArray(key.keys);
@@ -387,4 +389,4 @@ function isPublicJWK(key) {
 	}
 	return false;
 }
-export { validateCriticalHeadersJWS as C, JWTError as D, inferJWSAllowedAlgorithms as E, isJWTError as O, validateCriticalHeadersJWE as S, inferJWEAllowedAlgorithms as T, decodeMaybeJWTString as _, isCryptoKeyPair as a, getPlaintextBytes as b, isPrivateJWK as c, maybeArray as d, applyTypCtyDefaults as f, computeMaxTokenAgeSeconds as g, computeJwtTimeClaims as h, isCryptoKey as i, isPublicJWK as l, computeExpiresInSeconds as m, concatUint8Arrays as n, isJWK as o, computeDurationInSeconds as p, isAsymmetricJWK as r, isJWKSet as s, assertCryptoKey as t, isSymmetricJWK as u, decodePayloadFromB64UrlSegment as v, validateJwtClaims as w, isJWTContent as x, decodePayloadFromBytes as y };
+export { JWTError, applyTypCtyDefaults, assertCryptoKey, computeDurationInSeconds, computeExpiresInSeconds, computeJwtTimeClaims, computeMaxTokenAgeSeconds, concatUint8Arrays, decodeMaybeJWTString, decodePayloadFromB64UrlSegment, decodePayloadFromBytes, getPlaintextBytes, inferJWEAllowedAlgorithms, inferJWSAllowedAlgorithms, isAsymmetricJWK, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet, isJWTContent, isJWTError, isPrivateJWK, isPublicJWK, isSymmetricJWK, maybeArray, validateCriticalHeadersJWE, validateCriticalHeadersJWS, validateJwtClaims };