@modern-js/prod-server 2.35.1 → 2.37.0

package/dist/cjs/libs/render/cache/page-caches/lru.js

@@ -1,16 +1,38 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "LRUCaches", {
-  enumerable: true,
-  get: function() {
-    return LRUCaches;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lru_exports = {};
+__export(lru_exports, {
+  LRUCaches: () => LRUCaches
 });
-const _define_property = require("@swc/helpers/_/_define_property");
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _lrucache = /* @__PURE__ */ _interop_require_default._(require("lru-cache"));
+module.exports = __toCommonJS(lru_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_lru_cache = __toESM(require("lru-cache"));
 class LRUCaches {
   init() {
     return Promise.resolve();
@@ -32,9 +54,13 @@ class LRUCaches {
     this.caches.del(key);
   }
   constructor(options) {
-    _define_property._(this, "caches", void 0);
-    _define_property._(this, "max", void 0);
+    (0, import_define_property._)(this, "caches", void 0);
+    (0, import_define_property._)(this, "max", void 0);
     this.max = options.max;
-    this.caches = new _lrucache.default(this.max);
+    this.caches = new import_lru_cache.default(this.max);
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCaches
+});

package/dist/cjs/libs/render/cache/spr.js

@@ -1,29 +1,43 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  createCache: function() {
-    return createCache;
-  },
-  destroyCache: function() {
-    return destroyCache;
+    __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var spr_exports = {};
+__export(spr_exports, {
+  createCache: () => createCache,
+  destroyCache: () => destroyCache
 });
-const _define_property = require("@swc/helpers/_/_define_property");
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _crypto = /* @__PURE__ */ _interop_require_default._(require("crypto"));
-const _lrucache = /* @__PURE__ */ _interop_require_default._(require("lru-cache"));
-const _utils = require("@modern-js/utils");
-const _util = require("./util");
-const _pagecaches = require("./page-caches");
+module.exports = __toCommonJS(spr_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_crypto = __toESM(require("crypto"));
+var import_lru_cache = __toESM(require("lru-cache"));
+var import_utils = require("@modern-js/utils");
+var import_util = require("./util");
+var import_page_caches = require("./page-caches");
 const MAX_CACHE_EACH_REQ = Number(process.env.ROUTE_CACHE_LIMIT) || 10;
 const MAX_SIZE_EACH_CLUSTER = Number(process.env.CLUSTER_CACHE_LIMIT) || 100;
 const BASE_LEVEL = 0;
@@ -32,7 +46,7 @@ const HEADER_LEVEL = 2;
 const QUERY_HEADER_LEVEL = 3;
 class CacheManager {
   md5(content) {
-    const md5 = _crypto.default.createHash("md5");
+    const md5 = import_crypto.default.createHash("md5");
     return md5.update(content).digest("hex");
   }
   generateRequestKey(context) {
@@ -53,7 +67,7 @@ class CacheManager {
   }
   factor(keys, obj, matches = {}) {
     keys.sort();
-    const getValue = (0, _util.valueFactory)(obj);
+    const getValue = (0, import_util.valueFactory)(obj);
     const factorAry = keys.reduce((ary, key) => {
       let value = getValue(key) || "";
       const matcher = matches[key];
@@ -91,7 +105,7 @@ class CacheManager {
   }
   async best(context, cacheKey, data) {
     const { level } = data;
-    const cacheHash = this.find[(0, _util.fname)(level)](context, cacheKey, data);
+    const cacheHash = this.find[(0, import_util.fname)(level)](context, cacheKey, data);
     if (!cacheHash) {
       return null;
     }
@@ -122,7 +136,7 @@ class CacheManager {
     const isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
     return {
       content: html || "",
-      contentType: _utils.mime.contentType("html"),
+      contentType: import_utils.mime.contentType("html"),
       isStale,
       isGarbage,
       hash: cacheHash
@@ -135,17 +149,17 @@ class CacheManager {
     const cacheKey = this.generateRequestKey(context);
     let data = this.cache.get(cacheKey);
     if (!data) {
-      const caches = await (0, _pagecaches.createPageCaches)(MAX_CACHE_EACH_REQ);
+      const caches = await (0, import_page_caches.createPageCaches)(MAX_CACHE_EACH_REQ);
       data = this.createCacheContent(cacheConfig, caches);
     }
-    const cacheHash = this.find[(0, _util.fname)(cacheConfig.level)](context, cacheKey, data);
+    const cacheHash = this.find[(0, import_util.fname)(cacheConfig.level)](context, cacheKey, data);
     if (!cacheHash) {
       return false;
     }
     const cacheSyncOrAsync = async () => {
       const next = data;
       const limit = cacheConfig.staleLimit;
-      const storeHTML = (0, _util.cacheAddition)(html, cacheHash);
+      const storeHTML = (0, import_util.cacheAddition)(html, cacheHash);
       const size = storeHTML.length;
       await next.caches.set(cacheHash, {
         expireTime: Date.now() + cacheConfig.interval * 1e3,
@@ -157,8 +171,8 @@ class CacheManager {
       this.cache.set(cacheKey, next);
       return true;
     };
-    const doCache = (0, _util.withCoalescedInvoke)(cacheSyncOrAsync).bind(null, (0, _util.namespaceHash)("stream", cacheHash), []);
-    return (0, _util.maybeSync)(doCache)(sync);
+    const doCache = (0, import_util.withCoalescedInvoke)(cacheSyncOrAsync).bind(null, (0, import_util.namespaceHash)("stream", cacheHash), []);
+    return (0, import_util.maybeSync)(doCache)(sync);
   }
   async del(context, cacheHash) {
     const cacheKey = this.generateRequestKey(context);
@@ -166,42 +180,42 @@ class CacheManager {
     data === null || data === void 0 ? void 0 : data.caches.del(cacheHash);
   }
   constructor(cacheOptions) {
-    _define_property._(this, "cache", void 0);
-    _define_property._(this, "cacheOptions", void 0);
-    _define_property._(this, "find", (() => {
+    (0, import_define_property._)(this, "cache", void 0);
+    (0, import_define_property._)(this, "cacheOptions", void 0);
+    (0, import_define_property._)(this, "find", (() => {
       {
         const _this = this;
         return {
-          [(0, _util.fname)(BASE_LEVEL)](context, cacheKey) {
+          [(0, import_util.fname)(BASE_LEVEL)](context, cacheKey) {
             return _this.md5(cacheKey);
           },
-          [(0, _util.fname)(QUERY_LEVEL)](context, cacheKey, data) {
+          [(0, import_util.fname)(QUERY_LEVEL)](context, cacheKey, data) {
             const queryFactor = _this.queryFactor(context, data);
             if (!queryFactor) {
               return null;
             }
-            return _this.md5((0, _util.connectFactor)(cacheKey, queryFactor));
+            return _this.md5((0, import_util.connectFactor)(cacheKey, queryFactor));
           },
-          [(0, _util.fname)(HEADER_LEVEL)](context, cacheKey, data) {
+          [(0, import_util.fname)(HEADER_LEVEL)](context, cacheKey, data) {
             const headerFactor = _this.headerFactor(context, data);
             if (!headerFactor) {
               return null;
             }
-            return _this.md5((0, _util.connectFactor)(cacheKey, headerFactor));
+            return _this.md5((0, import_util.connectFactor)(cacheKey, headerFactor));
           },
-          [(0, _util.fname)(QUERY_HEADER_LEVEL)](context, cacheKey, data) {
+          [(0, import_util.fname)(QUERY_HEADER_LEVEL)](context, cacheKey, data) {
             const queryFactor = _this.queryFactor(context, data);
             const headerFactor = _this.headerFactor(context, data);
             if (!queryFactor || !headerFactor) {
               return null;
             }
-            return _this.md5((0, _util.connectFactor)(cacheKey, headerFactor, queryFactor));
+            return _this.md5((0, import_util.connectFactor)(cacheKey, headerFactor, queryFactor));
           }
         };
       }
     })());
     this.cacheOptions = cacheOptions;
-    this.cache = new _lrucache.default({
+    this.cache = new import_lru_cache.default({
       max: Math.min(MAX_SIZE_EACH_CLUSTER, 600) * 1024 * 1024,
       length(n) {
         const len = n.caches.keys().reduce((total, cur) => {
@@ -226,3 +240,8 @@ function createCache() {
 function destroyCache() {
   manager = null;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCache,
+  destroyCache
+});

package/dist/cjs/libs/render/cache/type.js

@@ -1,4 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);

package/dist/cjs/libs/render/cache/util.js

@@ -1,42 +1,44 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
   for (var name in all)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  namespaceHash: function() {
-    return namespaceHash;
-  },
-  fname: function() {
-    return fname;
-  },
-  connectFactor: function() {
-    return connectFactor;
-  },
-  valueFactory: function() {
-    return valueFactory;
-  },
-  getTime: function() {
-    return getTime;
-  },
-  cacheAddition: function() {
-    return cacheAddition;
-  },
-  withCoalescedInvoke: function() {
-    return withCoalescedInvoke;
-  },
-  maybeSync: function() {
-    return maybeSync;
+    __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  cacheAddition: () => cacheAddition,
+  connectFactor: () => connectFactor,
+  fname: () => fname,
+  getTime: () => getTime,
+  maybeSync: () => maybeSync,
+  namespaceHash: () => namespaceHash,
+  valueFactory: () => valueFactory,
+  withCoalescedInvoke: () => withCoalescedInvoke
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _url = /* @__PURE__ */ _interop_require_default._(require("url"));
+module.exports = __toCommonJS(util_exports);
+var import_url = __toESM(require("url"));
 function namespaceHash(namespace, hash) {
   return `${namespace}/${hash}`;
 }
@@ -47,7 +49,7 @@ function connectFactor(...args) {
   return args.join("-");
 }
 function valueFactory(obj) {
-  if (obj instanceof _url.default.URLSearchParams) {
+  if (obj instanceof import_url.default.URLSearchParams) {
     return function(key) {
       return obj.get(key);
     };
@@ -106,3 +108,14 @@ function maybeSync(fn) {
     }
   };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheAddition,
+  connectFactor,
+  fname,
+  getTime,
+  maybeSync,
+  namespaceHash,
+  valueFactory,
+  withCoalescedInvoke
+});

package/dist/cjs/libs/render/index.js

@@ -1,36 +1,57 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "createRenderHandler", {
-  enumerable: true,
-  get: function() {
-    return createRenderHandler;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+__export(render_exports, {
+  createRenderHandler: () => createRenderHandler
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-const _constants = require("../../constants");
-const _shouldFlushServerHeader = require("../preload/shouldFlushServerHeader");
-const _static = require("./static");
-const _reader = require("./reader");
-const _ssr = /* @__PURE__ */ _interop_require_wildcard._(require("./ssr"));
-const _utils1 = require("./utils");
-const calcFallback = (metaName) => `x-${(0, _utils.cutNameByHyphen)(metaName)}-ssr-fallback`;
+module.exports = __toCommonJS(render_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("../../constants");
+var import_shouldFlushServerHeader = require("../preload/shouldFlushServerHeader");
+var import_static = require("./static");
+var import_reader = require("./reader");
+var ssr = __toESM(require("./ssr"));
+var import_utils2 = require("./utils");
+const calcFallback = (metaName) => `x-${(0, import_utils.cutNameByHyphen)(metaName)}-ssr-fallback`;
 const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
   if (ctx.resHasHandled()) {
     return null;
   }
   const { entryPath, urlPath } = route;
-  const entry = _path.default.join(distDir, entryPath);
+  const entry = import_path.default.join(distDir, entryPath);
   if (!route.isSPA) {
-    const result = await (0, _static.handleDirectory)(ctx, entry, urlPath);
+    const result = await (0, import_static.handleDirectory)(ctx, entry, urlPath);
     return result;
   }
   const templatePath = entry;
-  const content = await (0, _reader.readFile)(templatePath);
+  const content = await (0, import_reader.readFile)(templatePath);
   if (!content) {
     return null;
   }
@@ -38,16 +59,16 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
   if (route.isSSR && !useCSR) {
     try {
       const userAgent = ctx.getReqHeader("User-Agent");
-      const disablePreload = Boolean(ctx.headers[`x-${(0, _utils.cutNameByHyphen)(metaName)}-disable-preload`]);
-      if ((0, _shouldFlushServerHeader.shouldFlushServerHeader)(conf.server, userAgent, disablePreload)) {
-        const { flushServerHeader } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../preload")));
+      const disablePreload = Boolean(ctx.headers[`x-${(0, import_utils.cutNameByHyphen)(metaName)}-disable-preload`]);
+      if ((0, import_shouldFlushServerHeader.shouldFlushServerHeader)(conf.server, userAgent, disablePreload)) {
+        const { flushServerHeader } = await Promise.resolve().then(() => __toESM(require("../preload")));
         flushServerHeader({
           serverConf: conf.server,
           ctx,
           distDir,
           template: content.toString(),
           headers: {
-            "Content-Type": _utils.mime.contentType(_path.default.extname(templatePath))
+            "Content-Type": import_utils.mime.contentType(import_path.default.extname(templatePath))
           }
         });
       }
@@ -60,7 +81,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
         staticGenerate,
         nonce
       };
-      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : _ssr.render(ctx, {
+      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, {
         distDir,
         entryName: route.entryName,
         urlPath: route.urlPath,
@@ -71,12 +92,16 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
       }, runner));
       return result;
     } catch (err) {
-      ctx.error(_constants.ERROR_DIGEST.ERENDER, err.stack || err.message);
+      ctx.error(import_constants.ERROR_DIGEST.ERENDER, err.stack || err.message);
       ctx.res.set(calcFallback(metaName), "1");
     }
   }
   return {
-    content: route.entryName ? (0, _utils1.injectServerData)(content.toString(), ctx) : content,
-    contentType: _utils.mime.contentType(_path.default.extname(templatePath))
+    content: route.entryName ? (0, import_utils2.injectServerData)(content.toString(), ctx) : content,
+    contentType: import_utils.mime.contentType(import_path.default.extname(templatePath))
   };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRenderHandler
+});

package/dist/cjs/libs/render/measure.js

@@ -1,23 +1,28 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  createMetrics: function() {
-    return createMetrics;
-  },
-  createLogger: function() {
-    return createLogger;
+    __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 measure_exports = {};
+__export(measure_exports, {
+  createLogger: () => createLogger,
+  createMetrics: () => createMetrics
 });
-const _utils = require("../../utils");
+module.exports = __toCommonJS(measure_exports);
+var import_utils = require("../../utils");
 const createMetrics = (context, metrics) => {
   const { entryName: entry, request } = context;
   const { pathname = "" } = request || {};
@@ -54,7 +59,7 @@ const createLogger = (serverContext, logger) => {
       e = message;
       message = "";
     }
-    logger.error(`SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, pathname, (0, _utils.headersWithoutCookie)(headers));
+    logger.error(`SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, pathname, (0, import_utils.headersWithoutCookie)(headers));
   };
   return {
     error,
@@ -62,3 +67,8 @@ const createLogger = (serverContext, logger) => {
     debug
   };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLogger,
+  createMetrics
+});