@depup/hono 4.12.8-depup.0

package/dist/cjs/helper/cookie/index.js

@@ -0,0 +1,130 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cookie_exports = {};
+__export(cookie_exports, {
+  deleteCookie: () => deleteCookie,
+  generateCookie: () => generateCookie,
+  generateSignedCookie: () => generateSignedCookie,
+  getCookie: () => getCookie,
+  getSignedCookie: () => getSignedCookie,
+  setCookie: () => setCookie,
+  setSignedCookie: () => setSignedCookie
+});
+module.exports = __toCommonJS(cookie_exports);
+var import_cookie = require("../../utils/cookie");
+const getCookie = (c, key, prefix) => {
+  const cookie = c.req.raw.headers.get("Cookie");
+  if (typeof key === "string") {
+    if (!cookie) {
+      return void 0;
+    }
+    let finalKey = key;
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    }
+    const obj2 = (0, import_cookie.parse)(cookie, finalKey);
+    return obj2[finalKey];
+  }
+  if (!cookie) {
+    return {};
+  }
+  const obj = (0, import_cookie.parse)(cookie);
+  return obj;
+};
+const getSignedCookie = async (c, secret, key, prefix) => {
+  const cookie = c.req.raw.headers.get("Cookie");
+  if (typeof key === "string") {
+    if (!cookie) {
+      return void 0;
+    }
+    let finalKey = key;
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    }
+    const obj2 = await (0, import_cookie.parseSigned)(cookie, secret, finalKey);
+    return obj2[finalKey];
+  }
+  if (!cookie) {
+    return {};
+  }
+  const obj = await (0, import_cookie.parseSigned)(cookie, secret);
+  return obj;
+};
+const generateCookie = (name, value, opt) => {
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = (0, import_cookie.serialize)("__Secure-" + name, value, { path: "/", ...opt, secure: true });
+  } else if (opt?.prefix === "host") {
+    cookie = (0, import_cookie.serialize)("__Host-" + name, value, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = (0, import_cookie.serialize)(name, value, { path: "/", ...opt });
+  }
+  return cookie;
+};
+const setCookie = (c, name, value, opt) => {
+  const cookie = generateCookie(name, value, opt);
+  c.header("Set-Cookie", cookie, { append: true });
+};
+const generateSignedCookie = async (name, value, secret, opt) => {
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = await (0, import_cookie.serializeSigned)("__Secure-" + name, value, secret, {
+      path: "/",
+      ...opt,
+      secure: true
+    });
+  } else if (opt?.prefix === "host") {
+    cookie = await (0, import_cookie.serializeSigned)("__Host-" + name, value, secret, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = await (0, import_cookie.serializeSigned)(name, value, secret, { path: "/", ...opt });
+  }
+  return cookie;
+};
+const setSignedCookie = async (c, name, value, secret, opt) => {
+  const cookie = await generateSignedCookie(name, value, secret, opt);
+  c.header("set-cookie", cookie, { append: true });
+};
+const deleteCookie = (c, name, opt) => {
+  const deletedCookie = getCookie(c, name, opt?.prefix);
+  setCookie(c, name, "", { ...opt, maxAge: 0 });
+  return deletedCookie;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteCookie,
+  generateCookie,
+  generateSignedCookie,
+  getCookie,
+  getSignedCookie,
+  setCookie,
+  setSignedCookie
+});

package/dist/cjs/helper/css/common.js

