@zuplo/cli 7.4.7 → 7.5.0

package/node_modules/@zuplo/editor/node_modules/hono/dist/utils/ipaddr.js

@@ -1,288 +0,0 @@
-// src/utils/ipaddr.ts
-var expandIPv6 = (ipV6) => {
-  const sections = ipV6.split(":");
-  if (IPV4_REGEX.test(sections.at(-1))) {
-    sections.splice(
-      -1,
-      1,
-      ...convertIPv6BinaryToString(convertIPv4ToBinary(sections.at(-1))).substring(2).split(":")
-      // => ['7f00', '0001']
-    );
-  }
-  for (let i = 0; i < sections.length; i++) {
-    const node = sections[i];
-    if (node !== "") {
-      sections[i] = node.padStart(4, "0");
-    } else {
-      while (sections[i + 1] === "") {
-        sections.splice(i + 1, 1);
-      }
-      sections[i] = new Array(8 - sections.length + 1).fill("0000").join(":");
-    }
-  }
-  return sections.join(":");
-};
-var IPV4_OCTET_PART = "(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])";
-var IPV4_REGEX = new RegExp(`^(?:${IPV4_OCTET_PART}\\.){3}${IPV4_OCTET_PART}$`);
-var INVALID_IP_ADDRESS_ERROR_CODE = "ERR_INVALID_IP_ADDRESS";
-var CHAR_CODE_0 = 48;
-var CHAR_CODE_9 = 57;
-var CHAR_CODE_A = 65;
-var CHAR_CODE_F = 70;
-var CHAR_CODE_a = 97;
-var CHAR_CODE_f = 102;
-var CHAR_CODE_DOT = 46;
-var CHAR_CODE_COLON = 58;
-var CHAR_CODE_PERCENT = 37;
-var distinctRemoteAddr = (remoteAddr) => {
-  if (IPV4_REGEX.test(remoteAddr)) {
-    return "IPv4";
-  }
-  if (remoteAddr.includes(":")) {
-    return "IPv6";
-  }
-};
-var createInvalidIPAddressError = (message) => {
-  const error = new TypeError(message);
-  error.code = INVALID_IP_ADDRESS_ERROR_CODE;
-  return error;
-};
-var throwInvalidIPv4Address = (ipv4) => {
-  throw createInvalidIPAddressError(`Invalid IPv4 address: ${ipv4}`);
-};
-var throwInvalidIPv6Address = (ipv6) => {
-  throw createInvalidIPAddressError(`Invalid IPv6 address: ${ipv6}`);
-};
-var parseIPv4ToBinary = (ipv4, start, end, onInvalid) => {
-  let result = 0n;
-  let octets = 0;
-  let octet = 0;
-  let digits = 0;
-  let firstDigit = 0;
-  for (let i = start; i <= end; i++) {
-    const code = i < end ? ipv4.charCodeAt(i) : CHAR_CODE_DOT;
-    if (code >= CHAR_CODE_0 && code <= CHAR_CODE_9) {
-      if (digits === 0) {
-        firstDigit = code;
-      } else if (firstDigit === CHAR_CODE_0) {
-        onInvalid();
-      }
-      octet = octet * 10 + code - CHAR_CODE_0;
-      if (octet > 255) {
-        onInvalid();
-      }
-      digits++;
-      continue;
-    }
-    if (code !== CHAR_CODE_DOT || digits === 0 || octets === 4) {
-      onInvalid();
-    }
-    result = (result << 8n) + BigInt(octet);
-    octets++;
-    octet = 0;
-    digits = 0;
-  }
-  if (octets !== 4) {
-    onInvalid();
-  }
-  return result;
-};
-var parseIPv6HexCode = (code) => {
-  if (code >= CHAR_CODE_0 && code <= CHAR_CODE_9) {
-    return code - CHAR_CODE_0;
-  }
-  if (code >= CHAR_CODE_A && code <= CHAR_CODE_F) {
-    return code - CHAR_CODE_A + 10;
-  }
-  if (code >= CHAR_CODE_a && code <= CHAR_CODE_f) {
-    return code - CHAR_CODE_a + 10;
-  }
-  return -1;
-};
-var isIPv6LinkLocal = (ipv6binary) => ipv6binary >> 118n === 0x3fan;
-var convertIPv4ToBinary = (ipv4) => {
-  return parseIPv4ToBinary(ipv4, 0, ipv4.length, () => throwInvalidIPv4Address(ipv4));
-};
-var convertIPv6ToBinary = (ipv6) => {
-  const length = ipv6.length;
-  const sections = [];
-  let hasZoneId = false;
-  let compressAt = -1;
-  let index = 0;
-  if (length === 0) {
-    throwInvalidIPv6Address(ipv6);
-  }
-  while (index < length) {
-    if (sections.length > 8) {
-      throwInvalidIPv6Address(ipv6);
-    }
-    let code = ipv6.charCodeAt(index);
-    if (code === CHAR_CODE_PERCENT) {
-      if (index + 1 === length) {
-        throwInvalidIPv6Address(ipv6);
-      }
-      hasZoneId = true;
-      break;
-    }
-    if (code === CHAR_CODE_COLON) {
-      if (index + 1 < length && ipv6.charCodeAt(index + 1) === CHAR_CODE_COLON) {
-        if (compressAt !== -1) {
-          throwInvalidIPv6Address(ipv6);
-        }
-        compressAt = sections.length;
-        index += 2;
-        continue;
-      }
-      throwInvalidIPv6Address(ipv6);
-    }
-    let value = 0;
-    let digits = 0;
-    const sectionStart = index;
-    while (index < length) {
-      code = ipv6.charCodeAt(index);
-      const hex = parseIPv6HexCode(code);
-      if (hex === -1) {
-        break;
-      }
-      if (digits === 4) {
-        throwInvalidIPv6Address(ipv6);
-      }
-      value = value << 4 | hex;
-      digits++;
-      index++;
-    }
-    if (index < length && ipv6.charCodeAt(index) === CHAR_CODE_DOT) {
-      let ipv4End = length;
-      for (let i = index; i < length; i++) {
-        if (ipv6.charCodeAt(i) === CHAR_CODE_PERCENT) {
-          if (i + 1 === length) {
-            throwInvalidIPv6Address(ipv6);
-          }
-          hasZoneId = true;
-          ipv4End = i;
-          break;
-        }
-      }
-      const ipv4 = parseIPv4ToBinary(
-        ipv6,
-        sectionStart,
-        ipv4End,
-        () => throwInvalidIPv6Address(ipv6)
-      );
-      sections.push(Number(ipv4 >> 16n & 0xffffn), Number(ipv4 & 0xffffn));
-      index = length;
-      break;
-    }
-    if (digits === 0) {
-      throwInvalidIPv6Address(ipv6);
-    }
-    sections.push(value);
-    if (index === length) {
-      break;
-    }
-    code = ipv6.charCodeAt(index);
-    if (code === CHAR_CODE_PERCENT) {
-      if (index + 1 === length) {
-        throwInvalidIPv6Address(ipv6);
-      }
-      hasZoneId = true;
-      break;
-    }
-    if (code !== CHAR_CODE_COLON) {
-      throwInvalidIPv6Address(ipv6);
-    }
-    if (index + 1 < length && ipv6.charCodeAt(index + 1) === CHAR_CODE_COLON) {
-      if (compressAt !== -1) {
-        throwInvalidIPv6Address(ipv6);
-      }
-      compressAt = sections.length;
-      index += 2;
-      continue;
-    }
-    index++;
-    if (index === length) {
-      throwInvalidIPv6Address(ipv6);
-    }
-  }
-  if (compressAt === -1 ? sections.length !== 8 : sections.length >= 8) {
-    throwInvalidIPv6Address(ipv6);
-  }
-  let result = 0n;
-  const zeros = compressAt === -1 ? 0 : 8 - sections.length;
-  const firstSectionEnd = compressAt === -1 ? sections.length : compressAt;
-  for (let i = 0; i < firstSectionEnd; i++) {
-    result <<= 16n;
-    result += BigInt(sections[i]);
-  }
-  for (let i = 0; i < zeros; i++) {
-    result <<= 16n;
-  }
-  for (let i = firstSectionEnd; i < sections.length; i++) {
-    result <<= 16n;
-    result += BigInt(sections[i]);
-  }
-  if (hasZoneId && !isIPv6LinkLocal(result)) {
-    throwInvalidIPv6Address(ipv6);
-  }
-  return result;
-};
-var convertIPv4BinaryToString = (ipV4) => {
-  const sections = [];
-  for (let i = 0; i < 4; i++) {
-    sections.push(ipV4 >> BigInt(8 * (3 - i)) & 0xffn);
-  }
-  return sections.join(".");
-};
-var isIPv4MappedIPv6 = (ipv6binary) => ipv6binary >> 32n === 0xffffn;
-var convertIPv4MappedIPv6ToIPv4 = (ipv6binary) => ipv6binary & 0xffffffffn;
-var convertIPv6BinaryToString = (ipV6) => {
-  if (ipV6 === 0n) {
-    return "::";
-  }
-  if (isIPv4MappedIPv6(ipV6)) {
-    return `::ffff:${convertIPv4BinaryToString(convertIPv4MappedIPv6ToIPv4(ipV6))}`;
-  }
-  const sections = [];
-  for (let i = 0; i < 8; i++) {
-    sections.push((ipV6 >> BigInt(16 * (7 - i)) & 0xffffn).toString(16));
-  }
-  let currentZeroStart = -1;
-  let maxZeroStart = -1;
-  let maxZeroEnd = -1;
-  for (let i = 0; i < 8; i++) {
-    if (sections[i] === "0") {
-      if (currentZeroStart === -1) {
-        currentZeroStart = i;
-      }
-    } else {
-      if (currentZeroStart > -1) {
-        if (i - currentZeroStart > maxZeroEnd - maxZeroStart) {
-          maxZeroStart = currentZeroStart;
-          maxZeroEnd = i;
-        }
-        currentZeroStart = -1;
-      }
-    }
-  }
-  if (currentZeroStart > -1) {
-    if (8 - currentZeroStart > maxZeroEnd - maxZeroStart) {
-      maxZeroStart = currentZeroStart;
-      maxZeroEnd = 8;
-    }
-  }
-  if (maxZeroStart !== -1 && maxZeroEnd - maxZeroStart > 1) {
-    sections.splice(maxZeroStart, maxZeroEnd - maxZeroStart, ":");
-  }
-  return sections.join(":").replace(/:{2,}/g, "::");
-};
-export {
-  INVALID_IP_ADDRESS_ERROR_CODE,
-  convertIPv4BinaryToString,
-  convertIPv4MappedIPv6ToIPv4,
-  convertIPv4ToBinary,
-  convertIPv6BinaryToString,
-  convertIPv6ToBinary,
-  distinctRemoteAddr,
-  expandIPv6,
-  isIPv4MappedIPv6
-};

