unjwt 0.5.9 → 0.5.11

package/dist/shared/{unjwt.DRUXIabl.mjs → unjwt.DuBBF25X.mjs}

@@ -1,4 +1,4 @@
-import { h as isCryptoKey, f as concatUint8Arrays, b as base64UrlEncode, j as base64Decode, k as base64Encode, t as textEncoder, r as randomBytes, a as isJWK, d as base64UrlDecode, e as isJWKSet } from './unjwt.BHpknTpg.mjs';
+import { m as isCryptoKey, k as concatUint8Arrays, d as base64UrlEncode, q as base64Decode, s as base64Encode, t as textEncoder, r as randomBytes, a as isJWK, f as base64UrlDecode, g as isJWKSet } from './unjwt.Ce8yMcp_.mjs';
 
 /**
  * This is a fork of Jose library's utility functions.
@@ -330,7 +330,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
 async function encrypt(enc, plaintext, cek, iv, aad) {
   if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
     throw new TypeError(
-      `Key must be ${cek} one of type: CryptoKey, Uint8Array, or JSON Web Key`
+      `Key must be ${cek} one of type: CryptoKey or Uint8Array`
     );
   }
   if (iv) {
@@ -461,7 +461,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
 async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
   if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
     throw new TypeError(
-      `Key must be ${cek} one of type: CryptoKey, Uint8Array, or JSON Web Key`
+      `Key must be ${cek} one of type: CryptoKey or Uint8Array`
     );
   }
   if (!iv) {
@@ -497,18 +497,24 @@ async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
  * @source https://github.com/panva/jose/tree/69b7960c67e05be55fa2ec31c74b987696c20c60/src/lib/aesgcmkw.ts
  * @license MIT https://github.com/panva/jose/blob/69b7960c67e05be55fa2ec31c74b987696c20c60/LICENSE.md
  */
-async function encryptIV(alg, key, cek, iv) {
+async function encryptIV(alg, key, plaintext, iv) {
   const jweAlgorithm = alg.slice(0, 7);
-  const wrapped = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array(0));
+  const wrapped = await encrypt(
+    jweAlgorithm,
+    plaintext,
+    key,
+    iv,
+    new Uint8Array(0)
+  );
   return {
     encryptedKey: wrapped.ciphertext,
     iv: base64UrlEncode(wrapped.iv),
     tag: base64UrlEncode(wrapped.tag)
   };
 }