@@ -0,0 +1,222 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+__export(common_exports, {
+  CLASS_NAME: () => CLASS_NAME,
+  DEFAULT_STYLE_ID: () => DEFAULT_STYLE_ID,
+  EXTERNAL_CLASS_NAMES: () => EXTERNAL_CLASS_NAMES,
+  IS_CSS_ESCAPED: () => IS_CSS_ESCAPED,
+  PSEUDO_GLOBAL_SELECTOR: () => PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR: () => SELECTOR,
+  SELECTORS: () => SELECTORS,
+  STYLE_STRING: () => STYLE_STRING,
+  buildStyleString: () => buildStyleString,
+  cssCommon: () => cssCommon,
+  cxCommon: () => cxCommon,
+  isPseudoGlobalSelectorRe: () => isPseudoGlobalSelectorRe,
+  keyframesCommon: () => keyframesCommon,
+  minify: () => minify,
+  rawCssString: () => rawCssString,
+  viewTransitionCommon: () => viewTransitionCommon
+});
+module.exports = __toCommonJS(common_exports);
+const PSEUDO_GLOBAL_SELECTOR = ":-hono-global";
+const isPseudoGlobalSelectorRe = new RegExp(`^${PSEUDO_GLOBAL_SELECTOR}{(.*)}$`);
+const DEFAULT_STYLE_ID = "hono-css";
+const SELECTOR = /* @__PURE__ */ Symbol();
+const CLASS_NAME = /* @__PURE__ */ Symbol();
+const STYLE_STRING = /* @__PURE__ */ Symbol();
+const SELECTORS = /* @__PURE__ */ Symbol();
+const EXTERNAL_CLASS_NAMES = /* @__PURE__ */ Symbol();
+const CSS_ESCAPED = /* @__PURE__ */ Symbol();
+const IS_CSS_ESCAPED = /* @__PURE__ */ Symbol();
+const rawCssString = (value) => {
+  return {
+    [CSS_ESCAPED]: value
+  };
+};
+const toHash = (str) => {
+  let i = 0, out = 11;
+  while (i < str.length) {
+    out = 101 * out + str.charCodeAt(i++) >>> 0;
+  }
+  return "css-" + out;
+};
+const cssStringReStr = [
+  '"(?:(?:\\\\[\\s\\S]|[^"\\\\])*)"',
+  // double quoted string
+  "'(?:(?:\\\\[\\s\\S]|[^'\\\\])*)'"
+  // single quoted string
+].join("|");
+const minifyCssRe = new RegExp(
+  [
+    "(" + cssStringReStr + ")",
+    // $1: quoted string
+    "(?:" + [
+      "^\\s+",
+      // head whitespace
+      "\\/\\*.*?\\*\\/\\s*",
+      // multi-line comment
+      "\\/\\/.*\\n\\s*",
+      // single-line comment
+      "\\s+$"
+      // tail whitespace
+    ].join("|") + ")",
+    "\\s*;\\s*(}|$)\\s*",
+    // $2: trailing semicolon
+    "\\s*([{};:,])\\s*",
+    // $3: whitespace around { } : , ;
+    "(\\s)\\s+"
+    // $4: 2+ spaces
+  ].join("|"),
+  "g"
+);
+const minify = (css) => {
+  return css.replace(minifyCssRe, (_, $1, $2, $3, $4) => $1 || $2 || $3 || $4 || "");
+};
+const buildStyleString = (strings, values) => {
+  const selectors = [];
+  const externalClassNames = [];
+  const label = strings[0].match(/^\s*\/\*(.*?)\*\//)?.[1] || "";
+  let styleString = "";
+  for (let i = 0, len = strings.length; i < len; i++) {
+    styleString += strings[i];
+    let vArray = values[i];
+    if (typeof vArray === "boolean" || vArray === null || vArray === void 0) {
+      continue;
+    }
+    if (!Array.isArray(vArray)) {
+      vArray = [vArray];
+    }
+    for (let j = 0, len2 = vArray.length; j < len2; j++) {
+      let value = vArray[j];
+      if (typeof value === "boolean" || value === null || value === void 0) {
+        continue;
+      }
+      if (typeof value === "string") {
+        if (/([\\"'\/])/.test(value)) {
+          styleString += value.replace(/([\\"']|(?<=<)\/)/g, "\\$1");
+        } else {
+          styleString += value;
+        }
+      } else if (typeof value === "number") {
+        styleString += value;
+      } else if (value[CSS_ESCAPED]) {
+        styleString += value[CSS_ESCAPED];
+      } else if (value[CLASS_NAME].startsWith("@keyframes ")) {
+        selectors.push(value);
+        styleString += ` ${value[CLASS_NAME].substring(11)} `;
+      } else {
+        if (strings[i + 1]?.match(/^\s*{/)) {
+          selectors.push(value);
+          value = `.${value[CLASS_NAME]}`;
+        } else {
+          selectors.push(...value[SELECTORS]);
+          externalClassNames.push(...value[EXTERNAL_CLASS_NAMES]);
+          value = value[STYLE_STRING];
+          const valueLen = value.length;
+          if (valueLen > 0) {
+            const lastChar = value[valueLen - 1];
+            if (lastChar !== ";" && lastChar !== "}") {
+              value += ";";
+            }
+          }
+        }
+        styleString += `${value || ""}`;
+      }
+    }
+  }
+  return [label, minify(styleString), selectors, externalClassNames];
+};
+const cssCommon = (strings, values) => {
+  let [label, thisStyleString, selectors, externalClassNames] = buildStyleString(strings, values);
+  const isPseudoGlobal = isPseudoGlobalSelectorRe.exec(thisStyleString);
+  if (isPseudoGlobal) {
+    thisStyleString = isPseudoGlobal[1];
+  }
+  const selector = (isPseudoGlobal ? PSEUDO_GLOBAL_SELECTOR : "") + toHash(label + thisStyleString);
+  const className = (isPseudoGlobal ? selectors.map((s) => s[CLASS_NAME]) : [selector, ...externalClassNames]).join(" ");
+  return {
+    [SELECTOR]: selector,
+    [CLASS_NAME]: className,
+    [STYLE_STRING]: thisStyleString,
+    [SELECTORS]: selectors,
+    [EXTERNAL_CLASS_NAMES]: externalClassNames
+  };
+};
+const cxCommon = (args) => {
+  for (let i = 0, len = args.length; i < len; i++) {
+    const arg = args[i];
+    if (typeof arg === "string") {
+      args[i] = {
+        [SELECTOR]: "",
+        [CLASS_NAME]: "",
+        [STYLE_STRING]: "",
+        [SELECTORS]: [],
+        [EXTERNAL_CLASS_NAMES]: [arg]
+      };
+    }
+  }
+  return args;
+};
+const keyframesCommon = (strings, ...values) => {
+  const [label, styleString] = buildStyleString(strings, values);
+  return {
+    [SELECTOR]: "",
+    [CLASS_NAME]: `@keyframes ${toHash(label + styleString)}`,
+    [STYLE_STRING]: styleString,
+    [SELECTORS]: [],
+    [EXTERNAL_CLASS_NAMES]: []
+  };
+};
+let viewTransitionNameIndex = 0;
+const viewTransitionCommon = ((strings, values) => {
+  if (!strings) {
+    strings = [`/* h-v-t ${viewTransitionNameIndex++} */`];
+  }
+  const content = Array.isArray(strings) ? cssCommon(strings, values) : strings;
+  const transitionName = content[CLASS_NAME];
+  const res = cssCommon(["view-transition-name:", ""], [transitionName]);
+  content[CLASS_NAME] = PSEUDO_GLOBAL_SELECTOR + content[CLASS_NAME];
+  content[STYLE_STRING] = content[STYLE_STRING].replace(
+    /(?<=::view-transition(?:[a-z-]*)\()(?=\))/g,
+    transitionName
+  );
+  res[CLASS_NAME] = res[SELECTOR] = transitionName;
+  res[SELECTORS] = [...content[SELECTORS], content];
+  return res;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLASS_NAME,
+  DEFAULT_STYLE_ID,
+  EXTERNAL_CLASS_NAMES,
+  IS_CSS_ESCAPED,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
+  buildStyleString,
+  cssCommon,
+  cxCommon,
+  isPseudoGlobalSelectorRe,
+  keyframesCommon,
+  minify,
+  rawCssString,
+  viewTransitionCommon
+});

package/dist/cjs/helper/css/index.js

@@ -0,0 +1,142 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var css_exports = {};
+__export(css_exports, {
+  Style: () => Style,
+  createCssContext: () => createCssContext,
+  css: () => css,
+  cx: () => cx,
+  keyframes: () => keyframes,
+  rawCssString: () => import_common2.rawCssString,
+  viewTransition: () => viewTransition
+});
+module.exports = __toCommonJS(css_exports);
+var import_html = require("../../helper/html");
+var import_constants = require("../../jsx/constants");
+var import_css = require("../../jsx/dom/css");
+var import_common = require("./common");
+var import_common2 = require("./common");
+const createCssContext = ({ id }) => {
+  const [cssJsxDomObject, StyleRenderToDom] = (0, import_css.createCssJsxDomObjects)({ id });
+  const contextMap = /* @__PURE__ */ new WeakMap();
+  const nonceMap = /* @__PURE__ */ new WeakMap();
+  const replaceStyleRe = new RegExp(`(<style id="${id}"(?: nonce="[^"]*")?>.*?)(</style>)`);
+  const newCssClassNameObject = (cssClassName) => {
+    const appendStyle = ({ buffer, context }) => {
+      const [toAdd, added] = contextMap.get(context);
+      const names = Object.keys(toAdd);
+      if (!names.length) {
+        return;
+      }
+      let stylesStr = "";
+      names.forEach((className2) => {
+        added[className2] = true;
+        stylesStr += className2.startsWith(import_common.PSEUDO_GLOBAL_SELECTOR) ? toAdd[className2] : `${className2[0] === "@" ? "" : "."}${className2}{${toAdd[className2]}}`;
+      });
+      contextMap.set(context, [{}, added]);
+      if (buffer && replaceStyleRe.test(buffer[0])) {
+        buffer[0] = buffer[0].replace(replaceStyleRe, (_, pre, post) => `${pre}${stylesStr}${post}`);
+        return;
+      }
+      const nonce = nonceMap.get(context);
+      const appendStyleScript = `<script${nonce ? ` nonce="${nonce}"` : ""}>document.querySelector('#${id}').textContent+=${JSON.stringify(stylesStr)}</script>`;
+      if (buffer) {
+        buffer[0] = `${appendStyleScript}${buffer[0]}`;
+        return;
+      }
+      return Promise.resolve(appendStyleScript);
+    };
+    const addClassNameToContext = ({ context }) => {
+      if (!contextMap.has(context)) {
+        contextMap.set(context, [{}, {}]);
+      }
+      const [toAdd, added] = contextMap.get(context);
+      let allAdded = true;
+      if (!added[cssClassName[import_common.SELECTOR]]) {
+        allAdded = false;
+        toAdd[cssClassName[import_common.SELECTOR]] = cssClassName[import_common.STYLE_STRING];
+      }
+      cssClassName[import_common.SELECTORS].forEach(
+        ({ [import_common.CLASS_NAME]: className2, [import_common.STYLE_STRING]: styleString }) => {
+          if (!added[className2]) {
+            allAdded = false;
+            toAdd[className2] = styleString;
+          }
+        }
+      );
+      if (allAdded) {
+        return;
+      }
+      return Promise.resolve((0, import_html.raw)("", [appendStyle]));
+    };
+    const className = new String(cssClassName[import_common.CLASS_NAME]);
+    Object.assign(className, cssClassName);
+    className.isEscaped = true;
+    className.callbacks = [addClassNameToContext];
+    const promise = Promise.resolve(className);
+    Object.assign(promise, cssClassName);
+    promise.toString = cssJsxDomObject.toString;
+    return promise;
+  };
+  const css2 = (strings, ...values) => {
+    return newCssClassNameObject((0, import_common.cssCommon)(strings, values));
+  };
+  const cx2 = (...args) => {
+    args = (0, import_common.cxCommon)(args);
+    return css2(Array(args.length).fill(""), ...args);
+  };
+  const keyframes2 = import_common.keyframesCommon;
+  const viewTransition2 = ((strings, ...values) => {
+    return newCssClassNameObject((0, import_common.viewTransitionCommon)(strings, values));
+  });
+  const Style2 = ({ children, nonce } = {}) => (0, import_html.raw)(
+    `<style id="${id}"${nonce ? ` nonce="${nonce}"` : ""}>${children ? children[import_common.STYLE_STRING] : ""}</style>`,
+    [
+      ({ context }) => {
+        nonceMap.set(context, nonce);
+        return void 0;
+      }
+    ]
+  );
+  Style2[import_constants.DOM_RENDERER] = StyleRenderToDom;
+  return {
+    css: css2,
+    cx: cx2,
+    keyframes: keyframes2,
+    viewTransition: viewTransition2,
+    Style: Style2
+  };
+};
+const defaultContext = createCssContext({
+  id: import_common.DEFAULT_STYLE_ID
+});
+const css = defaultContext.css;
+const cx = defaultContext.cx;
+const keyframes = defaultContext.keyframes;
+const viewTransition = defaultContext.viewTransition;
+const Style = defaultContext.Style;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Style,
+  createCssContext,
+  css,
+  cx,
+  keyframes,
+  rawCssString,
+  viewTransition
+});

package/dist/cjs/helper/dev/index.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dev_exports = {};
+__export(dev_exports, {
+  getRouterName: () => getRouterName,
+  inspectRoutes: () => inspectRoutes,
+  showRoutes: () => showRoutes
+});
+module.exports = __toCommonJS(dev_exports);
+var import_color = require("../../utils/color");
+var import_handler = require("../../utils/handler");
+const handlerName = (handler) => {
+  return handler.name || ((0, import_handler.isMiddleware)(handler) ? "[middleware]" : "[handler]");
+};
+const inspectRoutes = (hono) => {
+  return hono.routes.map(({ path, method, handler }) => {
+    const targetHandler = (0, import_handler.findTargetHandler)(handler);
+    return {
+      path,
+      method,
+      name: handlerName(targetHandler),
+      isMiddleware: (0, import_handler.isMiddleware)(targetHandler)
+    };
+  });
+};
+const showRoutes = (hono, opts) => {
+  const colorEnabled = opts?.colorize ?? (0, import_color.getColorEnabled)();
+  const routeData = {};
+  let maxMethodLength = 0;
+  let maxPathLength = 0;
+  inspectRoutes(hono).filter(({ isMiddleware: isMiddleware2 }) => opts?.verbose || !isMiddleware2).map((route) => {
+    const key = `${route.method}-${route.path}`;
+    (routeData[key] ||= []).push(route);
+    if (routeData[key].length > 1) {
+      return;
+    }
+    maxMethodLength = Math.max(maxMethodLength, route.method.length);
+    maxPathLength = Math.max(maxPathLength, route.path.length);
+    return { method: route.method, path: route.path, routes: routeData[key] };
+  }).forEach((data) => {
+    if (!data) {
+      return;
+    }
+    const { method, path, routes } = data;
+    const methodStr = colorEnabled ? `\x1B[32m${method}\x1B[0m` : method;
+    console.log(`${methodStr} ${" ".repeat(maxMethodLength - method.length)} ${path}`);
+    if (!opts?.verbose) {
+      return;
+    }
+    routes.forEach(({ name }) => {
+      console.log(`${" ".repeat(maxMethodLength + 3)} ${name}`);
+    });
+  });
+};
+const getRouterName = (app) => {
+  app.router.match("GET", "/");
+  return app.router.name;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRouterName,
+  inspectRoutes,
+  showRoutes
+});

package/dist/cjs/helper/factory/index.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  Factory: () => Factory,
+  createFactory: () => createFactory,
+  createMiddleware: () => createMiddleware
+});
+module.exports = __toCommonJS(factory_exports);
+var import_hono = require("../../hono");
+class Factory {
+  initApp;
+  #defaultAppOptions;
+  constructor(init) {
+    this.initApp = init?.initApp;
+    this.#defaultAppOptions = init?.defaultAppOptions;
+  }
+  createApp = (options) => {
+    const app = new import_hono.Hono(
+      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions
+    );
+    if (this.initApp) {
+      this.initApp(app);
+    }
+    return app;
+  };
+  createMiddleware = (middleware) => middleware;
+  createHandlers = (...handlers) => {
+    return handlers.filter((handler) => handler !== void 0);
+  };
+}
+const createFactory = (init) => new Factory(init);
+const createMiddleware = (middleware) => middleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Factory,
+  createFactory,
+  createMiddleware
+});

