@hot-updater/console 0.0.2 → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2437 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src-server/index.ts
+var src_server_exports = {};
+__export(src_server_exports, {
+  default: () => src_server_default
+});
+module.exports = __toCommonJS(src_server_exports);
+var import_path = __toESM(require("path"), 1);
+var import_url7 = require("url");
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/filepath.js
+var getFilePath = (options) => {
+  let filename = options.filename;
+  const defaultDocument = options.defaultDocument || "index.html";
+  if (filename.endsWith("/")) {
+    filename = filename.concat(defaultDocument);
+  } else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) {
+    filename = filename.concat("/" + defaultDocument);
+  }
+  const path2 = getFilePathWithoutDefaultDocument({
+    root: options.root,
+    filename
+  });
+  return path2;
+};
+var getFilePathWithoutDefaultDocument = (options) => {
+  let root = options.root || "";
+  let filename = options.filename;
+  if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
+    return;
+  }
+  filename = filename.replace(/^\.?[\/\\]/, "");
+  filename = filename.replace(/\\/, "/");
+  root = root.replace(/\/$/, "");
+  let path2 = root ? root + "/" + filename : filename;
+  path2 = path2.replace(/^\.?\//, "");
+  if (root[0] !== "/" && path2[0] === "/") {
+    return;
+  }
+  return path2;
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/mime.js
+var getMimeType = (filename, mimes = baseMimes) => {
+  const regexp = /\.([a-zA-Z0-9]+?)$/;
+  const match = filename.match(regexp);
+  if (!match) {
+    return;
+  }
+  let mimeType = mimes[match[1]];
+  if (mimeType && mimeType.startsWith("text") || mimeType === "application/json") {
+    mimeType += "; charset=utf-8";
+  }
+  return mimeType;
+};
+var baseMimes = {
+  aac: "audio/aac",
+  avi: "video/x-msvideo",
+  avif: "image/avif",
+  av1: "video/av1",
+  bin: "application/octet-stream",
+  bmp: "image/bmp",
+  css: "text/css",
+  csv: "text/csv",
+  eot: "application/vnd.ms-fontobject",
+  epub: "application/epub+zip",
+  gif: "image/gif",
+  gz: "application/gzip",
+  htm: "text/html",
+  html: "text/html",
+  ico: "image/x-icon",
+  ics: "text/calendar",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  js: "text/javascript",
+  json: "application/json",
+  jsonld: "application/ld+json",
+  map: "application/json",
+  mid: "audio/x-midi",
+  midi: "audio/x-midi",
+  mjs: "text/javascript",
+  mp3: "audio/mpeg",
+  mp4: "video/mp4",
+  mpeg: "video/mpeg",
+  oga: "audio/ogg",
+  ogv: "video/ogg",
+  ogx: "application/ogg",
+  opus: "audio/opus",
+  otf: "font/otf",
+  pdf: "application/pdf",
+  png: "image/png",
+  rtf: "application/rtf",
+  svg: "image/svg+xml",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  ts: "video/mp2t",
+  ttf: "font/ttf",
+  txt: "text/plain",
+  wasm: "application/wasm",
+  webm: "video/webm",
+  weba: "audio/webm",
+  webp: "image/webp",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  xhtml: "application/xhtml+xml",
+  xml: "application/xml",
+  zip: "application/zip",
+  "3gp": "video/3gpp",
+  "3g2": "video/3gpp2",
+  gltf: "model/gltf+json",
+  glb: "model/gltf-binary"
+};
+
+// ../../node_modules/.pnpm/@hono+node-server@1.13.4_hono@4.6.3/node_modules/@hono/node-server/dist/serve-static.mjs
+var import_fs = require("fs");
+var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\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;
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var createStreamBody = (stream) => {
+  const body = new ReadableStream({
+    start(controller) {
+      stream.on("data", (chunk) => {
+        controller.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        controller.close();
+      });
+    },
+    cancel() {
+      stream.destroy();
+    }
+  });
+  return body;
+};
+var addCurrentDirPrefix = (path2) => {
+  return `./${path2}`;
+};
+var getStats = (path2) => {
+  let stats;
+  try {
+    stats = (0, import_fs.lstatSync)(path2);
+  } catch {
+  }
+  return stats;
+};
+var serveStatic = (options = { root: "" }) => {
+  return async (c, next) => {
+    if (c.finalized) {
+      return next();
+    }
+    let filename;
+    try {
+      filename = options.path ?? decodeURIComponent(c.req.path);
+    } catch {
+      await options.onNotFound?.(c.req.path, c);
+      return next();
+    }
+    let path2 = getFilePathWithoutDefaultDocument({
+      filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+      root: options.root
+    });
+    if (path2) {
+      path2 = addCurrentDirPrefix(path2);
+    } else {
+      return next();
+    }
+    let stats = getStats(path2);
+    if (stats && stats.isDirectory()) {
+      path2 = getFilePath({
+        filename: options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename,
+        root: options.root,
+        defaultDocument: options.index ?? "index.html"
+      });
+      if (path2) {
+        path2 = addCurrentDirPrefix(path2);
+      } else {
+        return next();
+      }
+      stats = getStats(path2);
+    }
+    if (!stats) {
+      await options.onNotFound?.(path2, c);
+      return next();
+    }
+    await options.onFound?.(path2, c);
+    const mimeType = getMimeType(path2);
+    c.header("Content-Type", mimeType || "application/octet-stream");
+    if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+      const acceptEncodingSet = new Set(
+        c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim())
+      );
+      for (const encoding of ENCODINGS_ORDERED_KEYS) {
+        if (!acceptEncodingSet.has(encoding)) {
+          continue;
+        }
+        const precompressedStats = getStats(path2 + ENCODINGS[encoding]);
+        if (precompressedStats) {
+          c.header("Content-Encoding", encoding);
+          c.header("Vary", "Accept-Encoding", { append: true });
+          stats = precompressedStats;
+          path2 = path2 + ENCODINGS[encoding];
+          break;
+        }
+      }
+    }
+    const size = stats.size;
+    if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
+      c.header("Content-Length", size.toString());
+      c.status(200);
+      return c.body(null);
+    }
+    const range = c.req.header("range") || "";
+    if (!range) {
+      c.header("Content-Length", size.toString());
+      return c.body(createStreamBody((0, import_fs.createReadStream)(path2)), 200);
+    }
+    c.header("Accept-Ranges", "bytes");
+    c.header("Date", stats.birthtime.toUTCString());
+    const parts = range.replace(/bytes=/, "").split("-", 2);
+    const start = parts[0] ? parseInt(parts[0], 10) : 0;
+    let end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;
+    if (size < end - start + 1) {
+      end = size - 1;
+    }
+    const chunksize = end - start + 1;
+    const stream = (0, import_fs.createReadStream)(path2, { start, end });
+    c.header("Content-Length", chunksize.toString());
+    c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
+    return c.body(createStreamBody(stream), 206);
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/body.js
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = request instanceof 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;
+}
+var 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 {
+    form[key] = value;
+  }
+};
+var handleParsingNestedValues = (form, key, value) => {
+  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];
+    }
+  });
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/url.js
+var splitPath = (path2) => {
+  const paths = path2.split("/");
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path: path2 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path2);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path2) => {
+  const groups = [];
+  path2 = path2.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return { groups, path: path2 };
+};
+var replaceGroupMarks = (paths, groups) => {
+  for (let i = groups.length - 1; i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths.length - 1; j >= 0; j--) {
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1]);
+        break;
+      }
+    }
+  }
+  return paths;
+};
+var patternCache = {};
+var getPattern = (label) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    if (!patternCache[label]) {
+      if (match[2]) {
+        patternCache[label] = [label, match[1], new RegExp("^" + match[2] + "$")];
+      } else {
+        patternCache[label] = [label, match[1], true];
+      }
+    }
+    return patternCache[label];
+  }
+  return null;
+};
+var tryDecodeURI = (str) => {
+  try {
+    return decodeURI(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decodeURI(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", 8);
+  let i = start;
+  for (; i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const path2 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
+      return tryDecodeURI(path2.includes("%25") ? path2.replace(/%25/g, "%2525") : path2);
+    } else if (charCode === 63) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result[result.length - 1] === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (...paths) => {
+  let p = "";
+  let endsWithSlash = false;
+  for (let path2 of paths) {
+    if (p[p.length - 1] === "/") {
+      p = p.slice(0, -1);
+      endsWithSlash = true;
+    }
+    if (path2[0] !== "/") {
+      path2 = `/${path2}`;
+    }
+    if (path2 === "/" && endsWithSlash) {
+      p = `${p}/`;
+    } else if (path2 !== "/") {
+      p = `${p}${path2}`;
+    }
+    if (path2 === "/" && p === "") {
+      p = "/";
+    }
+  }
+  return p;
+};
+var checkOptionalParameter = (path2) => {
+  if (!path2.match(/\:.+\?$/)) {
+    return null;
+  }
+  const segments = path2.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (/\?/.test(segment)) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.replace("?", "");
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var _decodeURI = (value) => {
+  if (!/[%+]/.test(value)) {
+    return value;
+  }
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return /%/.test(value) ? decodeURIComponent_(value) : value;
+};
+var _getQueryParam = (url, key, multiple) => {
+  let encoded;
+  if (!multiple && key && !/[%+]/.test(key)) {
+    let keyIndex2 = url.indexOf(`?${key}`, 8);
+    if (keyIndex2 === -1) {
+      keyIndex2 = url.indexOf(`&${key}`, 8);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return void 0;
+    }
+  }
+  const results = {};
+  encoded ?? (encoded = /[%+]/.test(url));
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name = url.slice(
+      keyIndex + 1,
+      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
+    );
+    if (encoded) {
+      name = _decodeURI(name);
+    }
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      ;
+      results[name].push(value);
+    } else {
+      results[name] ?? (results[name] = value);
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/request.js
+var _validatedData, _matchResult, _a;
+var HonoRequest = (_a = class {
+  constructor(request, path2 = "/", matchResult = [[]]) {
+    __publicField(this, "raw");
+    __privateAdd(this, _validatedData);
+    __privateAdd(this, _matchResult);
+    __publicField(this, "routeIndex", 0);
+    __publicField(this, "path");
+    __publicField(this, "bodyCache", {});
+    __publicField(this, "cachedBody", (key) => {
+      const { bodyCache, raw: raw2 } = this;
+      const cachedBody = bodyCache[key];
+      if (cachedBody) {
+        return cachedBody;
+      }
+      const anyCachedKey = Object.keys(bodyCache)[0];
+      if (anyCachedKey) {
+        return bodyCache[anyCachedKey].then((body) => {
+          if (anyCachedKey === "json") {
+            body = JSON.stringify(body);
+          }
+          return new Response(body)[key]();
+        });
+      }
+      return bodyCache[key] = raw2[key]();
+    });
+    this.raw = request;
+    this.path = path2;
+    __privateSet(this, _matchResult, matchResult);
+    __privateSet(this, _validatedData, {});
+  }
+  param(key) {
+    return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
+  }
+  getDecodedParam(key) {
+    const paramKey = __privateGet(this, _matchResult)[0][this.routeIndex][1][key];
+    const param = this.getParamValue(paramKey);
+    return param ? /\%/.test(param) ? decodeURIComponent_(param) : param : void 0;
+  }
+  getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(__privateGet(this, _matchResult)[0][this.routeIndex][1]);
+    for (const key of keys) {
+      const value = this.getParamValue(__privateGet(this, _matchResult)[0][this.routeIndex][1][key]);
+      if (value && typeof value === "string") {
+        decoded[key] = /\%/.test(value) ? decodeURIComponent_(value) : value;
+      }
+    }
+    return decoded;
+  }
+  getParamValue(paramKey) {
+    return __privateGet(this, _matchResult)[1] ? __privateGet(this, _matchResult)[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name.toLowerCase()) ?? void 0;
+    }
+    const headerData = {};
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    var _a4;
+    return (_a4 = this.bodyCache).parsedBody ?? (_a4.parsedBody = await parseBody(this, options));
+  }
+  json() {
+    return this.cachedBody("json");
+  }
+  text() {
+    return this.cachedBody("text");
+  }
+  arrayBuffer() {
+    return this.cachedBody("arrayBuffer");
+  }
+  blob() {
+    return this.cachedBody("blob");
+  }
+  formData() {
+    return this.cachedBody("formData");
+  }
+  addValidatedData(target, data) {
+    __privateGet(this, _validatedData)[target] = data;
+  }
+  valid(target) {
+    return __privateGet(this, _validatedData)[target];
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get matchedRoutes() {
+    return __privateGet(this, _matchResult)[0].map(([[, route]]) => route);
+  }
+  get routePath() {
+    return __privateGet(this, _matchResult)[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+}, _validatedData = new WeakMap(), _matchResult = new WeakMap(), _a);
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+    (res) => Promise.all(
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+    ).then(() => buffer[0])
+  );
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setHeaders = (headers, map = {}) => {
+  Object.entries(map).forEach(([key, value]) => headers.set(key, value));
+  return headers;
+};
+var _rawRequest, _req, _var, _status, _executionCtx, _headers, _preparedHeaders, _res, _isFresh, _layout, _renderer, _notFoundHandler, _matchResult2, _path, _a2;
+var Context = (_a2 = class {
+  constructor(req, options) {
+    __privateAdd(this, _rawRequest);
+    __privateAdd(this, _req);
+    __publicField(this, "env", {});
+    __privateAdd(this, _var);
+    __publicField(this, "finalized", false);
+    __publicField(this, "error");
+    __privateAdd(this, _status, 200);
+    __privateAdd(this, _executionCtx);
+    __privateAdd(this, _headers);
+    __privateAdd(this, _preparedHeaders);
+    __privateAdd(this, _res);
+    __privateAdd(this, _isFresh, true);
+    __privateAdd(this, _layout);
+    __privateAdd(this, _renderer);
+    __privateAdd(this, _notFoundHandler);
+    __privateAdd(this, _matchResult2);
+    __privateAdd(this, _path);
+    __publicField(this, "render", (...args) => {
+      __privateGet(this, _renderer) ?? __privateSet(this, _renderer, (content) => this.html(content));
+      return __privateGet(this, _renderer).call(this, ...args);
+    });
+    __publicField(this, "setLayout", (layout) => __privateSet(this, _layout, layout));
+    __publicField(this, "getLayout", () => __privateGet(this, _layout));
+    __publicField(this, "setRenderer", (renderer) => {
+      __privateSet(this, _renderer, renderer);
+    });
+    __publicField(this, "header", (name, value, options) => {
+      if (value === void 0) {
+        if (__privateGet(this, _headers)) {
+          __privateGet(this, _headers).delete(name);
+        } else if (__privateGet(this, _preparedHeaders)) {
+          delete __privateGet(this, _preparedHeaders)[name.toLocaleLowerCase()];
+        }
+        if (this.finalized) {
+          this.res.headers.delete(name);
+        }
+        return;
+      }
+      if (options?.append) {
+        if (!__privateGet(this, _headers)) {
+          __privateSet(this, _isFresh, false);
+          __privateSet(this, _headers, new Headers(__privateGet(this, _preparedHeaders)));
+          __privateSet(this, _preparedHeaders, {});
+        }
+        __privateGet(this, _headers).append(name, value);
+      } else {
+        if (__privateGet(this, _headers)) {
+          __privateGet(this, _headers).set(name, value);
+        } else {
+          __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
+          __privateGet(this, _preparedHeaders)[name.toLowerCase()] = value;
+        }
+      }
+      if (this.finalized) {
+        if (options?.append) {
+          this.res.headers.append(name, value);
+        } else {
+          this.res.headers.set(name, value);
+        }
+      }
+    });
+    __publicField(this, "status", (status) => {
+      __privateSet(this, _isFresh, false);
+      __privateSet(this, _status, status);
+    });
+    __publicField(this, "set", (key, value) => {
+      __privateGet(this, _var) ?? __privateSet(this, _var, /* @__PURE__ */ new Map());
+      __privateGet(this, _var).set(key, value);
+    });
+    __publicField(this, "get", (key) => {
+      return __privateGet(this, _var) ? __privateGet(this, _var).get(key) : void 0;
+    });
+    __publicField(this, "newResponse", (data, arg, headers) => {
+      if (__privateGet(this, _isFresh) && !headers && !arg && __privateGet(this, _status) === 200) {
+        return new Response(data, {
+          headers: __privateGet(this, _preparedHeaders)
+        });
+      }
+      if (arg && typeof arg !== "number") {
+        const header = new Headers(arg.headers);
+        if (__privateGet(this, _headers)) {
+          __privateGet(this, _headers).forEach((v, k) => {
+            if (k === "set-cookie") {
+              header.append(k, v);
+            } else {
+              header.set(k, v);
+            }
+          });
+        }
+        const headers2 = setHeaders(header, __privateGet(this, _preparedHeaders));
+        return new Response(data, {
+          headers: headers2,
+          status: arg.status ?? __privateGet(this, _status)
+        });
+      }
+      const status = typeof arg === "number" ? arg : __privateGet(this, _status);
+      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
+      __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
+      setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
+      if (__privateGet(this, _res)) {
+        __privateGet(this, _res).headers.forEach((v, k) => {
+          if (k === "set-cookie") {
+            __privateGet(this, _headers)?.append(k, v);
+          } else {
+            __privateGet(this, _headers)?.set(k, v);
+          }
+        });
+        setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
+      }
+      headers ?? (headers = {});
+      for (const [k, v] of Object.entries(headers)) {
+        if (typeof v === "string") {
+          __privateGet(this, _headers).set(k, v);
+        } else {
+          __privateGet(this, _headers).delete(k);
+          for (const v2 of v) {
+            __privateGet(this, _headers).append(k, v2);
+          }
+        }
+      }
+      return new Response(data, {
+        status,
+        headers: __privateGet(this, _headers)
+      });
+    });
+    __publicField(this, "body", (data, arg, headers) => {
+      return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
+    });
+    __publicField(this, "text", (text, arg, headers) => {
+      if (!__privateGet(this, _preparedHeaders)) {
+        if (__privateGet(this, _isFresh) && !headers && !arg) {
+          return new Response(text);
+        }
+        __privateSet(this, _preparedHeaders, {});
+      }
+      __privateGet(this, _preparedHeaders)["content-type"] = TEXT_PLAIN;
+      return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
+    });
+    __publicField(this, "json", (object2, arg, headers) => {
+      const body = JSON.stringify(object2);
+      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
+      __privateGet(this, _preparedHeaders)["content-type"] = "application/json; charset=UTF-8";
+      return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
+    });
+    __publicField(this, "html", (html, arg, headers) => {
+      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
+      __privateGet(this, _preparedHeaders)["content-type"] = "text/html; charset=UTF-8";
+      if (typeof html === "object") {
+        return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
+          return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+        });
+      }
+      return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
+    });
+    __publicField(this, "redirect", (location, status) => {
+      __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
+      __privateGet(this, _headers).set("Location", location);
+      return this.newResponse(null, status ?? 302);
+    });
+    __publicField(this, "notFound", () => {
+      __privateGet(this, _notFoundHandler) ?? __privateSet(this, _notFoundHandler, () => new Response());
+      return __privateGet(this, _notFoundHandler).call(this, this);
+    });
+    __privateSet(this, _rawRequest, req);
+    if (options) {
+      __privateSet(this, _executionCtx, options.executionCtx);
+      this.env = options.env;
+      __privateSet(this, _notFoundHandler, options.notFoundHandler);
+      __privateSet(this, _path, options.path);
+      __privateSet(this, _matchResult2, options.matchResult);
+    }
+  }
+  get req() {
+    __privateGet(this, _req) ?? __privateSet(this, _req, new HonoRequest(__privateGet(this, _rawRequest), __privateGet(this, _path), __privateGet(this, _matchResult2)));
+    return __privateGet(this, _req);
+  }
+  get event() {
+    if (__privateGet(this, _executionCtx) && "respondWith" in __privateGet(this, _executionCtx)) {
+      return __privateGet(this, _executionCtx);
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  get executionCtx() {
+    if (__privateGet(this, _executionCtx)) {
+      return __privateGet(this, _executionCtx);
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  get res() {
+    __privateSet(this, _isFresh, false);
+    return __privateGet(this, _res) || __privateSet(this, _res, new Response("404 Not Found", { status: 404 }));
+  }
+  set res(_res2) {
+    __privateSet(this, _isFresh, false);
+    if (__privateGet(this, _res) && _res2) {
+      try {
+        for (const [k, v] of __privateGet(this, _res).headers.entries()) {
+          if (k === "content-type") {
+            continue;
+          }
+          if (k === "set-cookie") {
+            const cookies = __privateGet(this, _res).headers.getSetCookie();
+            _res2.headers.delete("set-cookie");
+            for (const cookie of cookies) {
+              _res2.headers.append("set-cookie", cookie);
+            }
+          } else {
+            _res2.headers.set(k, v);
+          }
+        }
+      } catch (e) {
+        if (e instanceof TypeError && e.message.includes("immutable")) {
+          this.res = new Response(_res2.body, {
+            headers: _res2.headers,
+            status: _res2.status
+          });
+          return;
+        } else {
+          throw e;
+        }
+      }
+    }
+    __privateSet(this, _res, _res2);
+    this.finalized = true;
+  }
+  get var() {
+    if (!__privateGet(this, _var)) {
+      return {};
+    }
+    return Object.fromEntries(__privateGet(this, _var));
+  }
+}, _rawRequest = new WeakMap(), _req = new WeakMap(), _var = new WeakMap(), _status = new WeakMap(), _executionCtx = new WeakMap(), _headers = new WeakMap(), _preparedHeaders = new WeakMap(), _res = new WeakMap(), _isFresh = new WeakMap(), _layout = new WeakMap(), _renderer = new WeakMap(), _notFoundHandler = new WeakMap(), _matchResult2 = new WeakMap(), _path = new WeakMap(), _a2);
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      let res;
+      let isError = false;
+      let handler;
+      if (middleware[i]) {
+        handler = middleware[i][0][0];
+        if (context instanceof Context) {
+          context.req.routeIndex = i;
+        }
+      } else {
+        handler = i === middleware.length && next || void 0;
+      }
+      if (!handler) {
+        if (context instanceof Context && context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      } else {
+        try {
+          res = await handler(context, () => {
+            return dispatch(i + 1);
+          });
+        } catch (err) {
+          if (err instanceof Error && context instanceof Context && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono-base.js
+var COMPOSED_HANDLER = Symbol("composedHandler");
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    return err.getResponse();
+  }
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+var _path2, _a3;
+var Hono = (_a3 = class {
+  constructor(options = {}) {
+    __publicField(this, "get");
+    __publicField(this, "post");
+    __publicField(this, "put");
+    __publicField(this, "delete");
+    __publicField(this, "options");
+    __publicField(this, "patch");
+    __publicField(this, "all");
+    __publicField(this, "on");
+    __publicField(this, "use");
+    __publicField(this, "router");
+    __publicField(this, "getPath");
+    __publicField(this, "_basePath", "/");
+    __privateAdd(this, _path2, "/");
+    __publicField(this, "routes", []);
+    __publicField(this, "notFoundHandler", notFoundHandler);
+    __publicField(this, "errorHandler", errorHandler);
+    __publicField(this, "onError", (handler) => {
+      this.errorHandler = handler;
+      return this;
+    });
+    __publicField(this, "notFound", (handler) => {
+      this.notFoundHandler = handler;
+      return this;
+    });
+    __publicField(this, "fetch", (request, ...rest) => {
+      return this.dispatch(request, rest[1], rest[0], request.method);
+    });
+    __publicField(this, "request", (input, requestInit, Env, executionCtx) => {
+      if (input instanceof Request) {
+        if (requestInit !== void 0) {
+          input = new Request(input, requestInit);
+        }
+        return this.fetch(input, Env, executionCtx);
+      }
+      input = input.toString();
+      const path2 = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
+      const req = new Request(path2, requestInit);
+      return this.fetch(req, Env, executionCtx);
+    });
+    __publicField(this, "fire", () => {
+      addEventListener("fetch", (event) => {
+        event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+      });
+    });
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          __privateSet(this, _path2, args1);
+        } else {
+          this.addRoute(method, __privateGet(this, _path2), args1);
+        }
+        args.forEach((handler) => {
+          if (typeof handler !== "string") {
+            this.addRoute(method, __privateGet(this, _path2), handler);
+          }
+        });
+        return this;
+      };
+    });
+    this.on = (method, path2, ...handlers) => {
+      for (const p of [path2].flat()) {
+        __privateSet(this, _path2, p);
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.addRoute(m.toUpperCase(), __privateGet(this, _path2), handler);
+          });
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        __privateSet(this, _path2, arg1);
+      } else {
+        __privateSet(this, _path2, "*");
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.addRoute(METHOD_NAME_ALL, __privateGet(this, _path2), handler);
+      });
+      return this;
+    };
+    const strict = options.strict ?? true;
+    delete options.strict;
+    Object.assign(this, options);
+    this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  clone() {
+    const clone = new Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.routes = this.routes;
+    return clone;
+  }
+  route(path2, app2) {
+    const subApp = this.basePath(path2);
+    app2.routes.map((r) => {
+      let handler;
+      if (app2.errorHandler === errorHandler) {
+        handler = r.handler;
+      } else {
+        handler = async (c, next) => (await compose([], app2.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.addRoute(r.method, r.path, handler);
+    });
+    return this;
+  }
+  basePath(path2) {
+    const subApp = this.clone();
+    subApp._basePath = mergePath(this._basePath, path2);
+    return subApp;
+  }
+  mount(path2, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        replaceRequest = options.replaceRequest;
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = void 0;
+      try {
+        executionContext = c.executionCtx;
+      } catch {
+      }
+      return [c.env, executionContext];
+    };
+    replaceRequest || (replaceRequest = (() => {
+      const mergedPath = mergePath(this._basePath, path2);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })());
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+      if (res) {
+        return res;
+      }
+      await next();
+    };
+    this.addRoute(METHOD_NAME_ALL, mergePath(path2, "*"), handler);
+    return this;
+  }
+  addRoute(method, path2, handler) {
+    method = method.toUpperCase();
+    path2 = mergePath(this._basePath, path2);
+    const r = { path: path2, method, handler };
+    this.router.add(method, path2, [handler, r]);
+    this.routes.push(r);
+  }
+  matchRoute(method, path2) {
+    return this.router.match(method, path2);
+  }
+  handleError(err, c) {
+    if (err instanceof Error) {
+      return this.errorHandler(err, c);
+    }
+    throw err;
+  }
+  dispatch(request, executionCtx, env, method) {
+    if (method === "HEAD") {
+      return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+    }
+    const path2 = this.getPath(request, { env });
+    const matchResult = this.matchRoute(method, path2);
+    const c = new Context(request, {
+      path: path2,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.notFoundHandler(c);
+        });
+      } catch (err) {
+        return this.handleError(err, c);
+      }
+      return res instanceof Promise ? res.then(
+        (resolved) => resolved || (c.finalized ? c.res : this.notFoundHandler(c))
+      ).catch((err) => this.handleError(err, c)) : res ?? this.notFoundHandler(c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, this.notFoundHandler);
+    return (async () => {
+      try {
+        const context = await composed(c);
+        if (!context.finalized) {
+          throw new Error(
+            "Context is not finalized. Did you forget to return a Response object or `await next()`?"
+          );
+        }
+        return context.res;
+      } catch (err) {
+        return this.handleError(err, c);
+      }
+    })();
+  }
+}, _path2 = new WeakMap(), _a3);
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class {
+  constructor() {
+    __publicField(this, "index");
+    __publicField(this, "varIndex");
+    __publicField(this, "children", /* @__PURE__ */ Object.create(null));
+  }
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+    if (tokens.length === 0) {
+      if (this.index !== void 0) {
+        throw PATH_ERROR;
+      }
+      if (pathErrorCheckOnly) {
+        return;
+      }
+      this.index = index;
+      return;
+    }
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern) {
+      const name = pattern[1];
+      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+      if (name && pattern[2]) {
+        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+        if (/\((?!\?:)/.test(regexpStr)) {
+          throw PATH_ERROR;
+        }
+      }
+      node = this.children[regexpStr];
+      if (!node) {
+        if (Object.keys(this.children).some(
+          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.children[regexpStr] = new Node();
+        if (name !== "") {
+          node.varIndex = context.varIndex++;
+        }
+      }
+      if (!pathErrorCheckOnly && name !== "") {
+        paramMap.push([name, node.varIndex]);
+      }
+    } else {
+      node = this.children[token];
+      if (!node) {
+        if (Object.keys(this.children).some(
+          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.children[token] = new Node();
+      }
+    }
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.children[k];
+      return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+    });
+    if (typeof this.index === "number") {
+      strList.unshift(`#${this.index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  constructor() {
+    __publicField(this, "context", { varIndex: 0 });
+    __publicField(this, "root", new Node());
+  }
+  insert(path2, index, pathErrorCheckOnly) {
+    const paramAssoc = [];
+    const groups = [];
+    for (let i = 0; ; ) {
+      let replaced = false;
+      path2 = path2.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = path2.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1; i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+    }
+    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+    return paramAssoc;
+  }
+  buildRegExp() {
+    let regexp = this.root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (typeof handlerIndex !== "undefined") {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (typeof paramIndex !== "undefined") {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/reg-exp-router/router.js
+var emptyParam = [];
+var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
+var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+function buildWildcardRegExp(path2) {
+  return wildcardRegExpCache[path2] ?? (wildcardRegExpCache[path2] = new RegExp(
+    path2 === "*" ? "" : `^${path2.replace(
+      /\/\*$|([.\\+*[^\]$()])/g,
+      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
+    )}$`
+  ));
+}
+function clearWildcardRegExpCache() {
+  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+}
+function buildMatcherFromPreprocessedRoutes(routes) {
+  const trie = new Trie();
+  const handlerData = [];
+  if (routes.length === 0) {
+    return nullMatcher;
+  }
+  const routesWithStaticPathFlag = routes.map(
+    (route) => [!/\*|\/:/.test(route[0]), ...route]
+  ).sort(
+    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
+  );
+  const staticMap = /* @__PURE__ */ Object.create(null);
+  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
+    const [pathErrorCheckOnly, path2, handlers] = routesWithStaticPathFlag[i];
+    if (pathErrorCheckOnly) {
+      staticMap[path2] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+    } else {
+      j++;
+    }
+    let paramAssoc;
+    try {
+      paramAssoc = trie.insert(path2, j, pathErrorCheckOnly);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path2) : e;
+    }
+    if (pathErrorCheckOnly) {
+      continue;
+    }
+    handlerData[j] = handlers.map(([h, paramCount]) => {
+      const paramIndexMap = /* @__PURE__ */ Object.create(null);
+      paramCount -= 1;
+      for (; paramCount >= 0; paramCount--) {
+        const [key, value] = paramAssoc[paramCount];
+        paramIndexMap[key] = value;
+      }
+      return [h, paramIndexMap];
+    });
+  }
+  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+  for (let i = 0, len = handlerData.length; i < len; i++) {
+    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
+      const map = handlerData[i][j]?.[1];
+      if (!map) {
+        continue;
+      }
+      const keys = Object.keys(map);
+      for (let k = 0, len3 = keys.length; k < len3; k++) {
+        map[keys[k]] = paramReplacementMap[map[keys[k]]];
+      }
+    }
+  }
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlerData[indexReplacementMap[i]];
+  }
+  return [regexp, handlerMap, staticMap];
+}
+function findMiddleware(middleware, path2) {
+  if (!middleware) {
+    return void 0;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path2)) {
+      return [...middleware[k]];
+    }
+  }
+  return void 0;
+}
+var RegExpRouter = class {
+  constructor() {
+    __publicField(this, "name", "RegExpRouter");
+    __publicField(this, "middleware");
+    __publicField(this, "routes");
+    this.middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+  }
+  add(method, path2, handler) {
+    var _a4;
+    const { middleware, routes } = this;
+    if (!middleware || !routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    if (!middleware[method]) {
+      ;
+      [middleware, routes].forEach((handlerMap) => {
+        handlerMap[method] = /* @__PURE__ */ Object.create(null);
+        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+        });
+      });
+    }
+    if (path2 === "/*") {
+      path2 = "*";
+    }
+    const paramCount = (path2.match(/\/:/g) || []).length;
+    if (/\*$/.test(path2)) {
+      const re = buildWildcardRegExp(path2);
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          var _a5;
+          (_a5 = middleware[m])[path2] || (_a5[path2] = findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []);
+        });
+      } else {
+        (_a4 = middleware[method])[path2] || (_a4[path2] = findMiddleware(middleware[method], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []);
+      }
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            re.test(p) && middleware[m][p].push([handler, paramCount]);
+          });
+        }
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach(
+            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
+          );
+        }
+      });
+      return;
+    }
+    const paths = checkOptionalParameter(path2) || [path2];
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path22 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        var _a5;
+        if (method === METHOD_NAME_ALL || method === m) {
+          (_a5 = routes[m])[path22] || (_a5[path22] = [
+            ...findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
+          ]);
+          routes[m][path22].push([handler, paramCount - len + i + 1]);
+        }
+      });
+    }
+  }
+  match(method, path2) {
+    clearWildcardRegExpCache();
+    const matchers = this.buildAllMatchers();
+    this.match = (method2, path22) => {
+      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+      const staticMatch = matcher[2][path22];
+      if (staticMatch) {
+        return staticMatch;
+      }
+      const match = path22.match(matcher[0]);
+      if (!match) {
+        return [[], emptyParam];
+      }
+      const index = match.indexOf("", 1);
+      return [matcher[1][index], match];
+    };
+    return this.match(method, path2);
+  }
+  buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
+      matchers[method] || (matchers[method] = this.buildMatcher(method));
+    });
+    this.middleware = this.routes = void 0;
+    return matchers;
+  }
+  buildMatcher(method) {
+    const routes = [];
+    let hasOwnRoute = method === METHOD_NAME_ALL;
+    [this.middleware, this.routes].forEach((r) => {
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path2) => [path2, r[method][path2]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute || (hasOwnRoute = true);
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path2) => [path2, r[METHOD_NAME_ALL][path2]])
+        );
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  constructor(init) {
+    __publicField(this, "name", "SmartRouter");
+    __publicField(this, "routers", []);
+    __publicField(this, "routes", []);
+    Object.assign(this, init);
+  }
+  add(method, path2, handler) {
+    if (!this.routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    this.routes.push([method, path2, handler]);
+  }
+  match(method, path2) {
+    if (!this.routes) {
+      throw new Error("Fatal error");
+    }
+    const { routers, routes } = this;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (; i < len; i++) {
+      const router = routers[i];
+      try {
+        routes.forEach((args) => {
+          router.add(...args);
+        });
+        res = router.match(method, path2);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
+        }
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.routers = [router];
+      this.routes = void 0;
+      break;
+    }
+    if (i === len) {
+      throw new Error("Fatal error");
+    }
+    this.name = `SmartRouter + ${this.activeRouter.name}`;
+    return res;
+  }
+  get activeRouter() {
+    if (this.routes || this.routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
+    }
+    return this.routers[0];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/node.js
+var Node2 = class {
+  constructor(method, handler, children) {
+    __publicField(this, "methods");
+    __publicField(this, "children");
+    __publicField(this, "patterns");
+    __publicField(this, "order", 0);
+    __publicField(this, "name");
+    __publicField(this, "params", /* @__PURE__ */ Object.create(null));
+    this.children = children || /* @__PURE__ */ Object.create(null);
+    this.methods = [];
+    this.name = "";
+    if (method && handler) {
+      const m = /* @__PURE__ */ Object.create(null);
+      m[method] = { handler, possibleKeys: [], score: 0, name: this.name };
+      this.methods = [m];
+    }
+    this.patterns = [];
+  }
+  insert(method, path2, handler) {
+    this.name = `${method} ${path2}`;
+    this.order = ++this.order;
+    let curNode = this;
+    const parts = splitRoutingPath(path2);
+    const possibleKeys = [];
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const p = parts[i];
+      if (Object.keys(curNode.children).includes(p)) {
+        curNode = curNode.children[p];
+        const pattern2 = getPattern(p);
+        if (pattern2) {
+          possibleKeys.push(pattern2[1]);
+        }
+        continue;
+      }
+      curNode.children[p] = new Node2();
+      const pattern = getPattern(p);
+      if (pattern) {
+        curNode.patterns.push(pattern);
+        possibleKeys.push(pattern[1]);
+      }
+      curNode = curNode.children[p];
+    }
+    if (!curNode.methods.length) {
+      curNode.methods = [];
+    }
+    const m = /* @__PURE__ */ Object.create(null);
+    const handlerSet = {
+      handler,
+      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+      name: this.name,
+      score: this.order
+    };
+    m[method] = handlerSet;
+    curNode.methods.push(m);
+    return curNode;
+  }
+  gHSets(node, method, nodeParams, params) {
+    const handlerSets = [];
+    for (let i = 0, len = node.methods.length; i < len; i++) {
+      const m = node.methods[i];
+      const handlerSet = m[method] || m[METHOD_NAME_ALL];
+      const processedSet = /* @__PURE__ */ Object.create(null);
+      if (handlerSet !== void 0) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSet.possibleKeys.forEach((key) => {
+          const processed = processedSet[handlerSet.name];
+          handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
+          processedSet[handlerSet.name] = true;
+        });
+        handlerSets.push(handlerSet);
+      }
+    }
+    return handlerSets;
+  }
+  search(method, path2) {
+    const handlerSets = [];
+    this.params = /* @__PURE__ */ Object.create(null);
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path2);
+    for (let i = 0, len = parts.length; i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.children[part];
+        if (nextNode) {
+          nextNode.params = node.params;
+          if (isLast === true) {
+            if (nextNode.children["*"]) {
+              handlerSets.push(
+                ...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
+              );
+            }
+            handlerSets.push(...this.gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+          const pattern = node.patterns[k];
+          const params = { ...node.params };
+          if (pattern === "*") {
+            const astNode = node.children["*"];
+            if (astNode) {
+              handlerSets.push(...this.gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+              tempNodes.push(astNode);
+            }
+            continue;
+          }
+          if (part === "") {
+            continue;
+          }
+          const [key, name, matcher] = pattern;
+          const child = node.children[key];
+          const restPathString = parts.slice(i).join("/");
+          if (matcher instanceof RegExp && matcher.test(restPathString)) {
+            params[name] = restPathString;
+            handlerSets.push(...this.gHSets(child, method, node.params, params));
+            continue;
+          }
+          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+            if (typeof key === "string") {
+              params[name] = part;
+              if (isLast === true) {
+                handlerSets.push(...this.gHSets(child, method, params, node.params));
+                if (child.children["*"]) {
+                  handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));
+                }
+              } else {
+                child.params = params;
+                tempNodes.push(child);
+              }
+            }
+          }
+        }
+      }
+      curNodes = tempNodes;
+    }
+    const results = handlerSets.sort((a, b) => {
+      return a.score - b.score;
+    });
+    return [results.map(({ handler, params }) => [handler, params])];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  constructor() {
+    __publicField(this, "name", "TrieRouter");
+    __publicField(this, "node");
+    this.node = new Node2();
+  }
+  add(method, path2, handler) {
+    const results = checkOptionalParameter(path2);
+    if (results) {
+      for (const p of results) {
+        this.node.insert(method, p, handler);
+      }
+      return;
+    }
+    this.node.insert(method, path2, handler);
+  }
+  match(method, path2) {
+    return this.node.search(method, path2);
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/hono.js
+var Hono2 = class extends Hono {
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new SmartRouter({
+      routers: [new RegExpRouter(), new TrieRouter()]
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/cookie.js
+var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+var parse = (cookie, name) => {
+  const pairs = cookie.trim().split(";");
+  return pairs.reduce((parsedCookie, pairStr) => {
+    pairStr = pairStr.trim();
+    const valueStartPos = pairStr.indexOf("=");
+    if (valueStartPos === -1) {
+      return parsedCookie;
+    }
+    const cookieName = pairStr.substring(0, valueStartPos).trim();
+    if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) {
+      return parsedCookie;
+    }
+    let cookieValue = pairStr.substring(valueStartPos + 1).trim();
+    if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
+      cookieValue = cookieValue.slice(1, -1);
+    }
+    if (validCookieValueRegEx.test(cookieValue)) {
+      parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
+    }
+    return parsedCookie;
+  }, {});
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/helper/cookie/index.js
+var getCookie = (c, key, prefix) => {
+  const cookie = c.req.raw.headers.get("Cookie");
+  if (typeof key === "string") {
+    if (!cookie) {
+      return void 0;
+    }
+    let finalKey = key;
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    }
+    const obj2 = parse(cookie, finalKey);
+    return obj2[finalKey];
+  }
+  if (!cookie) {
+    return {};
+  }
+  const obj = parse(cookie);
+  return obj;
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/http-exception.js
+var HTTPException = class extends Error {
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    __publicField(this, "res");
+    __publicField(this, "status");
+    this.res = options?.res;
+    this.status = status;
+  }
+  getResponse() {
+    if (this.res) {
+      const newResponse = new Response(this.res.body, {
+        status: this.status,
+        headers: this.res.headers
+      });
+      return newResponse;
+    }
+    return new Response(this.message, {
+      status: this.status
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/utils/buffer.js
+var bufferToFormData = (arrayBuffer, contentType) => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      "Content-Type": contentType
+    }
+  });
+  return response.formData();
+};
+
+// ../../node_modules/.pnpm/hono@4.6.3/node_modules/hono/dist/validator/validator.js
+var jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+var multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
+var urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
+var validator = (target, validationFunc) => {
+  return async (c, next) => {
+    let value = {};
+    const contentType = c.req.header("Content-Type");
+    switch (target) {
+      case "json":
+        if (!contentType || !jsonRegex.test(contentType)) {
+          break;
+        }
+        try {
+          value = await c.req.json();
+        } catch {
+          const message = "Malformed JSON in request body";
+          throw new HTTPException(400, { message });
+        }
+        break;
+      case "form": {
+        if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) {
+          break;
+        }
+        let formData;
+        if (c.req.bodyCache.formData) {
+          formData = await c.req.bodyCache.formData;
+        } else {
+          try {
+            const arrayBuffer = await c.req.arrayBuffer();
+            formData = await bufferToFormData(arrayBuffer, contentType);
+            c.req.bodyCache.formData = formData;
+          } catch (e) {
+            let message = "Malformed FormData request.";
+            message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
+            throw new HTTPException(400, { message });
+          }
+        }
+        const form = {};
+        formData.forEach((value2, key) => {
+          if (key.endsWith("[]")) {
+            ;
+            (form[key] ?? (form[key] = [])).push(value2);
+          } else if (Array.isArray(form[key])) {
+            ;
+            form[key].push(value2);
+          } else if (key in form) {
+            form[key] = [form[key], value2];
+          } else {
+            form[key] = value2;
+          }
+        });
+        value = form;
+        break;
+      }
+      case "query":
+        value = Object.fromEntries(
+          Object.entries(c.req.queries()).map(([k, v]) => {
+            return v.length === 1 ? [k, v[0]] : [k, v];
+          })
+        );
+        break;
+      case "param":
+        value = c.req.param();
+        break;
+      case "header":
+        value = c.req.header();
+        break;
+      case "cookie":
+        value = getCookie(c);
+        break;
+    }
+    const res = await validationFunc(value, c);
+    if (res instanceof Response) {
+      return res;
+    }
+    c.req.addValidatedData(target, res);
+    await next();
+  };
+};
+
+// ../../node_modules/.pnpm/valibot@0.42.1_typescript@5.6.3/node_modules/valibot/dist/index.js
+var store;
+function getGlobalConfig(config2) {
+  return {
+    lang: config2?.lang ?? store?.lang,
+    message: config2?.message,
+    abortEarly: config2?.abortEarly ?? store?.abortEarly,
+    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+  };
+}
+var store2;
+function getGlobalMessage(lang) {
+  return store2?.get(lang);
+}
+var store3;
+function getSchemaMessage(lang) {
+  return store3?.get(lang);
+}
+var store4;
+function getSpecificMessage(reference, lang) {
+  return store4?.get(reference)?.get(lang);
+}
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") {
+    return `"${input}"`;
+  }
+  if (type === "number" || type === "bigint" || type === "boolean") {
+    return `${input}`;
+  }
+  if (type === "object" || type === "function") {
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  }
+  return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config2.lang,
+    abortEarly: config2.abortEarly,
+    abortPipeEarly: config2.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message = other?.message ?? context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
+  if (message) {
+    issue.message = typeof message === "function" ? (
+      // @ts-expect-error
+      message(issue)
+    ) : message;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
+}
+function _joinExpects(values, separator) {
+  const list = [...new Set(values)];
+  if (list.length > 1) {
+    return `(${list.join(` ${separator} `)})`;
+  }
+  return list[0] ?? "never";
+}
+function getDefault(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+function boolean(message) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message,
+    _run(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function literal(literal_, message) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal,
+    expects: _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message,
+    _run(dataset, config2) {
+      if (dataset.value === this.literal) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function number(message) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message,
+    _run(dataset, config2) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function object(entries, message) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries,
+    message,
+    _run(dataset, config2) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const value2 = input[key];
+          const valueDataset = this.entries[key]._run(
+            { typed: false, value: value2 },
+            config2
+          );
+          if (valueDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "value",
+              input,
+              key,
+              value: value2
+            };
+            for (const issue of valueDataset.issues) {
+              if (issue.path) {
+                issue.path.unshift(pathItem);
+              } else {
+                issue.path = [pathItem];
+              }
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) {
+              dataset.issues = valueDataset.issues;
+            }
+            if (config2.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!valueDataset.typed) {
+            dataset.typed = false;
+          }
+          if (valueDataset.value !== void 0 || key in input) {
+            dataset.value[key] = valueDataset.value;
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function optional(wrapped, ...args) {
+  const schema = {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    _run(dataset, config2) {
+      if (dataset.value === void 0) {
+        if ("default" in this) {
+          dataset.value = getDefault(
+            this,
+            dataset,
+            config2
+          );
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped._run(dataset, config2);
+    }
+  };
+  if (0 in args) {
+    schema.default = args[0];
+  }
+  return schema;
+}
+function string(message) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message,
+    _run(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) {
+    for (const dataset of datasets) {
+      if (issues) {
+        issues.push(...dataset.issues);
+      } else {
+        issues = dataset.issues;
+      }
+    }
+  }
+  return issues;
+}
+function union(options, message) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: _joinExpects(
+      options.map((option) => option.expects),
+      "|"
+    ),
+    async: false,
+    options,
+    message,
+    _run(dataset, config2) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema._run(
+          { typed: false, value: dataset.value },
+          config2
+        );
+        if (optionDataset.typed) {
+          if (optionDataset.issues) {
+            if (typedDatasets) {
+              typedDatasets.push(optionDataset);
+            } else {
+              typedDatasets = [optionDataset];
+            }
+          } else {
+            validDataset = optionDataset;
+            break;
+          }
+        } else {
+          if (untypedDatasets) {
+            untypedDatasets.push(optionDataset);
+          } else {
+            untypedDatasets = [optionDataset];
+          }
+        }
+      }
+      if (validDataset) {
+        return validDataset;
+      }
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) {
+          return typedDatasets[0];
+        }
+        _addIssue(this, "type", dataset, config2, {
+          issues: _subIssues(typedDatasets)
+        });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) {
+        return untypedDatasets[0];
+      } else {
+        _addIssue(this, "type", dataset, config2, {
+          issues: _subIssues(untypedDatasets)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+function partial(schema, keys) {
+  const entries = {};
+  for (const key in schema.entries) {
+    entries[key] = !keys || keys.includes(key) ? optional(schema.entries[key]) : schema.entries[key];
+  }
+  return { ...schema, entries };
+}
+async function safeParseAsync(schema, input, config2) {
+  const dataset = await schema._run(
+    { typed: false, value: input },
+    getGlobalConfig(config2)
+  );
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// ../../node_modules/.pnpm/@hono+valibot-validator@0.4.1_hono@4.6.3_valibot@0.42.1_typescript@5.6.3_/node_modules/@hono/valibot-validator/dist/index.js
+var vValidator = (target, schema, hook) => (
+  // @ts-expect-error not typed well
+  validator(target, async (value, c) => {
+    const result = await safeParseAsync(schema, value);
+    if (hook) {
+      const hookResult = hook(result, c);
+      if (hookResult instanceof Response || hookResult instanceof Promise) {
+        return hookResult;
+      }
+    }
+    if (!result.success) {
+      return c.json(result, 400);
+    }
+    const data = result.output;
+    return data;
+  })
+);
+
+// src-server/rpc.ts
+var import_plugin_core = require("@hot-updater/plugin-core");
+var updateSourceSchema = object({
+  platform: union([literal("ios"), literal("android")]),
+  targetVersion: string(),
+  bundleVersion: number(),
+  forceUpdate: boolean(),
+  enabled: boolean(),
+  file: string(),
+  hash: string(),
+  description: optional(string(), "")
+});
+var config = null;
+var rpc = new Hono2().get("/loadConfig", async (c) => {
+  config = await (0, import_plugin_core.loadConfig)();
+  return c.json(true);
+}).get("/isConfigLoaded", (c) => {
+  return c.json(config !== null);
+}).get("/getUpdateSources", async (c) => {
+  if (!config) {
+    config = await (0, import_plugin_core.loadConfig)();
+  }
+  const deployPlugin = config?.deploy({
+    cwd: (0, import_plugin_core.getCwd)()
+  });
+  const updateSources = await deployPlugin?.getUpdateSources();
+  return c.json(updateSources ?? []);
+}).post(
+  "/getUpdateSourceByBundleVersion",
+  vValidator("json", object({ bundleVersion: number() })),
+  async (c) => {
+    const { bundleVersion } = c.req.valid("json");
+    if (!config) {
+      config = await (0, import_plugin_core.loadConfig)();
+    }
+    const deployPlugin = config?.deploy({
+      cwd: (0, import_plugin_core.getCwd)()
+    });
+    const updateSources = await deployPlugin?.getUpdateSources();
+    const updateSource = updateSources?.find(
+      (source) => source.bundleVersion === bundleVersion
+    );
+    return c.json(updateSource ?? null);
+  }
+).post(
+  "/updateUpdateSource",
+  vValidator(
+    "json",
+    object({
+      targetBundleVersion: number(),
+      updateSource: partial(updateSourceSchema)
+    })
+  ),
+  async (c) => {
+    const { targetBundleVersion, updateSource } = c.req.valid("json");
+    if (!config) {
+      config = await (0, import_plugin_core.loadConfig)();
+    }
+    const deployPlugin = config?.deploy({
+      cwd: (0, import_plugin_core.getCwd)()
+    });
+    await deployPlugin?.updateUpdateSource(targetBundleVersion, updateSource);
+    await deployPlugin?.commitUpdateSource();
+    return c.json(true);
+  }
+);
+
+// src-server/index.ts
+var import_meta = {};
+var __dirname = (0, import_url7.fileURLToPath)(new URL(".", import_meta.url));
+var relativePathToScript = import_path.default.relative(process.cwd(), __dirname);
+var app = new Hono2().get("/ping", (c) => c.text("pong")).route("/rpc", rpc).use(
+  "/static/*",
+  serveStatic({
+    root: relativePathToScript
+  })
+).get(
+  "*",
+  serveStatic({
+    root: relativePathToScript,
+    path: "index.html"
+  })
+);
+var src_server_default = app;