@zuplo/cli 6.69.11 → 6.70.0

package/node_modules/hono/dist/cjs/router.js

@@ -0,0 +1,40 @@
+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 router_exports = {};
+__export(router_exports, {
+  MESSAGE_MATCHER_IS_ALREADY_BUILT: () => MESSAGE_MATCHER_IS_ALREADY_BUILT,
+  METHODS: () => METHODS,
+  METHOD_NAME_ALL: () => METHOD_NAME_ALL,
+  METHOD_NAME_ALL_LOWERCASE: () => METHOD_NAME_ALL_LOWERCASE,
+  UnsupportedPathError: () => UnsupportedPathError
+});
+module.exports = __toCommonJS(router_exports);
+const METHOD_NAME_ALL = "ALL";
+const METHOD_NAME_ALL_LOWERCASE = "all";
+const METHODS = ["get", "post", "put", "delete", "options", "patch"];
+const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+class UnsupportedPathError extends Error {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_MATCHER_IS_ALREADY_BUILT,
+  METHODS,
+  METHOD_NAME_ALL,
+  METHOD_NAME_ALL_LOWERCASE,
+  UnsupportedPathError
+});

package/node_modules/hono/dist/cjs/types.js

@@ -0,0 +1,28 @@
+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 types_exports = {};
+__export(types_exports, {
+  FetchEventLike: () => FetchEventLike
+});
+module.exports = __toCommonJS(types_exports);
+class FetchEventLike {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FetchEventLike
+});

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

@@ -0,0 +1,245 @@
+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 accept_exports = {};
+__export(accept_exports, {
+  parseAccept: () => parseAccept
+});
+module.exports = __toCommonJS(accept_exports);
+const isWhitespace = (char) => char === 32 || char === 9 || char === 10 || char === 13;
+const consumeWhitespace = (acceptHeader, startIndex) => {
+  while (startIndex < acceptHeader.length) {
+    if (!isWhitespace(acceptHeader.charCodeAt(startIndex))) {
+      break;
+    }
+    startIndex++;
+  }
+  return startIndex;
+};
+const ignoreTrailingWhitespace = (acceptHeader, startIndex) => {
+  while (startIndex > 0) {
+    if (!isWhitespace(acceptHeader.charCodeAt(startIndex - 1))) {
+      break;
+    }
+    startIndex--;
+  }
+  return startIndex;
+};
+const skipInvalidParam = (acceptHeader, startIndex) => {
+  while (startIndex < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(startIndex);
+    if (char === 59) {
+      return [startIndex + 1, true];
+    }
+    if (char === 44) {
+      return [startIndex + 1, false];
+    }
+    startIndex++;
+  }
+  return [startIndex, false];
+};
+const skipInvalidAcceptValue = (acceptHeader, startIndex) => {
+  let i = startIndex;
+  let inQuotes = false;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (inQuotes && char === 92) {
+      i++;
+    } else if (char === 34) {
+      inQuotes = !inQuotes;
+    } else if (!inQuotes && char === 44) {
+      return i + 1;
+    }
+    i++;
+  }
+  return i;
+};
+const getNextParam = (acceptHeader, startIndex) => {
+  startIndex = consumeWhitespace(acceptHeader, startIndex);
+  let i = startIndex;
+  let key;
+  let value;
+  let hasNext = false;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (char === 61) {
+      key = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+      i++;
+      break;
+    }
+    if (char === 59) {
+      return [i + 1, void 0, void 0, true];
+    }
+    if (char === 44) {
+      return [i + 1, void 0, void 0, false];
+    }
+    i++;
+  }
+  if (key === void 0) {
+    return [i, void 0, void 0, false];
+  }
+  i = consumeWhitespace(acceptHeader, i);
+  if (acceptHeader.charCodeAt(i) === 61) {
+    const skipResult = skipInvalidParam(acceptHeader, i + 1);
+    return [skipResult[0], key, void 0, skipResult[1]];
+  }
+  let inQuotes = false;
+  const paramStartIndex = i;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (inQuotes && char === 92) {
+      i++;
+    } else if (char === 34) {
+      if (inQuotes) {
+        let nextIndex = consumeWhitespace(acceptHeader, i + 1);
+        const nextChar = acceptHeader.charCodeAt(nextIndex);
+        if (nextIndex < acceptHeader.length && !(nextChar === 59 || nextChar === 44)) {
+          const skipResult = skipInvalidParam(acceptHeader, nextIndex);
+          return [skipResult[0], key, void 0, skipResult[1]];
+        }
+        value = acceptHeader.slice(paramStartIndex + 1, i);
+        if (value.includes("\\")) {
+          value = value.replace(/\\(.)/g, "$1");
+        }
+        if (nextChar === 44) {
+          return [nextIndex + 1, key, value, false];
+        }
+        if (nextChar === 59) {
+          hasNext = true;
+          nextIndex++;
+        }
+        i = nextIndex;
+        break;
+      }
+      inQuotes = true;
+    } else if (!inQuotes && (char === 59 || char === 44)) {
+      value = acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i));
+      if (char === 59) {
+        hasNext = true;
+      }
+      i++;
+      break;
+    }
+    i++;
+  }
+  return [
+    i,
+    key,
+    value ?? acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i)),
+    hasNext
+  ];
+};
+const getNextAcceptValue = (acceptHeader, startIndex) => {
+  const accept = {
+    type: "",
+    params: {},
+    q: 1
+  };
+  startIndex = consumeWhitespace(acceptHeader, startIndex);
+  let i = startIndex;
+  while (i < acceptHeader.length) {
+    const char = acceptHeader.charCodeAt(i);
+    if (char === 59 || char === 44) {
+      accept.type = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+      i++;
+      if (char === 44) {
+        return [i, accept.type ? accept : void 0];
+      }
+      if (!accept.type) {
+        return [skipInvalidAcceptValue(acceptHeader, i), void 0];
+      }
+      break;
+    }
+    i++;
+  }
+  if (!accept.type) {
+    accept.type = acceptHeader.slice(
+      startIndex,
+      ignoreTrailingWhitespace(acceptHeader, acceptHeader.length)
+    );
+    return [acceptHeader.length, accept.type ? accept : void 0];
+  }
+  let param;
+  let value;
+  let hasNext;
+  while (i < acceptHeader.length) {
+    ;
+    [i, param, value, hasNext] = getNextParam(acceptHeader, i);
+    if (param && value) {
+      accept.params[param] = value;
+    }
+    if (!hasNext) {
+      break;
+    }
+  }
+  return [i, accept];
+};
+const parseAccept = (acceptHeader) => {
+  if (!acceptHeader) {
+    return [];
+  }
+  const values = [];
+  let i = 0;
+  let accept;
+  let requiresSort = false;
+  let lastAccept;
+  while (i < acceptHeader.length) {
+    ;
+    [i, accept] = getNextAcceptValue(acceptHeader, i);
+    if (accept) {
+      accept.q = parseQuality(accept.params.q);
+      values.push(accept);
+      if (lastAccept && lastAccept.q < accept.q) {
+        requiresSort = true;
+      }
+      lastAccept = accept;
+    }
+  }
+  if (requiresSort) {
+    values.sort((a, b) => b.q - a.q);
+  }
+  return values;
+};
+const parseQuality = (qVal) => {
+  if (qVal === void 0) {
+    return 1;
+  }
+  if (qVal === "") {
+    return 1;
+  }
+  if (qVal === "NaN") {
+    return 0;
+  }
+  const num = Number(qVal);
+  if (num === Infinity) {
+    return 1;
+  }
+  if (num === -Infinity) {
+    return 0;
+  }
+  if (Number.isNaN(num)) {
+    return 1;
+  }
+  if (num < 0 || num > 1) {
+    return 1;
+  }
+  return num;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseAccept
+});