package/dist/cjs/helper/html/index.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var html_exports = {};
+__export(html_exports, {
+  html: () => html,
+  raw: () => import_html.raw
+});
+module.exports = __toCommonJS(html_exports);
+var import_html = require("../../utils/html");
+const html = (strings, ...values) => {
+  const buffer = [""];
+  for (let i = 0, len = strings.length - 1; i < len; i++) {
+    buffer[0] += strings[i];
+    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
+    for (let i2 = 0, len2 = children.length; i2 < len2; i2++) {
+      const child = children[i2];
+      if (typeof child === "string") {
+        (0, import_html.escapeToBuffer)(child, buffer);
+      } else if (typeof child === "number") {
+        ;
+        buffer[0] += child;
+      } else if (typeof child === "boolean" || child === null || child === void 0) {
+        continue;
+      } else if (typeof child === "object" && child.isEscaped) {
+        if (child.callbacks) {
+          buffer.unshift("", child);
+        } else {
+          const tmp = child.toString();
+          if (tmp instanceof Promise) {
+            buffer.unshift("", tmp);
+          } else {
+            buffer[0] += tmp;
+          }
+        }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
+      } else {
+        (0, import_html.escapeToBuffer)(child.toString(), buffer);
+      }
+    }
+  }
+  buffer[0] += strings.at(-1);
+  return buffer.length === 1 ? "callbacks" in buffer ? (0, import_html.raw)((0, import_html.resolveCallbackSync)((0, import_html.raw)(buffer[0], buffer.callbacks))) : (0, import_html.raw)(buffer[0]) : (0, import_html.stringBufferToString)(buffer, buffer.callbacks);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  html,
+  raw
+});