package/node_modules/@zuplo/editor/node_modules/hono/dist/utils/jwt/index.js

@@ -1,6 +0,0 @@
-// src/utils/jwt/index.ts
-import { decode, sign, verify, verifyWithJwks } from "./jwt.js";
-var Jwt = { sign, verify, decode, verifyWithJwks };
-export {
-  Jwt
-};

package/node_modules/@zuplo/editor/node_modules/hono/dist/utils/jwt/jwa.js

@@ -1,20 +0,0 @@
-// src/utils/jwt/jwa.ts
-var AlgorithmTypes = /* @__PURE__ */ ((AlgorithmTypes2) => {
-  AlgorithmTypes2["HS256"] = "HS256";
-  AlgorithmTypes2["HS384"] = "HS384";
-  AlgorithmTypes2["HS512"] = "HS512";
-  AlgorithmTypes2["RS256"] = "RS256";
-  AlgorithmTypes2["RS384"] = "RS384";
-  AlgorithmTypes2["RS512"] = "RS512";
-  AlgorithmTypes2["PS256"] = "PS256";
-  AlgorithmTypes2["PS384"] = "PS384";
-  AlgorithmTypes2["PS512"] = "PS512";
-  AlgorithmTypes2["ES256"] = "ES256";
-  AlgorithmTypes2["ES384"] = "ES384";
-  AlgorithmTypes2["ES512"] = "ES512";
-  AlgorithmTypes2["EdDSA"] = "EdDSA";
-  return AlgorithmTypes2;
-})(AlgorithmTypes || {});
-export {
-  AlgorithmTypes
-};