package/node_modules/hono/dist/cjs/utils/basic-auth.js

@@ -0,0 +1,45 @@
+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 basic_auth_exports = {};
+__export(basic_auth_exports, {
+  auth: () => auth
+});
+module.exports = __toCommonJS(basic_auth_exports);
+var import_encode = require("./encode");
+const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
+const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
+const utf8Decoder = new TextDecoder();
+const auth = (req) => {
+  const match = CREDENTIALS_REGEXP.exec(req.headers.get("Authorization") || "");
+  if (!match) {
+    return void 0;
+  }
+  let userPass = void 0;
+  try {
+    userPass = USER_PASS_REGEXP.exec(utf8Decoder.decode((0, import_encode.decodeBase64)(match[1])));
+  } catch {
+  }
+  if (!userPass) {
+    return void 0;
+  }
+  return { username: userPass[1], password: userPass[2] };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  auth
+});

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

@@ -0,0 +1,97 @@
+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 body_exports = {};
+__export(body_exports, {
+  parseBody: () => parseBody
+});
+module.exports = __toCommonJS(body_exports);
+var import_request = require("../request");
+const parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = request instanceof import_request.HonoRequest ? request.raw.headers : request.headers;
+  const contentType = headers.get("Content-Type");
+  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  const formData = await request.formData();
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+const handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== void 0) {
+    if (Array.isArray(form[key])) {
+      ;
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
+  }
+};
+const handleParsingNestedValues = (form, key, value) => {
+  if (/(?:^|\.)__proto__\./.test(key)) {
+    return;
+  }
+  let nestedForm = form;
+  const keys = key.split(".");
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseBody
+});

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

