unjwt 0.5.7 → 0.5.9

package/dist/index.mjs

@@ -1,5 +1,5 @@
 export { i as utils } from './shared/unjwt.BHpknTpg.mjs';
 export { j as jwe } from './shared/unjwt.B2olxeGL.mjs';
 export { j as jwk } from './shared/unjwt.DRUXIabl.mjs';
-export { j as jws } from './shared/unjwt.DqUOpdA-.mjs';
+export { j as jws } from './shared/unjwt.wHjOCapq.mjs';
 import './shared/unjwt.Ca03jPX3.mjs';

package/dist/jws.mjs

@@ -1,4 +1,4 @@
 import './shared/unjwt.DRUXIabl.mjs';
 import './shared/unjwt.BHpknTpg.mjs';
 import './shared/unjwt.Ca03jPX3.mjs';
-export { s as sign, v as verify } from './shared/unjwt.DqUOpdA-.mjs';
+export { s as sign, v as verify } from './shared/unjwt.wHjOCapq.mjs';

package/dist/shared/{unjwt.DqUOpdA-.mjs → unjwt.wHjOCapq.mjs}

@@ -16,6 +16,8 @@ async function sign(payload, key, options = {}) {
   const signingKey = await importKey(key, alg);
   const protectedHeader = {
     ...additionalProtectedHeader,
+    ...isJWK(key) && key.kid ? { kid: additionalProtectedHeader?.kid || key.kid } : {},
+    // Include kid if available
     alg,
     typ: additionalProtectedHeader?.typ ?? (typeof payload === "object" && !(payload instanceof Uint8Array) ? "JWT" : void 0)
     // Default typ to JWT for objects
@@ -30,9 +32,11 @@ async function sign(payload, key, options = {}) {
   let computedPayload = void 0;
   if (options.expiresIn !== void 0 && protectedHeader.typ === "JWT" && typeof payload === "object" && !(payload instanceof Uint8Array) && !payload.exp) {
     computedPayload = { ...payload };
-    const iat = typeof payload.iat === "number" ? payload.iat : Math.round((options.currentDate ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
-    computedPayload.iat = iat;
-    computedPayload.exp = iat + options.expiresIn;
+    const currentTime = Math.round(
+      (options.currentDate ?? /* @__PURE__ */ new Date()).getTime() / 1e3
+    );
+    computedPayload.iat ||= currentTime;
+    computedPayload.exp = currentTime + options.expiresIn;
   }
   const protectedHeaderString = JSON.stringify(protectedHeader);
   const protectedHeaderEncoded = base64UrlEncode(protectedHeaderString);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unjwt",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Low-level JWT utilities",
   "repository": "sandros94/unjwt",
   "license": "MIT",

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-export { C as CompositeKey, d as ContentEncryptionAlgorithm, D as DeriveKeyOptions, c as DeriveKeyReturn, G as GenerateKeyAlgorithm, a as GenerateKeyOptions, b as GenerateKeyReturn, m as JWK, E as JWKAlgorithm, F as JWKPEMAlgorithm, J as JWKParameters, n as JWKSet, v as JWK_AES_CBC_HMAC, w as JWK_AES_GCM, u as JWK_AES_GCM_KW, t as JWK_AES_KW, B as JWK_Asymmetric_Algorithm, h as JWK_EC, y as JWK_ECDH_ES, r as JWK_ECDSA, g as JWK_EC_Private, f as JWK_EC_Public, z as JWK_ED, o as JWK_HMAC, x as JWK_PBES2, k as JWK_RSA, s as JWK_RSA_ENC, q as JWK_RSA_PSS, j as JWK_RSA_Private, i as JWK_RSA_Public, p as JWK_RSA_SIGN, A as JWK_Symmetric_Algorithm, l as JWK_oct, K as KeyManagementAlgorithm, U as UnwrapKeyOptions, W as WrapKeyOptions, e as WrapKeyResult } from './shared/unjwt.D9da8HQF.js';
-export { b as JWT, a as JWTClaims, J as JoseHeaderParameters } from './shared/unjwt.c10n3uM8.js';
-export { J as JWSAlgorithm, a as JWSHeaderParameters, f as JWSKeyLookupFunction, b as JWSProtectedHeader, c as JWSSignOptions, e as JWSVerifyOptions, d as JWSVerifyResult, j as jws } from './shared/unjwt.w-IAnI15.js';
-export { d as JWEDecryptOptions, e as JWEDecryptResult, b as JWEEncryptOptions, J as JWEHeaderParameters, c as JWEKeyLookupFunction, a as JWEKeyManagementHeaderParameters, j as jwe } from './shared/unjwt.CoSilGqk.js';
-export { i as utils } from './shared/unjwt.D4DUiNeM.js';
-export { j as jwk } from './shared/unjwt.CrcUJklb.js';

package/dist/jwe.d.ts

@@ -1,3 +0,0 @@
-import './shared/unjwt.D9da8HQF.js';
-import './shared/unjwt.c10n3uM8.js';
-export { d as JWEDecryptOptions, e as JWEDecryptResult, b as JWEEncryptOptions, J as JWEHeaderParameters, c as JWEKeyLookupFunction, a as JWEKeyManagementHeaderParameters, g as decrypt, f as encrypt } from './shared/unjwt.CoSilGqk.js';

package/dist/jwk.d.ts

@@ -1,3 +0,0 @@
-export { C as CompositeKey, d as ContentEncryptionAlgorithm, D as DeriveKeyOptions, c as DeriveKeyReturn, G as GenerateKeyAlgorithm, a as GenerateKeyOptions, b as GenerateKeyReturn, m as JWK, E as JWKAlgorithm, F as JWKPEMAlgorithm, J as JWKParameters, n as JWKSet, v as JWK_AES_CBC_HMAC, w as JWK_AES_GCM, u as JWK_AES_GCM_KW, t as JWK_AES_KW, B as JWK_Asymmetric_Algorithm, h as JWK_EC, y as JWK_ECDH_ES, r as JWK_ECDSA, g as JWK_EC_Private, f as JWK_EC_Public, z as JWK_ED, o as JWK_HMAC, x as JWK_PBES2, k as JWK_RSA, s as JWK_RSA_ENC, q as JWK_RSA_PSS, j as JWK_RSA_Private, i as JWK_RSA_Public, p as JWK_RSA_SIGN, A as JWK_Symmetric_Algorithm, l as JWK_oct, K as KeyManagementAlgorithm, U as UnwrapKeyOptions, W as WrapKeyOptions, e as WrapKeyResult } from './shared/unjwt.D9da8HQF.js';
-import './shared/unjwt.c10n3uM8.js';
-export { d as deriveKeyFromPassword, b as exportJWKToPEM, e as exportKey, g as generateKey, c as getJWKFromSet, a as importJWKFromPEM, i as importKey, u as unwrapKey, w as wrapKey } from './shared/unjwt.CrcUJklb.js';

package/dist/jws.d.ts

@@ -1,3 +0,0 @@
-import './shared/unjwt.D9da8HQF.js';
-import './shared/unjwt.c10n3uM8.js';
-export { J as JWSAlgorithm, a as JWSHeaderParameters, f as JWSKeyLookupFunction, b as JWSProtectedHeader, c as JWSSignOptions, e as JWSVerifyOptions, d as JWSVerifyResult, s as sign, v as verify } from './shared/unjwt.w-IAnI15.js';

package/dist/shared/unjwt.CoSilGqk.d.ts

@@ -1,189 +0,0 @@
-import { K as KeyManagementAlgorithm, d as ContentEncryptionAlgorithm, f as JWK_EC_Public, m as JWK } from './unjwt.D9da8HQF.js';
-import { J as JoseHeaderParameters, a as JWTClaims } from './unjwt.c10n3uM8.js';
-
-/** Recognized JWE Header Parameters, any other Header Members may also be present. */
-interface JWEHeaderParameters extends JoseHeaderParameters {
-    /**
-     * `alg` (Algorithm): Header Parameter - Key Management Algorithm
-     */
-    alg?: string;
-    /**
-     * `enc` (Encryption Algorithm): Header Parameter - Content Encryption Algorithm
-     */
-    enc?: string;
-    /**
-     * `p2c` (PBES2 Count): Header Parameter
-     */
-    p2c?: number;
-    /**
-     * `p2s` (PBES2 Salt): Header Parameter. Base64URL encoded.
-     */
-    p2s?: string;
-    /**
-     * "iv" (Initialization Vector) Header Parameter for AES GCM Key Wrapping. Base64URL encoded.
-     */
-    iv?: string;
-    /**
-     * "tag" (Authentication Tag) Header Parameter for AES GCM Key Wrapping. Base64URL encoded.
-     */
-    tag?: string;
-    /**
-     * "epk" (Ephemeral Public Key) Header Parameter for ECDH-ES.
-     */
-    epk?: JWK_EC_Public;
-    /**
-     * "apu" (Agreement PartyUInfo) Header Parameter for ECDH-ES. Base64URL encoded.
-     */
-    apu?: string;
-    /**
-     * "apv" (Agreement PartyVInfo) Header Parameter for ECDH-ES. Base64URL encoded.
-     */
-    apv?: string;
-    /** Any other JWE Header member. */
-    [propName: string]: unknown;
-}
-/** Recognized JWE Key Management-related Header Parameters. */
-interface JWEKeyManagementHeaderParameters {
-    apu?: Uint8Array;
-    apv?: Uint8Array;
-    /**
-     * For Internal use only
-     */
-    p2c?: number;
-    /**
-     * For Internal use only
-     */
-    p2s?: Uint8Array;
-    /**
-     * For Internal use only
-     */
-    iv?: Uint8Array;
-    /**
-     * For Internal use only
-     */
-    epk?: CryptoKey;
-}
-/**
- * JWE (JSON Web Encryption) encryption options
- */
-interface JWEEncryptOptions {
-    /** JWE "alg" (Algorithm) Header Parameter. Key Management Algorithm. */
-    alg?: KeyManagementAlgorithm;
-    /** JWE "enc" (Encryption Algorithm) Header Parameter. Content Encryption Algorithm. */
-    enc?: ContentEncryptionAlgorithm;
-    /** Additional JWE Protected Header parameters. */
-    protectedHeader?: Omit<JWEHeaderParameters, "alg" | "enc" | "iv" | "tag" | "p2s" | "p2c" | "apu" | "apv">;
-    /** Initialization Vector for AES-GCMKW key wrapping. Generated if not provided. */
-    keyManagementIV?: Uint8Array;
-    /** PBES2 Salt value (p2s). Required for PBES2 algorithms. */
-    p2s?: Uint8Array;
-    /** PBES2 Iteration count (p2c). Required for PBES2 algorithms. */
-    p2c?: number;
-    /** ECDH-ES Agreement PartyUInfo. */
-    ecdhPartyUInfo?: Uint8Array;
-    /** ECDH-ES Agreement PartyVInfo. */
-    ecdhPartyVInfo?: Uint8Array;
-    /**
-     * Content Encryption Key (CEK) to use.
-     * If provided, it will be used directly. Otherwise, a CEK will be generated.
-     */
-    cek?: Uint8Array;
-    /**
-     * Initialization Vector for content encryption.
-     * If provided, it will be used. Otherwise, one will be generated.
-     */
-    contentEncryptionIV?: Uint8Array;
-}
-/**
- * Key lookup function for JWE decryption.
- * @param header The JWE Protected Header.
- * @returns The key material (CryptoKey, JWK, password string, or raw Uint8Array) or a Promise resolving to it.
- */
-type JWEKeyLookupFunction = (header: JWEHeaderParameters, token: string) => CryptoKey | JWK | string | Uint8Array | Promise<CryptoKey | JWK | string | Uint8Array>;
-/**
- * JWE (JSON Web Encryption) decryption options
- */
-interface JWEDecryptOptions {
-    /** A list of allowed JWE "alg" (Algorithm) Header Parameter values for key management. */
-    algorithms?: KeyManagementAlgorithm[];
-    /** A list of allowed JWE "enc" (Encryption Algorithm) Header Parameter values for content encryption. */
-    encryptionAlgorithms?: ContentEncryptionAlgorithm[];
-    /**
-     * Critical Header Parameters to be understood and processed.
-     * If the JWE contains critical headers not in this list (and not inherently understood by the library), decryption will fail.
-     */
-    critical?: string[];
-    /** Algorithm to import the unwrapped CEK as (e.g., { name: 'AES-GCM' }). Defaults based on 'enc'. */
-    unwrappedKeyAlgorithm?: Parameters<typeof crypto.subtle.importKey>[2];
-    /** Key usages for the unwrapped CEK. Defaults based on 'enc' (typically ['encrypt', 'decrypt']). */
-    keyUsage?: KeyUsage[];
-    /** Mark the unwrapped CEK as extractable. Defaults to true. */
-    extractable?: boolean;
-    /** If true, forces the payload to be returned as a Uint8Array, otherwise type is inferred based on JWE headers. */
-    forceUint8Array?: boolean;
-}
-/**
- * Result of a JWE decryption operation.
- */
-interface JWEDecryptResult<T extends JWTClaims | Uint8Array | string = JWTClaims | Uint8Array | string> {
-    /** The decrypted payload. */
-    payload: T;
-    /** The JWE Protected Header. */
-    protectedHeader: JWEHeaderParameters;
-    /** The Content Encryption Key (CEK) used for decryption, as Uint8Array. */
-    cek: Uint8Array;
-    /** The Additional Authenticated Data (AAD) used, as Uint8Array. */
-    aad: Uint8Array;
-}
-
-/**
- * Encrypts a payload to produce a JWE Compact Serialization string.
- *
- * @param payload The payload to encrypt. Can be a string, Uint8Array, or a JSON-serializable object.
- * @param key The key encryption key (KEK). Can be a CryptoKey, JWK, or for PBES2, a password string/Uint8Array.
- * @param options JWE encryption options, including `alg` (key management algorithm) and `enc` (content encryption algorithm).
- * @returns A Promise resolving to the JWE Compact Serialization string.
- */
-declare function encrypt(payload: JWTClaims, key: JWK | string | Uint8Array, options?: JWEEncryptOptions): Promise<string>;
-declare function encrypt(payload: string | Uint8Array | Record<string, any>, key: JWK | string | Uint8Array, options?: JWEEncryptOptions): Promise<string>;
-declare function encrypt(payload: JWTClaims, key: CryptoKey, options: JWEEncryptOptions & {
-    alg: KeyManagementAlgorithm;
-    enc: ContentEncryptionAlgorithm;
-}): Promise<string>;
-declare function encrypt(payload: string | Uint8Array | Record<string, any>, key: CryptoKey, options: JWEEncryptOptions & {
-    alg: KeyManagementAlgorithm;
-    enc: ContentEncryptionAlgorithm;
-}): Promise<string>;
-declare function encrypt(payload: string | Uint8Array | Record<string, any>, key: CryptoKey | JWK | string | Uint8Array, options: JWEEncryptOptions & {
-    alg: KeyManagementAlgorithm;
-    enc: ContentEncryptionAlgorithm;
-}): Promise<string>;
-/**
- * Decrypts a JWE Compact Serialization string.
- *
- * @param jwe The JWE Compact Serialization string.
- * @param key The key decryption key (KEK) or a function to look up the key.
- * @param options JWE decryption options.
- * @returns A Promise resolving to an object containing the decrypted plaintext, protected header, CEK, and AAD.
- * @throws If JWE is invalid, decryption fails, or options are not met.
- */
-declare function decrypt<T extends JWTClaims | Uint8Array | string>(jwe: string, key: CryptoKey | JWK | string | Uint8Array | JWEKeyLookupFunction, options?: JWEDecryptOptions): Promise<JWEDecryptResult<T>>;
-declare function decrypt(jwe: string, key: CryptoKey | JWK | string | Uint8Array | JWEKeyLookupFunction, options: JWEDecryptOptions & {
-    forceUint8Array: true;
-}): Promise<JWEDecryptResult<Uint8Array>>;
-
-type jwe_JWEDecryptOptions = JWEDecryptOptions;
-type jwe_JWEDecryptResult<T extends JWTClaims | Uint8Array | string = JWTClaims | Uint8Array | string> = JWEDecryptResult<T>;
-type jwe_JWEEncryptOptions = JWEEncryptOptions;
-type jwe_JWEHeaderParameters = JWEHeaderParameters;
-type jwe_JWEKeyLookupFunction = JWEKeyLookupFunction;
-type jwe_JWEKeyManagementHeaderParameters = JWEKeyManagementHeaderParameters;
-declare const jwe_decrypt: typeof decrypt;
-declare const jwe_encrypt: typeof encrypt;
-declare namespace jwe {
-  export { jwe_decrypt as decrypt, jwe_encrypt as encrypt };
-  export type { jwe_JWEDecryptOptions as JWEDecryptOptions, jwe_JWEDecryptResult as JWEDecryptResult, jwe_JWEEncryptOptions as JWEEncryptOptions, jwe_JWEHeaderParameters as JWEHeaderParameters, jwe_JWEKeyLookupFunction as JWEKeyLookupFunction, jwe_JWEKeyManagementHeaderParameters as JWEKeyManagementHeaderParameters };
-}
-
-export { encrypt as f, decrypt as g, jwe as j };
-export type { JWEHeaderParameters as J, JWEKeyManagementHeaderParameters as a, JWEEncryptOptions as b, JWEKeyLookupFunction as c, JWEDecryptOptions as d, JWEDecryptResult as e };

package/dist/shared/unjwt.CrcUJklb.d.ts

@@ -1,221 +0,0 @@
-import { G as GenerateKeyAlgorithm, a as GenerateKeyOptions, b as GenerateKeyReturn, x as JWK_PBES2, D as DeriveKeyOptions, c as DeriveKeyReturn, l as JWK_oct, m as JWK, K as KeyManagementAlgorithm, W as WrapKeyOptions, e as WrapKeyResult, U as UnwrapKeyOptions, F as JWKPEMAlgorithm, n as JWKSet, C as CompositeKey, d as ContentEncryptionAlgorithm, E as JWKAlgorithm, J as JWKParameters, v as JWK_AES_CBC_HMAC, w as JWK_AES_GCM, u as JWK_AES_GCM_KW, t as JWK_AES_KW, B as JWK_Asymmetric_Algorithm, h as JWK_EC, y as JWK_ECDH_ES, r as JWK_ECDSA, g as JWK_EC_Private, f as JWK_EC_Public, z as JWK_ED, o as JWK_HMAC, k as JWK_RSA, s as JWK_RSA_ENC, q as JWK_RSA_PSS, j as JWK_RSA_Private, i as JWK_RSA_Public, p as JWK_RSA_SIGN, A as JWK_Symmetric_Algorithm } from './unjwt.D9da8HQF.js';
-import { J as JoseHeaderParameters } from './unjwt.c10n3uM8.js';
-
-/**
- * This is a fork of Jose library's utility functions.
- * @source https://github.com/panva/jose/tree/69b7960c67e05be55fa2ec31c74b987696c20c60/src/lib/asn1.ts
- * @license MIT https://github.com/panva/jose/blob/69b7960c67e05be55fa2ec31c74b987696c20c60/LICENSE.md
- */
-/** Key Import Function options. */
-interface KeyImportOptions {
-    /**
-     * The value to use as {@link !SubtleCrypto.importKey} `extractable` argument. Default is false for
-     * private keys, true otherwise.
-     */
-    extractable?: boolean;
-}
-
-/**
- * Generates a cryptographic key for the specified algorithm.
- *
- * @param alg The JWA algorithm identifier (e.g., "HS256", "RS256", "A128GCM").
- * @param options Configuration options for key generation.
- * @returns A Promise resolving to the generated key (CryptoKey, CryptoKeyPair, or Uint8Array) or its JWK representation.
- */
-declare function generateKey<TAlg extends GenerateKeyAlgorithm, TOptions extends GenerateKeyOptions>(alg: TAlg, options?: TOptions): Promise<GenerateKeyReturn<TAlg, TOptions>>;
-/**
- * Derives a key from a password using PBKDF2 as specified by PBES2 algorithms.
- *
- * @param password The password to derive the key from (string or Uint8Array).
- * @param alg The PBES2 algorithm identifier (e.g., "PBES2-HS256+A128KW").
- * @param options Configuration options including salt and iterations.
- * @returns A Promise resolving to the derived key (CryptoKey) or its JWK_oct representation.
- */
-declare function deriveKeyFromPassword<TAlg extends JWK_PBES2, TOptions extends DeriveKeyOptions>(password: string | Uint8Array, alg: TAlg, options: TOptions): Promise<DeriveKeyReturn<TOptions>>;
-/**
- * Imports a key from various formats (CryptoKey, JWK, Uint8Array).
- *
- * - If `key` is a CryptoKey, it's returned directly.
- * - If `key` is a Uint8Array, it's returned directly.
- * - If `key` is a JWK_oct (symmetric key with 'k'), the raw key bytes are returned as Uint8Array.
- * - If `key` is any other JWK type (asymmetric), the `alg` parameter is required, and a CryptoKey is returned.
- *
- * @param key The key to import.
- * @param alg The algorithm hint, required when importing asymmetric JWKs.
- * @returns A Promise resolving to the imported key as CryptoKey or Uint8Array.
- */
-declare function importKey(key: string): Promise<Uint8Array>;
-declare function importKey(key: Uint8Array): Promise<Uint8Array>;
-declare function importKey(key: CryptoKey): Promise<CryptoKey>;
-declare function importKey(key: JWK_oct): Promise<Uint8Array>;
-declare function importKey(key: CryptoKey | JWK | Uint8Array | string, alg?: string): Promise<CryptoKey | Uint8Array>;
-/**
- * Exports a CryptoKey to a JWK (JSON Web Key) format.
- *
- * @param key The CryptoKey to export.
- * @param jwk Optional partial JWK to merge with the exported key, allowing overrides.
- * @returns A Promise resolving to the exported JWK.
- */
-declare function exportKey(key: CryptoKey, jwk?: Partial<JWK>): Promise<JWK>;
-/**
- * Wraps a Content Encryption Key (CEK) using the specified algorithm and wrapping key.
- *
- * @param alg The JWA key management algorithm (e.g., "A128KW", "RSA-OAEP", "PBES2-HS256+A128KW").
- * @param keyToWrap The key to be wrapped (CEK), typically a symmetric key as Uint8Array or CryptoKey.
- * @param wrappingKey The key used to wrap the CEK (CryptoKey, JWK, or password string/Uint8Array for PBES2).
- * @param options Additional options required by certain algorithms (e.g., p2s, p2c for PBES2).
- * @returns A Promise resolving to an object containing the wrapped key and any necessary parameters (iv, tag, epk, etc.).
- */
-declare function wrapKey(alg: KeyManagementAlgorithm, keyToWrap: CryptoKey | Uint8Array, wrappingKey: CryptoKey | JWK | string | Uint8Array, options?: WrapKeyOptions): Promise<WrapKeyResult>;
-/**
- * Unwraps a Content Encryption Key (CEK) using the specified algorithm and unwrapping key.
- *
- * @param alg The JWA key management algorithm (e.g., "A128KW", "RSA-OAEP", "PBES2-HS256+A128KW").
- * @param wrappedKey The wrapped key (ciphertext) as Uint8Array.
- * @param unwrappingKey The key used to unwrap the CEK (CryptoKey, JWK, or password string/Uint8Array for PBES2).
- * @param options Additional options required by certain algorithms (e.g., iv, tag, p2s, p2c, epk).
- * @returns A Promise resolving to the unwrapped key (CEK) as a CryptoKey or Uint8Array.
- */
-declare function unwrapKey<T extends boolean | undefined = undefined>(alg: KeyManagementAlgorithm, wrappedKey: Uint8Array, unwrappingKey: CryptoKey | JWK | string | Uint8Array, options?: UnwrapKeyOptions & {
-    returnAs?: T;
-}): Promise<T extends false ? Uint8Array : CryptoKey>;
-/**
- * Imports a key from a PEM-encoded string and converts it to a JWK.
- *
- * @param pem The PEM-encoded string.
- * @param pemType The type of PEM encoding ('pkcs8' for private keys, 'spki' for public keys, 'x509' for certificates).
- * @param alg The JWA algorithm identifier. This is crucial for `crypto.subtle.importKey`
- *            to understand the key's intended algorithm and for setting the 'alg' field in the resulting JWK.
- * @param importOptions Options for the PEM import process (e.g., extractable for the CryptoKey).
- * @param jwkExtras Additional properties to merge into the resulting JWK.
- * @returns A Promise resolving to the imported key as a JWK.
- */
-declare function importJWKFromPEM(pem: string, pemType: "pkcs8" | "spki" | "x509", alg: JWKPEMAlgorithm, importOptions?: KeyImportOptions, jwkExtras?: Partial<JWK>): Promise<JWK>;
-/**
- * Exports a JWK to a PEM-encoded string.
- *
- * @param jwk The JWK to export.
- * @param pemFormat The desired PEM format ('pkcs8' for private keys, 'spki' for public keys).
- * @param algForCryptoKeyImport If the JWK does not have an 'alg' property, this algorithm hint is
- *                              required to correctly convert it to a CryptoKey first.
- * @returns A Promise resolving to the PEM-encoded key string.
- */
-declare function exportJWKToPEM(jwk: JWK, pemFormat: "pkcs8" | "spki", algForCryptoKeyImport?: JWKPEMAlgorithm): Promise<string>;
-/**
- * Retrieves a JWK (JSON Web Key) from a JWKSet based on a key ID (kid) or
- * properties from a JOSE Header.
- *
- * @param jwkSet The JWKSet to search within.
- * @param kidOrProtectedHeader Either a string representing the 'kid' (Key ID)
- *        or an object representing the JOSE Protected Header. If an object is
- *        provided, it must contain a 'kid' property. It can optionally contain
- *        'alg' (Algorithm) and 'kty' (Key Type) to further refine the search.
- * @returns The matching JWK from the set.
- * @throws TypeError if `jwkSet` is invalid or `kidOrProtectedHeader` is not a
- *         string or a valid header object.
- * @throws Error if no key is found matching the provided criteria, or if the
- *         header object is missing the 'kid' property.
- */
-declare function getJWKFromSet(jwkSet: JWKSet, kidOrProtectedHeader: string | (JoseHeaderParameters & {
-    alg?: string;
-    kty?: string;
-})): JWK;
-
-declare const jwk_CompositeKey: typeof CompositeKey;
-declare const jwk_ContentEncryptionAlgorithm: typeof ContentEncryptionAlgorithm;
-declare const jwk_DeriveKeyOptions: typeof DeriveKeyOptions;
-declare const jwk_DeriveKeyReturn: typeof DeriveKeyReturn;
-declare const jwk_GenerateKeyAlgorithm: typeof GenerateKeyAlgorithm;
-declare const jwk_GenerateKeyOptions: typeof GenerateKeyOptions;
-declare const jwk_GenerateKeyReturn: typeof GenerateKeyReturn;
-declare const jwk_JWK: typeof JWK;
-declare const jwk_JWKAlgorithm: typeof JWKAlgorithm;
-declare const jwk_JWKPEMAlgorithm: typeof JWKPEMAlgorithm;
-declare const jwk_JWKParameters: typeof JWKParameters;
-declare const jwk_JWKSet: typeof JWKSet;
-declare const jwk_JWK_AES_CBC_HMAC: typeof JWK_AES_CBC_HMAC;
-declare const jwk_JWK_AES_GCM: typeof JWK_AES_GCM;
-declare const jwk_JWK_AES_GCM_KW: typeof JWK_AES_GCM_KW;
-declare const jwk_JWK_AES_KW: typeof JWK_AES_KW;
-declare const jwk_JWK_Asymmetric_Algorithm: typeof JWK_Asymmetric_Algorithm;
-declare const jwk_JWK_EC: typeof JWK_EC;
-declare const jwk_JWK_ECDH_ES: typeof JWK_ECDH_ES;
-declare const jwk_JWK_ECDSA: typeof JWK_ECDSA;
-declare const jwk_JWK_EC_Private: typeof JWK_EC_Private;
-declare const jwk_JWK_EC_Public: typeof JWK_EC_Public;
-declare const jwk_JWK_ED: typeof JWK_ED;
-declare const jwk_JWK_HMAC: typeof JWK_HMAC;
-declare const jwk_JWK_PBES2: typeof JWK_PBES2;
-declare const jwk_JWK_RSA: typeof JWK_RSA;
-declare const jwk_JWK_RSA_ENC: typeof JWK_RSA_ENC;
-declare const jwk_JWK_RSA_PSS: typeof JWK_RSA_PSS;
-declare const jwk_JWK_RSA_Private: typeof JWK_RSA_Private;
-declare const jwk_JWK_RSA_Public: typeof JWK_RSA_Public;
-declare const jwk_JWK_RSA_SIGN: typeof JWK_RSA_SIGN;
-declare const jwk_JWK_Symmetric_Algorithm: typeof JWK_Symmetric_Algorithm;
-declare const jwk_JWK_oct: typeof JWK_oct;
-declare const jwk_KeyManagementAlgorithm: typeof KeyManagementAlgorithm;
-declare const jwk_UnwrapKeyOptions: typeof UnwrapKeyOptions;
-declare const jwk_WrapKeyOptions: typeof WrapKeyOptions;
-declare const jwk_WrapKeyResult: typeof WrapKeyResult;
-declare const jwk_deriveKeyFromPassword: typeof deriveKeyFromPassword;
-declare const jwk_exportJWKToPEM: typeof exportJWKToPEM;
-declare const jwk_exportKey: typeof exportKey;
-declare const jwk_generateKey: typeof generateKey;
-declare const jwk_getJWKFromSet: typeof getJWKFromSet;
-declare const jwk_importJWKFromPEM: typeof importJWKFromPEM;
-declare const jwk_importKey: typeof importKey;
-declare const jwk_unwrapKey: typeof unwrapKey;
-declare const jwk_wrapKey: typeof wrapKey;
-declare namespace jwk {
-  export {
-    jwk_CompositeKey as CompositeKey,
-    jwk_ContentEncryptionAlgorithm as ContentEncryptionAlgorithm,
-    jwk_DeriveKeyOptions as DeriveKeyOptions,
-    jwk_DeriveKeyReturn as DeriveKeyReturn,
-    jwk_GenerateKeyAlgorithm as GenerateKeyAlgorithm,
-    jwk_GenerateKeyOptions as GenerateKeyOptions,
-    jwk_GenerateKeyReturn as GenerateKeyReturn,
-    jwk_JWK as JWK,
-    jwk_JWKAlgorithm as JWKAlgorithm,
-    jwk_JWKPEMAlgorithm as JWKPEMAlgorithm,
-    jwk_JWKParameters as JWKParameters,
-    jwk_JWKSet as JWKSet,
-    jwk_JWK_AES_CBC_HMAC as JWK_AES_CBC_HMAC,
-    jwk_JWK_AES_GCM as JWK_AES_GCM,
-    jwk_JWK_AES_GCM_KW as JWK_AES_GCM_KW,
-    jwk_JWK_AES_KW as JWK_AES_KW,
-    jwk_JWK_Asymmetric_Algorithm as JWK_Asymmetric_Algorithm,
-    jwk_JWK_EC as JWK_EC,
-    jwk_JWK_ECDH_ES as JWK_ECDH_ES,
-    jwk_JWK_ECDSA as JWK_ECDSA,
-    jwk_JWK_EC_Private as JWK_EC_Private,
-    jwk_JWK_EC_Public as JWK_EC_Public,
-    jwk_JWK_ED as JWK_ED,
-    jwk_JWK_HMAC as JWK_HMAC,
-    jwk_JWK_PBES2 as JWK_PBES2,
-    jwk_JWK_RSA as JWK_RSA,
-    jwk_JWK_RSA_ENC as JWK_RSA_ENC,
-    jwk_JWK_RSA_PSS as JWK_RSA_PSS,
-    jwk_JWK_RSA_Private as JWK_RSA_Private,
-    jwk_JWK_RSA_Public as JWK_RSA_Public,
-    jwk_JWK_RSA_SIGN as JWK_RSA_SIGN,
-    jwk_JWK_Symmetric_Algorithm as JWK_Symmetric_Algorithm,
-    jwk_JWK_oct as JWK_oct,
-    jwk_KeyManagementAlgorithm as KeyManagementAlgorithm,
-    jwk_UnwrapKeyOptions as UnwrapKeyOptions,
-    jwk_WrapKeyOptions as WrapKeyOptions,
-    jwk_WrapKeyResult as WrapKeyResult,
-    jwk_deriveKeyFromPassword as deriveKeyFromPassword,
-    jwk_exportJWKToPEM as exportJWKToPEM,
-    jwk_exportKey as exportKey,
-    jwk_generateKey as generateKey,
-    jwk_getJWKFromSet as getJWKFromSet,
-    jwk_importJWKFromPEM as importJWKFromPEM,
-    jwk_importKey as importKey,
-    jwk_unwrapKey as unwrapKey,
-    jwk_wrapKey as wrapKey,
-  };
-}
-
-export { importJWKFromPEM as a, exportJWKToPEM as b, getJWKFromSet as c, deriveKeyFromPassword as d, exportKey as e, generateKey as g, importKey as i, jwk as j, unwrapKey as u, wrapKey as w };

package/dist/shared/unjwt.D4DUiNeM.d.ts

@@ -1,58 +0,0 @@
-import { m as JWK, n as JWKSet } from './unjwt.D9da8HQF.js';
-
-declare const textEncoder: TextEncoder;
-declare const textDecoder: TextDecoder;
-declare function base64Encode(data: Uint8Array | string): string;
-declare function base64UrlEncode(data: Uint8Array | string): string;
-declare function base64Decode(str: string | undefined): string;
-declare function base64Decode<T extends boolean | undefined>(str?: string | undefined, toString?: T): T extends false ? Uint8Array : string;
-declare function base64UrlDecode(str: string | undefined): string;
-declare function base64UrlDecode<T extends boolean | undefined>(str?: string | undefined, toString?: T): T extends false ? Uint8Array : string;
-declare function randomBytes(length: Readonly<number>): Uint8Array;
-/**
- * Concatenates multiple Uint8Arrays
- * @param arrays Arrays to concatenate
- * @returns Concatenated array
- */
-declare function concatUint8Arrays(...arrays: Readonly<Uint8Array[]>): Uint8Array;
-declare function maybeArray<T>(item: T | T[]): T[];
-declare function isJWK(key: any): key is JWK;
-declare function isJWKSet(key: any): key is JWKSet;
-declare function assertCryptoKey(key: unknown): asserts key is CryptoKey;
-declare function isCryptoKey(key: unknown): key is CryptoKey;
-declare const isCryptoKeyPair: (key: any) => key is CryptoKeyPair;
-
-declare const index_assertCryptoKey: typeof assertCryptoKey;
-declare const index_base64Decode: typeof base64Decode;
-declare const index_base64Encode: typeof base64Encode;
-declare const index_base64UrlDecode: typeof base64UrlDecode;
-declare const index_base64UrlEncode: typeof base64UrlEncode;
-declare const index_concatUint8Arrays: typeof concatUint8Arrays;
-declare const index_isCryptoKey: typeof isCryptoKey;
-declare const index_isCryptoKeyPair: typeof isCryptoKeyPair;
-declare const index_isJWK: typeof isJWK;
-declare const index_isJWKSet: typeof isJWKSet;
-declare const index_maybeArray: typeof maybeArray;
-declare const index_randomBytes: typeof randomBytes;
-declare const index_textDecoder: typeof textDecoder;
-declare const index_textEncoder: typeof textEncoder;
-declare namespace index {
-  export {
-    index_assertCryptoKey as assertCryptoKey,
-    index_base64Decode as base64Decode,
-    index_base64Encode as base64Encode,
-    index_base64UrlDecode as base64UrlDecode,
-    index_base64UrlEncode as base64UrlEncode,
-    index_concatUint8Arrays as concatUint8Arrays,
-    index_isCryptoKey as isCryptoKey,
-    index_isCryptoKeyPair as isCryptoKeyPair,
-    index_isJWK as isJWK,
-    index_isJWKSet as isJWKSet,
-    index_maybeArray as maybeArray,
-    index_randomBytes as randomBytes,
-    index_textDecoder as textDecoder,
-    index_textEncoder as textEncoder,
-  };
-}
-
-export { textDecoder as a, base64Encode as b, base64UrlEncode as c, base64Decode as d, base64UrlDecode as e, concatUint8Arrays as f, isJWK as g, isJWKSet as h, index as i, assertCryptoKey as j, isCryptoKey as k, isCryptoKeyPair as l, maybeArray as m, randomBytes as r, textEncoder as t };

package/dist/shared/unjwt.D9da8HQF.d.ts

@@ -1,210 +0,0 @@
-/** Structure returned for composite AES-CBC + HMAC keys. */
-type CompositeKey = {
-    /** The AES-CBC encryption/decryption key. */
-    encryptionKey: CryptoKey;
-    /** The HMAC key for integrity/authentication. */
-    macKey: CryptoKey;
-};
-type GenerateKeyAlgorithm = Exclude<JWKAlgorithm, "none" | "dir" | JWK_PBES2 | JWK_ECDH_ES>;
-/** Options for the generateKey function. */
-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. */
-    extractable?: boolean;
-    /** RSA modulus length. Defaults to 2048. */
-    modulusLength?: number;
-    /** RSA public exponent. Defaults to 65537 (0x010001). */
-    publicExponent?: Uint8Array;
-    /** Export the generated key(s) as JWK. If true, the key(s) will be returned in JWK format. */
-    toJWK?: boolean | undefined;
-}
-type GenerateKeyReturnJWK<TAlg extends GenerateKeyAlgorithm> = TAlg extends JWK_Asymmetric_Algorithm ? {
-    privateKey: JWK;
-    publicKey: JWK;
-} : JWK;
-type GenerateKeyReturnCrypto<TAlg extends GenerateKeyAlgorithm> = TAlg extends JWK_AES_CBC_HMAC ? Uint8Array : TAlg extends JWK_Asymmetric_Algorithm ? CryptoKeyPair : CryptoKey;
-type GenerateKeyReturn<TAlg extends GenerateKeyAlgorithm, TOptions extends GenerateKeyOptions> = TOptions["toJWK"] extends true ? GenerateKeyReturnJWK<TAlg> : GenerateKeyReturnCrypto<TAlg>;
-/** Options for the deriveKeyFromPassword function. */
-interface DeriveKeyOptions {
-    /** Salt value (p2s). Must be at least 8 bytes. */
-    salt: Uint8Array;
-    /** Iteration count (p2c). Must be a positive integer. */
-    iterations: number;
-    /** Key usages for the derived key. Defaults to ["wrapKey", "unwrapKey"]. */
-    keyUsage?: KeyUsage[];
-    /** Mark the derived key as extractable. Defaults to false. */
-    extractable?: boolean;
-    /** Export the derived key as JWK. If true, the key will be returned in JWK_oct format. */
-    toJWK?: boolean | undefined;
-}
-type DeriveKeyReturn<TOptions extends DeriveKeyOptions> = TOptions["toJWK"] extends true ? JWK_oct : CryptoKey;
-type KeyManagementAlgorithm = JWK_RSA_ENC | JWK_AES_KW | JWK_AES_GCM | JWK_AES_GCM_KW | JWK_PBES2 | JWK_ECDH_ES;
-type ContentEncryptionAlgorithm = JWK_AES_GCM | JWK_AES_CBC_HMAC;
-/** Options for the wrapKey function. */
-interface WrapKeyOptions {
-    /** Initialization Vector for AES-GCMKW. Generated if not provided. */
-    iv?: Uint8Array;
-    /** PBES2 Salt value (p2s). Required for PBES2 algorithms. */
-    p2s?: Uint8Array;
-    /** PBES2 Iteration count (p2c). Required for PBES2 algorithms. */
-    p2c?: number;
-    /** ECDH-ES Ephemeral Public Key. Generated if not provided for ECDH-ES. */
-    epk?: JWK_EC_Public;
-    /** ECDH-ES Agreement PartyUInfo. */
-    apu?: Uint8Array;
-    /** ECDH-ES Agreement PartyVInfo. */
-    apv?: Uint8Array;
-}
-/** Result of the wrapKey function. */
-interface WrapKeyResult {
-    /** The wrapped key (Ciphertext). */
-    encryptedKey: Uint8Array;
-    /** Initialization Vector used (only for AES-GCMKW). Base64URL encoded. */
-    iv?: string;
-    /** Authentication Tag generated (only for AES-GCMKW). Base64URL encoded. */
-    tag?: string;
-    /** PBES2 Salt value used (only for PBES2). Base64URL encoded. */
-    p2s?: string;
-    /** PBES2 Iteration count used (only for PBES2). */
-    p2c?: number;
-    /** ECDH-ES Ephemeral Public Key used (only for ECDH-ES). */
-    epk?: JWK_EC_Public;
-    /** ECDH-ES Agreement PartyUInfo used (only for ECDH-ES). Base64URL encoded. */
-    apu?: string;
-    /** ECDH-ES Agreement PartyVInfo used (only for ECDH-ES). Base64URL encoded. */
-    apv?: string;
-}
-/** Options for the unwrapKey function. */
-interface UnwrapKeyOptions {
-    /** Initialization Vector (required for AES-GCMKW). Base64URL encoded or Uint8Array. */
-    iv?: Uint8Array | string;
-    /** Authentication Tag (required for AES-GCMKW). Base64URL encoded or Uint8Array. */
-    tag?: Uint8Array | string;
-    /** PBES2 Salt value (required for PBES2). Base64URL encoded or Uint8Array. */
-    p2s?: Uint8Array | string;
-    /** PBES2 Iteration count (required for PBES2). */
-    p2c?: number;
-    /** ECDH-ES Ephemeral Public Key (required for ECDH-ES). */
-    epk?: JWK_EC_Public;
-    /** ECDH-ES Agreement PartyUInfo. Base64URL encoded or Uint8Array. */
-    apu?: Uint8Array | string;
-    /** ECDH-ES Agreement PartyVInfo. Base64URL encoded or Uint8Array. */
-    apv?: Uint8Array | string;
-    /** Expected unwrapped key algorithm (e.g., 'AES-GCM', 'AES-CBC'). Used by crypto.subtle.unwrapKey. */
-    unwrappedKeyAlgorithm?: string | Algorithm | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams;
-    /** Expected key usages for the unwrapped key. */
-    keyUsage?: KeyUsage[];
-    /** Mark the unwrapped key as extractable. Defaults to true. */
-    extractable?: boolean;
-    returnAs?: boolean | undefined;
-}
-/**
- * Forked from https://github.com/panva/jose/tree/v6.0.10
- * Copyright (c) 2018 Filip Skokan.
- * LICENSE: https://github.com/panva/jose/blob/v6.0.10/LICENSE.md
- */
-/** Generic JSON Web Key Parameters. */
-interface JWKParameters {
-    /** JWK "kty" (Key Type) Parameter */
-    kty: string;
-    /**
-     * JWK "alg" (Algorithm) Parameter
-     *
-     * @see {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}
-     */
-    alg?: string;
-    /** JWK "key_ops" (Key Operations) Parameter */
-    key_ops?: KeyUsage[];
-    /** JWK "ext" (Extractable) Parameter */
-    ext?: boolean;
-    /** JWK "use" (Public Key Use) Parameter */
-    use?: string;
-    /** JWK "x5c" (X.509 Certificate Chain) Parameter */
-    x5c?: string[];
-    /** JWK "x5t" (X.509 Certificate SHA-1 Thumbprint) Parameter */
-    x5t?: string;
-    /** JWK "x5t#S256" (X.509 Certificate SHA-256 Thumbprint) Parameter */
-    "x5t#S256"?: string;
-    /** JWK "x5u" (X.509 URL) Parameter */
-    x5u?: string;
-    /** JWK "kid" (Key ID) Parameter */
-    kid?: string;
-}
-/** Public EC JSON Web Keys */
-interface JWK_EC_Public extends JWKParameters {
-    /** EC JWK "crv" (Curve) Parameter */
-    crv: string;
-    /** EC JWK "x" (X Coordinate) Parameter */
-    x: string;
-    /** EC JWK "y" (Y Coordinate) Parameter */
-    y: string;
-}
-/** Private EC JSON Web Keys */
-interface JWK_EC_Private extends JWK_EC_Public, JWKParameters {
-    /** EC JWK "d" (ECC Private Key) Parameter */
-    d: string;
-}
-/** EC JSON Web Keys */
-type JWK_EC = JWK_EC_Public | JWK_EC_Private;
-/** Public RSA JSON Web Keys */
-interface JWK_RSA_Public extends JWKParameters {
-    /** RSA JWK "e" (Exponent) Parameter */
-    e: string;
-    /** RSA JWK "n" (Modulus) Parameter */
-    n: string;
-    oth?: RsaOtherPrimesInfo[];
-}
-/** Private RSA JSON Web Keys */
-interface JWK_RSA_Private extends JWK_RSA_Public, JWKParameters {
-    /** RSA JWK "d" (Private Exponent) Parameter */
-    d: string;
-    /** RSA JWK "dp" (First Factor CRT Exponent) Parameter */
-    dp: string;
-    /** RSA JWK "dq" (Second Factor CRT Exponent) Parameter */
-    dq: string;
-    /** RSA JWK "p" (First Prime Factor) Parameter */
-    p: string;
-    /** RSA JWK "q" (Second Prime Factor) Parameter */
-    q: string;
-    /** RSA JWK "qi" (First CRT Coefficient) Parameter */
-    qi: string;
-}
-/** RSA JSON Web Keys */
-type JWK_RSA = JWK_RSA_Public | JWK_RSA_Private;
-/** oct JSON Web Keys */
-interface JWK_oct extends JWKParameters {
-    /** Oct JWK "k" (Key Value) Parameter */
-    k: string;
-}
-/**
- * JSON Web Key ({@link https://www.rfc-editor.org/rfc/rfc7517 JWK}). "RSA", "EC" and "oct" key types are supported.
- */
-type JWK = JWK_oct | JWK_RSA | JWK_EC;
-/**
- * JSON Web Key Set ({@link https://www.rfc-editor.org/rfc/rfc7517 JWK Set}). "RSA", "EC" and "oct" key types are supported.
- */
-interface JWKSet {
-    /** JWK Set "keys" Parameter */
-    keys: JWK[];
-    [parameter: string]: unknown;
-}
-/** JWK Key Algorithms */
-type JWK_HMAC = "HS256" | "HS384" | "HS512";
-type JWK_RSA_SIGN = "RS256" | "RS384" | "RS512";
-type JWK_RSA_PSS = "PS256" | "PS384" | "PS512";
-type JWK_ECDSA = "ES256" | "ES384" | "ES512";
-type JWK_RSA_ENC = "RSA-OAEP" | "RSA-OAEP-256" | "RSA-OAEP-384" | "RSA-OAEP-512";
-type JWK_AES_KW = "A128KW" | "A192KW" | "A256KW";
-type JWK_AES_GCM_KW = "A128GCMKW" | "A192GCMKW" | "A256GCMKW";
-type JWK_AES_CBC_HMAC = "A128CBC-HS256" | "A192CBC-HS384" | "A256CBC-HS512";
-type JWK_AES_GCM = "A128GCM" | "A192GCM" | "A256GCM";
-type JWK_PBES2 = "PBES2-HS256+A128KW" | "PBES2-HS384+A192KW" | "PBES2-HS512+A256KW";
-type JWK_ECDH_ES = "ECDH-ES" | "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW";
-type JWK_ED = "Ed25519" | "EdDSA";
-type JWK_Symmetric_Algorithm = JWK_HMAC | JWK_AES_KW | JWK_AES_GCM;
-type JWK_Asymmetric_Algorithm = JWK_RSA_SIGN | JWK_RSA_PSS | JWK_ECDSA | JWK_RSA_ENC;
-type JWKAlgorithm = JWK_Symmetric_Algorithm | JWK_Asymmetric_Algorithm | JWK_AES_CBC_HMAC | JWK_PBES2 | JWK_ECDH_ES | ("none" | "dir");
-type JWKPEMAlgorithm = JWK_RSA_PSS | JWK_RSA_SIGN | JWK_RSA_ENC | JWK_ECDSA | JWK_ECDH_ES | JWK_ED;
-
-export type { JWK_Symmetric_Algorithm as A, JWK_Asymmetric_Algorithm as B, CompositeKey as C, DeriveKeyOptions as D, JWKAlgorithm as E, JWKPEMAlgorithm as F, GenerateKeyAlgorithm as G, JWKParameters as J, KeyManagementAlgorithm as K, UnwrapKeyOptions as U, WrapKeyOptions as W, GenerateKeyOptions as a, GenerateKeyReturn as b, DeriveKeyReturn as c, ContentEncryptionAlgorithm as d, WrapKeyResult as e, JWK_EC_Public as f, JWK_EC_Private as g, JWK_EC as h, JWK_RSA_Public as i, JWK_RSA_Private as j, JWK_RSA as k, JWK_oct as l, JWK as m, JWKSet as n, JWK_HMAC as o, JWK_RSA_SIGN as p, JWK_RSA_PSS as q, JWK_ECDSA as r, JWK_RSA_ENC as s, JWK_AES_KW as t, JWK_AES_GCM_KW as u, JWK_AES_CBC_HMAC as v, JWK_AES_GCM as w, JWK_PBES2 as x, JWK_ECDH_ES as y, JWK_ED as z };

package/dist/shared/unjwt.c10n3uM8.d.ts

@@ -1,52 +0,0 @@
-import { i as JWK_RSA_Public } from './unjwt.D9da8HQF.js';
-
-/** Header Parameters common to JWE and JWS */
-interface JoseHeaderParameters {
-    /** "kid" (Key ID) Header Parameter */
-    kid?: string;
-    /** "x5t" (X.509 Certificate SHA-1 Thumbprint) Header Parameter */
-    x5t?: string;
-    /** "x5c" (X.509 Certificate Chain) Header Parameter */
-    x5c?: string[];
-    /** "x5u" (X.509 URL) Header Parameter */
-    x5u?: string;
-    /** "jku" (JWK Set URL) Header Parameter */
-    jku?: string;
-    /** "jwk" (JSON Web Key) Header Parameter */
-    jwk?: JWK_RSA_Public;
-    /** "typ" (Type) Header Parameter */
-    typ?: string;
-    /** "cty" (Content Type) Header Parameter */
-    cty?: string;
-    /** "crit" (Critical) Header Parameter */
-    crit?: string[];
-    /** Any other JWS/JWE Header member. */
-    [propName: string]: unknown;
-}
-interface JWTClaims {
-    /** "iss" (Issuer) Claim */
-    iss?: string;
-    /** "sub" (Subject) Claim */
-    sub?: string;
-    /** "aud" (Audience) Claim */
-    aud?: string | string[];
-    /** "exp" (Expiration Time) Claim */
-    exp?: number;
-    /** "nbf" (Not Before) Claim */
-    nbf?: number;
-    /** "iat" (Issued At) Claim */
-    iat?: number;
-    /** "jti" (JWT ID) Claim */
-    jti?: string;
-    /** Any other JWT member. */
-    [propName: string]: unknown;
-}
-interface JWT<T = JWTClaims> {
-    header: JoseHeaderParameters & {
-        /** "alg" (Algorithm) Header Parameter */
-        alg: string;
-    };
-    claims: T;
-}
-
-export type { JoseHeaderParameters as J, JWTClaims as a, JWT as b };

package/dist/shared/unjwt.w-IAnI15.d.ts

@@ -1,172 +0,0 @@
-import { o as JWK_HMAC, p as JWK_RSA_SIGN, q as JWK_RSA_PSS, r as JWK_ECDSA, m as JWK, n as JWKSet } from './unjwt.D9da8HQF.js';
-import { J as JoseHeaderParameters, a as JWTClaims } from './unjwt.c10n3uM8.js';
-
-type JWS_SIGN_EXTRA = "Ed25519" | "EdDSA";
-/** JWS Signing Algorithm Identifier. */
-type JWSAlgorithm = JWK_HMAC | JWK_RSA_SIGN | JWK_RSA_PSS | JWK_ECDSA | JWS_SIGN_EXTRA;
-/** Recognized JWS Header Parameters, any other Header Members may also be present. */
-interface JWSHeaderParameters extends JoseHeaderParameters {
-    /** JWS "alg" (Algorithm) Header Parameter */
-    alg?: JWSAlgorithm;
-    /**
-     * This JWS Extension Header Parameter modifies the JWS Payload representation and the JWS Signing
-     * Input computation as per {@link https://www.rfc-editor.org/rfc/rfc7797 RFC7797}.
-     * If `false`, the payload is used directly without Base64URL encoding.
-     * Defaults to `true`.
-     */
-    b64?: boolean;
-}
-/** JWS Protected Header */
-interface JWSProtectedHeader extends JWSHeaderParameters {
-    alg: JWSAlgorithm;
-}
-/**
- * JWS (JSON Web Signature) options for signing
- */
-interface JWSSignOptions {
-    /** The JWS Algorithm to use. Must be provided. */
-    alg?: JWSAlgorithm;
-    /**
-     * Additional protected header parameters. `alg` is automatically included.
-     * `typ` defaults to "JWT" if not provided.
-     */
-    protectedHeader?: JWSHeaderParameters;
-    /** Date to use when comparing NumericDate claims, defaults to `new Date()`. */
-    currentDate?: Date;
-    /**
-     * Time at which the JWS should expire, if no `exp` was already provided.
-     */
-    expiresIn?: number;
-}
-/** Result of JWS verification */
-interface JWSVerifyResult<T extends JWTClaims | Uint8Array | string = JWTClaims | Uint8Array | string> {
-    /** The decoded and verified payload. */
-    payload: T;
-    /** The JWS Protected Header. */
-    protectedHeader: JWSProtectedHeader;
-}
-/** Options for JWS verification */
-interface JWSVerifyOptions {
-    /** List of allowed algorithms. If provided, the JWS `alg` must be in this list. */
-    algorithms?: JWSAlgorithm[];
-    /** If true, forces the payload to be returned as a Uint8Array, otherwise type is inferred. */
-    forceUint8Array?: boolean;
-    /**
-     * Expected JWT "aud" (Audience) Claim value(s).
-     *
-     * This option makes the JWT "aud" (Audience) Claim presence required.
-     */
-    audience?: string | string[];
-    /**
-     * Clock skew tolerance (in seconds) for validating JWT claims.
-     *
-     * Used when validating the JWT "nbf" (Not Before) and "exp" (Expiration Time) claims, and when
-     * validating the "iat" (Issued At) claim if the {@link maxTokenAge `maxTokenAge` option} is set.
-     */
-    clockTolerance?: number;
-    /**
-     * Expected JWT "iss" (Issuer) Claim value(s).
-     *
-     * This option makes the JWT "iss" (Issuer) Claim presence required.
-     */
-    issuer?: string | string[];
-    /**
-     * Maximum time elapsed (in seconds) from the JWT "iat" (Issued At) Claim value.
-     *
-     * This option makes the JWT "iat" (Issued At) Claim presence required.
-     */
-    maxTokenAge?: number;
-    /**
-     * Expected JWT "sub" (Subject) Claim value.
-     *
-     * This option makes the JWT "sub" (Subject) Claim presence required.
-     */
-    subject?: string;
-    /**
-     * Expected JWT "typ" (Type) Header Parameter value.
-     *
-     * This option makes the JWT "typ" (Type) Header Parameter presence required.
-     */
-    typ?: string;
-    /** Date to use when comparing NumericDate claims, defaults to `new Date()`. */
-    currentDate?: Date;
-    /** List of critical header parameters that must be understood and processed. */
-    requiredHeaders?: string[];
-    /**
-     * Array of required Claim Names that must be present in the JWT Claims Set. Default is that: if
-     * the {@link issuer `issuer` option} is set, then JWT "iss" (Issuer) Claim must be present; if the
-     * {@link audience `audience` option} is set, then JWT "aud" (Audience) Claim must be present; if
-     * the {@link subject `subject` option} is set, then JWT "sub" (Subject) Claim must be present; if
-     * the {@link maxTokenAge `maxTokenAge` option} is set, then JWT "iat" (Issued At) Claim must be
-     * present.
-     */
-    requiredClaims?: string[];
-    /**
-     * List of critical header parameters that must be understood and processed.
-     * @deprecated use {@link requiredHeaders `recognizedHeaders` option} instead.
-     */
-    critical?: string[];
-}
-/**
- * Key lookup function for JWS verification.
- * @param header The JWS Protected Header.
- * @param token The JWS token.
- * @returns The key material (CryptoKey, JWK, or raw Uint8Array) or a Promise resolving to it.
- */
-type JWSKeyLookupFunction = (header: JWSProtectedHeader, token: string) => CryptoKey | JWK | JWKSet | Uint8Array | Promise<CryptoKey | JWK | JWKSet | Uint8Array>;
-
-/**
- * Creates a JWS (JSON Web Signature) in Compact Serialization format.
- *
- * @param payload The payload to sign. Can be a string, Uint8Array, or an object (which will be JSON stringified).
- * @param key The signing key (CryptoKey, JWK, or raw symmetric key as Uint8Array).
- * @param options Signing options, including the algorithm (`alg`) and protected header parameters.
- * @returns A Promise resolving to the JWS Compact Serialization string.
- */
-declare function sign(payload: JWTClaims, key: JWK, options?: JWSSignOptions): Promise<string>;
-declare function sign(payload: string | Uint8Array | Record<string, any>, key: JWK, options?: JWSSignOptions): Promise<string>;
-declare function sign(payload: JWTClaims, key: CryptoKey, options: JWSSignOptions & {
-    alg: JWSAlgorithm;
-}): Promise<string>;
-declare function sign(payload: string | Uint8Array | Record<string, any>, key: CryptoKey, options: JWSSignOptions & {
-    alg: JWSAlgorithm;
-}): Promise<string>;
-declare function sign(payload: JWTClaims, key: Uint8Array, options: JWSSignOptions & {
-    alg: JWSAlgorithm;
-}): Promise<string>;
-declare function sign(payload: string | Uint8Array | Record<string, any>, key: Uint8Array, options: JWSSignOptions & {
-    alg: JWSAlgorithm;
-}): Promise<string>;
-declare function sign(payload: string | Uint8Array | Record<string, any>, key: CryptoKey | JWK | Uint8Array, options: JWSSignOptions & {
-    alg: JWSAlgorithm;
-}): Promise<string>;
-/**
- * Verifies a JWS (JSON Web Signature) in Compact Serialization format.
- *
- * @param jws The JWS Compact Serialization string.
- * @param key The verification key (CryptoKey, JWK, JWKSet, raw symmetric key as Uint8Array, or a function resolving the key or set).
- * @param options Verification options, such as allowed algorithms.
- * @returns A Promise resolving to an object containing the verified payload and protected header.
- * @throws If the JWS is invalid, signature verification fails, or options are not met.
- */
-declare function verify<T extends JWTClaims | Uint8Array | string>(jws: string, key: CryptoKey | JWK | JWKSet | Uint8Array | JWSKeyLookupFunction, options?: JWSVerifyOptions): Promise<JWSVerifyResult<T>>;
-declare function verify(jws: string, key: CryptoKey | JWK | JWKSet | Uint8Array | JWSKeyLookupFunction, options: JWSVerifyOptions & {
-    forceUint8Array: true;
-}): Promise<JWSVerifyResult<Uint8Array>>;
-
-type jws_JWSAlgorithm = JWSAlgorithm;
-type jws_JWSHeaderParameters = JWSHeaderParameters;
-type jws_JWSKeyLookupFunction = JWSKeyLookupFunction;
-type jws_JWSProtectedHeader = JWSProtectedHeader;
-type jws_JWSSignOptions = JWSSignOptions;
-type jws_JWSVerifyOptions = JWSVerifyOptions;
-type jws_JWSVerifyResult<T extends JWTClaims | Uint8Array | string = JWTClaims | Uint8Array | string> = JWSVerifyResult<T>;
-declare const jws_sign: typeof sign;
-declare const jws_verify: typeof verify;
-declare namespace jws {
-  export { jws_sign as sign, jws_verify as verify };
-  export type { jws_JWSAlgorithm as JWSAlgorithm, jws_JWSHeaderParameters as JWSHeaderParameters, jws_JWSKeyLookupFunction as JWSKeyLookupFunction, jws_JWSProtectedHeader as JWSProtectedHeader, jws_JWSSignOptions as JWSSignOptions, jws_JWSVerifyOptions as JWSVerifyOptions, jws_JWSVerifyResult as JWSVerifyResult };
-}
-
-export { jws as j, sign as s, verify as v };
-export type { JWSAlgorithm as J, JWSHeaderParameters as a, JWSProtectedHeader as b, JWSSignOptions as c, JWSVerifyResult as d, JWSVerifyOptions as e, JWSKeyLookupFunction as f };

package/dist/utils.d.ts

@@ -1,2 +0,0 @@
-import './shared/unjwt.D9da8HQF.js';
-export { j as assertCryptoKey, d as base64Decode, b as base64Encode, e as base64UrlDecode, c as base64UrlEncode, f as concatUint8Arrays, k as isCryptoKey, l as isCryptoKeyPair, g as isJWK, h as isJWKSet, m as maybeArray, r as randomBytes, a as textDecoder, t as textEncoder } from './shared/unjwt.D4DUiNeM.js';