unjwt 0.5.8 → 0.5.10

package/dist/shared/unjwt.BZCtr-eB.mjs

@@ -1,277 +0,0 @@
-import { i as importKey, g as getJWKFromSet } from './unjwt.DRUXIabl.mjs';
-import { a as isJWK, b as base64UrlEncode, t as textEncoder, c as textDecoder, d as base64UrlDecode, e as isJWKSet, m as maybeArray } from './unjwt.BHpknTpg.mjs';
-import { s as sign$1, v as verify$1 } from './unjwt.Ca03jPX3.mjs';
-
-async function sign(payload, key, options = {}) {
-  const { protectedHeader: additionalProtectedHeader } = options;
-  let { alg } = options;
-  if (!alg) {
-    if (isJWK(key) && key.alg) {
-      alg = key.alg;
-    } else {
-      throw new TypeError('JWS "alg" (Algorithm) must be provided in options');
-    }
-  }
-  validateKeyLength(key, alg);
-  const signingKey = await importKey(key, alg);
-  const protectedHeader = {
-    ...additionalProtectedHeader,
-    alg,
-    typ: additionalProtectedHeader?.typ ?? (typeof payload === "object" && !(payload instanceof Uint8Array) ? "JWT" : void 0)
-    // Default typ to JWT for objects
-  };
-  if (protectedHeader.typ === void 0 && typeof payload === "object" && !(payload instanceof Uint8Array)) {
-    protectedHeader.typ = "JWT";
-    protectedHeader.cty ||= "json";
-  }
-  if (protectedHeader.b64 === true) {
-    delete protectedHeader.b64;
-  }
-  let computedPayload = void 0;
-  if (options.expiresIn !== void 0 && protectedHeader.typ === "JWT" && typeof payload === "object" && !(payload instanceof Uint8Array) && !payload.exp) {
-    computedPayload = { ...payload };
-    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);
-  let payloadBytes;
-  if (payload instanceof Uint8Array) {
-    payloadBytes = payload;
-  } else if (typeof payload === "string") {
-    payloadBytes = textEncoder.encode(payload);
-  } else if (typeof payload === "object" && payload !== null) {
-    payloadBytes = textEncoder.encode(
-      JSON.stringify(computedPayload || payload)
-    );
-  } else {
-    throw new TypeError(
-      "Payload must be a string, Uint8Array, or a JSON-serializable object."
-    );
-  }
-  const useB64 = protectedHeader.b64 !== false;
-  const payloadEncoded = useB64 ? base64UrlEncode(payloadBytes) : textDecoder.decode(payloadBytes);
-  const signingInputString = `${protectedHeaderEncoded}.${payloadEncoded}`;
-  const signingInputBytes = textEncoder.encode(signingInputString);
-  const signatureBytes = await sign$1(alg, signingKey, signingInputBytes);
-  const signatureEncoded = base64UrlEncode(signatureBytes);
-  return `${signingInputString}.${signatureEncoded}`;
-}
-async function verify(jws, key, options = {}) {
-  const parts = jws.split(".");
-  if (parts.length !== 3) {
-    throw new Error("Invalid JWS: Must contain three parts separated by dots.");
-  }
-  const [protectedHeaderEncoded, payloadEncoded, signatureEncoded] = parts;
-  let protectedHeader;
-  try {
-    const protectedHeaderString = base64UrlDecode(protectedHeaderEncoded);
-    protectedHeader = JSON.parse(protectedHeaderString);
-  } catch (error_) {
-    throw new Error(
-      `Invalid JWS: Protected header is not valid Base64URL or JSON (${error_ instanceof Error ? error_.message : error_})`
-    );
-  }
-  if (!protectedHeader || typeof protectedHeader !== "object" || !protectedHeader.alg) {
-    throw new Error(
-      'Invalid JWS: Protected header must be an object with an "alg" property.'
-    );
-  }
-  const alg = protectedHeader.alg;
-  if (options.algorithms && !options.algorithms.includes(alg)) {
-    throw new Error(`Algorithm not allowed: ${alg}`);
-  }
-  if (options.typ && protectedHeader.typ !== options.typ) {
-    throw new Error(
-      `Invalid JWS: "typ" (Type) Header Parameter mismatch. Expected "${options.typ}", got "${protectedHeader.typ}".`
-    );
-  }
-  let signatureBytes;
-  try {
-    signatureBytes = base64UrlDecode(signatureEncoded, false);
-  } catch (error_) {
-    throw new Error(
-      `Invalid JWS: Signature is not valid Base64URL (${error_ instanceof Error ? error_.message : error_})`
-    );
-  }
-  const keyInput = typeof key === "function" ? await key(protectedHeader, jws) : key;
-  const resolvedKey = isJWKSet(keyInput) ? getJWKFromSet(keyInput, protectedHeader) : keyInput;
-  const verificationKey = await importKey(resolvedKey, alg);
-  const signingInputString = `${protectedHeaderEncoded}.${payloadEncoded}`;
-  const signingInputBytes = textEncoder.encode(signingInputString);
-  const isValid = await verify$1(
-    alg,
-    verificationKey,
-    signatureBytes,
-    signingInputBytes
-  );
-  if (!isValid) {
-    throw new Error("JWS signature verification failed.");
-  }
-  const useB64 = protectedHeader.b64 !== false;
-  let payload;
-  try {
-    if (useB64) {
-      if (options.forceUint8Array) {
-        payload = base64UrlDecode(payloadEncoded, false);
-      } else {
-        const cty = protectedHeader.cty?.toLowerCase();
-        const isJsonOutput = protectedHeader.typ === "JWT" || cty === "json" || cty === "application/json" || cty && cty.endsWith("+json");
-        const decodedString = base64UrlDecode(payloadEncoded);
-        if (isJsonOutput) {
-          if (decodedString.startsWith("{") && decodedString.endsWith("}") || decodedString.startsWith("[") && decodedString.endsWith("]")) {
-            try {
-              payload = JSON.parse(decodedString);
-            } catch {
-              payload = decodedString;
-            }
-          } else {
-            payload = decodedString;
-          }
-        } else {
-          payload = decodedString;
-        }
-      }
-    } else {
-      payload = options.forceUint8Array ? textEncoder.encode(payloadEncoded) : payloadEncoded;
-    }
-  } catch (error_) {
-    throw new Error(
-      `Invalid JWS: Payload decoding failed (${error_ instanceof Error ? error_.message : error_})`
-    );
-  }
-  if (protectedHeader.crit) {
-    const missingHeaderParams = /* @__PURE__ */ new Set();
-    const recognizedParams = /* @__PURE__ */ new Set([
-      ...options.critical || [],
-      // TODO: remove deprecated option
-      ...options.requiredHeaders || [],
-      "alg",
-      "typ",
-      "cty",
-      "kid",
-      "jwk",
-      "jku",
-      "x5c",
-      "x5t",
-      "x5u",
-      "b64"
-    ]);
-    for (const param of protectedHeader.crit) {
-      if (recognizedParams.has(param) && (param in protectedHeader || param === "b64")) {
-        continue;
-      }
-      missingHeaderParams.add(param);
-    }
-    if (missingHeaderParams.size > 0) {
-      throw new Error(
-        `Missing critical header parameters: ${[...missingHeaderParams].join(", ")}`
-      );
-    }
-  }
-  if (payload && typeof payload === "object" && protectedHeader.typ === "JWT" && !options.forceUint8Array) {
-    const jwtClaims = payload;
-    const clockTolerance = options.clockTolerance ?? 0;
-    const currentTime = Math.round(
-      (options.currentDate ?? /* @__PURE__ */ new Date()).getTime() / 1e3
-    );
-    const allRequiredClaims = new Set(options.requiredClaims || []);
-    const missingClaims = /* @__PURE__ */ new Set();
-    if (options.issuer) allRequiredClaims.add("iss");
-    if (options.audience) allRequiredClaims.add("aud");
-    if (options.subject) allRequiredClaims.add("sub");
-    if (options.maxTokenAge) allRequiredClaims.add("iat");
-    for (const claimName of allRequiredClaims) {
-      if (!(claimName in jwtClaims)) {
-        missingClaims.add(claimName);
-      }
-    }
-    if (missingClaims.size > 0) {
-      throw new Error(
-        `Missing required JWT Claims: ${[...missingClaims].join(", ")}`
-      );
-    }
-    if (options.issuer) {
-      const expectedIssuers = maybeArray(options.issuer);
-      if (!jwtClaims.iss || !expectedIssuers.includes(jwtClaims.iss)) {
-        throw new Error(
-          `Invalid JWT "iss" (Issuer) Claim: Expected ${expectedIssuers.join(" or ")}, got ${jwtClaims.iss}`
-        );
-      }
-    }
-    if (options.subject && jwtClaims.sub !== options.subject) {
-      throw new Error(
-        `Invalid JWT "sub" (Subject) Claim: Expected ${options.subject}, got ${jwtClaims.sub}`
-      );
-    }
-    if (options.audience) {
-      const expectedAudiences = maybeArray(options.audience);
-      const claimAudience = maybeArray(jwtClaims.aud || []);
-      if (!claimAudience.some((aud) => expectedAudiences.includes(aud))) {
-        throw new Error(
-          `Invalid JWT "aud" (Audience) Claim: Expected ${expectedAudiences.join(" or ")}, got ${claimAudience.join(", ")}`
-        );
-      }
-    }
-    if (typeof jwtClaims.nbf === "number" && jwtClaims.nbf > currentTime + clockTolerance) {
-      throw new Error(
-        `JWT "nbf" (Not Before) Claim validation failed: Token is not yet valid (nbf: ${new Date(jwtClaims.nbf * 1e3).toISOString()})`
-      );
-    }
-    if (typeof jwtClaims.exp === "number" && jwtClaims.exp <= currentTime - clockTolerance) {
-      throw new Error(
-        `JWT "exp" (Expiration Time) Claim validation failed: Token has expired (exp: ${new Date(jwtClaims.exp * 1e3).toISOString()})`
-      );
-    }
-    if (options.maxTokenAge) {
-      if (typeof jwtClaims.iat !== "number") {
-        throw new TypeError(
-          'JWT "iat" (Issued At) Claim must be a number when maxTokenAge is set.'
-        );
-      }
-      if (jwtClaims.iat > currentTime + clockTolerance) {
-        throw new Error(
-          `JWT "iat" (Issued At) Claim validation failed: Token was issued in the future (iat: ${new Date(jwtClaims.iat * 1e3).toISOString()})`
-        );
-      }
-      if (jwtClaims.iat < currentTime - options.maxTokenAge - clockTolerance) {
-        throw new Error(
-          `JWT "iat" (Issued At) Claim validation failed: Token is too old (maxTokenAge: ${options.maxTokenAge}s, iat: ${new Date(jwtClaims.iat * 1e3).toISOString()})`
-        );
-      }
-    }
-  }
-  return {
-    payload,
-    protectedHeader
-  };
-}
-function validateKeyLength(key, alg) {
-  if (!alg || isJWK(key)) return;
-  if (alg.startsWith("HS") && key instanceof Uint8Array) {
-    const algLength = Number.parseInt(alg.slice(2)) / 8;
-    if (key.length < algLength) {
-      throw new TypeError(
-        `${alg} requires key length to be ${algLength} bytes or larger`
-      );
-    }
-  } else if ((alg.startsWith("RS") || alg.startsWith("PS")) && key instanceof CryptoKey) {
-    const { modulusLength } = key.algorithm;
-    if (typeof modulusLength !== "number" || modulusLength < 2048) {
-      throw new TypeError(
-        `${alg} requires key modulusLength to be 2048 bits or larger`
-      );
-    }
-  }
-}
-
-const jws = {
-  __proto__: null,
-  sign: sign,
-  verify: verify
-};
-
-export { jws as j, sign as s, verify as v };

package/dist/shared/unjwt.BvIkEGGz.d.mts

@@ -1,52 +0,0 @@
-import { i as JWK_RSA_Public } from './unjwt.D9da8HQF.mjs';
-
-/** 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.CbvzYE-m.d.mts

@@ -1,58 +0,0 @@
-import { m as JWK, n as JWKSet } from './unjwt.D9da8HQF.mjs';
-
-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.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.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 };