unjwt 0.5.9 → 0.5.10

package/dist/shared/unjwt.odifuYKu.mjs

@@ -0,0 +1,297 @@
+function applyTypCtyDefaults(header, payload) {
+  const isObjectPayload = typeof payload === "object" && payload !== null && !(payload instanceof Uint8Array);
+  if (header.typ === void 0 && isObjectPayload) {
+    header.typ = "JWT";
+  }
+  if (header.typ === "JWT" && isObjectPayload) {
+    header.cty ||= "json";
+  }
+  return header;
+}
+function isJsonContent(header) {
+  if (!header) return false;
+  if (header.typ === "JWT") return true;
+  const cty = header.cty?.toLowerCase();
+  return cty === "json" || cty === "application/json" || !!cty && cty.endsWith("+json");
+}
+function decodeMaybeJsonString(decodedString, header) {
+  if (isJsonContent(header)) {
+    const looksLikeJson = decodedString.startsWith("{") && decodedString.endsWith("}") || decodedString.startsWith("[") && decodedString.endsWith("]");
+    if (looksLikeJson) {
+      try {
+        return JSON.parse(decodedString);
+      } catch {
+      }
+    }
+  }
+  return decodedString;
+}
+function decodePayloadFromBytes(bytes, header, forceUint8Array) {
+  if (forceUint8Array) return bytes;
+  const decodedString = textDecoder.decode(bytes);
+  return decodeMaybeJsonString(decodedString, header);
+}
+function decodePayloadFromB64UrlSegment(payloadEncoded, header, forceUint8Array) {
+  if (forceUint8Array) return base64UrlDecode(payloadEncoded, false);
+  const decodedString = base64UrlDecode(payloadEncoded);
+  return decodeMaybeJsonString(decodedString, header);
+}
+function getPlaintextBytes(payload) {
+  if (payload instanceof Uint8Array) return payload;
+  if (typeof payload === "string") return textEncoder.encode(payload);
+  if (typeof payload === "object" && payload !== null)
+    return textEncoder.encode(JSON.stringify(payload));
+  throw new TypeError(
+    "Plaintext must be a string, Uint8Array, or a JSON-serializable object."
+  );
+}
+function computeJwtTimeClaims(payload, headerTyp, expiresIn, currentDate = /* @__PURE__ */ new Date()) {
+  if (expiresIn === void 0 || headerTyp !== "JWT" || !(payload && typeof payload === "object") || payload instanceof Uint8Array || payload.exp) {
+    return void 0;
+  }
+  const now = Math.round(currentDate.getTime() / 1e3);
+  const claims = { ...payload };
+  claims.iat ||= now;
+  claims.exp = now + expiresIn;
+  return claims;
+}
+function validateJwtClaims(jwtClaims, options = {}) {
+  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()})`
+      );
+    }
+  }
+}
+function validateCriticalHeadersJWS(protectedHeader, requiredHeaders = []) {
+  if (!protectedHeader.crit) return;
+  const missingHeaderParams = /* @__PURE__ */ new Set();
+  const recognizedParams = /* @__PURE__ */ new Set([
+    ...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(", ")}`
+    );
+  }
+}
+function validateCriticalHeadersJWE(protectedHeader, understoodFromOptions) {
+  if (protectedHeader.crit && !understoodFromOptions) {
+    throw new Error(
+      `Unprocessed critical header parameters: ${protectedHeader.crit.join(", ")}`
+    );
+  }
+  if (!protectedHeader.crit) return;
+  const understoodParams = /* @__PURE__ */ new Set([
+    ...understoodFromOptions || [],
+    // JWE specific standard headers:
+    "alg",
+    "enc",
+    "typ",
+    "cty",
+    "kid",
+    "jwk",
+    "jku",
+    "x5c",
+    "x5t",
+    "x5u",
+    "iv",
+    "tag",
+    "p2s",
+    "p2c",
+    "epk",
+    "apu",
+    "apv"
+  ]);
+  for (const critParam of protectedHeader.crit) {
+    if (!Object.prototype.hasOwnProperty.call(protectedHeader, critParam)) {
+      throw new Error(
+        `Critical header parameter "${critParam}" listed in "crit" but not present in the protected header.`
+      );
+    }
+    if (!understoodParams.has(critParam)) {
+      throw new Error(`Unprocessed critical header parameters: ${critParam}`);
+    }
+  }
+}
+
+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,
+  applyTypCtyDefaults: applyTypCtyDefaults,
+  assertCryptoKey: assertCryptoKey,
+  base64Decode: base64Decode,
+  base64Encode: base64Encode,
+  base64UrlDecode: base64UrlDecode,
+  base64UrlEncode: base64UrlEncode,
+  computeJwtTimeClaims: computeJwtTimeClaims,
+  concatUint8Arrays: concatUint8Arrays,
+  decodeMaybeJsonString: decodeMaybeJsonString,
+  decodePayloadFromB64UrlSegment: decodePayloadFromB64UrlSegment,
+  decodePayloadFromBytes: decodePayloadFromBytes,
+  getPlaintextBytes: getPlaintextBytes,
+  isCryptoKey: isCryptoKey,
+  isCryptoKeyPair: isCryptoKeyPair,
+  isJWK: isJWK,
+  isJWKSet: isJWKSet,
+  isJsonContent: isJsonContent,
+  maybeArray: maybeArray,
+  randomBytes: randomBytes,
+  textDecoder: textDecoder,
+  textEncoder: textEncoder,
+  validateCriticalHeadersJWE: validateCriticalHeadersJWE,
+  validateCriticalHeadersJWS: validateCriticalHeadersJWS,
+  validateJwtClaims: validateJwtClaims
+};
+
+export { isJWK as a, applyTypCtyDefaults as b, computeJwtTimeClaims as c, base64UrlEncode as d, textDecoder as e, base64UrlDecode as f, isJWKSet as g, decodePayloadFromB64UrlSegment as h, index as i, validateJwtClaims as j, concatUint8Arrays as k, assertCryptoKey as l, isCryptoKey as m, getPlaintextBytes as n, decodePayloadFromBytes as o, validateCriticalHeadersJWE as p, base64Decode as q, randomBytes as r, base64Encode as s, textEncoder as t, maybeArray as u, validateCriticalHeadersJWS as v, isCryptoKeyPair as w, isJsonContent as x, decodeMaybeJsonString 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.CUUg6g3N.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.odifuYKu.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unjwt",
-  "version": "0.5.9",
+  "version": "0.5.10",
   "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 };