hono 4.6.8 → 4.6.10

package/dist/cjs/jsx/dom/render.js

@@ -258,13 +258,19 @@ const applyNodeObject = (node, container, isNew) => {
   remove.forEach(removeNode);
   const childNodes = isNew ? void 0 : container.childNodes;
   let offset;
+  let insertBeforeNode = null;
   if (isNew) {
     offset = -1;
+  } else if (!childNodes.length) {
+    offset = 0;
   } else {
-    offset = (childNodes.length && (findChildNodeIndex(childNodes, findInsertBefore(node.nN)) ?? findChildNodeIndex(
-      childNodes,
-      next.find((n) => n.tag !== HONO_PORTAL_ELEMENT && n.e)?.e
-    ))) ?? -1;
+    const offsetByNextNode = findChildNodeIndex(childNodes, findInsertBefore(node.nN));
+    if (offsetByNextNode !== void 0) {
+      insertBeforeNode = childNodes[offsetByNextNode];
+      offset = offsetByNextNode;
+    } else {
+      offset = findChildNodeIndex(childNodes, next.find((n) => n.tag !== HONO_PORTAL_ELEMENT && n.e)?.e) ?? -1;
+    }
     if (offset === -1) {
       isNew = true;
     }
@@ -299,7 +305,7 @@ const applyNodeObject = (node, container, isNew) => {
       if (childNodes[offset + 1] === el) {
         container.appendChild(childNodes[offset]);
       } else {
-        container.insertBefore(el, childNodes[offset] || null);
+        container.insertBefore(el, insertBeforeNode || childNodes[offset] || null);
       }
     }
   }
@@ -381,12 +387,8 @@ const build = (context, node, children) => {
             if (typeof child.tag === "function") {
               oldChild[import_constants.DOM_STASH][2] = child[import_constants.DOM_STASH][2] || [];
               oldChild[import_constants.DOM_STASH][3] = child[import_constants.DOM_STASH][3];
-              if (!oldChild.f) {
-                const prevPropsKeys = Object.keys(pP);
-                const currentProps = oldChild.props;
-                if (prevPropsKeys.length === Object.keys(currentProps).length && prevPropsKeys.every((k) => k in currentProps && currentProps[k] === pP[k])) {
-                  oldChild.s = true;
-                }
+              if (!oldChild.f && ((oldChild.o || oldChild) === child.o || oldChild.tag[import_constants.DOM_MEMO]?.(pP, oldChild.props))) {
+                oldChild.s = true;
               }
             }
             child = oldChild;
@@ -473,7 +475,8 @@ const buildNode = (node) => {
         key: node.key,
         f: node.f,
         type: node.tag,
-        ref: node.props.ref
+        ref: node.props.ref,
+        o: node.o || node
       };
     }
     if (typeof node.tag === "function") {

package/dist/cjs/middleware/combine/index.js

@@ -51,16 +51,22 @@ const some = (...middleware) => {
   };
 };
 const every = (...middleware) => {
-  const wrappedMiddleware = middleware.map((m) => async (c, next) => {
-    const res = await m(c, next);
-    if (res === false) {
-      throw new Error("Unmet condition");
-    }
-    return res;
-  });
-  const handler = async (c, next) => (0, import_compose.compose)(wrappedMiddleware.map((m) => [[m, void 0], c.req.param()]))(c, next);
   return async function every2(c, next) {
-    await handler(c, next);
+    const currentRouteIndex = c.req.routeIndex;
+    await (0, import_compose.compose)(
+      middleware.map((m) => [
+        [
+          async (c2, next2) => {
+            c2.req.routeIndex = currentRouteIndex;
+            const res = await m(c2, next2);
+            if (res === false) {
+              throw new Error("Unmet condition");
+            }
+            return res;
+          }
+        ]
+      ])
+    )(c, next);
   };
 };
 const except = (condition, ...middleware) => {

package/dist/cjs/middleware/etag/digest.js

@@ -0,0 +1,59 @@
+"use strict";
+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 digest_exports = {};
+__export(digest_exports, {
+  generateDigest: () => generateDigest
+});
+module.exports = __toCommonJS(digest_exports);
+const mergeBuffers = (buffer1, buffer2) => {
+  if (!buffer1) {
+    return buffer2;
+  }
+  const merged = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
+  merged.set(new Uint8Array(buffer1), 0);
+  merged.set(buffer2, buffer1.byteLength);
+  return merged;
+};
+const generateDigest = async (stream) => {
+  if (!stream || !crypto || !crypto.subtle) {
+    return null;
+  }
+  let result = void 0;
+  const reader = stream.getReader();
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) {
+      break;
+    }
+    result = await crypto.subtle.digest(
+      {
+        name: "SHA-1"
+      },
+      mergeBuffers(result, value)
+    );
+  }
+  if (!result) {
+    return null;
+  }
+  return Array.prototype.map.call(new Uint8Array(result), (x) => x.toString(16).padStart(2, "0")).join("");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateDigest
+});

