unjwt 0.5.8 → 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.8",
+  "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/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.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 };