hono 4.6.7 → 4.6.9

package/dist/cjs/utils/url.js

@@ -28,7 +28,8 @@ __export(url_exports, {
   getQueryStrings: () => getQueryStrings,
   mergePath: () => mergePath,
   splitPath: () => splitPath,
-  splitRoutingPath: () => splitRoutingPath
+  splitRoutingPath: () => splitRoutingPath,
+  tryDecode: () => tryDecode
 });
 module.exports = __toCommonJS(url_exports);
 const splitPath = (path) => {
@@ -82,19 +83,20 @@ const getPattern = (label) => {
   }
   return null;
 };
-const tryDecodeURI = (str) => {
+const tryDecode = (str, decoder) => {
   try {
-    return decodeURI(str);
+    return decoder(str);
   } catch {
     return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
       try {
-        return decodeURI(match);
+        return decoder(match);
       } catch {
         return match;
       }
     });
   }
 };
+const tryDecodeURI = (str) => tryDecode(str, decodeURI);
 const getPath = (request) => {
   const url = request.url;
   const start = url.indexOf("/", 8);
@@ -175,7 +177,7 @@ const _decodeURI = (value) => {
   if (value.indexOf("+") !== -1) {
     value = value.replace(/\+/g, " ");
   }
-  return /%/.test(value) ? decodeURIComponent_(value) : value;
+  return value.indexOf("%") !== -1 ? decodeURIComponent_(value) : value;
 };
 const _getQueryParam = (url, key, multiple) => {
   let encoded;
@@ -258,5 +260,6 @@ const decodeURIComponent_ = decodeURIComponent;
   getQueryStrings,
   mergePath,
   splitPath,
-  splitRoutingPath
+  splitRoutingPath,
+  tryDecode
 });

package/dist/client/client.js

