@zuplo/cli 7.8.18 → 7.8.19

package/node_modules/hono/dist/cjs/utils/ipaddr.js

@@ -1,57 +1,26 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ipaddr_exports = {};
-__export(ipaddr_exports, {
-  INVALID_IP_ADDRESS_ERROR_CODE: () => INVALID_IP_ADDRESS_ERROR_CODE,
-  convertIPv4BinaryToString: () => convertIPv4BinaryToString,
-  convertIPv4MappedIPv6ToIPv4: () => convertIPv4MappedIPv6ToIPv4,
-  convertIPv4ToBinary: () => convertIPv4ToBinary,
-  convertIPv6BinaryToString: () => convertIPv6BinaryToString,
-  convertIPv6ToBinary: () => convertIPv6ToBinary,
-  distinctRemoteAddr: () => distinctRemoteAddr,
-  expandIPv6: () => expandIPv6,
-  isIPv4MappedIPv6: () => isIPv4MappedIPv6
-});
-module.exports = __toCommonJS(ipaddr_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/utils/ipaddr.ts
+/**
+* Expand IPv6 Address
+* @param ipV6 Shorten IPv6 Address
+* @return expanded IPv6 Address
+*/
 const expandIPv6 = (ipV6) => {
-  const sections = ipV6.split(":");
-  const lastSection = sections.at(-1);
-  if (IPV4_REGEX.test(lastSection)) {
-    const octets = lastSection.split(".").map(Number);
-    sections.splice(
-      -1,
-      1,
-      (octets[0] << 8 | octets[1]).toString(16),
-      (octets[2] << 8 | octets[3]).toString(16)
-    );
-  }
-  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(":");
+	const sections = ipV6.split(":");
+	const lastSection = sections.at(-1);
+	if (IPV4_REGEX.test(lastSection)) {
+		const octets = lastSection.split(".").map(Number);
+		sections.splice(-1, 1, (octets[0] << 8 | octets[1]).toString(16), (octets[2] << 8 | octets[3]).toString(16));
+	}
+	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(":");
 };
 const IPV4_OCTET_PART = "(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])";
 const IPV4_REGEX = new RegExp(`^(?:${IPV4_OCTET_PART}\\.){3}${IPV4_OCTET_PART}$`);
@@ -65,256 +34,214 @@ const CHAR_CODE_f = 102;
 const CHAR_CODE_DOT = 46;
 const CHAR_CODE_COLON = 58;
 const CHAR_CODE_PERCENT = 37;
+/**
+* Distinct Remote Addr
+* @param remoteAddr Remote Addr
+*/
 const distinctRemoteAddr = (remoteAddr) => {
-  if (IPV4_REGEX.test(remoteAddr)) {
-    return "IPv4";
-  }
-  if (remoteAddr.includes(":")) {
-    return "IPv6";
-  }
+	if (IPV4_REGEX.test(remoteAddr)) return "IPv4";
+	if (remoteAddr.includes(":")) return "IPv6";
 };
 const createInvalidIPAddressError = (message) => {
-  const error = new TypeError(message);
-  error.code = INVALID_IP_ADDRESS_ERROR_CODE;
-  return error;
+	const error = new TypeError(message);
+	error.code = INVALID_IP_ADDRESS_ERROR_CODE;
+	return error;
 };
 const throwInvalidIPv4Address = (ipv4) => {
-  throw createInvalidIPAddressError(`Invalid IPv4 address: ${ipv4}`);
+	throw createInvalidIPAddressError(`Invalid IPv4 address: ${ipv4}`);
 };
 const throwInvalidIPv6Address = (ipv6) => {
-  throw createInvalidIPAddressError(`Invalid IPv6 address: ${ipv6}`);
+	throw createInvalidIPAddressError(`Invalid IPv6 address: ${ipv6}`);
 };
 const 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;
+	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;
 };
 const 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;
+	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;
 };
-const isIPv6LinkLocal = (ipv6binary) => ipv6binary >> 118n === 0x3fan;
+const isIPv6LinkLocal = (ipv6binary) => ipv6binary >> 118n === 1018n;
+/**
+* Convert IPv4 to Uint8Array
+* @param ipv4 IPv4 Address
+* @returns BigInt
+*/
 const convertIPv4ToBinary = (ipv4) => {
-  return parseIPv4ToBinary(ipv4, 0, ipv4.length, () => throwInvalidIPv4Address(ipv4));
+	return parseIPv4ToBinary(ipv4, 0, ipv4.length, () => throwInvalidIPv4Address(ipv4));
 };
+/**
+* Convert IPv6 to Uint8Array
+* @param ipv6 IPv6 Address
+* @returns BigInt
+*/
 const 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;
+	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 & 65535n), Number(ipv4 & 65535n));
+			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;
 };
+/**
+* Convert a binary representation of an IPv4 address to a string.
+* @param ipV4 binary IPv4 Address
+* @return IPv4 Address in string
+*/
 const convertIPv4BinaryToString = (ipV4) => {
-  const sections = [];
-  for (let i = 0; i < 4; i++) {
-    sections.push(ipV4 >> BigInt(8 * (3 - i)) & 0xffn);
-  }
-  return sections.join(".");
+	const sections = [];
+	for (let i = 0; i < 4; i++) sections.push(ipV4 >> BigInt(8 * (3 - i)) & 255n);
+	return sections.join(".");
 };