@@ -0,0 +1,102 @@
+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 buffer_exports = {};
+__export(buffer_exports, {
+  bufferToFormData: () => bufferToFormData,
+  bufferToString: () => bufferToString,
+  equal: () => equal,
+  timingSafeEqual: () => timingSafeEqual
+});
+module.exports = __toCommonJS(buffer_exports);
+var import_crypto = require("./crypto");
+const equal = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  const va = new DataView(a);
+  const vb = new DataView(b);
+  let i = va.byteLength;
+  while (i--) {
+    if (va.getUint8(i) !== vb.getUint8(i)) {
+      return false;
+    }
+  }
+  return true;
+};
+const constantTimeEqualString = (a, b) => {
+  const aLen = a.length;
+  const bLen = b.length;
+  const maxLen = Math.max(aLen, bLen);
+  let out = aLen ^ bLen;
+  for (let i = 0; i < maxLen; i++) {
+    const aChar = i < aLen ? a.charCodeAt(i) : 0;
+    const bChar = i < bLen ? b.charCodeAt(i) : 0;
+    out |= aChar ^ bChar;
+  }
+  return out === 0;
+};
+const timingSafeEqualString = async (a, b, hashFunction) => {
+  if (!hashFunction) {
+    hashFunction = import_crypto.sha256;
+  }
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+  if (sa == null || sb == null || typeof sa !== "string" || typeof sb !== "string") {
+    return false;
+  }
+  const hashEqual = constantTimeEqualString(sa, sb);
+  const originalEqual = constantTimeEqualString(a, b);
+  return hashEqual && originalEqual;
+};
+const timingSafeEqual = async (a, b, hashFunction) => {
+  if (typeof a === "string" && typeof b === "string") {
+    return timingSafeEqualString(a, b, hashFunction);
+  }
+  if (!hashFunction) {
+    hashFunction = import_crypto.sha256;
+  }
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+  if (!sa || !sb || typeof sa !== "string" || typeof sb !== "string") {
+    return false;
+  }
+  return timingSafeEqualString(sa, sb);
+};
+const bufferToString = (buffer) => {
+  if (buffer instanceof ArrayBuffer) {
+    const enc = new TextDecoder("utf-8");
+    return enc.decode(buffer);
+  }
+  return buffer;
+};
+const bufferToFormData = (arrayBuffer, contentType) => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      "Content-Type": contentType
+    }
+  });
+  return response.formData();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bufferToFormData,
+  bufferToString,
+  equal,
+  timingSafeEqual
+});

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

@@ -0,0 +1,48 @@
+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 color_exports = {};
+__export(color_exports, {
+  getColorEnabled: () => getColorEnabled,
+  getColorEnabledAsync: () => getColorEnabledAsync
+});
+module.exports = __toCommonJS(color_exports);
+function getColorEnabled() {
+  const { process, Deno } = globalThis;
+  const isNoColor = typeof Deno?.noColor === "boolean" ? Deno.noColor : process !== void 0 ? (
+    // eslint-disable-next-line no-unsafe-optional-chaining
+    "NO_COLOR" in process?.env
+  ) : false;
+  return !isNoColor;
+}
+async function getColorEnabledAsync() {
+  const { navigator } = globalThis;
+  const cfWorkers = "cloudflare:workers";
+  const isNoColor = navigator !== void 0 && navigator.userAgent === "Cloudflare-Workers" ? await (async () => {
+    try {
+      return "NO_COLOR" in ((await import(cfWorkers)).env ?? {});
+    } catch {
+      return false;
+    }
+  })() : !getColorEnabled();
+  return !isNoColor;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getColorEnabled,
+  getColorEnabledAsync
+});

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

@@ -0,0 +1,27 @@
+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 compress_exports = {};
+__export(compress_exports, {
+  COMPRESSIBLE_CONTENT_TYPE_REGEX: () => COMPRESSIBLE_CONTENT_TYPE_REGEX
+});
+module.exports = __toCommonJS(compress_exports);
+const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMPRESSIBLE_CONTENT_TYPE_REGEX
+});

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

@@ -0,0 +1,61 @@
+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 concurrent_exports = {};
+__export(concurrent_exports, {
+  createPool: () => createPool
+});
+module.exports = __toCommonJS(concurrent_exports);
+const DEFAULT_CONCURRENCY = 1024;
+const createPool = ({
+  concurrency,
+  interval
+} = {}) => {
+  concurrency ||= DEFAULT_CONCURRENCY;
+  if (concurrency === Infinity) {
+    return {
+      run: async (fn) => fn()
+    };
+  }
+  const pool = /* @__PURE__ */ new Set();
+  const run = async (fn, promise, resolve) => {
+    if (pool.size >= concurrency) {
+      promise ||= new Promise((r) => resolve = r);
+      setTimeout(() => run(fn, promise, resolve));
+      return promise;
+    }
+    const marker = {};
+    pool.add(marker);
+    const result = await fn();
+    if (interval) {
+      setTimeout(() => pool.delete(marker), interval);
+    } else {
+      pool.delete(marker);
+    }
+    if (resolve) {
+      resolve(result);
+      return promise;
+    } else {
+      return result;
+    }
+  };
+  return { run };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPool
+});