@hyperspan/framework 0.0.3 → 0.1.1

package/dist/server.js

@@ -1,676 +1,166 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
-// node_modules/escape-html/index.js
-var require_escape_html = __commonJS((exports, module) => {
-  function escapeHtml(string) {
-    var str = "" + string;
-    var match = matchHtmlRegExp.exec(str);
-    if (!match) {
-      return str;
-    }
-    var escape;
-    var html = "";
-    var index = 0;
-    var lastIndex = 0;
-    for (index = match.index;index < str.length; index++) {
-      switch (str.charCodeAt(index)) {
-        case 34:
-          escape = "&quot;";
-          break;
-        case 38:
-          escape = "&amp;";
-          break;
-        case 39:
-          escape = "&#39;";
-          break;
-        case 60:
-          escape = "&lt;";
-          break;
-        case 62:
-          escape = "&gt;";
-          break;
-        default:
-          continue;
-      }
-      if (lastIndex !== index) {
-        html += str.substring(lastIndex, index);
-      }
-      lastIndex = index + 1;
-      html += escape;
-    }
-    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
-  }
-  /*!
-   * escape-html
-   * Copyright(c) 2012-2013 TJ Holowaychuk
-   * Copyright(c) 2015 Andreas Lubbe
-   * Copyright(c) 2015 Tiancheng "Timothy" Gu
-   * MIT Licensed
-   */
-  var matchHtmlRegExp = /["'&<>]/;
-  module.exports = escapeHtml;
-});
-
-// node_modules/trek-router/index.js
-var require_trek_router = __commonJS((exports, module) => {
-  /*!
-   * router
-   * Copyright(c) 2015-2017 Fangdun Cai
-   * MIT Licensed
-   */
-  var [SKIND, PKIND, AKIND, STAR, SLASH, COLON] = [0, 1, 2, 42, 47, 58];
+// src/server.ts
+import { readdir as readdir2 } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
 
-  class Node {
-    constructor(prefix = "/", children = [], kind = SKIND, map = Object.create(null)) {
-      this.label = prefix.charCodeAt(0);
-      this.prefix = prefix;
-      this.children = children;
-      this.kind = kind;
-      this.map = map;
-    }
-    addChild(n) {
-      this.children.push(n);
-    }
-    findChild(c, t, l, e, i = 0) {
-      for (l = this.children.length;i < l; i++) {
-        e = this.children[i];
-        if (c === e.label && t === e.kind) {
-          return e;
-        }
-      }
-    }
-    findChildWithLabel(c, l, e, i = 0) {
-      for (l = this.children.length;i < l; i++) {
-        e = this.children[i];
-        if (c === e.label) {
-          return e;
-        }
-      }
-    }
-    findChildByKind(t, l, e, i = 0) {
-      for (l = this.children.length;i < l; i++) {
-        e = this.children[i];
-        if (t === e.kind) {
-          return e;
-        }
-      }
-    }
-    addHandler(method, handler, pnames) {
-      this.map[method] = { handler, pnames };
+// node_modules/@hyperspan/html/dist/html.js
+/*!
+ * escape-html
+ * Copyright(c) 2012-2013 TJ Holowaychuk
+ * Copyright(c) 2015 Andreas Lubbe
+ * Copyright(c) 2015 Tiancheng "Timothy" Gu
+ * MIT Licensed
+ */
+var matchHtmlRegExp = /["'&<>]/;
+function escapeHtml(string) {
+  const str = "" + string;
+  const match = matchHtmlRegExp.exec(str);
+  if (!match) {
+    return str;
+  }
+  let escape;
+  let html = "";
+  let index = 0;
+  let lastIndex = 0;
+  for (index = match.index;index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escape = "&quot;";
+        break;
+      case 38:
+        escape = "&amp;";
+        break;
+      case 39:
+        escape = "&#39;";
+        break;
+      case 60:
+        escape = "&lt;";
+        break;
+      case 62:
+        escape = "&gt;";
+        break;
+      default:
+        continue;
     }
-    findHandler(method) {
-      return this.map[method];
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
     }
+    lastIndex = index + 1;
+    html += escape;
   }
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
 
-  class Router {
-    constructor() {
-      this.tree = new Node;
-    }
-    add(method, path, handler) {
-      let [i, l, pnames, ch, j] = [0, path.length, []];
-      for (;i < l; ++i) {
-        ch = path.charCodeAt(i);
-        if (ch === COLON) {
-          j = i + 1;
-          this.insert(method, path.substring(0, i), SKIND);
-          while (i < l && path.charCodeAt(i) !== SLASH) {
-            i++;
-          }
-          pnames.push(path.substring(j, i));
-          path = path.substring(0, j) + path.substring(i);
-          i = j;
-          l = path.length;
-          if (i === l) {
-            this.insert(method, path.substring(0, i), PKIND, pnames, handler);
-            return;
-          }
-          this.insert(method, path.substring(0, i), PKIND, pnames);
-        } else if (ch === STAR) {
-          this.insert(method, path.substring(0, i), SKIND);
-          pnames.push("*");
-          this.insert(method, path.substring(0, l), AKIND, pnames, handler);
-          return;
-        }
-      }
-      this.insert(method, path, SKIND, pnames, handler);
-    }
-    insert(method, path, t, pnames, handler) {
-      let [cn, prefix, sl, pl, l, max, n, c] = [this.tree];
-      while (true) {
-        prefix = cn.prefix;
-        sl = path.length;
-        pl = prefix.length;
-        l = 0;
-        max = sl < pl ? sl : pl;
-        while (l < max && path.charCodeAt(l) === prefix.charCodeAt(l)) {
-          l++;
-        }
-        if (l < pl) {
-          n = new Node(prefix.substring(l), cn.children, cn.kind, cn.map);
-          cn.children = [n];
-          cn.label = prefix.charCodeAt(0);
-          cn.prefix = prefix.substring(0, l);
-          cn.map = Object.create(null);
-          cn.kind = SKIND;
-          if (l === sl) {
-            cn.addHandler(method, handler, pnames);
-            cn.kind = t;
-          } else {
-            n = new Node(path.substring(l), [], t);
-            n.addHandler(method, handler, pnames);
-            cn.addChild(n);
-          }
-        } else if (l < sl) {
-          path = path.substring(l);
-          c = cn.findChildWithLabel(path.charCodeAt(0));
-          if (c !== undefined) {
-            cn = c;
-            continue;
-          }
-          n = new Node(path, [], t);
-          n.addHandler(method, handler, pnames);
-          cn.addChild(n);
-        } else if (handler !== undefined) {
-          cn.addHandler(method, handler, pnames);
-        }
-        return;
-      }
-    }
-    find(method, path, cn, n = 0, result = [undefined, []]) {
-      cn = cn || this.tree;
-      const sl = path.length;
-      const prefix = cn.prefix;
-      const pvalues = result[1];
-      let i, pl, l, max, c;
-      let preSearch;
-      if (sl === 0 || path === prefix) {
-        const r = cn.findHandler(method);
-        if ((result[0] = r && r.handler) !== undefined) {
-          const pnames = r.pnames;
-          if (pnames !== undefined) {
-            for (i = 0, l = pnames.length;i < l; ++i) {
-              pvalues[i] = {
-                name: pnames[i],
-                value: pvalues[i]
-              };
-            }
-          }
-        }
-        return result;
-      }
-      pl = prefix.length;
-      l = 0;
-      max = sl < pl ? sl : pl;
-      while (l < max && path.charCodeAt(l) === prefix.charCodeAt(l)) {
-        l++;
-      }
-      if (l === pl) {
-        path = path.substring(l);
-      }
-      preSearch = path;
-      c = cn.findChild(path.charCodeAt(0), SKIND);
-      if (c !== undefined) {
-        this.find(method, path, c, n, result);
-        if (result[0] !== undefined) {
-          return result;
-        }
-        path = preSearch;
-      }
-      if (l !== pl) {
-        return result;
-      }
-      c = cn.findChildByKind(PKIND);
-      if (c !== undefined) {
-        l = path.length;
-        i = 0;
-        while (i < l && path.charCodeAt(i) !== SLASH) {
-          i++;
-        }
-        pvalues[n] = path.substring(0, i);
-        n++;
-        preSearch = path;
-        path = path.substring(i);
-        this.find(method, path, c, n, result);
-        if (result[0] !== undefined) {
-          return result;
-        }
-        n--;
-        pvalues.pop();
-        path = preSearch;
-      }
-      c = cn.findChildByKind(AKIND);
-      if (c !== undefined) {
-        pvalues[n] = path;
-        path = "";
-        this.find(method, path, c, n, result);
+class TmplHtml {
+  content = "";
+  asyncContent;
+  constructor(props) {
+    this.content = props.content;
+    this.asyncContent = props.asyncContent;
+  }
+}
+var htmlId = 0;
+function html(strings, ...values) {
+  const asyncContent = [];
+  let content = "";
+  for (let i = 0;i < strings.length; i++) {
+    let value = values[i];
+    let renderValue;
+    if (value !== null && value !== undefined) {
+      let id = `async_loading_${htmlId++}`;
+      let kind = _typeOf(value);
+      if (!renderValue) {
+        renderValue = _renderValue(value, { id, kind, asyncContent }) || "";
       }
-      return result;
     }
+    content += strings[i] + (renderValue ? renderValue : "");
   }
-  Router.Node = Node;
-  module.exports = Router;
-});
-
-// node_modules/trek-middleware/index.js
-var require_trek_middleware = __commonJS((exports, module) => {
-  /*!
-   * middleware
-   * Copyright(c) 2015-2017 Fangdun Cai
-   * MIT Licensed
-   */
-  module.exports = class Middleware extends Array {
-    next(context, last, i, done, called, fn) {
-      if (done = i > this.length)
-        return;
-      fn = this[i] || last;
-      return fn && fn(context, () => {
-        if (called)
-          throw new Error("next() called multiple times");
-        called = true;
-        return Promise.resolve(this.next(context, last, i + 1));
-      });
-    }
-    compose(context, last) {
-      try {
-        return Promise.resolve(this.next(context, last, 0));
-      } catch (err) {
-        return Promise.reject(err);
+  return new TmplHtml({ content, asyncContent });
+}
+html.raw = (content) => ({ _kind: "html_safe", content });
+function _renderValue(value, opts = {
+  kind: undefined,
+  id: undefined,
+  asyncContent: []
+}) {
+  if (value === null || value === undefined || Number.isNaN(value)) {
+    return "";
+  }
+  const kind = opts.kind || _typeOf(value);
+  const id = opts.id || "";
+  switch (kind) {
+    case "array":
+      return value.map((v) => _renderValue(v, { id, asyncContent: opts.asyncContent })).join("");
+    case "object":
+      if (value instanceof TmplHtml) {
+        opts.asyncContent.push(...value.asyncContent);
+        return value.content;
       }
-    }
-  };
-});
-
-// node_modules/@fastify/deepmerge/index.js
-var require_deepmerge = __commonJS((exports, module) => {
-  function deepmergeConstructor(options) {
-    function isNotPrototypeKey(value) {
-      return value !== "constructor" && value !== "prototype" && value !== "__proto__";
-    }
-    function cloneArray(value) {
-      let i = 0;
-      const il = value.length;
-      const result = new Array(il);
-      for (i = 0;i < il; ++i) {
-        result[i] = clone(value[i]);
-      }
-      return result;
-    }
-    function cloneObject(target) {
-      const result = {};
-      if (cloneProtoObject && Object.getPrototypeOf(target) !== JSON_PROTO) {
-        return cloneProtoObject(target);
-      }
-      const targetKeys = getKeys(target);
-      let i, il, key;
-      for (i = 0, il = targetKeys.length;i < il; ++i) {
-        isNotPrototypeKey(key = targetKeys[i]) && (result[key] = clone(target[key]));
-      }
-      return result;
-    }
-    function concatArrays(target, source) {
-      const tl = target.length;
-      const sl = source.length;
-      let i = 0;
-      const result = new Array(tl + sl);
-      for (i = 0;i < tl; ++i) {
-        result[i] = clone(target[i]);
-      }
-      for (i = 0;i < sl; ++i) {
-        result[i + tl] = clone(source[i]);
-      }
-      return result;
-    }
-    const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
-    function getSymbolsAndKeys(value) {
-      const result = Object.keys(value);
-      const keys = Object.getOwnPropertySymbols(value);
-      for (let i = 0, il = keys.length;i < il; ++i) {
-        propertyIsEnumerable.call(value, keys[i]) && result.push(keys[i]);
-      }
-      return result;
-    }
-    const getKeys = options && options.symbols ? getSymbolsAndKeys : Object.keys;
-    const cloneProtoObject = typeof options?.cloneProtoObject === "function" ? options.cloneProtoObject : undefined;
-    function isMergeableObject(value) {
-      return typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Date);
-    }
-    function isPrimitive(value) {
-      return typeof value !== "object" || value === null;
-    }
-    const isPrimitiveOrBuiltIn = typeof Buffer !== "undefined" ? (value) => typeof value !== "object" || value === null || value instanceof RegExp || value instanceof Date || value instanceof Buffer : (value) => typeof value !== "object" || value === null || value instanceof RegExp || value instanceof Date;
-    const mergeArray = options && typeof options.mergeArray === "function" ? options.mergeArray({ clone, deepmerge: _deepmerge, getKeys, isMergeableObject }) : concatArrays;
-    function clone(entry) {
-      return isMergeableObject(entry) ? Array.isArray(entry) ? cloneArray(entry) : cloneObject(entry) : entry;
-    }
-    function mergeObject(target, source) {
-      const result = {};
-      const targetKeys = getKeys(target);
-      const sourceKeys = getKeys(source);
-      let i, il, key;
-      for (i = 0, il = targetKeys.length;i < il; ++i) {
-        isNotPrototypeKey(key = targetKeys[i]) && sourceKeys.indexOf(key) === -1 && (result[key] = clone(target[key]));
-      }
-      for (i = 0, il = sourceKeys.length;i < il; ++i) {
-        isNotPrototypeKey(key = sourceKeys[i]) && ((key in target) && (targetKeys.indexOf(key) !== -1 && (result[key] = _deepmerge(target[key], source[key])), true) || (result[key] = clone(source[key])));
-      }
-      return result;
-    }
-    function _deepmerge(target, source) {
-      const sourceIsArray = Array.isArray(source);
-      const targetIsArray = Array.isArray(target);
-      if (isPrimitive(source)) {
-        return source;
-      } else if (isPrimitiveOrBuiltIn(target)) {
-        return clone(source);
-      } else if (sourceIsArray && targetIsArray) {
-        return mergeArray(target, source);
-      } else if (sourceIsArray !== targetIsArray) {
-        return clone(source);
-      } else {
-        return mergeObject(target, source);
+      if (value?._kind === "html_safe") {
+        return value?.content || "";
       }
-    }
-    function _deepmergeAll() {
-      switch (arguments.length) {
-        case 0:
-          return {};
-        case 1:
-          return clone(arguments[0]);
-        case 2:
-          return _deepmerge(arguments[0], arguments[1]);
+      if (typeof value.renderAsync === "function") {
+        opts.asyncContent.push({
+          id,
+          promise: value.renderAsync().then((result) => ({
+            id,
+            value: result,
+            asyncContent: opts.asyncContent
+          }))
+        });
       }
-      let result;
-      for (let i = 0, il = arguments.length;i < il; ++i) {
-        result = _deepmerge(result, arguments[i]);
+      if (typeof value.render === "function") {
+        return render(_htmlPlaceholder(id, value.render()));
       }
-      return result;
-    }
-    return options && options.all ? _deepmergeAll : _deepmerge;
-  }
-  var JSON_PROTO = Object.getPrototypeOf({});
-  module.exports = deepmergeConstructor;
-  module.exports.default = deepmergeConstructor;
-  module.exports.deepmerge = deepmergeConstructor;
-});
-
-// src/server.ts
-import { readdir } from "node:fs/promises";
-import { basename, extname, join, resolve } from "node:path";
-
-// src/html.ts
-var import_escape_html = __toESM(require_escape_html(), 1);
-
-// src/clientjs/md5.js
-function md5cycle(x, k) {
-  var a = x[0], b = x[1], c = x[2], d = x[3];
-  a = ff(a, b, c, d, k[0], 7, -680876936);
-  d = ff(d, a, b, c, k[1], 12, -389564586);
-  c = ff(c, d, a, b, k[2], 17, 606105819);
-  b = ff(b, c, d, a, k[3], 22, -1044525330);
-  a = ff(a, b, c, d, k[4], 7, -176418897);
-  d = ff(d, a, b, c, k[5], 12, 1200080426);
-  c = ff(c, d, a, b, k[6], 17, -1473231341);
-  b = ff(b, c, d, a, k[7], 22, -45705983);
-  a = ff(a, b, c, d, k[8], 7, 1770035416);
-  d = ff(d, a, b, c, k[9], 12, -1958414417);
-  c = ff(c, d, a, b, k[10], 17, -42063);
-  b = ff(b, c, d, a, k[11], 22, -1990404162);
-  a = ff(a, b, c, d, k[12], 7, 1804603682);
-  d = ff(d, a, b, c, k[13], 12, -40341101);
-  c = ff(c, d, a, b, k[14], 17, -1502002290);
-  b = ff(b, c, d, a, k[15], 22, 1236535329);
-  a = gg(a, b, c, d, k[1], 5, -165796510);
-  d = gg(d, a, b, c, k[6], 9, -1069501632);
-  c = gg(c, d, a, b, k[11], 14, 643717713);
-  b = gg(b, c, d, a, k[0], 20, -373897302);
-  a = gg(a, b, c, d, k[5], 5, -701558691);
-  d = gg(d, a, b, c, k[10], 9, 38016083);
-  c = gg(c, d, a, b, k[15], 14, -660478335);
-  b = gg(b, c, d, a, k[4], 20, -405537848);
-  a = gg(a, b, c, d, k[9], 5, 568446438);
-  d = gg(d, a, b, c, k[14], 9, -1019803690);
-  c = gg(c, d, a, b, k[3], 14, -187363961);
-  b = gg(b, c, d, a, k[8], 20, 1163531501);
-  a = gg(a, b, c, d, k[13], 5, -1444681467);
-  d = gg(d, a, b, c, k[2], 9, -51403784);
-  c = gg(c, d, a, b, k[7], 14, 1735328473);
-  b = gg(b, c, d, a, k[12], 20, -1926607734);
-  a = hh(a, b, c, d, k[5], 4, -378558);
-  d = hh(d, a, b, c, k[8], 11, -2022574463);
-  c = hh(c, d, a, b, k[11], 16, 1839030562);
-  b = hh(b, c, d, a, k[14], 23, -35309556);
-  a = hh(a, b, c, d, k[1], 4, -1530992060);
-  d = hh(d, a, b, c, k[4], 11, 1272893353);
-  c = hh(c, d, a, b, k[7], 16, -155497632);
-  b = hh(b, c, d, a, k[10], 23, -1094730640);
-  a = hh(a, b, c, d, k[13], 4, 681279174);
-  d = hh(d, a, b, c, k[0], 11, -358537222);
-  c = hh(c, d, a, b, k[3], 16, -722521979);
-  b = hh(b, c, d, a, k[6], 23, 76029189);
-  a = hh(a, b, c, d, k[9], 4, -640364487);
-  d = hh(d, a, b, c, k[12], 11, -421815835);
-  c = hh(c, d, a, b, k[15], 16, 530742520);
-  b = hh(b, c, d, a, k[2], 23, -995338651);
-  a = ii(a, b, c, d, k[0], 6, -198630844);
-  d = ii(d, a, b, c, k[7], 10, 1126891415);
-  c = ii(c, d, a, b, k[14], 15, -1416354905);
-  b = ii(b, c, d, a, k[5], 21, -57434055);
-  a = ii(a, b, c, d, k[12], 6, 1700485571);
-  d = ii(d, a, b, c, k[3], 10, -1894986606);
-  c = ii(c, d, a, b, k[10], 15, -1051523);
-  b = ii(b, c, d, a, k[1], 21, -2054922799);
-  a = ii(a, b, c, d, k[8], 6, 1873313359);
-  d = ii(d, a, b, c, k[15], 10, -30611744);
-  c = ii(c, d, a, b, k[6], 15, -1560198380);
-  b = ii(b, c, d, a, k[13], 21, 1309151649);
-  a = ii(a, b, c, d, k[4], 6, -145523070);
-  d = ii(d, a, b, c, k[11], 10, -1120210379);
-  c = ii(c, d, a, b, k[2], 15, 718787259);
-  b = ii(b, c, d, a, k[9], 21, -343485551);
-  x[0] = add32(a, x[0]);
-  x[1] = add32(b, x[1]);
-  x[2] = add32(c, x[2]);
-  x[3] = add32(d, x[3]);
-}
-function cmn(q, a, b, x, s, t) {
-  a = add32(add32(a, q), add32(x, t));
-  return add32(a << s | a >>> 32 - s, b);
-}
-function ff(a, b, c, d, x, s, t) {
-  return cmn(b & c | ~b & d, a, b, x, s, t);
-}
-function gg(a, b, c, d, x, s, t) {
-  return cmn(b & d | c & ~d, a, b, x, s, t);
-}
-function hh(a, b, c, d, x, s, t) {
-  return cmn(b ^ c ^ d, a, b, x, s, t);
-}
-function ii(a, b, c, d, x, s, t) {
-  return cmn(c ^ (b | ~d), a, b, x, s, t);
-}
-function md51(s) {
-  var txt = "";
-  var n = s.length, state = [1732584193, -271733879, -1732584194, 271733878], i;
-  for (i = 64;i <= s.length; i += 64) {
-    md5cycle(state, md5blk(s.substring(i - 64, i)));
-  }
-  s = s.substring(i - 64);
-  var tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-  for (i = 0;i < s.length; i++)
-    tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
-  tail[i >> 2] |= 128 << (i % 4 << 3);
-  if (i > 55) {
-    md5cycle(state, tail);
-    for (i = 0;i < 16; i++)
-      tail[i] = 0;
-  }
-  tail[14] = n * 8;
-  md5cycle(state, tail);
-  return state;
-}
-function md5blk(s) {
-  var md5blks = [], i;
-  for (i = 0;i < 64; i += 4) {
-    md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+      return JSON.stringify(value);
+    case "promise":
+      opts.asyncContent.push({
+        id,
+        promise: value.then((result) => ({
+          id,
+          value: result,
+          asyncContent: opts.asyncContent
+        }))
+      });
+      return render(_htmlPlaceholder(id));
+    case "generator":
+      throw new Error("Generators are not supported as a template value at this time. Sorry :(");
   }
-  return md5blks;
-}
-function rhex(n) {
-  var s = "", j = 0;
-  for (;j < 4; j++)
-    s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];
-  return s;
-}
-function hex(x) {
-  for (var i = 0;i < x.length; i++)
-    x[i] = rhex(x[i]);
-  return x.join("");
+  return escapeHtml(String(value));
 }
-function add32(a, b) {
-  return a + b & 4294967295;
+function _htmlPlaceholder(id, content = "Loading...") {
+  return html`<!--hs:loading:${id}--><slot id="${id}">${content}</slot><!--/hs:loading:${id}-->`;
 }
-function md5(s) {
-  return hex(md51(s));
-}
-var hex_chr = "0123456789abcdef".split("");
-
-// src/html.ts
-function html(strings, ...values) {
-  const content = [];
-  if (values.length === 0) {
-    content.push({ kind: "string_safe", value: strings.join("\n") });
-    return new HSTemplate(content);
-  }
-  let i = 0;
-  for (i = 0;i < values.length; i++) {
-    content.push({ kind: "string_safe", value: strings[i] });
-    let tValue = values[i] === undefined || values[i] === null || values[i] === "" ? "" : values[i];
-    if (!Array.isArray(tValue)) {
-      tValue = [tValue];
-    }
-    for (let j = 0;j < tValue.length; j++) {
-      content.push({ kind: _typeOf(tValue[j]), value: tValue[j] });
-    }
-  }
-  content.push({ kind: "string_safe", value: strings[i] });
-  return new HSTemplate(content);
-}
-async function* _render(obj, promises = [], { js }) {
-  let { kind, value } = obj;
-  let id = randomId();
-  if (!kind || !value) {
-    kind = _typeOf(obj);
-    value = obj;
-  }
-  if (value instanceof HSTemplate || value.__hsTemplate) {
-    yield* renderToStream(value);
-  } else if (typeof value.render !== "undefined") {
-    value.id = id;
-    yield await value.render();
-  } else if (value === undefined || value === null) {
-    yield "";
-  } else {
-    switch (kind) {
-      case "string":
-        yield import_escape_html.default(value);
-        break;
-      case "string_safe":
-        yield value;
-        break;
-      case "array":
-        yield* value;
-        break;
-      case "promise":
-        const promise = value.then((v) => {
-          return _render(v, promises, { js });
-        });
-        const pid = "async_" + id;
-        promises.push({ id: pid, pending: true, promise });
-        yield* renderToStream(html`<div id="${pid}">Loading...</div>`);
-        break;
-      case "function":
-        const fns = renderFunctionToString(value);
-        const fnId = "fn_" + md5(fns);
-        if (!IS_CLIENT || !window.hyperspan._fn.has(fnId)) {
-          js.push(`hyperspan.fn('${fnId}', ${fns});`);
-        }
-        yield `"hyperspan:${fnId}"`;
-        break;
-      case "json":
-        yield "";
-        break;
-      case "number":
-        yield String(value);
-        break;
-      case "object":
-        if (typeof value.render === "function") {
-          yield value.render();
-        } else if (typeof value.toString === "function") {
-          yield value.toString();
-        } else {
-          yield value;
-        }
-        break;
-      case "generator":
-        yield* value;
-        break;
-      case "date":
-        yield value.toISOString();
-        break;
-      default:
-        yield String(value);
-    }
-  }
+function render(tmpl) {
+  return tmpl.content;
 }
-async function* renderToStream(template) {
-  let promises = [];
-  let js = [];
-  if (typeof template === "string") {
-    return template;
-  }
-  for (let i = 0;i < template.content.length; i++) {
-    yield* _render(template.content[i], promises, { js });
-  }
-  while (promises.length > 0) {
-    const promisesToRun = promises.map((p) => p.promise.then((v) => {
-      return { id: p.id, pending: false, value: v, promise: null };
-    }));
-    const result = await Promise.race(promisesToRun);
-    yield* renderToStream(html`<template id="${result.id}_content">${result.value}</template>`);
-    promises = promises.filter((p) => {
-      return p.id !== result.id;
+async function renderAsync(tmpl) {
+  let { content, asyncContent } = tmpl;
+  while (asyncContent.length !== 0) {
+    const resolvedHtml = await Promise.all(asyncContent.map((p) => p.promise));
+    asyncContent = [];
+    resolvedHtml.map((obj) => {
+      const r = new RegExp(`<!--hs:loading:${obj.id}-->(.*?)<!--/hs:loading:${obj.id}-->`);
+      const found = content.match(r);
+      if (found) {
+        content = content.replace(found[0], _renderValue(obj.value, { asyncContent }));
+      }
     });
   }
-  if (js.length !== 0) {
-    yield "<script>" + js.join("\n") + "</script>";
-  }
+  return content;
 }
-async function renderToString(template) {
-  let result = "";
-  for await (const chunk of renderToStream(template)) {
-    result += chunk;
+async function* renderStream(tmpl) {
+  yield render(tmpl);
+  let asyncContent = tmpl.asyncContent;
+  while (asyncContent.length > 0) {
+    const nextContent = await Promise.race(asyncContent.map((p) => p.promise));
+    asyncContent = asyncContent.filter((p) => p.id !== nextContent.id);
+    const id = nextContent.id;
+    const content = _renderValue(nextContent.value, {
+      asyncContent
+    });
+    const script = html`<template id="${id}_content">${html.raw(content)}</template>`;
+    yield render(script);
   }
-  return result;
-}
-function randomId() {
-  return Math.random().toString(36).substring(2, 9);
 }
 function _typeOf(obj) {
   if (obj instanceof Promise)
@@ -688,55 +178,23 @@ function _typeOf(obj) {
   if (Array.isArray(obj))
     return "array";
   if (Number.isNaN(obj))
-    return "nan";
+    return "NaN";
   if (obj === undefined)
     return "undefined";
   if (obj === null)
     return "null";
   if (isGenerator(obj))
     return "generator";
-  if (isPlainObject(obj))
-    return "json";
   return typeof obj;
 }
 function isGenerator(obj) {
   return obj && typeof obj.next == "function" && typeof obj.throw == "function";
 }
-function isPlainObject(val) {
-  return Object == val.constructor;
-}
-function renderFunctionToString(fn) {
-  let fns = fn.toString();
-  const firstLine = fns.split("\n")[0];
-  const isFatArrow = firstLine.includes("=>");
-  const isAsync = firstLine.includes("async");
-  const hasFunctionWord = firstLine.includes("function");
-  if (isFatArrow) {
-    fns = "function (...args) { return (" + fns + ")(..args); }";
-  } else {
-    if (!hasFunctionWord) {
-      fns = "function " + fns;
-    }
-  }
-  if (isAsync) {
-    fns = "async " + fns.replace("async ", "");
-  }
-  return fns;
-}
-var IS_CLIENT = typeof window !== "undefined";
-
-class HSTemplate {
-  __hsTemplate = true;
-  content;
-  constructor(content) {
-    this.content = content;
-  }
-}
-html.raw = (value) => {
-  return new HSTemplate([{ kind: "string_safe", value }]);
-};
 
-// node_modules/isbot/index.mjs
+// ../../node_modules/isbot/index.mjs
+var fullPattern = " daum[ /]| deusu/| yadirectfetcher|(?:^|[^g])news(?!sapphire)|(?<! (?:channel/|google/))google(?!(app|/google| pixel))|(?<! cu)bots?(?:\\b|_)|(?<!(?:lib))http|(?<![hg]m)score|@[a-z][\\w-]+\\.|\\(\\)|\\.com\\b|\\btime/|\\||^<|^[\\w \\.\\-\\(?:\\):%]+(?:/v?\\d+(?:\\.\\d+)?(?:\\.\\d{1,10})*?)?(?:,|$)|^[^ ]{50,}$|^\\d+\\b|^\\w*search\\b|^\\w+/[\\w\\(\\)]*$|^active|^ad muncher|^amaya|^avsdevicesdk/|^biglotron|^bot|^bw/|^clamav[ /]|^client/|^cobweb/|^custom|^ddg[_-]android|^discourse|^dispatch/\\d|^downcast/|^duckduckgo|^email|^facebook|^getright/|^gozilla/|^hobbit|^hotzonu|^hwcdn/|^igetter/|^jeode/|^jetty/|^jigsaw|^microsoft bits|^movabletype|^mozilla/\\d\\.\\d\\s[\\w\\.-]+$|^mozilla/\\d\\.\\d\\s\\(compatible;?(?:\\s\\w+\\/\\d+\\.\\d+)?\\)$|^navermailapp|^netsurf|^offline|^openai/|^owler|^php|^postman|^python|^rank|^read|^reed|^rest|^rss|^snapchat|^space bison|^svn|^swcd |^taringa|^thumbor/|^track|^w3c|^webbandit/|^webcopier|^wget|^whatsapp|^wordpress|^xenu link sleuth|^yahoo|^yandex|^zdm/\\d|^zoom marketplace/|^{{.*}}$|adscanner/|analyzer|archive|ask jeeves/teoma|audit|bit\\.ly/|bluecoat drtr|browsex|burpcollaborator|capture|catch|check\\b|checker|chrome-lighthouse|chromeframe|classifier|cloudflare|convertify|cookiehubscan|crawl|cypress/|dareboost|datanyze|dejaclick|detect|dmbrowser|download|evc-batch/|exaleadcloudview|feed|firephp|functionize|gomezagent|headless|httrack|hubspot marketing grader|hydra|ibisbrowser|infrawatch|insight|inspect|iplabel|ips-agent|java(?!;)|jsjcw_scanner|library|linkcheck|mail\\.ru/|manager|measure|neustar wpm|node|nutch|offbyone|onetrust|optimize|pageburst|pagespeed|parser|perl|phantomjs|pingdom|powermarks|preview|proxy|ptst[ /]\\d|retriever|rexx;|rigor|rss\\b|scanner\\.|scrape|server|sogou|sparkler/|speedcurve|spider|splash|statuscake|supercleaner|synapse|synthetic|tools|torrent|transcoder|url|validator|virtuoso|wappalyzer|webglance|webkit2png|whatcms/|zgrab";
+var naivePattern = /bot|crawl|http|lighthouse|scan|search|spider/i;
+var pattern;
 function getPattern() {
   if (pattern instanceof RegExp) {
     return pattern;
@@ -751,1005 +209,2119 @@ function getPattern() {
 function isbot(userAgent) {
   return Boolean(userAgent) && getPattern().test(userAgent);
 }
-var fullPattern = " daum[ /]| deusu/| yadirectfetcher|(?:^|[^g])news(?!sapphire)|(?<! (?:channel/|google/))google(?!(app|/google| pixel))|(?<! cu)bots?(?:\\b|_)|(?<!(?:lib))http|(?<![hg]m)score|@[a-z][\\w-]+\\.|\\(\\)|\\.com\\b|\\btime/|^<|^[\\w \\.\\-\\(?:\\):]+(?:/v?\\d+(?:\\.\\d+)?(?:\\.\\d{1,10})*?)?(?:,|$)|^[^ ]{50,}$|^\\d+\\b|^\\w*search\\b|^\\w+/[\\w\\(\\)]*$|^active|^ad muncher|^amaya|^avsdevicesdk/|^biglotron|^bot|^bw/|^clamav[ /]|^client/|^cobweb/|^custom|^ddg[_-]android|^discourse|^dispatch/\\d|^downcast/|^duckduckgo|^facebook|^getright/|^gozilla/|^hobbit|^hotzonu|^hwcdn/|^jeode/|^jetty/|^jigsaw|^microsoft bits|^movabletype|^mozilla/5\\.0\\s[a-z\\.-]+$|^mozilla/\\d\\.\\d \\(compatible;?\\)$|^mozilla/\\d\\.\\d \\w*$|^navermailapp|^netsurf|^offline|^owler|^php|^postman|^python|^rank|^read|^reed|^rest|^rss|^snapchat|^space bison|^svn|^swcd |^taringa|^thumbor/|^track|^valid|^w3c|^webbandit/|^webcopier|^wget|^whatsapp|^wordpress|^xenu link sleuth|^yahoo|^yandex|^zdm/\\d|^zoom marketplace/|^{{.*}}$|adscanner/|analyzer|archive|ask jeeves/teoma|bit\\.ly/|bluecoat drtr|browsex|burpcollaborator|capture|catch|check\\b|checker|chrome-lighthouse|chromeframe|classifier|cloudflare|convertify|crawl|cypress/|dareboost|datanyze|dejaclick|detect|dmbrowser|download|evc-batch/|exaleadcloudview|feed|firephp|functionize|gomezagent|headless|httrack|hubspot marketing grader|hydra|ibisbrowser|images|infrawatch|insight|inspect|iplabel|ips-agent|java(?!;)|jsjcw_scanner|library|linkcheck|mail\\.ru/|manager|measure|neustar wpm|node|nutch|offbyone|optimize|pageburst|pagespeed|parser|perl|phantomjs|pingdom|powermarks|preview|proxy|ptst[ /]\\d|reputation|resolver|retriever|rexx;|rigor|rss\\b|scanner\\.|scrape|server|sogou|sparkler/|speedcurve|spider|splash|statuscake|supercleaner|synapse|synthetic|tools|torrent|trace|transcoder|url|virtuoso|wappalyzer|webglance|webkit2png|whatcms/|zgrab";
-var naivePattern = /bot|crawl|http|lighthouse|scan|search|spider/i;
-var pattern;
 
-// src/app.ts
-var import_trek_router = __toESM(require_trek_router(), 1);
-var import_trek_middleware = __toESM(require_trek_middleware(), 1);
-var import_deepmerge = __toESM(require_deepmerge(), 1);
+// src/clientjs/md5.js
+var hex_chr = "0123456789abcdef".split("");
 
-// node_modules/@mjackson/headers/dist/lib/param-values.js
-function parseParams(input, delimiter = ";") {
-  let regex = /(?:^|;)\s*([^=;\s]+)(\s*=\s*(?:"((?:[^"\\]|\\.)*)"|((?:[^;]|\\\;)+))?)?/g;
-  if (delimiter === ",") {
-    regex = /(?:^|,)\s*([^=,\s]+)(\s*=\s*(?:"((?:[^"\\]|\\.)*)"|((?:[^,]|\\\,)+))?)?/g;
-  }
-  let params = [];
-  let match;
-  while ((match = regex.exec(input)) !== null) {
-    let key = match[1].trim();
-    let value;
-    if (match[2]) {
-      value = (match[3] || match[4] || "").replace(/\\(.)/g, "$1").trim();
+// src/assets.ts
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+var IS_PROD = false;
+var PWD = import.meta.dir;
+var clientJSFiles = new Map;
+async function buildClientJS() {
+  const sourceFile = resolve(PWD, "../", "./hyperspan/clientjs/hyperspan-client.ts");
+  const output = await Bun.build({
+    entrypoints: [sourceFile],
+    outdir: `./public/_hs/js`,
+    naming: IS_PROD ? "[dir]/[name]-[hash].[ext]" : undefined,
+    minify: IS_PROD
+  });
+  const jsFile = output.outputs[0].path.split("/").reverse()[0];
+  clientJSFiles.set("_hs", { src: "/_hs/js/" + jsFile });
+  return jsFile;
+}
+var clientCSSFiles = new Map;
+async function buildClientCSS() {
+  if (clientCSSFiles.has("_hs")) {
+    return clientCSSFiles.get("_hs");
+  }
+  const cssDir = "./public/_hs/css/";
+  const cssFiles = await readdir(cssDir);
+  let foundCSSFile = "";
+  for (const file of cssFiles) {
+    if (!file.endsWith(".css")) {
+      continue;
     }
-    params.push([key, value]);
+    foundCSSFile = file.replace(cssDir, "");
+    clientCSSFiles.set("_hs", foundCSSFile);
+    break;
   }
-  return params;
-}
-function quote(value) {
-  if (value.includes('"') || value.includes(";") || value.includes(" ")) {
-    return `"${value.replace(/"/g, '\\"')}"`;
+  if (!foundCSSFile) {
+    console.log(`Unable to build CSS files from ${cssDir}`);
   }
-  return value;
 }
 
-// node_modules/@mjackson/headers/dist/lib/utils.js
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-}
-function isIterable(value) {
-  return value != null && typeof value[Symbol.iterator] === "function";
-}
-function isValidDate(date) {
-  return date instanceof Date && !isNaN(date.getTime());
-}
-
-// node_modules/@mjackson/headers/dist/lib/accept-language.js
-class AcceptLanguage {
-  #map;
-  constructor(init) {
-    this.#map = new Map;
-    if (init) {
-      if (typeof init === "string") {
-        let params = parseParams(init, ",");
-        for (let [language, quality] of params) {
-          if (typeof quality === "string") {
-            language = language.slice(0, -2).trim();
+// ../../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];
+        context.req.routeIndex = i;
+      } else {
+        handler = i === middleware.length && next || undefined;
+      }
+      if (handler) {
+        try {
+          res = await handler(context, () => dispatch(i + 1));
+        } catch (err) {
+          if (err instanceof Error && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
           } else {
-            quality = "1";
-          }
-          this.#map.set(language, Number(quality));
-        }
-      } else if (isIterable(init)) {
-        for (let language of init) {
-          let quality;
-          if (Array.isArray(language)) {
-            [language, quality] = language;
+            throw err;
           }
-          this.#map.set(language, quality ?? 1);
         }
       } else {
-        for (let language in init) {
-          if (Object.prototype.hasOwnProperty.call(init, language)) {
-            this.#map.set(language, init[language] ?? 1);
-          }
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
         }
       }
-      this.#sort();
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
     }
+  };
+};
+
+// ../../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);
   }
-  #sort() {
-    this.#map = new Map([...this.#map].sort(([, a], [, b]) => b - a));
-  }
-  get(language) {
-    return this.#map.get(language);
-  }
-  set(language, quality = 1) {
-    this.#map.set(language, quality);
-    this.#sort();
-  }
-  delete(language) {
-    return this.#map.delete(language);
-  }
-  has(language) {
-    return this.#map.has(language);
-  }
-  clear() {
-    this.#map.clear();
+  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];
+      }
+    });
   }
-  entries() {
-    return this.#map.entries();
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== undefined) {
+    if (Array.isArray(form[key])) {
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    form[key] = value;
   }
-  get languages() {
-    return Array.from(this.#map.keys());
+};
+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/hono/dist/utils/url.js
+var splitPath = (path) => {
+  const paths = path.split("/");
+  if (paths[0] === "") {
+    paths.shift();
   }
-  get qualities() {
-    return Array.from(this.#map.values());
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path) => {
+  const groups = [];
+  path = path.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return { groups, path };
+};
+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;
+      }
+    }
   }
-  [Symbol.iterator]() {
-    return this.entries();
+  return paths;
+};
+var patternCache = {};
+var getPattern2 = (label, next) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
+      if (match[2]) {
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
+      } else {
+        patternCache[cacheKey] = [label, match[1], true];
+      }
+    }
+    return patternCache[cacheKey];
   }
-  forEach(callback, thisArg) {
-    this.#map.forEach((quality, language, map) => callback(language, quality, map), thisArg);
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decoder(match);
+      } catch {
+        return match;
+      }
+    });
   }
-  get size() {
-    return this.#map.size;
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+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 path = url.slice(start, queryIndex === -1 ? undefined : queryIndex);
+      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+    } else if (charCode === 63) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
   }
-  toString() {
-    let pairs = [];
-    for (let [language, quality] of this.#map) {
-      pairs.push(`${language}${quality === 1 ? "" : `;q=${quality}`}`);
-    }
-    return pairs.join(",");
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path) => {
+  if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) {
+    return null;
   }
-}
-// node_modules/@mjackson/headers/dist/lib/cache-control.js
-class CacheControl {
-  maxAge;
-  maxStale;
-  minFresh;
-  sMaxage;
-  noCache;
-  noStore;
-  noTransform;
-  onlyIfCached;
-  mustRevalidate;
-  proxyRevalidate;
-  mustUnderstand;
-  private;
-  public;
-  immutable;
-  staleWhileRevalidate;
-  staleIfError;
-  constructor(init) {
-    if (init) {
-      if (typeof init === "string") {
-        let params = parseParams(init, ",");
-        if (params.length > 0) {
-          for (let [name, value] of params) {
-            switch (name) {
-              case "max-age":
-                this.maxAge = Number(value);
-                break;
-              case "max-stale":
-                this.maxStale = Number(value);
-                break;
-              case "min-fresh":
-                this.minFresh = Number(value);
-                break;
-              case "s-maxage":
-                this.sMaxage = Number(value);
-                break;
-              case "no-cache":
-                this.noCache = true;
-                break;
-              case "no-store":
-                this.noStore = true;
-                break;
-              case "no-transform":
-                this.noTransform = true;
-                break;
-              case "only-if-cached":
-                this.onlyIfCached = true;
-                break;
-              case "must-revalidate":
-                this.mustRevalidate = true;
-                break;
-              case "proxy-revalidate":
-                this.proxyRevalidate = true;
-                break;
-              case "must-understand":
-                this.mustUnderstand = true;
-                break;
-              case "private":
-                this.private = true;
-                break;
-              case "public":
-                this.public = true;
-                break;
-              case "immutable":
-                this.immutable = true;
-                break;
-              case "stale-while-revalidate":
-                this.staleWhileRevalidate = Number(value);
-                break;
-              case "stale-if-error":
-                this.staleIfError = Number(value);
-                break;
-            }
-          }
+  const segments = path.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 {
-        this.maxAge = init.maxAge;
-        this.maxStale = init.maxStale;
-        this.minFresh = init.minFresh;
-        this.sMaxage = init.sMaxage;
-        this.noCache = init.noCache;
-        this.noStore = init.noStore;
-        this.noTransform = init.noTransform;
-        this.onlyIfCached = init.onlyIfCached;
-        this.mustRevalidate = init.mustRevalidate;
-        this.proxyRevalidate = init.proxyRevalidate;
-        this.mustUnderstand = init.mustUnderstand;
-        this.private = init.private;
-        this.public = init.public;
-        this.immutable = init.immutable;
-        this.staleWhileRevalidate = init.staleWhileRevalidate;
-        this.staleIfError = init.staleIfError;
+        basePath += "/" + segment;
       }
     }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var _decodeURI = (value) => {
+  if (!/[%+]/.test(value)) {
+    return value;
   }
-  toString() {
-    let parts = [];
-    if (this.public) {
-      parts.push("public");
-    }
-    if (this.private) {
-      parts.push("private");
-    }
-    if (typeof this.maxAge === "number") {
-      parts.push(`max-age=${this.maxAge}`);
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return value.indexOf("%") !== -1 ? 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 ? undefined : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
     }
-    if (typeof this.sMaxage === "number") {
-      parts.push(`s-maxage=${this.sMaxage}`);
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return;
     }
-    if (this.noCache) {
-      parts.push("no-cache");
+  }
+  const results = {};
+  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;
     }
-    if (this.noStore) {
-      parts.push("no-store");
+    let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? undefined : nextKeyIndex : valueIndex);
+    if (encoded) {
+      name = _decodeURI(name);
     }
-    if (this.noTransform) {
-      parts.push("no-transform");
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
     }
-    if (this.onlyIfCached) {
-      parts.push("only-if-cached");
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
     }
-    if (this.mustRevalidate) {
-      parts.push("must-revalidate");
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      results[name].push(value);
+    } else {
+      results[name] ??= value;
     }
-    if (this.proxyRevalidate) {
-      parts.push("proxy-revalidate");
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// ../../node_modules/hono/dist/request.js
+var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
+var HonoRequest = class {
+  raw;
+  #validatedData;
+  #matchResult;
+  routeIndex = 0;
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+    this.#validatedData = {};
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const param = this.#getParamValue(paramKey);
+    return param ? /\%/.test(param) ? tryDecodeURIComponent(param) : param : undefined;
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value && typeof value === "string") {
+        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+      }
     }
-    if (this.mustUnderstand) {
-      parts.push("must-understand");
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? 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) ?? undefined;
     }
-    if (this.immutable) {
-      parts.push("immutable");
+    const headerData = {};
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return this.bodyCache.parsedBody ??= await parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw } = 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]();
+      });
     }
-    if (typeof this.staleWhileRevalidate === "number") {
-      parts.push(`stale-while-revalidate=${this.staleWhileRevalidate}`);
+    return bodyCache[key] = raw[key]();
+  };
+  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) {
+    this.#validatedData[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData[target];
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// ../../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 (typeof this.staleIfError === "number") {
-      parts.push(`stale-if-error=${this.staleIfError}`);
+    if (str instanceof Promise) {
+      str = await str;
     }
-    if (typeof this.maxStale === "number") {
-      parts.push(`max-stale=${this.maxStale}`);
+  }
+  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/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setHeaders = (headers, map = {}) => {
+  for (const key of Object.keys(map)) {
+    headers.set(key, map[key]);
+  }
+  return headers;
+};
+var Context = class {
+  #rawRequest;
+  #req;
+  env = {};
+  #var;
+  finalized = false;
+  error;
+  #status = 200;
+  #executionCtx;
+  #headers;
+  #preparedHeaders;
+  #res;
+  #isFresh = true;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #matchResult;
+  #path;
+  constructor(req, options) {
+    this.#rawRequest = req;
+    if (options) {
+      this.#executionCtx = options.executionCtx;
+      this.env = options.env;
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
+    }
+  }
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
     }
-    if (typeof this.minFresh === "number") {
-      parts.push(`min-fresh=${this.minFresh}`);
+  }
+  get executionCtx() {
+    if (this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
     }
-    return parts.join(", ");
   }
-}
-// node_modules/@mjackson/headers/dist/lib/content-disposition.js
-function decodeFilenameSplat(value) {
-  let match = value.match(/^([\w-]+)'([^']*)'(.+)$/);
-  if (!match)
-    return null;
-  let [, charset, , encodedFilename] = match;
-  let decodedFilename = percentDecode(encodedFilename);
-  try {
-    let decoder = new TextDecoder(charset);
-    let bytes = new Uint8Array(decodedFilename.split("").map((char) => char.charCodeAt(0)));
-    return decoder.decode(bytes);
-  } catch (error) {
-    console.warn(`Failed to decode filename from charset ${charset}:`, error);
-    return decodedFilename;
+  get res() {
+    this.#isFresh = false;
+    return this.#res ||= new Response("404 Not Found", { status: 404 });
   }
-}
-function percentDecode(value) {
-  return value.replace(/\+/g, " ").replace(/%([0-9A-Fa-f]{2})/g, (_, hex2) => {
-    return String.fromCharCode(parseInt(hex2, 16));
-  });
-}
-
-class ContentDisposition {
-  filename;
-  filenameSplat;
-  name;
-  type;
-  constructor(init) {
-    if (init) {
-      if (typeof init === "string") {
-        let params = parseParams(init);
-        if (params.length > 0) {
-          this.type = params[0][0];
-          for (let [name, value] of params.slice(1)) {
-            if (name === "filename") {
-              this.filename = value;
-            } else if (name === "filename*") {
-              this.filenameSplat = value;
-            } else if (name === "name") {
-              this.name = value;
+  set res(_res) {
+    this.#isFresh = false;
+    if (this.#res && _res) {
+      try {
+        for (const [k, v] of this.#res.headers.entries()) {
+          if (k === "content-type") {
+            continue;
+          }
+          if (k === "set-cookie") {
+            const cookies = this.#res.headers.getSetCookie();
+            _res.headers.delete("set-cookie");
+            for (const cookie of cookies) {
+              _res.headers.append("set-cookie", cookie);
             }
+          } else {
+            _res.headers.set(k, v);
           }
         }
-      } else {
-        this.filename = init.filename;
-        this.filenameSplat = init.filenameSplat;
-        this.name = init.name;
-        this.type = init.type;
+      } catch (e) {
+        if (e instanceof TypeError && e.message.includes("immutable")) {
+          this.res = new Response(_res.body, {
+            headers: _res.headers,
+            status: _res.status
+          });
+          return;
+        } else {
+          throw e;
+        }
       }
     }
+    this.#res = _res;
+    this.finalized = true;
   }
-  get preferredFilename() {
-    let filenameSplat = this.filenameSplat;
-    if (filenameSplat) {
-      let decodedFilename = decodeFilenameSplat(filenameSplat);
-      if (decodedFilename)
-        return decodedFilename;
-    }
-    return this.filename;
-  }
-  toString() {
-    if (!this.type) {
-      return "";
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  setLayout = (layout) => this.#layout = layout;
+  getLayout = () => this.#layout;
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  header = (name, value, options) => {
+    if (value === undefined) {
+      if (this.#headers) {
+        this.#headers.delete(name);
+      } else if (this.#preparedHeaders) {
+        delete this.#preparedHeaders[name.toLocaleLowerCase()];
+      }
+      if (this.finalized) {
+        this.res.headers.delete(name);
+      }
+      return;
     }
-    let parts = [this.type];
-    if (this.name) {
-      parts.push(`name=${quote(this.name)}`);
+    if (options?.append) {
+      if (!this.#headers) {
+        this.#isFresh = false;
+        this.#headers = new Headers(this.#preparedHeaders);
+        this.#preparedHeaders = {};
+      }
+      this.#headers.append(name, value);
+    } else {
+      if (this.#headers) {
+        this.#headers.set(name, value);
+      } else {
+        this.#preparedHeaders ??= {};
+        this.#preparedHeaders[name.toLowerCase()] = value;
+      }
     }
-    if (this.filename) {
-      parts.push(`filename=${quote(this.filename)}`);
+    if (this.finalized) {
+      if (options?.append) {
+        this.res.headers.append(name, value);
+      } else {
+        this.res.headers.set(name, value);
+      }
     }
-    if (this.filenameSplat) {
-      parts.push(`filename*=${quote(this.filenameSplat)}`);
+  };
+  status = (status) => {
+    this.#isFresh = false;
+    this.#status = status;
+  };
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map;
+    this.#var.set(key, value);
+  };
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : undefined;
+  };
+  get var() {
+    if (!this.#var) {
+      return {};
     }
-    return parts.join("; ");
+    return Object.fromEntries(this.#var);
   }
-}
-// node_modules/@mjackson/headers/dist/lib/content-type.js
-class ContentType {
-  boundary;
-  charset;
-  mediaType;
-  constructor(init) {
-    if (init) {
-      if (typeof init === "string") {
-        let params = parseParams(init);
-        if (params.length > 0) {
-          this.mediaType = params[0][0];
-          for (let [name, value] of params.slice(1)) {
-            if (name === "boundary") {
-              this.boundary = value;
-            } else if (name === "charset") {
-              this.charset = value;
-            }
+  #newResponse(data, arg, headers) {
+    if (this.#isFresh && !headers && !arg && this.#status === 200) {
+      return new Response(data, {
+        headers: this.#preparedHeaders
+      });
+    }
+    if (arg && typeof arg !== "number") {
+      const header = new Headers(arg.headers);
+      if (this.#headers) {
+        this.#headers.forEach((v, k) => {
+          if (k === "set-cookie") {
+            header.append(k, v);
+          } else {
+            header.set(k, v);
           }
+        });
+      }
+      const headers2 = setHeaders(header, this.#preparedHeaders);
+      return new Response(data, {
+        headers: headers2,
+        status: arg.status ?? this.#status
+      });
+    }
+    const status = typeof arg === "number" ? arg : this.#status;
+    this.#preparedHeaders ??= {};
+    this.#headers ??= new Headers;
+    setHeaders(this.#headers, this.#preparedHeaders);
+    if (this.#res) {
+      this.#res.headers.forEach((v, k) => {
+        if (k === "set-cookie") {
+          this.#headers?.append(k, v);
+        } else {
+          this.#headers?.set(k, v);
         }
+      });
+      setHeaders(this.#headers, this.#preparedHeaders);
+    }
+    headers ??= {};
+    for (const [k, v] of Object.entries(headers)) {
+      if (typeof v === "string") {
+        this.#headers.set(k, v);
       } else {
-        this.boundary = init.boundary;
-        this.charset = init.charset;
-        this.mediaType = init.mediaType;
+        this.#headers.delete(k);
+        for (const v2 of v) {
+          this.#headers.append(k, v2);
+        }
       }
     }
+    return new Response(data, {
+      status,
+      headers: this.#headers
+    });
   }
-  toString() {
-    if (!this.mediaType) {
-      return "";
+  newResponse = (...args) => this.#newResponse(...args);
+  body = (data, arg, headers) => {
+    return typeof arg === "number" ? this.#newResponse(data, arg, headers) : this.#newResponse(data, arg);
+  };
+  text = (text, arg, headers) => {
+    if (!this.#preparedHeaders) {
+      if (this.#isFresh && !headers && !arg) {
+        return new Response(text);
+      }
+      this.#preparedHeaders = {};
     }
-    let parts = [this.mediaType];
-    if (this.charset) {
-      parts.push(`charset=${quote(this.charset)}`);
+    this.#preparedHeaders["content-type"] = TEXT_PLAIN;
+    if (typeof arg === "number") {
+      return this.#newResponse(text, arg, headers);
     }
-    if (this.boundary) {
-      parts.push(`boundary=${quote(this.boundary)}`);
+    return this.#newResponse(text, arg);
+  };
+  json = (object, arg, headers) => {
+    const body = JSON.stringify(object);
+    this.#preparedHeaders ??= {};
+    this.#preparedHeaders["content-type"] = "application/json";
+    return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
+  };
+  html = (html2, arg, headers) => {
+    this.#preparedHeaders ??= {};
+    this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
+    if (typeof html2 === "object") {
+      return resolveCallback(html2, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html22) => {
+        return typeof arg === "number" ? this.#newResponse(html22, arg, headers) : this.#newResponse(html22, arg);
+      });
     }
-    return parts.join("; ");
+    return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
+  };
+  redirect = (location, status) => {
+    this.#headers ??= new Headers;
+    this.#headers.set("Location", String(location));
+    return this.newResponse(null, status ?? 302);
+  };
+  notFound = () => {
+    this.#notFoundHandler ??= () => new Response;
+    return this.#notFoundHandler(this);
+  };
+};
+
+// ../../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/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// ../../node_modules/hono/dist/hono-base.js
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    return err.getResponse();
   }
-}
-// node_modules/@mjackson/headers/dist/lib/cookie.js
-class Cookie {
-  #map;
-  constructor(init) {
-    this.#map = new Map;
-    if (init) {
-      if (typeof init === "string") {
-        let params = parseParams(init);
-        for (let [name, value] of params) {
-          this.#map.set(name, value || "");
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+var Hono = class {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  all;
+  on;
+  use;
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          this.#path = args1;
+        } else {
+          this.#addRoute(method, this.#path, args1);
         }
-      } else if (isIterable(init)) {
-        for (let [name, value] of init) {
-          this.#map.set(name, value);
+        args.forEach((handler) => {
+          this.#addRoute(method, this.#path, handler);
+        });
+        return this;
+      };
+    });
+    this.on = (method, path, ...handlers) => {
+      for (const p of [path].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
+          });
         }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        this.#path = arg1;
       } else {
-        for (let name in init) {
-          if (Object.prototype.hasOwnProperty.call(init, name)) {
-            this.#map.set(name, init[name]);
-          }
-        }
+        this.#path = "*";
+        handlers.unshift(arg1);
       }
-    }
-  }
-  get(name) {
-    return this.#map.get(name);
+      handlers.forEach((handler) => {
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  #clone() {
+    const clone = new Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  errorHandler = errorHandler;
+  route(path, app) {
+    const subApp = this.basePath(path);
+    app.routes.map((r) => {
+      let handler;
+      if (app.errorHandler === errorHandler) {
+        handler = r.handler;
+      } else {
+        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler);
+    });
+    return this;
   }
-  set(name, value) {
-    this.#map.set(name, value);
+  basePath(path) {
+    const subApp = this.#clone();
+    subApp._basePath = mergePath(this._basePath, path);
+    return subApp;
   }
-  delete(name) {
-    return this.#map.delete(name);
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  mount(path, 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 = undefined;
+      try {
+        executionContext = c.executionCtx;
+      } catch {}
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path);
+      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(path, "*"), handler);
+    return this;
   }
-  has(name) {
-    return this.#map.has(name);
+  #addRoute(method, path, handler) {
+    method = method.toUpperCase();
+    path = mergePath(this._basePath, path);
+    const r = { path, method, handler };
+    this.router.add(method, path, [handler, r]);
+    this.routes.push(r);
+  }
+  #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 path = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path);
+    const c = new Context(request, {
+      path,
+      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);
+      }
+    })();
   }
-  clear() {
-    this.#map.clear();
+  fetch = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method);
+  };
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    }
+    input = input.toString();
+    return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, undefined, event.request.method));
+    });
+  };
+};
+
+// ../../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 {
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+    if (tokens.length === 0) {
+      if (this.#index !== undefined) {
+        throw PATH_ERROR;
+      }
+      if (pathErrorCheckOnly) {
+        return;
+      }
+      this.#index = index;
+      return;
+    }
+    const [token, ...restTokens] = tokens;
+    const pattern2 = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern2) {
+      const name = pattern2[1];
+      let regexpStr = pattern2[2] || LABEL_REG_EXP_STR;
+      if (name && pattern2[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);
   }
-  entries() {
-    return this.#map.entries();
+  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("|") + ")";
   }
-  names() {
-    return this.#map.keys();
+};
+
+// ../../node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node;
+  insert(path, index, pathErrorCheckOnly) {
+    const paramAssoc = [];
+    const groups = [];
+    for (let i = 0;; ) {
+      let replaced = false;
+      path = path.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = path.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 (handlerIndex !== undefined) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== undefined) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
   }
-  values() {
-    return this.#map.values();
+};
+
+// ../../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(path) {
+  return wildcardRegExpCache[path] ??= new RegExp(path === "*" ? "" : `^${path.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, path, handlers] = routesWithStaticPathFlag[i];
+    if (pathErrorCheckOnly) {
+      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+    } else {
+      j++;
+    }
+    let paramAssoc;
+    try {
+      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : 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];
+    });
   }
-  [Symbol.iterator]() {
-    return this.entries();
+  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]]];
+      }
+    }
   }
-  forEach(callback, thisArg) {
-    this.#map.forEach(callback, thisArg);
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlerData[indexReplacementMap[i]];
   }
-  get size() {
-    return this.#map.size;
+  return [regexp, handlerMap, staticMap];
+}
+function findMiddleware(middleware, path) {
+  if (!middleware) {
+    return;
   }
-  toString() {
-    let pairs = [];
-    for (let [name, value] of this.#map) {
-      pairs.push(`${name}=${quote(value)}`);
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
     }
-    return pairs.join("; ");
   }
+  return;
 }
-// node_modules/@mjackson/headers/dist/lib/set-cookie.js
-class SetCookie {
-  domain;
-  expires;
-  httpOnly;
-  maxAge;
-  name;
-  path;
-  sameSite;
-  secure;
-  value;
-  constructor(init) {
-    if (init) {
-      if (typeof init === "string") {
-        let params = parseParams(init);
-        if (params.length > 0) {
-          this.name = params[0][0];
-          this.value = params[0][1];
-          for (let [key, value] of params.slice(1)) {
-            switch (key.toLowerCase()) {
-              case "domain":
-                this.domain = value;
-                break;
-              case "expires": {
-                if (typeof value === "string") {
-                  let v = new Date(value);
-                  if (isValidDate(v))
-                    this.expires = v;
-                }
-                break;
-              }
-              case "httponly":
-                this.httpOnly = true;
-                break;
-              case "max-age": {
-                if (typeof value === "string") {
-                  let v = parseInt(value, 10);
-                  if (!isNaN(v))
-                    this.maxAge = v;
-                }
-                break;
-              }
-              case "path":
-                this.path = value;
-                break;
-              case "samesite":
-                if (typeof value === "string" && /strict|lax|none/i.test(value)) {
-                  this.sameSite = capitalize(value);
-                }
-                break;
-              case "secure":
-                this.secure = true;
-                break;
-            }
-          }
-        }
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  constructor() {
+    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+  }
+  add(method, path, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    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 (path === "/*") {
+      path = "*";
+    }
+    const paramCount = (path.match(/\/:/g) || []).length;
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path);
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+        });
       } else {
-        this.domain = init.domain;
-        this.expires = init.expires;
-        this.httpOnly = init.httpOnly;
-        this.maxAge = init.maxAge;
-        this.name = init.name;
-        this.path = init.path;
-        this.sameSite = init.sameSite;
-        this.secure = init.secure;
-        this.value = init.value;
+        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
       }
+      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(path) || [path];
+    for (let i = 0, len = paths.length;i < len; i++) {
+      const path2 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          routes[m][path2] ||= [
+            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+          ];
+          routes[m][path2].push([handler, paramCount - len + i + 1]);
+        }
+      });
     }
   }
-  toString() {
-    if (!this.name) {
-      return "";
-    }
-    let parts = [`${this.name}=${quote(this.value || "")}`];
-    if (this.domain) {
-      parts.push(`Domain=${this.domain}`);
-    }
-    if (this.path) {
-      parts.push(`Path=${this.path}`);
+  match(method, path) {
+    clearWildcardRegExpCache();
+    const matchers = this.#buildAllMatchers();
+    this.match = (method2, path2) => {
+      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+      const staticMatch = matcher[2][path2];
+      if (staticMatch) {
+        return staticMatch;
+      }
+      const match = path2.match(matcher[0]);
+      if (!match) {
+        return [[], emptyParam];
+      }
+      const index = match.indexOf("", 1);
+      return [matcher[1][index], match];
+    };
+    return this.match(method, path);
+  }
+  #buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
+      matchers[method] ||= this.#buildMatcher(method);
+    });
+    this.#middleware = this.#routes = undefined;
+    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((path) => [path, r[method][path]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute ||= true;
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]));
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
     }
-    if (this.expires) {
-      parts.push(`Expires=${this.expires.toUTCString()}`);
+  }
+};
+
+// ../../node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  name = "SmartRouter";
+  #routers = [];
+  #routes = [];
+  constructor(init) {
+    this.#routers = init.routers;
+  }
+  add(method, path, handler) {
+    if (!this.#routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    if (this.maxAge) {
-      parts.push(`Max-Age=${this.maxAge}`);
+    this.#routes.push([method, path, handler]);
+  }
+  match(method, path) {
+    if (!this.#routes) {
+      throw new Error("Fatal error");
     }
-    if (this.secure) {
-      parts.push("Secure");
+    const routers = this.#routers;
+    const routes = this.#routes;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (;i < len; i++) {
+      const router = routers[i];
+      try {
+        for (let i2 = 0, len2 = routes.length;i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
+        res = router.match(method, path);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
+        }
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.#routers = [router];
+      this.#routes = undefined;
+      break;
     }
-    if (this.httpOnly) {
-      parts.push("HttpOnly");
+    if (i === len) {
+      throw new Error("Fatal error");
     }
-    if (this.sameSite) {
-      parts.push(`SameSite=${this.sameSite}`);
+    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 parts.join("; ");
+    return this.#routers[0];
   }
-}
-// node_modules/@mjackson/headers/dist/lib/header-names.js
-function canonicalHeaderName(name) {
-  return name.toLowerCase().split("-").map((word) => HeaderWordCasingExceptions[word] || word.charAt(0).toUpperCase() + word.slice(1)).join("-");
-}
-var HeaderWordCasingExceptions = {
-  ct: "CT",
-  etag: "ETag",
-  te: "TE",
-  www: "WWW",
-  x: "X",
-  xss: "XSS"
 };
 
-// node_modules/@mjackson/headers/dist/lib/super-headers.js
-var CRLF = "\r\n";
-var SetCookieKey = "set-cookie";
-
-class SuperHeaders extends Headers {
-  #map;
-  #setCookieValues = [];
-  constructor(init) {
-    super();
-    this.#map = new Map;
-    if (init) {
-      if (typeof init === "string") {
-        let lines = init.split(CRLF);
-        for (let line of lines) {
-          let match = line.match(/^([^:]+):(.*)/);
-          if (match) {
-            this.append(match[1].trim(), match[2].trim());
+// ../../node_modules/hono/dist/router/trie-router/node.js
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var Node2 = class {
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = emptyParams;
+  constructor(method, handler, children) {
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
+    if (method && handler) {
+      const m = /* @__PURE__ */ Object.create(null);
+      m[method] = { handler, possibleKeys: [], score: 0 };
+      this.#methods = [m];
+    }
+    this.#patterns = [];
+  }
+  insert(method, path, handler) {
+    this.#order = ++this.#order;
+    let curNode = this;
+    const parts = splitRoutingPath(path);
+    const possibleKeys = [];
+    for (let i = 0, len = parts.length;i < len; i++) {
+      const p = parts[i];
+      const nextP = parts[i + 1];
+      const pattern2 = getPattern2(p, nextP);
+      const key = Array.isArray(pattern2) ? pattern2[0] : p;
+      if (Object.keys(curNode.#children).includes(key)) {
+        curNode = curNode.#children[key];
+        const pattern22 = getPattern2(p, nextP);
+        if (pattern22) {
+          possibleKeys.push(pattern22[1]);
+        }
+        continue;
+      }
+      curNode.#children[key] = new Node2;
+      if (pattern2) {
+        curNode.#patterns.push(pattern2);
+        possibleKeys.push(pattern2[1]);
+      }
+      curNode = curNode.#children[key];
+    }
+    const m = /* @__PURE__ */ Object.create(null);
+    const handlerSet = {
+      handler,
+      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+      score: this.#order
+    };
+    m[method] = handlerSet;
+    curNode.#methods.push(m);
+    return curNode;
+  }
+  #getHandlerSets(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 = {};
+      if (handlerSet !== undefined) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSets.push(handlerSet);
+        if (nodeParams !== emptyParams || params && params !== emptyParams) {
+          for (let i2 = 0, len2 = handlerSet.possibleKeys.length;i2 < len2; i2++) {
+            const key = handlerSet.possibleKeys[i2];
+            const processed = processedSet[handlerSet.score];
+            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
+            processedSet[handlerSet.score] = true;
           }
         }
-      } else if (isIterable(init)) {
-        for (let [name, value] of init) {
-          this.append(name, value);
+      }
+    }
+    return handlerSets;
+  }
+  search(method, path) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path);
+    const curNodesQueue = [];
+    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) {
+            if (nextNode.#children["*"]) {
+              handlerSets.push(...this.#getHandlerSets(nextNode.#children["*"], method, node.#params));
+            }
+            handlerSets.push(...this.#getHandlerSets(nextNode, method, node.#params));
+          } else {
+            tempNodes.push(nextNode);
+          }
         }
-      } else if (typeof init === "object") {
-        for (let name in init) {
-          if (Object.prototype.hasOwnProperty.call(init, name)) {
-            let setter = Object.getOwnPropertyDescriptor(SuperHeaders.prototype, name)?.set;
-            if (setter) {
-              setter.call(this, init[name]);
+        for (let k = 0, len3 = node.#patterns.length;k < len3; k++) {
+          const pattern2 = node.#patterns[k];
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (pattern2 === "*") {
+            const astNode = node.#children["*"];
+            if (astNode) {
+              handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
+              astNode.#params = params;
+              tempNodes.push(astNode);
+            }
+            continue;
+          }
+          if (part === "") {
+            continue;
+          }
+          const [key, name, matcher] = pattern2;
+          const child = node.#children[key];
+          const restPathString = parts.slice(i).join("/");
+          if (matcher instanceof RegExp) {
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
+              if (Object.keys(child.#children).length) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
+              if (child.#children["*"]) {
+                handlerSets.push(...this.#getHandlerSets(child.#children["*"], method, params, node.#params));
+              }
             } else {
-              this.append(name, init[name]);
+              child.#params = params;
+              tempNodes.push(child);
             }
           }
         }
       }
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
     }
-  }
-  append(name, value) {
-    let key = name.toLowerCase();
-    if (key === SetCookieKey) {
-      this.#setCookieValues.push(value);
-    } else {
-      let existingValue = this.#map.get(key);
-      this.#map.set(key, existingValue ? `${existingValue}, ${value}` : value);
+    if (handlerSets.length > 1) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
     }
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
   }
-  delete(name) {
-    let key = name.toLowerCase();
-    if (key === SetCookieKey) {
-      this.#setCookieValues = [];
-    } else {
-      this.#map.delete(key);
-    }
+};
+
+// ../../node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node;
+  constructor() {
+    this.#node = new Node2;
   }
-  get(name) {
-    let key = name.toLowerCase();
-    if (key === SetCookieKey) {
-      return this.#setCookieValues.map((value) => value.toString()).join(", ");
-    } else {
-      let value = this.#map.get(key);
-      if (typeof value === "string") {
-        return value;
-      } else if (value instanceof Date) {
-        return value.toUTCString();
-      } else if (value != null) {
-        return value.toString();
-      } else {
-        return null;
+  add(method, path, handler) {
+    const results = checkOptionalParameter(path);
+    if (results) {
+      for (let i = 0, len = results.length;i < len; i++) {
+        this.#node.insert(method, results[i], handler);
       }
+      return;
     }
+    this.#node.insert(method, path, handler);
   }
-  getSetCookie() {
-    return this.#setCookieValues.map((value) => value.toString());
+  match(method, path) {
+    return this.#node.search(method, path);
   }
-  has(name) {
-    let key = name.toLowerCase();
-    if (key === SetCookieKey) {
-      return this.#setCookieValues.length > 0;
-    } else {
-      return this.#map.has(key);
-    }
+};
+
+// ../../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]
+    });
   }
-  set(name, value) {
-    let key = name.toLowerCase();
-    if (key === SetCookieKey) {
-      this.#setCookieValues = [value];
+};
+
+// ../../node_modules/hono/dist/adapter/bun/serve-static.js
+import { stat } from "node:fs/promises";
+
+// ../../node_modules/hono/dist/utils/compress.js
+var 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;
+
+// ../../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 path = getFilePathWithoutDefaultDocument({
+    root: options.root,
+    filename
+  });
+  return path;
+};
+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 path = root ? root + "/" + filename : filename;
+  path = path.replace(/^\.?\//, "");
+  if (root[0] !== "/" && path[0] === "/") {
+    return;
+  }
+  return path;
+};
+
+// ../../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 += "; 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"
+};
+var baseMimes = _baseMimes;
+
+// ../../node_modules/hono/dist/middleware/serve-static/index.js
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var DEFAULT_DOCUMENT = "index.html";
+var defaultPathResolve = (path) => path;
+var serveStatic = (options) => {
+  let isAbsoluteRoot = false;
+  let root;
+  if (options.root) {
+    if (options.root.startsWith("/")) {
+      isAbsoluteRoot = true;
+      root = new URL(`file://${options.root}`).pathname;
     } else {
-      this.#map.set(key, value);
+      root = options.root;
     }
   }
-  *entries() {
-    for (let [key] of this.#map) {
-      let stringValue = this.get(key);
-      if (stringValue) {
-        yield [key, stringValue];
-      }
+  return async (c, next) => {
+    if (c.finalized) {
+      await next();
+      return;
     }
-    for (let value of this.#setCookieValues) {
-      let stringValue = value.toString();
-      if (stringValue) {
-        yield [SetCookieKey, stringValue];
+    let filename = options.path ?? decodeURI(c.req.path);
+    filename = options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename;
+    if (!filename.endsWith("/") && options.isDir) {
+      const path2 = getFilePathWithoutDefaultDocument({
+        filename,
+        root
+      });
+      if (path2 && await options.isDir(path2)) {
+        filename += "/";
       }
     }
-  }
-  *keys() {
-    for (let [key] of this) {
-      yield key;
-    }
-  }
-  *values() {
-    for (let [, value] of this) {
-      yield value;
+    let path = getFilePath({
+      filename,
+      root,
+      defaultDocument: DEFAULT_DOCUMENT
+    });
+    if (!path) {
+      return await next();
+    }
+    if (isAbsoluteRoot) {
+      path = "/" + path;
+    }
+    const getContent = options.getContent;
+    const pathResolve = options.pathResolve ?? defaultPathResolve;
+    path = pathResolve(path);
+    let content = await getContent(path, c);
+    if (!content) {
+      let pathWithoutDefaultDocument = getFilePathWithoutDefaultDocument({
+        filename,
+        root
+      });
+      if (!pathWithoutDefaultDocument) {
+        return await next();
+      }
+      pathWithoutDefaultDocument = pathResolve(pathWithoutDefaultDocument);
+      if (pathWithoutDefaultDocument !== path) {
+        content = await getContent(pathWithoutDefaultDocument, c);
+        if (content) {
+          path = pathWithoutDefaultDocument;
+        }
+      }
     }
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  forEach(callback, thisArg) {
-    for (let [key, value] of this) {
-      callback.call(thisArg, value, key, this);
+    if (content instanceof Response) {
+      return c.newResponse(content.body, content);
     }
-  }
-  toString() {
-    let lines = [];
-    for (let [key, value] of this) {
-      lines.push(`${canonicalHeaderName(key)}: ${value}`);
+    if (content) {
+      const mimeType = options.mimes && getMimeType(path, options.mimes) || getMimeType(path);
+      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 compressedContent = await getContent(path + ENCODINGS[encoding], c);
+          if (compressedContent) {
+            content = compressedContent;
+            c.header("Content-Encoding", encoding);
+            c.header("Vary", "Accept-Encoding", { append: true });
+            break;
+          }
+        }
+      }
+      await options.onFound?.(path, c);
+      return c.body(content);
     }
-    return lines.join(CRLF);
-  }
-  get acceptLanguage() {
-    return this.#getHeaderValue("accept-language", AcceptLanguage);
-  }
-  set acceptLanguage(value) {
-    this.#setHeaderValue("accept-language", AcceptLanguage, value);
-  }
-  get age() {
-    return this.#getNumberValue("age");
-  }
-  set age(value) {
-    this.#map.set("age", value);
-  }
-  get cacheControl() {
-    return this.#getHeaderValue("cache-control", CacheControl);
-  }
-  set cacheControl(value) {
-    this.#setHeaderValue("cache-control", CacheControl, value);
-  }
-  get contentDisposition() {
-    return this.#getHeaderValue("content-disposition", ContentDisposition);
-  }
-  set contentDisposition(value) {
-    this.#setHeaderValue("content-disposition", ContentDisposition, value);
-  }
-  get contentLength() {
-    return this.#getNumberValue("content-length");
-  }
-  set contentLength(value) {
-    this.#map.set("content-length", value);
-  }
-  get contentType() {
-    return this.#getHeaderValue("content-type", ContentType);
-  }
-  set contentType(value) {
-    this.#setHeaderValue("content-type", ContentType, value);
-  }
-  get cookie() {
-    return this.#getHeaderValue("cookie", Cookie);
-  }
-  set cookie(value) {
-    this.#setHeaderValue("cookie", Cookie, value);
-  }
-  get date() {
-    return this.#getDateValue("date");
-  }
-  set date(value) {
-    this.#map.set("date", value);
+    await options.onNotFound?.(path, c);
+    await next();
+    return;
+  };
+};
+
+// ../../node_modules/hono/dist/adapter/bun/serve-static.js
+var serveStatic2 = (options) => {
+  return async function serveStatic2(c, next) {
+    const getContent = async (path) => {
+      path = path.startsWith("/") ? path : `./${path}`;
+      const file = Bun.file(path);
+      return await file.exists() ? file : null;
+    };
+    const pathResolve = (path) => {
+      return path.startsWith("/") ? path : `./${path}`;
+    };
+    const isDir = async (path) => {
+      let isDir2;
+      try {
+        const stats = await stat(path);
+        isDir2 = stats.isDirectory();
+      } catch {}
+      return isDir2;
+    };
+    return serveStatic({
+      ...options,
+      getContent,
+      pathResolve,
+      isDir
+    })(c, next);
+  };
+};
+
+// ../../node_modules/hono/dist/helper/ssg/middleware.js
+var X_HONO_DISABLE_SSG_HEADER_KEY = "x-hono-disable-ssg";
+var SSG_DISABLED_RESPONSE = (() => {
+  try {
+    return new Response("SSG is disabled", {
+      status: 404,
+      headers: { [X_HONO_DISABLE_SSG_HEADER_KEY]: "true" }
+    });
+  } catch {
+    return null;
   }
-  get expires() {
-    return this.#getDateValue("expires");
+})();
+// ../../node_modules/hono/dist/adapter/bun/ssg.js
+var { write } = Bun;
+
+// ../../node_modules/hono/dist/helper/websocket/index.js
+var WSContext = class {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
   }
-  set expires(value) {
-    this.#map.set("expires", value);
+  send(source, options) {
+    this.#init.send(source, options ?? {});
   }
-  get ifModifiedSince() {
-    return this.#getDateValue("if-modified-since");
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
   }
-  set ifModifiedSince(value) {
-    this.#map.set("if-modified-since", value);
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
   }
-  get ifUnmodifiedSince() {
-    return this.#getDateValue("if-unmodified-since");
+};
+
+// ../../node_modules/@zod/core/dist/esm/core.js
+var $brand = Symbol("zod_brand");
+
+class $ZodAsyncError extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
   }
-  set ifUnmodifiedSince(value) {
-    this.#map.set("if-unmodified-since", value);
+}
+var globalConfig = {};
+function config(config2) {
+  if (config2)
+    Object.assign(globalConfig, config2);
+  return globalConfig;
+}
+
+// ../../node_modules/@zod/core/dist/esm/util.js
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+var allowsEval = cached(() => {
+  try {
+    new Function("");
+    return true;
+  } catch (_) {
+    return false;
   }
-  get lastModified() {
-    return this.#getDateValue("last-modified");
+});
+var propertyKeyTypes = new Set(["string", "number", "symbol"]);
+var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+var NUMBER_FORMAT_RANGES = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
+  float64: [-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
+};
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config2) {
+  const full = { ...iss, path: iss.path ?? [] };
+  if (!iss.message) {
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
+    full.message = message;
+  }
+  delete full.inst;
+  delete full.continue;
+  if (!ctx?.reportInput) {
+    delete full.input;
+  }
+  return full;
+}
+
+// ../../node_modules/@zod/core/dist/esm/errors.js
+var ZOD_ERROR = Symbol.for("{{zod.error}}");
+
+class $ZodError {
+  get message() {
+    return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
   }
-  set lastModified(value) {
-    this.#map.set("last-modified", value);
+  constructor(issues) {
+    Object.defineProperty(this, "_tag", { value: ZOD_ERROR, enumerable: false });
+    Object.defineProperty(this, "name", { value: "$ZodError", enumerable: false });
+    this.issues = issues;
   }
-  get setCookie() {
-    for (let i = 0;i < this.#setCookieValues.length; ++i) {
-      let value = this.#setCookieValues[i];
-      if (typeof value === "string") {
-        this.#setCookieValues[i] = new SetCookie(value);
-      }
-    }
-    return this.#setCookieValues;
+  static [Symbol.hasInstance](inst) {
+    return inst?._tag === ZOD_ERROR;
   }
-  set setCookie(values) {
-    if (typeof values === "string") {
-      this.#setCookieValues = [values];
+}
+function flattenError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = {};
+  const formErrors = [];
+  for (const sub of error.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
     } else {
-      this.#setCookieValues = values.map((value) => {
-        if (typeof value === "string" || value instanceof SetCookie) {
-          return value;
-        } else {
-          return new SetCookie(value);
-        }
-      });
+      formErrors.push(mapper(sub));
     }
   }
-  #getDateValue(key) {
-    let value = this.#map.get(key);
-    if (value) {
-      if (typeof value === "string") {
-        let date = new Date(value);
-        if (isValidDate(date)) {
-          this.#map.set(key, date);
-          return date;
-        } else {
-          this.#map.delete(key);
-        }
-      } else if (value instanceof Date) {
-        return value;
+  return { formErrors, fieldErrors };
+}
+function formatError(error, _mapper) {
+  const mapper = _mapper || function(issue) {
+    return issue.message;
+  };
+  const fieldErrors = { _errors: [] };
+  const processError = (error2) => {
+    for (const issue of error2.issues) {
+      if (issue.code === "invalid_union") {
+        issue.errors.map((issues) => processError({ issues }));
+      } else if (issue.code === "invalid_key") {
+        processError({ issues: issue.issues });
+      } else if (issue.code === "invalid_element") {
+        processError({ issues: issue.issues });
+      } else if (issue.path.length === 0) {
+        fieldErrors._errors.push(mapper(issue));
       } else {
-        this.#map.delete(key);
-      }
-    }
-  }
-  #getNumberValue(key) {
-    let value = this.#map.get(key);
-    if (value) {
-      if (typeof value === "string") {
-        let v = parseInt(value, 10);
-        if (!isNaN(v)) {
-          this.#map.set(key, v);
-          return v;
-        } else {
-          this.#map.delete(key);
+        let curr = fieldErrors;
+        let i = 0;
+        while (i < issue.path.length) {
+          const el = issue.path[i];
+          const terminal = i === issue.path.length - 1;
+          if (!terminal) {
+            curr[el] = curr[el] || { _errors: [] };
+          } else {
+            curr[el] = curr[el] || { _errors: [] };
+            curr[el]._errors.push(mapper(issue));
+          }
+          curr = curr[el];
+          i++;
         }
-      } else if (typeof value === "number") {
-        return value;
-      } else {
-        this.#map.delete(key);
-      }
-    }
-  }
-  #getHeaderValue(key, ctor) {
-    let value = this.#map.get(key);
-    if (value) {
-      if (typeof value === "string") {
-        let headerValue = new ctor(value);
-        this.#map.set(key, headerValue);
-        return headerValue;
-      } else {
-        return value;
       }
-    } else {
-      let headerValue = new ctor;
-      this.#map.set(key, headerValue);
-      return headerValue;
     }
+  };
+  processError(error);
+  return fieldErrors;
+}
+
+// ../../node_modules/@zod/core/dist/esm/parse.js
+function _parse(schema, value, _ctx) {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError;
   }
-  #setHeaderValue(key, ctor, value) {
-    if (typeof value === "string" || value instanceof ctor) {
-      this.#map.set(key, value);
-    } else {
-      this.#map.set(key, new ctor(value));
-    }
+  if (result.issues.length) {
+    throw new (this?.Error ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
   }
+  return result.value;
 }
-// src/app.ts
-function normalizePath(urlPath) {
-  return (urlPath.endsWith("/") ? urlPath.substring(0, urlPath.length - 1) : urlPath).toLowerCase() || "/";
-}
-var mergeAll = import_deepmerge.default({ all: true });
 
-class HSRequestContext {
-  req;
-  locals;
-  headers;
-  route;
-  constructor(req, params = {}) {
-    this.req = req;
-    this.locals = {};
-    this.route = {
-      params,
-      query: new URL(req.url).searchParams
-    };
-    const allowHeaders = ["cookie"];
-    const reqHeaders = {};
-    for (let [name, value] of req.headers) {
-      if (allowHeaders.includes(name)) {
-        reqHeaders[name] = value;
-      }
-    }
-    this.headers = new SuperHeaders(reqHeaders);
+// ../../node_modules/zod/dist/esm/errors.js
+class ZodError extends $ZodError {
+  format(mapper) {
+    return formatError(this, mapper);
   }
-  resMerge(res) {
-    const cHeaders = {};
-    for (let [name, value] of this.headers) {
-      cHeaders[name] = value;
-    }
-    const newRes = new Response(res.body, mergeAll({ headers: cHeaders }, { headers: res.headers.toJSON() }, { status: res.status, statusText: res.statusText }));
-    return newRes;
+  flatten(mapper) {
+    return flattenError(this, mapper);
   }
-  html(content, options) {
-    return new Response(content, mergeAll({ headers: { "Content-Type": "text/html" } }, options));
+  addIssue(issue) {
+    this.issues.push(issue);
   }
-  json(content, options) {
-    return new Response(JSON.stringify(content), mergeAll({ headers: { "Content-Type": "application/json" } }, options));
+  addIssues(issues) {
+    this.issues.push(...issues);
   }
-  notFound(msg = "Not found!") {
-    return this.html(msg, { status: 404 });
+  get isEmpty() {
+    return this.issues.length === 0;
   }
 }
 
-class HSApp {
-  _router;
-  _mw;
-  _defaultRoute;
-  constructor() {
-    this._router = new import_trek_router.default;
-    this._mw = new import_trek_middleware.default;
-    this._defaultRoute = (c) => {
-      return c.notFound("Not found");
-    };
+// ../../node_modules/zod/dist/esm/parse.js
+var parse = /* @__PURE__ */ _parse.bind({ Error: ZodError });
+
+// src/server.ts
+var IS_PROD2 = false;
+var CWD = process.cwd();
+function createRoute(handler) {
+  return new HSRoute(handler);
+}
+function createComponent(render2) {
+  return new HSComponent(render2);
+}
+function createForm(renderForm, schema) {
+  return new HSFormRoute(renderForm, schema);
+}
+var HS_DEFAULT_LOADING = () => html`<div>Loading...</div>`;
+
+class HSComponent {
+  _kind = "hsComponent";
+  _handlers = {};
+  _loading;
+  render;
+  constructor(render2) {
+    this.render = render2;
+  }
+  loading(fn) {
+    this._loading = fn;
+    return this;
   }
-  get(path, handler) {
-    return this._route("GET", path, handler);
+}
+
+class HSRoute {
+  _kind = "hsRoute";
+  _handlers = {};
+  _methods = null;
+  constructor(handler) {
+    this._handlers.GET = handler;
   }
-  post(path, handler) {
-    return this._route("POST", path, handler);
+}
+
+class HSFormRoute {
+  _kind = "hsFormRoute";
+  _handlers = {};
+  _form;
+  _methods = null;
+  _schema = null;
+  constructor(renderForm, schema = null) {
+    if (schema) {
+      this._form = renderForm;
+      this._schema = schema;
+    } else {
+      this._form = renderForm;
+    }
+    this._handlers.GET = () => renderForm(this.getDefaultData());
   }
-  put(path, handler) {
-    return this._route("PUT", path, handler);
+  getDefaultData() {
+    if (!this._schema) {
+      return {};
+    }
+    const data = parse(this._schema, {});
+    return data;
   }
-  delete(path, handler) {
-    return this._route("DELETE", path, handler);
+  renderForm(data) {
+    return this._form(data || this.getDefaultData());
   }
-  all(path, handler) {
-    return this.addRoute(["GET", "POST", "PUT", "PATCH", "DELETE"], path, handler);
+  get(handler) {
+    this._handlers.GET = handler;
+    return this;
   }
-  addRoute(methods, path, handler) {
-    methods.forEach((method) => {
-      this._route(method, path, handler);
-    });
+  patch(handler) {
+    this._handlers.PATCH = handler;
     return this;
   }
-  defaultRoute(handler) {
-    this._defaultRoute = handler;
+  post(handler) {
+    this._handlers.POST = handler;
+    return this;
   }
-  _route(method, path, handler) {
-    this._router.add(method, path, handler);
+  put(handler) {
+    this._handlers.PUT = handler;
     return this;
   }
-  async run(req) {
-    let response;
-    let url = new URL(req.url);
-    let urlPath = normalizePath(url.pathname);
-    if (urlPath !== url.pathname) {
-      url.pathname = urlPath;
-      return Response.redirect(url);
-    }
-    let result = this._router.find(req.method.toUpperCase(), urlPath);
-    let params = {};
-    if (result && result[0]) {
-      result[1].forEach((param) => params[param.name] = param.value);
-      const context2 = new HSRequestContext(req, params);
-      response = result[0](context2);
-    }
-    if (response) {
-      return response;
-    }
-    const context = new HSRequestContext(req);
-    return this._defaultRoute(context);
+  delete(handler) {
+    this._handlers.DELETE = handler;
+    return this;
   }
 }
-
-// src/server.ts
-function requestIsBot(req) {
-  const ua = req.headers.get("User-Agent");
-  return ua ? isbot(ua) : false;
-}
-async function runFileRoute(routeFile, context) {
+async function runFileRoute(RouteModule, context) {
   const req = context.req;
   const url = new URL(req.url);
   const qs = url.searchParams;
+  const userIsBot = isbot(context.req.header("User-Agent"));
   const streamOpt = qs.get("__nostream") ? !Boolean(qs.get("__nostream")) : undefined;
-  const streamingEnabled = streamOpt !== undefined ? streamOpt : true;
-  const RouteModule = _routeCache[routeFile] || await import(routeFile);
-  if (IS_PROD) {
-    _routeCache[routeFile] = RouteModule;
-  }
+  const streamingEnabled = !userIsBot && (streamOpt !== undefined ? streamOpt : true);
   const RouteComponent = RouteModule.default;
   const reqMethod = req.method.toUpperCase();
-  const routeMiddleware = RouteModule.middleware || {};
-  const middlewareResult = {};
   try {
-    if (Object.keys(routeMiddleware).length) {
-      for (const mKey in routeMiddleware) {
-        const mRes = await routeMiddleware[mKey](context);
-        if (mRes instanceof Response) {
-          return context.resMerge(mRes);
-        }
-        middlewareResult[mKey] = mRes;
-      }
-    }
     if (RouteModule[reqMethod] !== undefined) {
-      return await runAPIRoute(RouteModule[reqMethod], context, middlewareResult);
+      return await runAPIRoute(RouteModule[reqMethod], context);
+    }
+    let routeContent;
+    if (!RouteComponent) {
+      throw new Error("No route was exported by default in matched route file.");
+    }
+    if (typeof RouteComponent._handlers !== "undefined") {
+      const routeMethodHandler = RouteComponent._handlers[reqMethod];
+      if (!routeMethodHandler) {
+        return new Response("Method Not Allowed", {
+          status: 405,
+          headers: { "content-type": "text/plain" }
+        });
+      }
+      routeContent = await routeMethodHandler(context);
+    } else {
+      routeContent = await RouteComponent(context);
     }
-    const routeContent = await RouteComponent(context, middlewareResult);
     if (routeContent instanceof Response) {
-      return context.resMerge(routeContent);
+      return routeContent;
     }
-    if (streamingEnabled && !requestIsBot(req)) {
-      return context.resMerge(new StreamResponse(renderToStream(routeContent)));
-    } else {
-      const output = await renderToString(routeContent);
-      return context.html(output);
+    if (routeContent instanceof TmplHtml) {
+      if (streamingEnabled) {
+        return new StreamResponse(renderStream(routeContent));
+      } else {
+        const output = await renderAsync(routeContent);
+        return context.html(output);
+      }
     }
+    return routeContent;
   } catch (e) {
     console.error(e);
     return await showErrorReponse(context, e);
@@ -1765,26 +2337,31 @@ async function runAPIRoute(routeFn, context, middlewareResult) {
       meta: { success: false },
       data: {
         message: e.message,
-        stack: IS_PROD ? undefined : e.stack?.split("\n")
+        stack: IS_PROD2 ? undefined : e.stack?.split(`
+`)
       }
     }, { status: 500 });
   }
 }
 async function showErrorReponse(context, err) {
-  const output = await renderToString(html`
+  const output = render(html`
     <main>
       <h1>Error</h1>
       <pre>${err.message}</pre>
-      <pre>${!IS_PROD && err.stack ? err.stack.split("\n").slice(1).join("\n") : ""}</pre>
+      <pre>${!IS_PROD2 && err.stack ? err.stack.split(`
+`).slice(1).join(`
+`) : ""}</pre>
     </main>
   `);
   return context.html(output, {
     status: 500
   });
 }
-async function buildRoutes(config) {
-  const routesDir = join(config.appDir, "routes");
-  const files = await readdir(routesDir, { recursive: true });
+var ROUTE_SEGMENT = /(\[[a-zA-Z_\.]+\])/g;
+async function buildRoutes(config2) {
+  const routesDir = join(config2.appDir, "routes");
+  console.log(routesDir);
+  const files = await readdir2(routesDir, { recursive: true });
   const routes = [];
   for (const file of files) {
     if (!file.includes(".") || basename(file).startsWith(".")) {
@@ -1798,7 +2375,7 @@ async function buildRoutes(config) {
     const dynamicPaths = ROUTE_SEGMENT.test(route);
     if (dynamicPaths) {
       params = [];
-      route = route.replace(ROUTE_SEGMENT, (match, p1, offset) => {
+      route = route.replace(ROUTE_SEGMENT, (match) => {
         const paramName = match.replace(/[^a-zA-Z_\.]+/g, "");
         if (match.includes("...")) {
           params.push(paramName.replace("...", ""));
@@ -1817,75 +2394,58 @@ async function buildRoutes(config) {
   }
   return routes;
 }
-async function createServer(config) {
+async function createServer(config2) {
   await Promise.all([buildClientJS(), buildClientCSS()]);
-  const app = new HSApp;
-  app.defaultRoute(() => {
-    return new Response("Not... found?", { status: 404 });
-  });
-  config.beforeRoutesAdded && config.beforeRoutesAdded(app);
-  const fileRoutes = await buildRoutes(config);
+  const app = new Hono2;
+  config2.beforeRoutesAdded && config2.beforeRoutesAdded(app);
+  const fileRoutes = await buildRoutes(config2);
   const routeMap = [];
   for (let i = 0;i < fileRoutes.length; i++) {
     let route = fileRoutes[i];
     const fullRouteFile = join(CWD, route.file);
     const routePattern = normalizePath(route.route);
     routeMap.push({ route: routePattern, file: route.file });
+    const routeModule = await import(fullRouteFile);
     app.all(routePattern, async (context) => {
-      const matchedRoute = await runFileRoute(fullRouteFile, context);
+      const matchedRoute = await runFileRoute(routeModule, context);
       if (matchedRoute) {
         return matchedRoute;
       }
-      return app._defaultRoute(context);
+      return context.notFound();
     });
   }
-  if (!IS_PROD) {
+  if (routeMap.length === 0) {
+    app.get("/", (context) => {
+      return context.text("No routes found. Add routes to app/routes. Example: `app/routes/index.ts`", { status: 404 });
+    });
+  }
+  if (!IS_PROD2) {
     console.log("[Hyperspan] File system routes (in app/routes):");
     console.table(routeMap);
   }
-  config.afterRoutesAdded && config.afterRoutesAdded(app);
-  app.all("*", (context) => {
-    const req = context.req;
-    if (STATIC_FILE_MATCHER.test(req.url)) {
-      const filePath = config.staticFileRoot + new URL(req.url).pathname;
-      const file = Bun.file(filePath);
-      let headers = {};
-      if (IS_PROD) {
-        headers = {
-          "cache-control": "public, max-age=31557600"
-        };
-      }
-      return new Response(file, { headers });
-    }
-    return app._defaultRoute(context);
+  config2.afterRoutesAdded && config2.afterRoutesAdded(app);
+  app.use("*", serveStatic2({
+    root: config2.staticFileRoot
+  }));
+  app.notFound((context) => {
+    return context.text("Not... found?", { status: 404 });
   });
   return app;
 }
-async function buildClientJS() {
-  const sourceFile = resolve(PWD, "../", "./src/clientjs/hyperspan-client.ts");
-  const output = await Bun.build({
-    entrypoints: [sourceFile],
-    outdir: `./public/_hs/js`,
-    naming: IS_PROD ? "[dir]/[name]-[hash].[ext]" : undefined,
-    minify: IS_PROD
-  });
-  clientJSFile = output.outputs[0].path.split("/").reverse()[0];
-  return clientJSFile;
-}
-async function buildClientCSS() {
-  if (clientCSSFile) {
-    return clientCSSFile;
-  }
-  const cssDir = "./public/_hs/css/";
-  const cssFiles = await readdir(cssDir);
-  for (const file of cssFiles) {
-    if (clientCSSFile || !file.endsWith(".css")) {
-      continue;
-    }
-    return clientCSSFile = file.replace(cssDir, "");
-  }
-  if (!clientCSSFile) {
-    throw new Error(`Unable to build CSS files from ${cssDir}`);
+
+class StreamResponse extends Response {
+  constructor(iterator, options = {}) {
+    super();
+    const stream = createReadableStreamFromAsyncGenerator(iterator);
+    return new Response(stream, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/html",
+        "Transfer-Encoding": "chunked",
+        ...options?.headers ?? {}
+      },
+      ...options
+    });
   }
 }
 function createReadableStreamFromAsyncGenerator(output) {
@@ -1903,43 +2463,22 @@ function createReadableStreamFromAsyncGenerator(output) {
     }
   });
 }
-function formRoute(handlerFn) {
-  return function _formRouteHandler(context) {
-  };
-}
-var IS_PROD = false;
-var PWD = import.meta.dir;
-var CWD = process.cwd();
-var STATIC_FILE_MATCHER = /[^/\\&\?]+\.([a-zA-Z]+)$/;
-var _routeCache = {};
-var ROUTE_SEGMENT = /(\[[a-zA-Z_\.]+\])/g;
-var clientJSFile;
-var clientCSSFile;
-
-class StreamResponse {
-  constructor(iterator, options = {}) {
-    const stream = createReadableStreamFromAsyncGenerator(iterator);
-    return new Response(stream, {
-      status: 200,
-      headers: {
-        "Content-Type": "text/html",
-        "Transfer-Encoding": "chunked",
-        ...options?.headers ?? {}
-      },
-      ...options
-    });
-  }
+function normalizePath(urlPath) {
+  return (urlPath.endsWith("/") ? urlPath.substring(0, urlPath.length - 1) : urlPath).toLowerCase() || "/";
 }
 export {
   runFileRoute,
-  formRoute,
+  normalizePath,
   createServer,
+  createRoute,
   createReadableStreamFromAsyncGenerator,
-  clientJSFile,
-  clientCSSFile,
+  createForm,
+  createComponent,
   buildRoutes,
-  buildClientJS,
-  buildClientCSS,
   StreamResponse,
-  IS_PROD
+  IS_PROD2 as IS_PROD,
+  HS_DEFAULT_LOADING,
+  HSRoute,
+  HSFormRoute,
+  HSComponent
 };