package/dist/cjs/middleware/etag/index.js

@@ -22,7 +22,7 @@ __export(etag_exports, {
   etag: () => etag
 });
 module.exports = __toCommonJS(etag_exports);
-var import_crypto = require("../../utils/crypto");
+var import_digest = require("./digest");
 const RETAINED_304_HEADERS = [
   "cache-control",
   "content-location",
@@ -43,7 +43,10 @@ const etag = (options) => {
     const res = c.res;
     let etag3 = res.headers.get("ETag");
     if (!etag3) {
-      const hash = await (0, import_crypto.sha1)(res.clone().body || "");
+      const hash = await (0, import_digest.generateDigest)(res.clone().body);
+      if (hash === null) {
+        return;
+      }
       etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
     }
     if (etagMatches(etag3, ifNoneMatch)) {

package/dist/cjs/middleware/ip-restriction/index.js

@@ -35,14 +35,14 @@ const buildMatcher = (rules) => {
       functionRules.push(rule);
     } else {
       if (IS_CIDR_NOTATION_REGEX.test(rule)) {
-        const splittedRule = rule.split("/");
-        const addrStr = splittedRule[0];
+        const separatedRule = rule.split("/");
+        const addrStr = separatedRule[0];
         const type2 = (0, import_ipaddr.distinctRemoteAddr)(addrStr);
         if (type2 === void 0) {
           throw new TypeError(`Invalid rule: ${rule}`);
         }
         const isIPv4 = type2 === "IPv4";
-        const prefix = parseInt(splittedRule[1]);
+        const prefix = parseInt(separatedRule[1]);
         if (isIPv4 ? prefix === 32 : prefix === 128) {
           rule = addrStr;
         } else {

package/dist/cjs/middleware/jsx-renderer/index.js

@@ -32,7 +32,8 @@ const createRenderer = (c, Layout, component, options) => (children, props) => {
   const currentLayout = component ? (0, import_jsx.jsx)(
     (props2) => component(props2, c),
     {
-      ...{ Layout, ...props }
+      Layout,
+      ...props
     },
     children
   ) : children;

package/dist/cjs/middleware/logger/index.js

@@ -40,17 +40,19 @@ const time = (start) => {
 };
 const colorStatus = (status) => {
   const colorEnabled = (0, import_color.getColorEnabled)();
-  const out = {
-    7: colorEnabled ? `\x1B[35m${status}\x1B[0m` : `${status}`,
-    5: colorEnabled ? `\x1B[31m${status}\x1B[0m` : `${status}`,
-    4: colorEnabled ? `\x1B[33m${status}\x1B[0m` : `${status}`,
-    3: colorEnabled ? `\x1B[36m${status}\x1B[0m` : `${status}`,
-    2: colorEnabled ? `\x1B[32m${status}\x1B[0m` : `${status}`,
-    1: colorEnabled ? `\x1B[32m${status}\x1B[0m` : `${status}`,
-    0: colorEnabled ? `\x1B[33m${status}\x1B[0m` : `${status}`
-  };
-  const calculateStatus = status / 100 | 0;
-  return out[calculateStatus];
+  if (colorEnabled) {
+    switch (status / 100 | 0) {
+      case 5:
+        return `\x1B[31m${status}\x1B[0m`;
+      case 4:
+        return `\x1B[33m${status}\x1B[0m`;
+      case 3:
+        return `\x1B[36m${status}\x1B[0m`;
+      case 2:
+        return `\x1B[32m${status}\x1B[0m`;
+    }
+  }
+  return `${status}`;
 };
 function log(fn, prefix, method, path, status = 0, elapsed) {
   const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;

package/dist/cjs/middleware/timing/timing.js

@@ -34,13 +34,11 @@ const getTime = () => {
 };
 const timing = (config) => {
   const options = {
-    ...{
-      total: true,
-      enabled: true,
-      totalDescription: "Total Response Time",
-      autoEnd: true,
-      crossOrigin: false
-    },
+    total: true,
+    enabled: true,
+    totalDescription: "Total Response Time",
+    autoEnd: true,
+    crossOrigin: false,
     ...config
   };
   return async function timing2(c, next) {

package/dist/cjs/request.js

@@ -23,6 +23,7 @@ __export(request_exports, {
 module.exports = __toCommonJS(request_exports);
 var import_body = require("./utils/body");
 var import_url = require("./utils/url");
+const tryDecodeURIComponent = (str) => (0, import_url.tryDecode)(str, import_url.decodeURIComponent_);
 class HonoRequest {
   raw;
   #validatedData;
@@ -37,25 +38,25 @@ class HonoRequest {
     this.#validatedData = {};
   }
   param(key) {
-    return key ? this.getDecodedParam(key) : this.getAllDecodedParams();
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
   }
-  getDecodedParam(key) {
+  #getDecodedParam(key) {
     const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-    const param = this.getParamValue(paramKey);
-    return param ? /\%/.test(param) ? (0, import_url.decodeURIComponent_)(param) : param : void 0;
+    const param = this.#getParamValue(paramKey);
+    return param ? /\%/.test(param) ? tryDecodeURIComponent(param) : param : void 0;
   }
-  getAllDecodedParams() {
+  #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]);
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value && typeof value === "string") {
-        decoded[key] = /\%/.test(value) ? (0, import_url.decodeURIComponent_)(value) : value;
+        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
       }
     }
     return decoded;
   }
-  getParamValue(paramKey) {
+  #getParamValue(paramKey) {
     return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
   }
   query(key) {
@@ -77,7 +78,7 @@ class HonoRequest {
   async parseBody(options) {
     return this.bodyCache.parsedBody ??= await (0, import_body.parseBody)(this, options);
   }
-  cachedBody = (key) => {
+  #cachedBody = (key) => {
     const { bodyCache, raw } = this;
     const cachedBody = bodyCache[key];
     if (cachedBody) {
@@ -95,19 +96,19 @@ class HonoRequest {
     return bodyCache[key] = raw[key]();
   };
   json() {
-    return this.cachedBody("json");
+    return this.#cachedBody("json");
   }
   text() {
-    return this.cachedBody("text");
+    return this.#cachedBody("text");
   }
   arrayBuffer() {
-    return this.cachedBody("arrayBuffer");
+    return this.#cachedBody("arrayBuffer");
   }
   blob() {
-    return this.cachedBody("blob");
+    return this.#cachedBody("blob");
   }
   formData() {
-    return this.cachedBody("formData");
+    return this.#cachedBody("formData");
   }
   addValidatedData(target, data) {
     this.#validatedData[target] = data;

package/dist/cjs/router/linear-router/router.js

@@ -28,17 +28,17 @@ const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 const splitByStarRe = /\*/;
 class LinearRouter {
   name = "LinearRouter";
-  routes = [];
+  #routes = [];
   add(method, path, handler) {
     for (let i = 0, paths = (0, import_url.checkOptionalParameter)(path) || [path], len = paths.length; i < len; i++) {
-      this.routes.push([method, paths[i], handler]);
+      this.#routes.push([method, paths[i], handler]);
     }
   }
   match(method, path) {
     const handlers = [];
     ROUTES_LOOP:
-      for (let i = 0, len = this.routes.length; i < len; i++) {
-        const [routeMethod, routePath, handler] = this.routes[i];
+      for (let i = 0, len = this.#routes.length; i < len; i++) {
+        const [routeMethod, routePath, handler] = this.#routes[i];
         if (routeMethod === method || routeMethod === import_router.METHOD_NAME_ALL) {
           if (routePath === "*" || routePath === "/*") {
             handlers.push([handler, emptyParams]);

package/dist/cjs/router/pattern-router/router.js

@@ -24,7 +24,7 @@ module.exports = __toCommonJS(router_exports);
 var import_router = require("../../router");
 class PatternRouter {
   name = "PatternRouter";
-  routes = [];
+  #routes = [];
   add(method, path, handler) {
     const endsWithWildcard = path[path.length - 1] === "*";
     if (endsWithWildcard) {
@@ -46,12 +46,12 @@ class PatternRouter {
     } catch {
       throw new import_router.UnsupportedPathError();
     }
-    this.routes.push([re, method, handler]);
+    this.#routes.push([re, method, handler]);
   }
   match(method, path) {
     const handlers = [];
-    for (let i = 0, len = this.routes.length; i < len; i++) {
-      const [pattern, routeMethod, handler] = this.routes[i];
+    for (let i = 0, len = this.#routes.length; i < len; i++) {
+      const [pattern, routeMethod, handler] = this.#routes[i];
       if (routeMethod === method || routeMethod === import_router.METHOD_NAME_ALL) {
         const match = pattern.exec(path);
         if (match) {

package/dist/cjs/router/reg-exp-router/node.js

@@ -47,18 +47,18 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 class Node {
-  index;
-  varIndex;
-  children = /* @__PURE__ */ Object.create(null);
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
   insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
-      if (this.index !== void 0) {
+      if (this.#index !== void 0) {
         throw PATH_ERROR;
       }
       if (pathErrorCheckOnly) {
         return;
       }
-      this.index = index;
+      this.#index = index;
       return;
     }
     const [token, ...restTokens] = tokens;
@@ -73,9 +73,9 @@ class Node {
           throw PATH_ERROR;
         }
       }
-      node = this.children[regexpStr];
+      node = this.#children[regexpStr];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -83,18 +83,18 @@ class Node {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[regexpStr] = new Node();
+        node = this.#children[regexpStr] = new Node();
         if (name !== "") {
-          node.varIndex = context.varIndex++;
+          node.#varIndex = context.varIndex++;
         }
       }
       if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.varIndex]);
+        paramMap.push([name, node.#varIndex]);
       }
     } else {
-      node = this.children[token];
+      node = this.#children[token];
       if (!node) {
-        if (Object.keys(this.children).some(
+        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;
@@ -102,19 +102,19 @@ class Node {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[token] = new Node();
+        node = this.#children[token] = new Node();
       }
     }
     node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
   buildRegExpStr() {
-    const childKeys = Object.keys(this.children).sort(compareKey);
+    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();
+      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 (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
     }
     if (strList.length === 0) {
       return "";

package/dist/cjs/router/reg-exp-router/router.js

@@ -109,14 +109,15 @@ function findMiddleware(middleware, path) {
 }
 class RegExpRouter {
   name = "RegExpRouter";
-  middleware;
-  routes;
+  #middleware;
+  #routes;
   constructor() {
-    this.middleware = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.routes = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#middleware = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
   add(method, path, handler) {
-    const { middleware, routes } = this;
+    const middleware = this.#middleware;
+    const routes = this.#routes;
     if (!middleware || !routes) {
       throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
@@ -173,7 +174,7 @@ class RegExpRouter {
   }
   match(method, path) {
     clearWildcardRegExpCache();
-    const matchers = this.buildAllMatchers();
+    const matchers = this.#buildAllMatchers();
     this.match = (method2, path2) => {
       const matcher = matchers[method2] || matchers[import_router.METHOD_NAME_ALL];
       const staticMatch = matcher[2][path2];
@@ -189,18 +190,18 @@ class RegExpRouter {
     };
     return this.match(method, path);
   }
-  buildAllMatchers() {
+  #buildAllMatchers() {
     const matchers = /* @__PURE__ */ Object.create(null);
-    [...Object.keys(this.routes), ...Object.keys(this.middleware)].forEach((method) => {
-      matchers[method] ||= this.buildMatcher(method);
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
+      matchers[method] ||= this.#buildMatcher(method);
     });
-    this.middleware = this.routes = void 0;
+    this.#middleware = this.#routes = void 0;
     return matchers;
   }
-  buildMatcher(method) {
+  #buildMatcher(method) {
     const routes = [];
     let hasOwnRoute = method === import_router.METHOD_NAME_ALL;
-    [this.middleware, this.routes].forEach((r) => {
+    [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;

package/dist/cjs/router/reg-exp-router/trie.js

@@ -23,8 +23,8 @@ __export(trie_exports, {
 module.exports = __toCommonJS(trie_exports);
 var import_node = require("./node");
 class Trie {
-  context = { varIndex: 0 };
-  root = new import_node.Node();
+  #context = { varIndex: 0 };
+  #root = new import_node.Node();
   insert(path, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
@@ -51,11 +51,11 @@ class Trie {
         }
       }
     }
-    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
     return paramAssoc;
   }
   buildRegExp() {
-    let regexp = this.root.buildRegExpStr();
+    let regexp = this.#root.buildRegExpStr();
     if (regexp === "") {
       return [/^$/, [], []];
     }
@@ -63,11 +63,11 @@ class Trie {
     const indexReplacementMap = [];
     const paramReplacementMap = [];
     regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (typeof handlerIndex !== "undefined") {
+      if (handlerIndex !== void 0) {
         indexReplacementMap[++captureIndex] = Number(handlerIndex);
         return "$()";
       }
-      if (typeof paramIndex !== "undefined") {
+      if (paramIndex !== void 0) {
         paramReplacementMap[Number(paramIndex)] = ++captureIndex;
         return "";
       }

package/dist/cjs/router/smart-router/router.js

@@ -24,22 +24,23 @@ module.exports = __toCommonJS(router_exports);
 var import_router = require("../../router");
 class SmartRouter {
   name = "SmartRouter";
-  routers = [];
-  routes = [];
+  #routers = [];
+  #routes = [];
   constructor(init) {
-    Object.assign(this, init);
+    this.#routers = init.routers;
   }
   add(method, path, handler) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.routes.push([method, path, handler]);
+    this.#routes.push([method, path, handler]);
   }
   match(method, path) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error("Fatal error");
     }
-    const { routers, routes } = this;
+    const routers = this.#routers;
+    const routes = this.#routes;
     const len = routers.length;
     let i = 0;
     let res;
@@ -57,8 +58,8 @@ class SmartRouter {
         throw e;
       }
       this.match = router.match.bind(router);
-      this.routers = [router];
-      this.routes = void 0;
+      this.#routers = [router];
+      this.#routes = void 0;
       break;
     }
     if (i === len) {
@@ -68,10 +69,10 @@ class SmartRouter {
     return res;
   }
   get activeRouter() {
-    if (this.routes || this.routers.length !== 1) {
+    if (this.#routes || this.#routers.length !== 1) {
       throw new Error("No active router has been determined yet.");
     }
-    return this.routers[0];
+    return this.#routers[0];
   }
 }
 // Annotate the CommonJS export names for ESM import in node: