@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

package/dist/cjs/base/middlewares/customServer/base.js

@@ -0,0 +1,171 @@
+"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 base_exports = {};
+__export(base_exports, {
+  createBaseHookContext: () => createBaseHookContext
+});
+module.exports = __toCommonJS(base_exports);
+var import_class_private_field_get = require("@swc/helpers/_/_class_private_field_get");
+var import_class_private_field_init = require("@swc/helpers/_/_class_private_field_init");
+var import_class_private_field_set = require("@swc/helpers/_/_class_private_field_set");
+var import_cookie = require("hono/cookie");
+var import_utils = require("../../utils");
+function createBaseHookContext(c) {
+  const logger = c.get("logger");
+  const metrics = c.get("metrics");
+  return {
+    request: new BaseHookRequest(c),
+    response: new BaseHookResponse(c),
+    logger,
+    metrics
+  };
+}
+var _req = /* @__PURE__ */ new WeakMap(), _c = /* @__PURE__ */ new WeakMap(), _headersData = /* @__PURE__ */ new WeakMap(), _headers = /* @__PURE__ */ new WeakMap();
+class BaseHookRequest {
+  get url() {
+    return (0, import_class_private_field_get._)(this, _req).path;
+  }
+  // TODO: remove next major version
+  set url(_u) {
+  }
+  get host() {
+    return (0, import_utils.getHost)((0, import_class_private_field_get._)(this, _req).raw);
+  }
+  // TODO: remove next major version
+  set host(_h) {
+  }
+  get pathname() {
+    return (0, import_class_private_field_get._)(this, _req).path;
+  }
+  // TODO: remove next major version
+  set pathname(_p) {
+  }
+  get query() {
+    return (0, import_class_private_field_get._)(this, _req).query();
+  }
+  // TODO: remove next major version
+  set query(_q) {
+  }
+  get headers() {
+    return (0, import_class_private_field_get._)(this, _headers);
+  }
+  // TODO: remove next major version
+  set headers(_h) {
+  }
+  get cookies() {
+    return {
+      // FIXME: ModernRequest Type Error
+      get: (key) => {
+        return (0, import_cookie.getCookie)((0, import_class_private_field_get._)(this, _c), key);
+      }
+    };
+  }
+  get cookie() {
+    return (0, import_class_private_field_get._)(this, _req).header("cookie");
+  }
+  // TODO: remove next major version
+  set cookie(_c2) {
+  }
+  constructor(c) {
+    (0, import_class_private_field_init._)(this, _req, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_init._)(this, _c, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_init._)(this, _headersData, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_init._)(this, _headers, {
+      writable: true,
+      value: void 0
+    });
+    (0, import_class_private_field_set._)(this, _headersData, {});
+    (0, import_class_private_field_set._)(this, _c, c);
+    (0, import_class_private_field_set._)(this, _req, c.req);
+    const rawHeaders = (0, import_class_private_field_get._)(this, _req).raw.headers;
+    rawHeaders.forEach((value, key) => {
+      (0, import_class_private_field_get._)(this, _headersData)[key] = value;
+    });
+    (0, import_class_private_field_set._)(this, _headers, new Proxy((0, import_class_private_field_get._)(this, _headersData), {
+      get(target, p) {
+        return target[p];
+      },
+      set(target, p, newValue) {
+        target[p] = newValue;
+        rawHeaders.set(p, newValue);
+        return true;
+      }
+    }));
+  }
+}
+var _c1 = /* @__PURE__ */ new WeakMap();
+class BaseHookResponse {
+  get(key) {
+    return (0, import_class_private_field_get._)(this, _c1).res.headers.get(key);
+  }
+  set(key, value) {
+    if ([
+      "set-cookie",
+      "Set-Cookie"
+    ].includes(key)) {
+      (0, import_class_private_field_get._)(this, _c1).header(key, value.toString(), {
+        append: true
+      });
+    } else {
+      (0, import_class_private_field_get._)(this, _c1).header(key, value.toString());
+    }
+  }
+  status(code) {
+    (0, import_class_private_field_get._)(this, _c1).status(code);
+  }
+  get cookies() {
+    const setCookie = (key, value) => {
+      (0, import_class_private_field_get._)(this, _c1).header("set-cookie", `${key}=${value}`, {
+        append: true
+      });
+    };
+    const clearCookie = () => {
+      (0, import_class_private_field_get._)(this, _c1).header("set-cookie", void 0);
+    };
+    return {
+      set: setCookie,
+      clear: clearCookie
+    };
+  }
+  raw(body, options) {
+    (0, import_class_private_field_get._)(this, _c1).res = (0, import_class_private_field_get._)(this, _c1).newResponse(body, options);
+    this.private_overrided = true;
+  }
+  constructor(c) {
+    (0, import_class_private_field_init._)(this, _c1, {
+      writable: true,
+      value: void 0
+    });
+    this.private_overrided = false;
+    (0, import_class_private_field_set._)(this, _c1, c);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBaseHookContext
+});

package/dist/cjs/base/middlewares/customServer/context.js

@@ -0,0 +1,73 @@
+"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 context_exports = {};
+__export(context_exports, {
+  createAfterStreamingRenderContext: () => createAfterStreamingRenderContext,
+  createCustomMiddlewaresCtx: () => createCustomMiddlewaresCtx,
+  getAfterMatchCtx: () => getAfterMatchCtx,
+  getAfterRenderCtx: () => getAfterRenderCtx
+});
+module.exports = __toCommonJS(context_exports);
+var import_routerApi = require("./routerApi");
+var import_template = require("./template");
+var import_base = require("./base");
+function getAfterMatchCtx(entryName, baseHookCtx) {
+  const afterMatchCtx = baseHookCtx;
+  afterMatchCtx.router = new import_routerApi.RouterAPI(entryName);
+  return afterMatchCtx;
+}
+async function getAfterRenderCtx(c, baseHookCtx, route) {
+  const afterRenderCtx = baseHookCtx;
+  const resBody = await c.res.text();
+  afterRenderCtx.template = new import_template.TemplateApi(resBody);
+  afterRenderCtx.route = route;
+  return afterRenderCtx;
+}
+function createCustomMiddlewaresCtx(c, locals) {
+  var _c_env_node, _c_env_node1;
+  const baseContext = (0, import_base.createBaseHookContext)(c);
+  const reporter = c.get("reporter");
+  return {
+    ...baseContext,
+    reporter,
+    response: {
+      ...baseContext.response,
+      locals
+    },
+    source: {
+      req: (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req,
+      res: (_c_env_node1 = c.env.node) === null || _c_env_node1 === void 0 ? void 0 : _c_env_node1.res
+    }
+  };
+}
+function createAfterStreamingRenderContext(baseHookCtx, route) {
+  const streamingRenderCtx = baseHookCtx;
+  streamingRenderCtx.route = route;
+  return (chunk) => {
+    streamingRenderCtx.chunk = chunk;
+    return streamingRenderCtx;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAfterStreamingRenderContext,
+  createCustomMiddlewaresCtx,
+  getAfterMatchCtx,
+  getAfterRenderCtx
+});

package/dist/cjs/base/middlewares/customServer/index.js

@@ -0,0 +1,136 @@
+"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 customServer_exports = {};
+__export(customServer_exports, {
+  CustomServer: () => CustomServer
+});
+module.exports = __toCommonJS(customServer_exports);
+var import_time = require("@modern-js/runtime-utils/time");
+var import_utils = require("../../utils");
+var import_constants = require("../../constants");
+var import_context = require("./context");
+var import_base = require("./base");
+const noop = () => {
+};
+const isHtmlResponse = (response) => {
+  const contentType = response.headers.get("content-type");
+  return contentType === null || contentType === void 0 ? void 0 : contentType.includes("text/html");
+};
+class CustomServer {
+  getHookMiddleware(entryName, routes) {
+    return async (c, next) => {
+      const routeInfo = routes.find((route) => route.entryName === entryName);
+      const reporter = c.get("reporter");
+      const baseHookCtx = (0, import_base.createBaseHookContext)(c);
+      const afterMatchCtx = (0, import_context.getAfterMatchCtx)(entryName, baseHookCtx);
+      const getCost = (0, import_time.time)();
+      await this.runner.afterMatch(afterMatchCtx, {
+        onLast: noop
+      });
+      const cost = getCost();
+      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(import_constants.ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost));
+      const { url, status } = afterMatchCtx.router;
+      if (url) {
+        return c.redirect(url, status);
+      }
+      const { current } = afterMatchCtx.router;
+      if (current !== entryName) {
+        const rewriteRoute = routes.find((route) => route.entryName === current);
+        if (rewriteRoute) {
+          return this.serverBase.request(rewriteRoute.urlPath);
+        }
+      }
+      if (c.finalized) {
+        return void 0;
+      }
+      await next();
+      if (c.finalized && (!c.res.body || !isHtmlResponse(c.res) || [
+        404,
+        500
+      ].includes(c.res.status))) {
+        return void 0;
+      }
+      if (c.res) {
+        c.status(c.res.status);
+      }
+      if (routeInfo.isStream) {
+        const afterStreamingRenderContext = (0, import_context.createAfterStreamingRenderContext)(baseHookCtx, routeInfo);
+        c.res = (0, import_utils.transformResponse)(c.res, (chunk) => {
+          const context = afterStreamingRenderContext(chunk);
+          return this.runner.afterStreamingRender(context, {
+            onLast: ({ chunk: chunk2 }) => chunk2
+          });
+        });
+      } else {
+        const afterRenderCtx = await (0, import_context.getAfterRenderCtx)(c, baseHookCtx, routeInfo);
+        const getCost2 = (0, import_time.time)();
+        await this.runner.afterRender(afterRenderCtx, {
+          onLast: noop
+        });
+        const cost2 = getCost2();
+        cost2 && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(import_constants.ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost2));
+        if (afterRenderCtx.response.private_overrided) {
+          return void 0;
+        }
+        const newBody = afterRenderCtx.template.get();
+        c.res = c.body(newBody);
+      }
+    };
+  }
+  getServerMiddleware() {
+    return async (c, next) => {
+      var _c_env;
+      const serverMiddleware = await this.serverMiddlewarePromise;
+      if (!serverMiddleware) {
+        return next();
+      }
+      const reporter = c.get("reporter");
+      const locals = {};
+      const customMiddlewareCtx = (0, import_context.createCustomMiddlewaresCtx)(c, locals);
+      const getCost = (0, import_time.time)();
+      await serverMiddleware(customMiddlewareCtx);
+      const cost = getCost();
+      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(import_constants.ServerReportTimings.SERVER_MIDDLEWARE, cost));
+      c.set("locals", locals);
+      if ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : _c_env.node.res.headersSent) {
+        return void 0;
+      }
+      if (!c.finalized) {
+        return next();
+      }
+    };
+  }
+  constructor(runner, serverBase, pwd) {
+    this.runner = runner;
+    this.serverBase = serverBase;
+    const webExtension = [];
+    this.serverMiddlewarePromise = runner.prepareWebServer({
+      pwd,
+      config: {
+        middleware: webExtension
+      }
+    }, {
+      onLast: () => null
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomServer
+});

package/dist/cjs/base/middlewares/customServer/routerApi.js

@@ -0,0 +1,44 @@
+"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 routerApi_exports = {};
+__export(routerApi_exports, {
+  RouterAPI: () => RouterAPI
+});
+module.exports = __toCommonJS(routerApi_exports);
+class RouterAPI {
+  redirect(url, status = 302) {
+    this.url = url;
+    this.status = status;
+  }
+  rewrite(entryName) {
+    this.current = entryName;
+  }
+  use(entryName) {
+    this.rewrite(entryName);
+  }
+  constructor(entryName) {
+    this.current = entryName;
+    this.status = 200;
+    this.url = "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RouterAPI
+});

package/dist/cjs/base/middlewares/customServer/template.js

@@ -0,0 +1,58 @@
+"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 template_exports = {};
+__export(template_exports, {
+  TemplateApi: () => TemplateApi
+});
+module.exports = __toCommonJS(template_exports);
+var import_constants = require("../../constants");
+class TemplateApi {
+  set(content) {
+    this.body = content;
+  }
+  get() {
+    return this.body;
+  }
+  prependHead(fragment) {
+    const { head } = import_constants.REPLACE_REG.before;
+    this.replaceBody(new RegExp(head), (beforeHead) => `${beforeHead}${fragment}`);
+  }
+  appendHead(fragment) {
+    const { head } = import_constants.REPLACE_REG.after;
+    this.replaceBody(head, () => `${fragment}${head}`);
+  }
+  prependBody(fragment) {
+    const { body } = import_constants.REPLACE_REG.before;
+    this.replaceBody(new RegExp(body), (beforeBody) => `${beforeBody}${fragment}`);
+  }
+  appendBody(fragment) {
+    const { body } = import_constants.REPLACE_REG.after;
+    this.replaceBody(body, () => `${fragment}${body}`);
+  }
+  replaceBody(searchValue, replaceCb) {
+    this.body = this.body.replace(searchValue, replaceCb);
+  }
+  constructor(body) {
+    this.body = body;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TemplateApi
+});

package/dist/cjs/base/middlewares/faviconFallback.js

@@ -0,0 +1,34 @@
+"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 faviconFallback_exports = {};
+__export(faviconFallback_exports, {
+  favionFallbackMiddleware: () => favionFallbackMiddleware
+});
+module.exports = __toCommonJS(faviconFallback_exports);
+const favionFallbackMiddleware = async (c, next) => {
+  if (c.req.path === "/favicon.ico") {
+    return c.body(null, 204);
+  } else {
+    return next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  favionFallbackMiddleware
+});

package/dist/cjs/base/middlewares/frameworkHeader.js

@@ -0,0 +1,31 @@
+"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 frameworkHeader_exports = {};
+__export(frameworkHeader_exports, {
+  processedBy: () => processedBy
+});
+module.exports = __toCommonJS(frameworkHeader_exports);
+const processedBy = async (ctx, next) => {
+  await next();
+  ctx.header("X-Processed-By", "Modern.js");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processedBy
+});