@@ -65,8 +65,8 @@ var ClientRequestImpl = class {
     }
     let methodUpperCase = this.method.toUpperCase();
     const headerValues = {
-      ...args?.header ?? {},
-      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers ? opt.headers : {}
+      ...args?.header,
+      ...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
     };
     if (args?.cookie) {
       const cookies = [];
@@ -157,7 +157,7 @@ var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   const req = new ClientRequestImpl(url, method);
   if (method) {
     options ??= {};
-    const args = deepMerge(options, { ...opts.args[1] ?? {} });
+    const args = deepMerge(options, { ...opts.args[1] });
     return req.fetch(opts.args[0], args);
   }
   return req;

package/dist/compose.js

@@ -3,6 +3,7 @@ import { Context } from "./context.js";
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
     let index = -1;
+    const isContext = context instanceof Context;
     return dispatch(0);
     async function dispatch(i) {
       if (i <= index) {
@@ -14,14 +15,14 @@ var compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        if (context instanceof Context) {
+        if (isContext) {
           context.req.routeIndex = i;
         }
       } else {
         handler = i === middleware.length && next || void 0;
       }
       if (!handler) {
-        if (context instanceof Context && context.finalized === false && onNotFound) {
+        if (isContext && context.finalized === false && onNotFound) {
           res = await onNotFound(context);
         }
       } else {
@@ -30,7 +31,7 @@ var compose = (middleware, onError, onNotFound) => {
             return dispatch(i + 1);
           });
         } catch (err) {
-          if (err instanceof Error && context instanceof Context && onError) {
+          if (err instanceof Error && isContext && onError) {
             context.error = err;
             res = await onError(err, context);
             isError = true;

package/dist/context.js

@@ -3,7 +3,9 @@ import { HonoRequest } from "./request.js";
 import { HtmlEscapedCallbackPhase, resolveCallback } from "./utils/html.js";
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
 var setHeaders = (headers, map = {}) => {
-  Object.entries(map).forEach(([key, value]) => headers.set(key, value));
+  for (const key of Object.keys(map)) {
+    headers.set(key, map[key]);
+  }
   return headers;
 };
 var Context = class {
@@ -150,7 +152,7 @@ var Context = class {
     }
     return Object.fromEntries(this.#var);
   }
-  newResponse = (data, arg, headers) => {
+  #newResponse(data, arg, headers) {
     if (this.#isFresh && !headers && !arg && this.#status === 200) {
       return new Response(data, {
         headers: this.#preparedHeaders
@@ -202,9 +204,10 @@ var Context = class {
       status,
       headers: this.#headers
     });
-  };
+  }
+  newResponse = (...args) => this.#newResponse(...args);
   body = (data, arg, headers) => {
-    return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
+    return typeof arg === "number" ? this.#newResponse(data, arg, headers) : this.#newResponse(data, arg);
   };
   text = (text, arg, headers) => {
     if (!this.#preparedHeaders) {
@@ -214,27 +217,27 @@ var Context = class {
       this.#preparedHeaders = {};
     }
     this.#preparedHeaders["content-type"] = TEXT_PLAIN;
-    return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
+    return typeof arg === "number" ? this.#newResponse(text, arg, headers) : this.#newResponse(text, arg);
   };
   json = (object, arg, headers) => {
     const body = JSON.stringify(object);
     this.#preparedHeaders ??= {};
     this.#preparedHeaders["content-type"] = "application/json; charset=UTF-8";
-    return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
+    return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
   };
   html = (html, arg, headers) => {
     this.#preparedHeaders ??= {};
     this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
     if (typeof html === "object") {
       return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
-        return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+        return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
       });
     }
-    return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
+    return typeof arg === "number" ? this.#newResponse(html, arg, headers) : this.#newResponse(html, arg);
   };
   redirect = (location, status) => {
     this.#headers ??= new Headers();
-    this.#headers.set("Location", location);
+    this.#headers.set("Location", String(location));
     return this.newResponse(null, status ?? 302);
   };
   notFound = () => {

package/dist/helper/cookie/index.js

@@ -56,7 +56,7 @@ var setCookie = (c, name, value, opt) => {
   } else {
     cookie = serialize(name, value, { path: "/", ...opt });
   }
-  c.header("set-cookie", cookie, { append: true });
+  c.header("Set-Cookie", cookie, { append: true });
 };
 var setSignedCookie = async (c, name, value, secret, opt) => {
   let cookie;

package/dist/helper/html/index.js

@@ -4,7 +4,7 @@ var html = (strings, ...values) => {
   const buffer = [""];
   for (let i = 0, len = strings.length - 1; i < len; i++) {
     buffer[0] += strings[i];
-    const children = values[i] instanceof Array ? values[i].flat(Infinity) : [values[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") {

package/dist/helper/ssg/ssg.js

@@ -233,8 +233,8 @@ var toSSG = async (app, fs, options) => {
     result = { success: false, files: [], error: errorObj };
   }
   if (options?.afterGenerateHook) {
-    const conbinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
-    await conbinedAfterGenerateHooks(result);
+    const combinedAfterGenerateHooks = combineAfterGenerateHooks(options?.afterGenerateHook);
+    await combinedAfterGenerateHooks(result);
   }
   return result;
 };

package/dist/helper/ssg/utils.js

@@ -2,8 +2,8 @@
 import { METHOD_NAME_ALL } from "../../router.js";
 import { findTargetHandler, isMiddleware } from "../../utils/handler.js";
 var dirname = (path) => {
-  const splittedPath = path.split(/[\/\\]/);
-  return splittedPath.slice(0, -1).join("/");
+  const separatedPath = path.split(/[\/\\]/);
+  return separatedPath.slice(0, -1).join("/");
 };
 var normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");

package/dist/helper/websocket/index.js

@@ -8,10 +8,7 @@ var WSContext = class {
     this.protocol = init.protocol ?? null;
   }
   send(source, options) {
-    this.#init.send(
-      typeof source === "string" ? source : source instanceof Uint8Array ? source.buffer : source,
-      options ?? {}
-    );
+    this.#init.send(source, options ?? {});
   }
   raw;
   binaryType = "arraybuffer";

package/dist/hono-base.js

@@ -36,11 +36,11 @@ var Hono = class {
         if (typeof args1 === "string") {
           this.#path = args1;
         } else {
-          this.addRoute(method, this.#path, args1);
+          this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
           if (typeof handler !== "string") {
-            this.addRoute(method, this.#path, handler);
+            this.#addRoute(method, this.#path, handler);
           }
         });
         return this;
@@ -51,7 +51,7 @@ var Hono = class {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
-            this.addRoute(m.toUpperCase(), this.#path, handler);
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
           });
         }
       }
@@ -65,7 +65,7 @@ var Hono = class {
         handlers.unshift(arg1);
       }
       handlers.forEach((handler) => {
-        this.addRoute(METHOD_NAME_ALL, this.#path, handler);
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
       });
       return this;
     };
@@ -74,7 +74,7 @@ var Hono = class {
     Object.assign(this, options);
     this.getPath = strict ? options.getPath ?? getPath : getPathNoStrict;
   }
-  clone() {
+  #clone() {
     const clone = new Hono({
       router: this.router,
       getPath: this.getPath
@@ -82,33 +82,33 @@ var Hono = class {
     clone.routes = this.routes;
     return clone;
   }
-  notFoundHandler = notFoundHandler;
-  errorHandler = errorHandler;
+  #notFoundHandler = notFoundHandler;
+  #errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     app.routes.map((r) => {
       let handler;
-      if (app.errorHandler === errorHandler) {
+      if (app.#errorHandler === errorHandler) {
         handler = r.handler;
       } else {
-        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        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);
+      subApp.#addRoute(r.method, r.path, handler);
     });
     return this;
   }
   basePath(path) {
-    const subApp = this.clone();
+    const subApp = this.#clone();
     subApp._basePath = mergePath(this._basePath, path);
     return subApp;
   }
   onError = (handler) => {
-    this.errorHandler = handler;
+    this.#errorHandler = handler;
     return this;
   };
   notFound = (handler) => {
-    this.notFoundHandler = handler;
+    this.#notFoundHandler = handler;
     return this;
   };
   mount(path, applicationHandler, options) {
@@ -149,52 +149,49 @@ var Hono = class {
       }
       await next();
     };
-    this.addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
     return this;
   }
-  addRoute(method, path, handler) {
+  #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);
   }
-  matchRoute(method, path) {
-    return this.router.match(method, path);
-  }
-  handleError(err, c) {
+  #handleError(err, c) {
     if (err instanceof Error) {
-      return this.errorHandler(err, c);
+      return this.#errorHandler(err, c);
     }
     throw err;
   }
-  dispatch(request, executionCtx, env, method) {
+  #dispatch(request, executionCtx, env, method) {
     if (method === "HEAD") {
-      return (async () => new Response(null, await this.dispatch(request, executionCtx, env, "GET")))();
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
     const path = this.getPath(request, { env });
-    const matchResult = this.matchRoute(method, path);
+    const matchResult = this.router.match(method, path);
     const c = new Context(request, {
       path,
       matchResult,
       env,
       executionCtx,
-      notFoundHandler: this.notFoundHandler
+      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);
+          c.res = await this.#notFoundHandler(c);
         });
       } catch (err) {
-        return this.handleError(err, c);
+        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);
+        (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);
+    const composed = compose(matchResult[0], this.#errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
         const context = await composed(c);
@@ -205,12 +202,12 @@ var Hono = class {
         }
         return context.res;
       } catch (err) {
-        return this.handleError(err, c);
+        return this.#handleError(err, c);
       }
     })();
   }
   fetch = (request, ...rest) => {
-    return this.dispatch(request, rest[1], rest[0], request.method);
+    return this.#dispatch(request, rest[1], rest[0], request.method);
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
@@ -226,7 +223,7 @@ var Hono = class {
   };
   fire = () => {
     addEventListener("fetch", (event) => {
-      event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
     });
   };
 };

package/dist/jsx/base.js

@@ -1,7 +1,7 @@
 // src/jsx/base.ts
 import { raw } from "../helper/html/index.js";
 import { escapeToBuffer, resolveCallbackSync, stringBufferToString } from "../utils/html.js";
-import { DOM_RENDERER } from "./constants.js";
+import { DOM_RENDERER, DOM_MEMO } from "./constants.js";
 import { createContext, globalContexts, useContext } from "./context.js";
 import { domRenderers } from "./intrinsic-element/common.js";
 import * as intrinsicElementTags from "./intrinsic-element/components.js";
@@ -270,13 +270,16 @@ var shallowEqual = (a, b) => {
 var memo = (component, propsAreEqual = shallowEqual) => {
   let computed = null;
   let prevProps = void 0;
-  return (props) => {
+  const wrapper = (props) => {
     if (prevProps && !propsAreEqual(prevProps, props)) {
       computed = null;
     }
     prevProps = props;
     return computed ||= component(props);
   };
+  wrapper[DOM_MEMO] = propsAreEqual;
+  wrapper[DOM_RENDERER] = component;
+  return wrapper;
 };
 var Fragment = ({
   children
@@ -311,5 +314,6 @@ export {
   jsx,
   jsxFn,
   memo,
-  reactAPICompatVersion
+  reactAPICompatVersion,
+  shallowEqual
 };

package/dist/jsx/constants.js

@@ -3,10 +3,12 @@ var DOM_RENDERER = Symbol("RENDERER");
 var DOM_ERROR_HANDLER = Symbol("ERROR_HANDLER");
 var DOM_STASH = Symbol("STASH");
 var DOM_INTERNAL_TAG = Symbol("INTERNAL");
+var DOM_MEMO = Symbol("MEMO");
 var PERMALINK = Symbol("PERMALINK");
 export {
   DOM_ERROR_HANDLER,
   DOM_INTERNAL_TAG,
+  DOM_MEMO,
   DOM_RENDERER,
   DOM_STASH,
   PERMALINK

package/dist/jsx/dom/index.js

@@ -1,6 +1,7 @@
 // src/jsx/dom/index.ts
-import { isValidElement, memo, reactAPICompatVersion } from "../base.js";
+import { isValidElement, reactAPICompatVersion, shallowEqual } from "../base.js";
 import { Children } from "../children.js";
+import { DOM_MEMO } from "../constants.js";
 import { useContext } from "../context.js";
 import {
   createRef,
@@ -53,6 +54,11 @@ var cloneElement = (element, props, ...children) => {
     element.key
   );
 };
+var memo = (component, propsAreEqual = shallowEqual) => {
+  const wrapper = (props) => component(props);
+  wrapper[DOM_MEMO] = propsAreEqual;
+  return wrapper;
+};
 var dom_default = {
   version: reactAPICompatVersion,
   useState,

package/dist/jsx/dom/render.js

@@ -1,6 +1,12 @@
 // src/jsx/dom/render.ts
 import { toArray } from "../children.js";
-import { DOM_ERROR_HANDLER, DOM_INTERNAL_TAG, DOM_RENDERER, DOM_STASH } from "../constants.js";
+import {
+  DOM_ERROR_HANDLER,
+  DOM_INTERNAL_TAG,
+  DOM_MEMO,
+  DOM_RENDERER,
+  DOM_STASH
+} from "../constants.js";
 import { globalContexts as globalJSXContexts, useContext } from "../context.js";
 import { STASH_EFFECT } from "../hooks/index.js";
 import { normalizeIntrinsicElementKey, styleObjectForEach } from "../utils.js";
@@ -228,13 +234,19 @@ var 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;
     }
@@ -269,7 +281,7 @@ var 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);
       }
     }
   }
@@ -351,12 +363,8 @@ var build = (context, node, children) => {
             if (typeof child.tag === "function") {
               oldChild[DOM_STASH][2] = child[DOM_STASH][2] || [];
               oldChild[DOM_STASH][3] = child[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[DOM_MEMO]?.(pP, oldChild.props))) {
+                oldChild.s = true;
               }
             }
             child = oldChild;
@@ -443,7 +451,8 @@ var 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/middleware/etag/digest.js

@@ -0,0 +1,36 @@
+// src/middleware/etag/digest.ts
+var 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;
+};
+var 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("");
+};
+export {
+  generateDigest
+};

package/dist/middleware/etag/index.js

@@ -1,5 +1,5 @@
 // src/middleware/etag/index.ts
-import { sha1 } from "../../utils/crypto.js";
+import { generateDigest } from "./digest.js";
 var RETAINED_304_HEADERS = [
   "cache-control",
   "content-location",
@@ -20,7 +20,10 @@ var etag = (options) => {
     const res = c.res;
     let etag3 = res.headers.get("ETag");
     if (!etag3) {
-      const hash = await sha1(res.clone().body || "");
+      const hash = await generateDigest(res.clone().body);
+      if (hash === null) {
+        return;
+      }
       etag3 = weak ? `W/"${hash}"` : `"${hash}"`;
     }
     if (etagMatches(etag3, ifNoneMatch)) {

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

@@ -18,14 +18,14 @@ var 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 = 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/middleware/jsx-renderer/index.js

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

package/dist/middleware/logger/index.js

@@ -12,17 +12,19 @@ var time = (start) => {
 };
 var colorStatus = (status) => {
   const colorEnabled = 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}`;