-async function decryptIV(alg, key, encryptedKey, iv, tag) {
+async function decryptIV(alg, key, ciphertext, iv, tag) {
   const jweAlgorithm = alg.slice(0, 7);
-  return decrypt(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
+  return decrypt(jweAlgorithm, key, ciphertext, iv, tag, new Uint8Array(0));
 }
 
 /**
@@ -1479,7 +1485,12 @@ function getGenerateKeyParams(alg, options) {
       keyUsages = defaultKeyUsage ?? ["sign", "verify"];
       break;
     }
-    // EdDSA Signatures should be imported
+    case "Ed25519":
+    case "EdDSA": {
+      algorithm = { name: "Ed25519" };
+      keyUsages = defaultKeyUsage ?? ["sign", "verify"];
+      break;
+    }
     // RSA Encryption
     case "RSA-OAEP":
     case "RSA-OAEP-256":

package/dist/shared/{unjwt.D_Mabhgz.d.mts → unjwt.QRureeXk.d.mts}

@@ -1,5 +1,4 @@
-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.mjs';
-import { J as JoseHeaderParameters, a as JWTClaims } from './unjwt.BvIkEGGz.mjs';
+import { o as JWK_HMAC, p as JWK_RSA_SIGN, q as JWK_RSA_PSS, r as JWK_ECDSA, H as JoseHeaderParameters, m as JWK, n as JWKSet, M as JWTClaimValidationOptions, I as JWTClaims } from './unjwt.CN1C8TlR.mjs';
 
 type JWS_SIGN_EXTRA = "Ed25519" | "EdDSA";
 /** JWS Signing Algorithm Identifier. */
@@ -28,7 +27,7 @@ interface JWSSignOptions {
     alg?: JWSAlgorithm;
     /**
      * Additional protected header parameters. `alg` is automatically included.
-     * `typ` defaults to "JWT" if not provided.
+     * `typ` defaults to "at+jwt" if not provided.
      */
     protectedHeader?: JWSHeaderParameters;
     /** Date to use when comparing NumericDate claims, defaults to `new Date()`. */
@@ -39,73 +38,18 @@ interface JWSSignOptions {
     expiresIn?: number;
 }
 /** Result of JWS verification */
-interface JWSVerifyResult<T extends JWTClaims | Uint8Array | string = JWTClaims | Uint8Array | string> {
+interface JWSVerifyResult<T extends JWTClaims | Uint8Array<ArrayBuffer> | string = JWTClaims | Uint8Array<ArrayBuffer> | string> {
     /** The decoded and verified payload. */
     payload: T;
     /** The JWS Protected Header. */
     protectedHeader: JWSProtectedHeader;
 }
 /** Options for JWS verification */
-interface JWSVerifyOptions {
+interface JWSVerifyOptions extends JWTClaimValidationOptions {
     /** 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.
@@ -113,7 +57,7 @@ interface JWSVerifyOptions {
  * @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>;
+type JWSKeyLookupFunction = (header: JWSProtectedHeader, token: string) => CryptoKey | JWK | JWKSet | Uint8Array<ArrayBuffer> | Promise<CryptoKey | JWK | JWKSet | Uint8Array<ArrayBuffer>>;
 
 /**
  * Creates a JWS (JSON Web Signature) in Compact Serialization format.
@@ -124,20 +68,20 @@ type JWSKeyLookupFunction = (header: JWSProtectedHeader, token: string) => Crypt
  * @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: string | Uint8Array<ArrayBuffer> | 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 & {
+declare function sign(payload: string | Uint8Array<ArrayBuffer> | Record<string, any>, key: CryptoKey, options: JWSSignOptions & {
     alg: JWSAlgorithm;
 }): Promise<string>;
-declare function sign(payload: JWTClaims, key: Uint8Array, options: JWSSignOptions & {
+declare function sign(payload: JWTClaims, key: Uint8Array<ArrayBuffer>, options: JWSSignOptions & {
     alg: JWSAlgorithm;
 }): Promise<string>;
-declare function sign(payload: string | Uint8Array | Record<string, any>, key: Uint8Array, options: JWSSignOptions & {
+declare function sign(payload: string | Uint8Array<ArrayBuffer> | Record<string, any>, key: Uint8Array<ArrayBuffer>, options: JWSSignOptions & {
     alg: JWSAlgorithm;
 }): Promise<string>;
-declare function sign(payload: string | Uint8Array | Record<string, any>, key: CryptoKey | JWK | Uint8Array, options: JWSSignOptions & {
+declare function sign(payload: string | Uint8Array<ArrayBuffer> | Record<string, any>, key: CryptoKey | JWK | Uint8Array<ArrayBuffer>, options: JWSSignOptions & {
     alg: JWSAlgorithm;
 }): Promise<string>;
 /**
@@ -149,10 +93,10 @@ declare function sign(payload: string | Uint8Array | Record<string, any>, key: C
  * @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 & {
+declare function verify<T extends JWTClaims | Uint8Array<ArrayBuffer> | string>(jws: string, key: CryptoKey | JWK | JWKSet | Uint8Array<ArrayBuffer> | JWSKeyLookupFunction, options?: JWSVerifyOptions): Promise<JWSVerifyResult<T>>;
+declare function verify(jws: string, key: CryptoKey | JWK | JWKSet | Uint8Array<ArrayBuffer> | JWSKeyLookupFunction, options: JWSVerifyOptions & {
     forceUint8Array: true;
-}): Promise<JWSVerifyResult<Uint8Array>>;
+}): Promise<JWSVerifyResult<Uint8Array<ArrayBuffer>>>;
 
 type jws_JWSAlgorithm = JWSAlgorithm;
 type jws_JWSHeaderParameters = JWSHeaderParameters;
@@ -160,7 +104,7 @@ 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>;
+type jws_JWSVerifyResult<T extends JWTClaims | Uint8Array<ArrayBuffer> | string = JWTClaims | Uint8Array<ArrayBuffer> | string> = JWSVerifyResult<T>;
 declare const jws_sign: typeof sign;
 declare const jws_verify: typeof verify;
 declare namespace jws {

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

@@ -0,0 +1,128 @@
+import { I as JWTClaims, M as JWTClaimValidationOptions, m as JWK, n as JWKSet } from './unjwt.CN1C8TlR.mjs';
+
+/**
+ * Apply default typ/cty semantics shared by JWS & JWE.
+ * - If typ is undefined and payload is a non-Uint8Array object, set typ="at+jwt".
+ * - If typ is "at+jwt" and payload is a non-Uint8Array object, ensure cty defaults to "application/json".
+ */
+declare function applyTypCtyDefaults<T extends {
+    typ?: string;
+    cty?: string;
+}>(header: T, payload: unknown): T;
+/** Returns true when headers indicate JSON content. */
+declare function isJsonContent(header: {
+    typ?: string;
+    cty?: string;
+} | undefined): boolean;
+/**
+ * Given a decoded string and JOSE headers, return an object if JSON, otherwise the string.
+ */
+declare function decodeMaybeJsonString<T = unknown>(decodedString: string, header: {
+    typ?: string;
+    cty?: string;
+} | undefined): T | string;
+/**
+ * Decode a payload that is represented as raw bytes into T | string, honoring forceUint8Array and headers.
+ */
+declare function decodePayloadFromBytes<T = unknown>(bytes: Uint8Array<ArrayBuffer>, header: {
+    typ?: string;
+    cty?: string;
+} | undefined, forceUint8Array?: boolean): T | Uint8Array<ArrayBuffer> | string;
+/**
+ * Decode a payload that is a Base64URL segment into T | string | Uint8Array based on flags and headers.
+ */
+declare function decodePayloadFromB64UrlSegment<T = unknown>(payloadEncoded: string, header: {
+    typ?: string;
+    cty?: string;
+} | undefined, forceUint8Array?: boolean): T | Uint8Array<ArrayBuffer> | string;
+/** Convert plaintext input to bytes, shared by JWS & JWE when preparing payload. */
+declare function getPlaintextBytes(payload: string | Uint8Array<ArrayBuffer> | Record<string, any>): Uint8Array<ArrayBuffer>;
+/** Optionally compute iat/exp when signing JWTs. */
+declare function computeJwtTimeClaims(payload: unknown, headerTyp: string | undefined, expiresIn?: number, currentDate?: Date): JWTClaims | undefined;
+/** Validate JWT claims under JWS verification rules (or custom JWE implementations). */
+declare function validateJwtClaims(jwtClaims: JWTClaims, options?: JWTClaimValidationOptions): void;
+/** Validate critical headers in JWS semantics. */
+declare function validateCriticalHeadersJWS(protectedHeader: {
+    crit?: string[];
+} & Record<string, any>, requiredHeaders?: string[]): void;
+/** Validate critical headers in JWE semantics. */
+declare function validateCriticalHeadersJWE(protectedHeader: {
+    crit?: string[];
+} & Record<string, any>, understoodFromOptions?: string[]): void;
+
+declare const textEncoder: TextEncoder;
+declare const textDecoder: TextDecoder;
+declare function base64Encode(data: Uint8Array<ArrayBuffer> | string): string;
+declare function base64UrlEncode(data: Uint8Array<ArrayBuffer> | 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<ArrayBuffer> : string;
+declare function base64UrlDecode(str: string | undefined): string;
+declare function base64UrlDecode<T extends boolean | undefined>(str?: string | undefined, toString?: T): T extends false ? Uint8Array<ArrayBuffer> : string;
+declare function randomBytes(length: Readonly<number>): Uint8Array<ArrayBuffer>;
+/**
+ * Concatenates multiple Uint8Arrays
+ * @param arrays Arrays to concatenate
+ * @returns Concatenated array
+ */
+declare function concatUint8Arrays(...arrays: Readonly<Uint8Array<ArrayBuffer>[]>): Uint8Array<ArrayBuffer>;
+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_applyTypCtyDefaults: typeof applyTypCtyDefaults;
+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_computeJwtTimeClaims: typeof computeJwtTimeClaims;
+declare const index_concatUint8Arrays: typeof concatUint8Arrays;
+declare const index_decodeMaybeJsonString: typeof decodeMaybeJsonString;
+declare const index_decodePayloadFromB64UrlSegment: typeof decodePayloadFromB64UrlSegment;
+declare const index_decodePayloadFromBytes: typeof decodePayloadFromBytes;
+declare const index_getPlaintextBytes: typeof getPlaintextBytes;
+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_isJsonContent: typeof isJsonContent;
+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 const index_validateCriticalHeadersJWE: typeof validateCriticalHeadersJWE;
+declare const index_validateCriticalHeadersJWS: typeof validateCriticalHeadersJWS;
+declare const index_validateJwtClaims: typeof validateJwtClaims;
+declare namespace index {
+  export {
+    index_applyTypCtyDefaults as applyTypCtyDefaults,
+    index_assertCryptoKey as assertCryptoKey,
+    index_base64Decode as base64Decode,
+    index_base64Encode as base64Encode,
+    index_base64UrlDecode as base64UrlDecode,
+    index_base64UrlEncode as base64UrlEncode,
+    index_computeJwtTimeClaims as computeJwtTimeClaims,
+    index_concatUint8Arrays as concatUint8Arrays,
+    index_decodeMaybeJsonString as decodeMaybeJsonString,
+    index_decodePayloadFromB64UrlSegment as decodePayloadFromB64UrlSegment,
+    index_decodePayloadFromBytes as decodePayloadFromBytes,
+    index_getPlaintextBytes as getPlaintextBytes,
+    index_isCryptoKey as isCryptoKey,
+    index_isCryptoKeyPair as isCryptoKeyPair,
+    index_isJWK as isJWK,
+    index_isJWKSet as isJWKSet,
+    index_isJsonContent as isJsonContent,
+    index_maybeArray as maybeArray,
+    index_randomBytes as randomBytes,
+    index_textDecoder as textDecoder,
+    index_textEncoder as textEncoder,
+    index_validateCriticalHeadersJWE as validateCriticalHeadersJWE,
+    index_validateCriticalHeadersJWS as validateCriticalHeadersJWS,
+    index_validateJwtClaims as validateJwtClaims,
+  };
+}
+
+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, applyTypCtyDefaults as n, isJsonContent as o, decodeMaybeJsonString as p, decodePayloadFromBytes as q, randomBytes as r, decodePayloadFromB64UrlSegment as s, textEncoder as t, getPlaintextBytes as u, computeJwtTimeClaims as v, validateJwtClaims as w, validateCriticalHeadersJWS as x, validateCriticalHeadersJWE as y };

package/dist/utils.d.mts

@@ -1,2 +1,2 @@
-import './shared/unjwt.D9da8HQF.mjs';
-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.CbvzYE-m.mjs';
+import './shared/unjwt.CN1C8TlR.mjs';
+export { n as applyTypCtyDefaults, j as assertCryptoKey, d as base64Decode, b as base64Encode, e as base64UrlDecode, c as base64UrlEncode, v as computeJwtTimeClaims, f as concatUint8Arrays, p as decodeMaybeJsonString, s as decodePayloadFromB64UrlSegment, q as decodePayloadFromBytes, u as getPlaintextBytes, k as isCryptoKey, l as isCryptoKeyPair, g as isJWK, h as isJWKSet, o as isJsonContent, m as maybeArray, r as randomBytes, a as textDecoder, t as textEncoder, y as validateCriticalHeadersJWE, x as validateCriticalHeadersJWS, w as validateJwtClaims } from './shared/unjwt.df8yQ5_5.mjs';

package/dist/utils.mjs

@@ -1 +1 @@
-export { g as assertCryptoKey, j as base64Decode, k as base64Encode, d as base64UrlDecode, b as base64UrlEncode, f as concatUint8Arrays, h as isCryptoKey, l as isCryptoKeyPair, a as isJWK, e as isJWKSet, m as maybeArray, r as randomBytes, c as textDecoder, t as textEncoder } from './shared/unjwt.BHpknTpg.mjs';
+export { b as applyTypCtyDefaults, l as assertCryptoKey, q as base64Decode, s as base64Encode, f as base64UrlDecode, d as base64UrlEncode, c as computeJwtTimeClaims, k as concatUint8Arrays, y as decodeMaybeJsonString, h as decodePayloadFromB64UrlSegment, o as decodePayloadFromBytes, n as getPlaintextBytes, m as isCryptoKey, w as isCryptoKeyPair, a as isJWK, g as isJWKSet, x as isJsonContent, u as maybeArray, r as randomBytes, e as textDecoder, t as textEncoder, p as validateCriticalHeadersJWE, v as validateCriticalHeadersJWS, j as validateJwtClaims } from './shared/unjwt.Ce8yMcp_.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unjwt",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "Low-level JWT utilities",
   "repository": "sandros94/unjwt",
   "license": "MIT",
@@ -50,16 +50,17 @@
     "test:types": "tsc --noEmit --skipLibCheck"
   },
   "devDependencies": {
-    "@types/node": "^22.13.13",
-    "@vitest/coverage-v8": "^3.1.2",
+    "@types/node": "^22.13.14",
+    "@vitest/coverage-v8": "^3.2.4",
     "automd": "^0.4.0",
-    "changelogen": "^0.6.1",
-    "eslint": "^9.23.0",
-    "eslint-config-unjs": "^0.4.2",
-    "prettier": "^3.5.3",
-    "typescript": "^5.8.2",
-    "unbuild": "^3.5.0",
-    "vitest": "^3.1.2"
+    "changelogen": "^0.6.2",
+    "eslint": "^9.34.0",
+    "eslint-config-unjs": "^0.5.0",
+    "jose": "^6.0.13",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "unbuild": "^3.6.1",
+    "vitest": "^3.2.4"
   },
-  "packageManager": "pnpm@10.7.0"
+  "packageManager": "pnpm@10.15.0"
 }

package/dist/shared/unjwt.BHpknTpg.mjs

@@ -1,93 +0,0 @@
-const textEncoder = /* @__PURE__ */ new TextEncoder();
-const textDecoder = /* @__PURE__ */ new TextDecoder();
-function base64Encode(data) {
-  const encodedData = data instanceof Uint8Array ? data : textEncoder.encode(data);
-  if (Uint8Array.prototype.toBase64) {
-    return encodedData.toBase64();
-  }
-  return btoa(String.fromCodePoint(...encodedData));
-}
-function base64UrlEncode(data) {
-  const encodedData = data instanceof Uint8Array ? data : textEncoder.encode(data);
-  if (Uint8Array.prototype.toBase64) {
-    return encodedData.toBase64({ alphabet: "base64url", omitPadding: true });
-  }
-  return btoa(String.fromCodePoint(...encodedData)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-function base64Decode(str, toString) {
-  const decodeToString = toString !== false;
-  if (!str) {
-    return decodeToString ? "" : new Uint8Array(0);
-  }
-  const data = Uint8Array.fromBase64 ? (
-    // @ts-expect-error
-    Uint8Array.fromBase64(str)
-  ) : Uint8Array.from(atob(str), (b) => b.codePointAt(0));
-  return decodeToString ? textDecoder.decode(data) : data;
-}
-function base64UrlDecode(str, toString) {
-  const decodeToString = toString !== false;
-  if (!str) {
-    return decodeToString ? "" : new Uint8Array(0);
-  }
-  let data;
-  if (Uint8Array.fromBase64) {
-    data = Uint8Array.fromBase64(str, { alphabet: "base64url" });
-  } else {
-    str = str.replace(/-/g, "+").replace(/_/g, "/");
-    while (str.length % 4) str += "=";
-    data = Uint8Array.from(atob(str), (b) => b.codePointAt(0));
-  }
-  return decodeToString ? textDecoder.decode(data) : data;
-}
-function randomBytes(length) {
-  return crypto.getRandomValues(new Uint8Array(length));
-}
-function concatUint8Arrays(...arrays) {
-  const totalLength = arrays.reduce((length, arr) => length + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-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";
-}
-function isJWKSet(key) {
-  return key && typeof key === "object" && "keys" in key && Array.isArray(key.keys);
-}
-function assertCryptoKey(key) {
-  if (!isCryptoKey(key)) {
-    throw new Error("CryptoKey instance expected");
-  }
-}
-function isCryptoKey(key) {
-  return key?.[Symbol.toStringTag] === "CryptoKey";
-}
-const isCryptoKeyPair = (key) => key && typeof key === "object" && isCryptoKey(key.publicKey) && isCryptoKey(key.privateKey);
-
-const index = {
-  __proto__: null,
-  assertCryptoKey: assertCryptoKey,
-  base64Decode: base64Decode,
-  base64Encode: base64Encode,
-  base64UrlDecode: base64UrlDecode,
-  base64UrlEncode: base64UrlEncode,
-  concatUint8Arrays: concatUint8Arrays,
-  isCryptoKey: isCryptoKey,
-  isCryptoKeyPair: isCryptoKeyPair,
-  isJWK: isJWK,
-  isJWKSet: isJWKSet,
-  maybeArray: maybeArray,
-  randomBytes: randomBytes,
-  textDecoder: textDecoder,
-  textEncoder: textEncoder
-};
-
-export { isJWK as a, base64UrlEncode as b, textDecoder as c, base64UrlDecode as d, isJWKSet as e, concatUint8Arrays as f, assertCryptoKey as g, isCryptoKey as h, index as i, base64Decode as j, base64Encode as k, isCryptoKeyPair as l, maybeArray as m, randomBytes as r, textEncoder as t };

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 };