package/dist/cjs/base/middlewares/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewares_exports = {};
+module.exports = __toCommonJS(middlewares_exports);
+__reExport(middlewares_exports, require("./faviconFallback"), module.exports);
+__reExport(middlewares_exports, require("./monitor"), module.exports);
+__reExport(middlewares_exports, require("./renderHandler"), module.exports);
+__reExport(middlewares_exports, require("./logger"), module.exports);
+__reExport(middlewares_exports, require("./frameworkHeader"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./faviconFallback"),
+  ...require("./monitor"),
+  ...require("./renderHandler"),
+  ...require("./logger"),
+  ...require("./frameworkHeader")
+});

package/dist/cjs/base/middlewares/logger.js

@@ -0,0 +1,77 @@
+"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 logger_exports = {};
+__export(logger_exports, {
+  logHandler: () => logHandler
+});
+module.exports = __toCommonJS(logger_exports);
+var import_utils = require("../utils");
+var LogPrefix;
+(function(LogPrefix2) {
+  LogPrefix2["Outgoing"] = "-->";
+  LogPrefix2["Incoming"] = "<--";
+  LogPrefix2["Error"] = "xxx";
+})(LogPrefix || (LogPrefix = {}));
+const humanize = (times) => {
+  const [delimiter, separator] = [
+    ",",
+    "."
+  ];
+  const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, `$1${delimiter}`));
+  return orderTimes.join(separator);
+};
+const time = (start) => {
+  const delta = Date.now() - start;
+  return humanize([
+    delta < 1e3 ? `${delta}ms` : `${Math.round(delta / 1e3)}s`
+  ]);
+};
+const colorStatus = (status) => {
+  const out = {
+    7: `\x1B[35m${status}\x1B[0m`,
+    5: `\x1B[31m${status}\x1B[0m`,
+    4: `\x1B[33m${status}\x1B[0m`,
+    3: `\x1B[36m${status}\x1B[0m`,
+    2: `\x1B[32m${status}\x1B[0m`,
+    1: `\x1B[32m${status}\x1B[0m`,
+    0: `\x1B[33m${status}\x1B[0m`
+  };
+  const calculateStatus = Math.floor(status / 100);
+  return out[calculateStatus];
+};
+function log(fn, prefix, method, path, status = 0, elapsed) {
+  const out = prefix === "<--" ? `  ${prefix} ${method} ${path}` : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+  fn(out);
+}
+function logHandler() {
+  return async function logger(c, next) {
+    const { method } = c.req;
+    const logger2 = c.get("logger");
+    const path = (0, import_utils.getPathname)(c.req.raw);
+    const logFn = logger2.debug;
+    log(logFn, "<--", method, path);
+    const start = Date.now();
+    await next();
+    log(logFn, "-->", method, path, c.res.status, time(start));
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  logHandler
+});