package/node_modules/@zuplo/editor/node_modules/hono/dist/utils/jwt/jws.js

@@ -1,192 +0,0 @@
-// src/utils/jwt/jws.ts
-import { getRuntimeKey } from "../../helper/adapter/index.js";
-import { decodeBase64 } from "../encode.js";
-import { CryptoKeyUsage, JwtAlgorithmNotImplemented } from "./types.js";
-import { utf8Encoder } from "./utf8.js";
-async function signing(privateKey, alg, data) {
-  const algorithm = getKeyAlgorithm(alg);
-  const cryptoKey = await importPrivateKey(privateKey, algorithm);
-  return await crypto.subtle.sign(algorithm, cryptoKey, data);
-}
-async function verifying(publicKey, alg, signature, data) {
-  const algorithm = getKeyAlgorithm(alg);
-  const cryptoKey = await importPublicKey(publicKey, algorithm);
-  return await crypto.subtle.verify(algorithm, cryptoKey, signature, data);
-}
-function pemToBinary(pem) {
-  return decodeBase64(pem.replace(/-+(BEGIN|END).*?-+/g, "").replace(/\s/g, ""));
-}
-async function importPrivateKey(key, alg) {
-  if (!crypto.subtle || !crypto.subtle.importKey) {
-    throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
-  }
-  if (isCryptoKey(key)) {
-    if (key.type !== "private" && key.type !== "secret") {
-      throw new Error(
-        `unexpected key type: CryptoKey.type is ${key.type}, expected private or secret`
-      );
-    }
-    return key;
-  }
-  const usages = [CryptoKeyUsage.Sign];
-  if (typeof key === "object") {
-    return await crypto.subtle.importKey("jwk", key, alg, false, usages);
-  }
-  if (key.includes("PRIVATE")) {
-    return await crypto.subtle.importKey("pkcs8", pemToBinary(key), alg, false, usages);
-  }
-  return await crypto.subtle.importKey("raw", utf8Encoder.encode(key), alg, false, usages);
-}
-async function importPublicKey(key, alg) {
-  if (!crypto.subtle || !crypto.subtle.importKey) {
-    throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
-  }
-  if (isCryptoKey(key)) {
-    if (key.type === "public" || key.type === "secret") {
-      return key;
-    }
-    key = await exportPublicJwkFrom(key);
-  }
-  if (typeof key === "string" && key.includes("PRIVATE")) {
-    const privateKey = await crypto.subtle.importKey("pkcs8", pemToBinary(key), alg, true, [
-      CryptoKeyUsage.Sign
-    ]);
-    key = await exportPublicJwkFrom(privateKey);
-  }
-  const usages = [CryptoKeyUsage.Verify];
-  if (typeof key === "object") {
-    return await crypto.subtle.importKey("jwk", key, alg, false, usages);
-  }
-  if (key.includes("PUBLIC")) {
-    return await crypto.subtle.importKey("spki", pemToBinary(key), alg, false, usages);
-  }
-  return await crypto.subtle.importKey("raw", utf8Encoder.encode(key), alg, false, usages);
-}
-async function exportPublicJwkFrom(privateKey) {
-  if (privateKey.type !== "private") {
-    throw new Error(`unexpected key type: ${privateKey.type}`);
-  }
-  if (!privateKey.extractable) {
-    throw new Error("unexpected private key is unextractable");
-  }
-  const jwk = await crypto.subtle.exportKey("jwk", privateKey);
-  const { kty } = jwk;
-  const { alg, e, n } = jwk;
-  const { crv, x, y } = jwk;
-  return { kty, alg, e, n, crv, x, y, key_ops: [CryptoKeyUsage.Verify] };
-}
-function getKeyAlgorithm(name) {
-  switch (name) {
-    case "HS256":
-      return {
-        name: "HMAC",
-        hash: {
-          name: "SHA-256"
-        }
-      };
-    case "HS384":
-      return {
-        name: "HMAC",
-        hash: {
-          name: "SHA-384"
-        }
-      };
-    case "HS512":
-      return {
-        name: "HMAC",
-        hash: {
-          name: "SHA-512"
-        }
-      };
-    case "RS256":
-      return {
-        name: "RSASSA-PKCS1-v1_5",
-        hash: {
-          name: "SHA-256"
-        }
-      };
-    case "RS384":
-      return {
-        name: "RSASSA-PKCS1-v1_5",
-        hash: {
-          name: "SHA-384"
-        }
-      };
-    case "RS512":
-      return {
-        name: "RSASSA-PKCS1-v1_5",
-        hash: {
-          name: "SHA-512"
-        }
-      };
-    case "PS256":
-      return {
-        name: "RSA-PSS",
-        hash: {
-          name: "SHA-256"
-        },
-        saltLength: 32
-        // 256 >> 3
-      };
-    case "PS384":
-      return {
-        name: "RSA-PSS",
-        hash: {
-          name: "SHA-384"
-        },
-        saltLength: 48
-        // 384 >> 3
-      };
-    case "PS512":
-      return {
-        name: "RSA-PSS",
-        hash: {
-          name: "SHA-512"
-        },
-        saltLength: 64
-        // 512 >> 3,
-      };
-    case "ES256":
-      return {
-        name: "ECDSA",
-        hash: {
-          name: "SHA-256"
-        },
-        namedCurve: "P-256"
-      };
-    case "ES384":
-      return {
-        name: "ECDSA",
-        hash: {
-          name: "SHA-384"
-        },
-        namedCurve: "P-384"
-      };
-    case "ES512":
-      return {
-        name: "ECDSA",
-        hash: {
-          name: "SHA-512"
-        },
-        namedCurve: "P-521"
-      };
-    case "EdDSA":
-      return {
-        name: "Ed25519",
-        namedCurve: "Ed25519"
-      };
-    default:
-      throw new JwtAlgorithmNotImplemented(name);
-  }
-}
-function isCryptoKey(key) {
-  const runtime = getRuntimeKey();
-  if (runtime === "node" && !!crypto.webcrypto) {
-    return key instanceof crypto.webcrypto.CryptoKey;
-  }
-  return key instanceof CryptoKey;
-}
-export {
-  signing,
-  verifying
-};