-const isIPv4MappedIPv6 = (ipv6binary) => ipv6binary >> 32n === 0xffffn;
-const convertIPv4MappedIPv6ToIPv4 = (ipv6binary) => ipv6binary & 0xffffffffn;
+/**
+* Check if a binary IPv6 address is an IPv4-mapped IPv6 address (::ffff:x.x.x.x)
+* @param ipv6binary binary IPv6 Address
+* @return true if the address is an IPv4-mapped IPv6 address
+*/
+const isIPv4MappedIPv6 = (ipv6binary) => ipv6binary >> 32n === 65535n;
+/**
+* Extract the IPv4 portion from an IPv4-mapped IPv6 address
+* @param ipv6binary binary IPv4-mapped IPv6 Address
+* @return binary IPv4 Address
+*/
+const convertIPv4MappedIPv6ToIPv4 = (ipv6binary) => ipv6binary & 4294967295n;
+/**
+* Convert a binary representation of an IPv6 address to a string.
+* @param ipV6 binary IPv6 Address
+* @return normalized IPv6 Address in string
+*/
 const 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, "::");
+	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)) & 65535n).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, "::");
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  INVALID_IP_ADDRESS_ERROR_CODE,
-  convertIPv4BinaryToString,
-  convertIPv4MappedIPv6ToIPv4,
-  convertIPv4ToBinary,
-  convertIPv6BinaryToString,
-  convertIPv6ToBinary,
-  distinctRemoteAddr,
-  expandIPv6,
-  isIPv4MappedIPv6
-});
+//#endregion
+exports.INVALID_IP_ADDRESS_ERROR_CODE = INVALID_IP_ADDRESS_ERROR_CODE;
+exports.convertIPv4BinaryToString = convertIPv4BinaryToString;
+exports.convertIPv4MappedIPv6ToIPv4 = convertIPv4MappedIPv6ToIPv4;
+exports.convertIPv4ToBinary = convertIPv4ToBinary;
+exports.convertIPv6BinaryToString = convertIPv6BinaryToString;
+exports.convertIPv6ToBinary = convertIPv6ToBinary;
+exports.distinctRemoteAddr = distinctRemoteAddr;
+exports.expandIPv6 = expandIPv6;
+exports.isIPv4MappedIPv6 = isIPv4MappedIPv6;

package/node_modules/hono/dist/cjs/utils/jwt/index.js

@@ -1,28 +1,15 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils_jwt_jwt = require("./jwt.js");
+//#region src/utils/jwt/index.ts
+/**
+* @module
+* JWT utility.
+*/
+const Jwt = {
+	sign: require_utils_jwt_jwt.sign,
+	verify: require_utils_jwt_jwt.verify,
+	decode: require_utils_jwt_jwt.decode,
+	verifyWithJwks: require_utils_jwt_jwt.verifyWithJwks
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var jwt_exports = {};
-__export(jwt_exports, {
-  Jwt: () => Jwt
-});
-module.exports = __toCommonJS(jwt_exports);
-var import_jwt = require("./jwt");
-const Jwt = { sign: import_jwt.sign, verify: import_jwt.verify, decode: import_jwt.decode, verifyWithJwks: import_jwt.verifyWithJwks };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Jwt
-});
+//#endregion
+exports.Jwt = Jwt;

package/node_modules/hono/dist/cjs/utils/jwt/jwa.js

@@ -1,42 +1,25 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var jwa_exports = {};
-__export(jwa_exports, {
-  AlgorithmTypes: () => AlgorithmTypes
-});
-module.exports = __toCommonJS(jwa_exports);
-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 || {});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AlgorithmTypes
-});
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/utils/jwt/jwa.ts
+/**
+* @module
+* JSON Web Algorithms (JWA)
+* https://datatracker.ietf.org/doc/html/rfc7518
+*/
+let AlgorithmTypes = /* @__PURE__ */ function(AlgorithmTypes) {
+	AlgorithmTypes["HS256"] = "HS256";
+	AlgorithmTypes["HS384"] = "HS384";
+	AlgorithmTypes["HS512"] = "HS512";
+	AlgorithmTypes["RS256"] = "RS256";
+	AlgorithmTypes["RS384"] = "RS384";
+	AlgorithmTypes["RS512"] = "RS512";
+	AlgorithmTypes["PS256"] = "PS256";
+	AlgorithmTypes["PS384"] = "PS384";
+	AlgorithmTypes["PS512"] = "PS512";
+	AlgorithmTypes["ES256"] = "ES256";
+	AlgorithmTypes["ES384"] = "ES384";
+	AlgorithmTypes["ES512"] = "ES512";
+	AlgorithmTypes["EdDSA"] = "EdDSA";
+	return AlgorithmTypes;
+}({});
+//#endregion
+exports.AlgorithmTypes = AlgorithmTypes;