package/node_modules/@zuplo/editor/node_modules/hono/dist/utils/jwt/jwt.js

@@ -1,207 +0,0 @@
-// src/utils/jwt/jwt.ts
-import { decodeBase64Url, encodeBase64Url } from "../../utils/encode.js";
-import { AlgorithmTypes } from "./jwa.js";
-import { signing, verifying } from "./jws.js";
-import {
-  JwtAlgorithmMismatch,
-  JwtAlgorithmNotAllowed,
-  JwtAlgorithmRequired,
-  JwtHeaderInvalid,
-  JwtHeaderRequiresKid,
-  JwtPayloadRequiresAud,
-  JwtSymmetricAlgorithmNotAllowed,
-  JwtTokenAudience,
-  JwtTokenExpired,
-  JwtTokenInvalid,
-  JwtTokenIssuedAt,
-  JwtTokenIssuer,
-  JwtTokenNotBefore,
-  JwtTokenSignatureMismatched
-} from "./types.js";
-import { utf8Decoder, utf8Encoder } from "./utf8.js";
-var encodeJwtPart = (part) => encodeBase64Url(utf8Encoder.encode(JSON.stringify(part)).buffer).replace(/=/g, "");
-var encodeSignaturePart = (buf) => encodeBase64Url(buf).replace(/=/g, "");
-var decodeJwtPart = (part) => JSON.parse(utf8Decoder.decode(decodeBase64Url(part)));
-function isTokenHeader(obj) {
-  if (typeof obj === "object" && obj !== null) {
-    const objWithAlg = obj;
-    return "alg" in objWithAlg && Object.values(AlgorithmTypes).includes(objWithAlg.alg) && (!("typ" in objWithAlg) || objWithAlg.typ === "JWT");
-  }
-  return false;
-}
-var sign = async (payload, privateKey, alg = "HS256") => {
-  const encodedPayload = encodeJwtPart(payload);
-  let encodedHeader;
-  if (typeof privateKey === "object" && "alg" in privateKey) {
-    alg = privateKey.alg;
-    encodedHeader = encodeJwtPart({ alg, typ: "JWT", kid: privateKey.kid });
-  } else {
-    encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
-  }
-  const partialToken = `${encodedHeader}.${encodedPayload}`;
-  const signaturePart = await signing(privateKey, alg, utf8Encoder.encode(partialToken));
-  const signature = encodeSignaturePart(signaturePart);
-  return `${partialToken}.${signature}`;
-};
-var verify = async (token, publicKey, algOrOptions) => {
-  if (!algOrOptions) {
-    throw new JwtAlgorithmRequired();
-  }
-  const {
-    alg,
-    iss,
-    nbf = true,
-    exp = true,
-    iat = true,
-    aud
-  } = typeof algOrOptions === "string" ? { alg: algOrOptions } : algOrOptions;
-  if (!alg) {
-    throw new JwtAlgorithmRequired();
-  }
-  const tokenParts = token.split(".");
-  if (tokenParts.length !== 3) {
-    throw new JwtTokenInvalid(token);
-  }
-  const { header, payload } = decode(token);
-  if (!isTokenHeader(header)) {
-    throw new JwtHeaderInvalid(header);
-  }
-  if (header.alg !== alg) {
-    throw new JwtAlgorithmMismatch(alg, header.alg);
-  }
-  const now = Math.floor(Date.now() / 1e3);
-  if (nbf && payload.nbf !== void 0) {
-    if (typeof payload.nbf !== "number" || !Number.isFinite(payload.nbf) || payload.nbf > now) {
-      throw new JwtTokenNotBefore(token);
-    }
-  }
-  if (exp && payload.exp !== void 0) {
-    if (typeof payload.exp !== "number" || !Number.isFinite(payload.exp) || payload.exp <= now) {
-      throw new JwtTokenExpired(token);
-    }
-  }
-  if (iat && payload.iat !== void 0) {
-    if (typeof payload.iat !== "number" || !Number.isFinite(payload.iat) || now < payload.iat) {
-      throw new JwtTokenIssuedAt(now, payload.iat);
-    }
-  }
-  if (iss) {
-    if (!payload.iss) {
-      throw new JwtTokenIssuer(iss, null);
-    }
-    if (typeof iss === "string" && payload.iss !== iss) {
-      throw new JwtTokenIssuer(iss, payload.iss);
-    }
-    if (iss instanceof RegExp && !iss.test(payload.iss)) {
-      throw new JwtTokenIssuer(iss, payload.iss);
-    }
-  }
-  if (aud) {
-    if (!payload.aud) {
-      throw new JwtPayloadRequiresAud(payload);
-    }
-    const audiences = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
-    const matched = audiences.some(
-      (payloadAud) => aud instanceof RegExp ? aud.test(payloadAud) : typeof aud === "string" ? payloadAud === aud : Array.isArray(aud) && aud.includes(payloadAud)
-    );
-    if (!matched) {
-      throw new JwtTokenAudience(aud, payload.aud);
-    }
-  }
-  const headerPayload = token.substring(0, token.lastIndexOf("."));
-  const verified = await verifying(
-    publicKey,
-    alg,
-    decodeBase64Url(tokenParts[2]),
-    utf8Encoder.encode(headerPayload)
-  );
-  if (!verified) {
-    throw new JwtTokenSignatureMismatched(token);
-  }
-  return payload;
-};
-var symmetricAlgorithms = [
-  AlgorithmTypes.HS256,
-  AlgorithmTypes.HS384,
-  AlgorithmTypes.HS512
-];
-var verifyWithJwks = async (token, options, init) => {
-  const verifyOpts = options.verification || {};
-  const header = decodeHeader(token);
-  if (!isTokenHeader(header)) {
-    throw new JwtHeaderInvalid(header);
-  }
-  if (!header.kid) {
-    throw new JwtHeaderRequiresKid(header);
-  }
-  if (symmetricAlgorithms.includes(header.alg)) {
-    throw new JwtSymmetricAlgorithmNotAllowed(header.alg);
-  }
-  if (!options.allowedAlgorithms.includes(header.alg)) {
-    throw new JwtAlgorithmNotAllowed(header.alg, options.allowedAlgorithms);
-  }
-  let verifyKeys = options.keys ? [...options.keys] : void 0;
-  if (options.jwks_uri) {
-    const response = await fetch(options.jwks_uri, init);
-    if (!response.ok) {
-      throw new Error(`failed to fetch JWKS from ${options.jwks_uri}`);
-    }
-    const data = await response.json();
-    if (!data.keys) {
-      throw new Error('invalid JWKS response. "keys" field is missing');
-    }
-    if (!Array.isArray(data.keys)) {
-      throw new Error('invalid JWKS response. "keys" field is not an array');
-    }
-    verifyKeys ??= [];
-    verifyKeys.push(...data.keys);
-  } else if (!verifyKeys) {
-    throw new Error('verifyWithJwks requires options for either "keys" or "jwks_uri" or both');
-  }
-  const matchingKey = verifyKeys.find((key) => key.kid === header.kid);
-  if (!matchingKey) {
-    throw new JwtTokenInvalid(token);
-  }
-  if (matchingKey.alg && matchingKey.alg !== header.alg) {
-    throw new JwtAlgorithmMismatch(matchingKey.alg, header.alg);
-  }
-  return await verify(token, matchingKey, {
-    alg: header.alg,
-    ...verifyOpts
-  });
-};
-var decode = (token) => {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw new JwtTokenInvalid(token);
-  }
-  try {
-    const header = decodeJwtPart(parts[0]);
-    const payload = decodeJwtPart(parts[1]);
-    return {
-      header,
-      payload
-    };
-  } catch {
-    throw new JwtTokenInvalid(token);
-  }
-};
-var decodeHeader = (token) => {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw new JwtTokenInvalid(token);
-  }
-  try {
-    return decodeJwtPart(parts[0]);
-  } catch {
-    throw new JwtTokenInvalid(token);
-  }
-};
-export {
-  decode,
-  decodeHeader,
-  isTokenHeader,
-  sign,
-  verify,
-  verifyWithJwks
-};