@modern-js/prod-server 2.35.1 → 2.36.0

package/dist/cjs/libs/preload/shouldFlushServerHeader.js

@@ -1,22 +1,27 @@
 "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, {
-  transformToRegExp: function() {
-    return transformToRegExp;
-  },
-  shouldFlushServerHeader: function() {
-    return shouldFlushServerHeader;
+    __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 shouldFlushServerHeader_exports = {};
+__export(shouldFlushServerHeader_exports, {
+  shouldFlushServerHeader: () => shouldFlushServerHeader,
+  transformToRegExp: () => transformToRegExp
 });
+module.exports = __toCommonJS(shouldFlushServerHeader_exports);
 function transformToRegExp(input) {
   if (typeof input === "string") {
     return new RegExp(input);
@@ -40,3 +45,8 @@ function shouldFlushServerHeader(serverConf, userAgent, disablePreload) {
   }
   return false;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  shouldFlushServerHeader,
+  transformToRegExp
+});

package/dist/cjs/libs/preload/transformLinks2String.js

@@ -1,14 +1,27 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "transformLinks2String", {
-  enumerable: true,
-  get: function() {
-    return transformLinks2String;
+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 transformLinks2String_exports = {};
+__export(transformLinks2String_exports, {
+  transformLinks2String: () => transformLinks2String
 });
-const _shouldFlushServerHeader = require("./shouldFlushServerHeader");
+module.exports = __toCommonJS(transformLinks2String_exports);
+var import_shouldFlushServerHeader = require("./shouldFlushServerHeader");
 function transformLinks2String(links, preload) {
   if (typeof preload === "boolean") {
     return transformLinkToString(dedup(links));
@@ -76,7 +89,7 @@ function addInclude(links, include) {
   return links.concat(includes);
 }
 function removeExclude(links, exclude) {
-  return exclude ? links.filter(({ uri }) => !(0, _shouldFlushServerHeader.transformToRegExp)(exclude).test(uri)) : links;
+  return exclude ? links.filter(({ uri }) => !(0, import_shouldFlushServerHeader.transformToRegExp)(exclude).test(uri)) : links;
 }
 function addAttributes(links, attributes) {
   const parseAttributes = (_attributes) => {
@@ -131,3 +144,7 @@ function transformLinkToString(links) {
     return as ? `<${uri}>; rel=${rel}; as=${as}${rest || ""}` : `<${uri}>; rel=${rel}${rest || ""}`;
   }).join(", ");
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformLinks2String
+});

package/dist/cjs/libs/proxy.js

@@ -1,24 +1,29 @@
 "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, {
-  formatProxyOptions: function() {
-    return formatProxyOptions;
-  },
-  createProxyHandler: function() {
-    return createProxyHandler;
+    __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 proxy_exports = {};
+__export(proxy_exports, {
+  createProxyHandler: () => createProxyHandler,
+  formatProxyOptions: () => formatProxyOptions
 });
-const _httpproxymiddleware = require("http-proxy-middleware/dist/http-proxy-middleware");
-const _utils = require("../utils");
+module.exports = __toCommonJS(proxy_exports);
+var import_http_proxy_middleware = require("http-proxy-middleware/dist/http-proxy-middleware");
+var import_utils = require("../utils");
 function formatProxyOptions(proxyOptions) {
   const ret = [];
   if (Array.isArray(proxyOptions)) {
@@ -51,12 +56,12 @@ function formatProxyOptions(proxyOptions) {
   return ret;
 }
 const createProxyHandler = (proxyOptions) => {
-  (0, _utils.debug)("createProxyHandler", proxyOptions);
+  (0, import_utils.debug)("createProxyHandler", proxyOptions);
   const formattedOptionsList = formatProxyOptions(proxyOptions);
   const proxies = [];
   const handlers = [];
   for (const opts of formattedOptionsList) {
-    const proxy = new _httpproxymiddleware.HttpProxyMiddleware(opts.context, opts);
+    const proxy = new import_http_proxy_middleware.HttpProxyMiddleware(opts.context, opts);
     const handler = async (ctx, next) => {
       const { req, res } = ctx;
       const bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
@@ -87,3 +92,8 @@ const createProxyHandler = (proxyOptions) => {
     handleUpgrade
   };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProxyHandler,
+  formatProxyOptions
+});

package/dist/cjs/libs/render/cache/__tests__/cache.fun.test.js

@@ -1,49 +1,67 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _url = /* @__PURE__ */ _interop_require_default._(require("url"));
-const _spr = require("../spr");
-const _util = require("../util");
+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 __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 import_url = __toESM(require("url"));
+var import_spr = require("../spr");
+var import_util = require("../util");
 describe("test spr util functions", () => {
   it("should return value correctly", () => {
-    expect((0, _util.connectFactor)("bar", "foo")).toBe("bar-foo");
-    expect((0, _util.fname)(1)).toBe("f1");
-    expect((0, _util.namespaceHash)("modern", "!@#$%^&")).toBe("modern/!@#$%^&");
+    expect((0, import_util.connectFactor)("bar", "foo")).toBe("bar-foo");
+    expect((0, import_util.fname)(1)).toBe("f1");
+    expect((0, import_util.namespaceHash)("modern", "!@#$%^&")).toBe("modern/!@#$%^&");
   });
   it("should create or destroy instance correctly", () => {
-    const ins1 = (0, _spr.createCache)();
-    const ins2 = (0, _spr.createCache)();
+    const ins1 = (0, import_spr.createCache)();
+    const ins2 = (0, import_spr.createCache)();
     expect(ins1 === ins2).toBe(true);
-    (0, _spr.destroyCache)();
-    const ins3 = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    const ins3 = (0, import_spr.createCache)();
     expect(ins1 === ins3).toBe(false);
     expect(ins2 === ins3).toBe(false);
   });
   it("should return function correctly", () => {
-    const urlParams = (() => new _url.default.URLSearchParams())();
+    const urlParams = (() => new import_url.default.URLSearchParams())();
     urlParams.set("name", "modern");
-    const getParam = (0, _util.valueFactory)(urlParams);
+    const getParam = (0, import_util.valueFactory)(urlParams);
     expect(getParam("name")).toBe("modern");
     const headers = {
       age: "12345"
     };
-    const getHeader = (0, _util.valueFactory)(headers);
+    const getHeader = (0, import_util.valueFactory)(headers);
     expect(getHeader("age")).toBe("12345");
   });
   it("should add target html content", () => {
     const contentNoHead = "<div>123</div>";
-    const html = (0, _util.cacheAddition)(contentNoHead, Math.random().toString());
+    const html = (0, import_util.cacheAddition)(contentNoHead, Math.random().toString());
     expect(html).toBe(contentNoHead);
     const contentWithHead = "<head></head><div>123</div>";
     const hash = Math.random().toString();
-    const htmlWithHead = (0, _util.cacheAddition)(contentWithHead, hash);
+    const htmlWithHead = (0, import_util.cacheAddition)(contentWithHead, hash);
     expect(htmlWithHead).toBe(`<head><meta name="x-moden-spr" content="${hash}"></head><div>123</div>`);
   });
   it("should only invoke func one time", async () => {
     let index = 0;
-    const fn = (0, _util.withCoalescedInvoke)(async () => new Promise((resolve) => {
+    const fn = (0, import_util.withCoalescedInvoke)(async () => new Promise((resolve) => {
       setTimeout(() => {
         index += 1;
         resolve(index);
@@ -61,13 +79,13 @@ describe("test spr util functions", () => {
   });
   it("should invoke sync or async", async () => {
     const foo = "";
-    const async = await (0, _util.maybeSync)(() => new Promise((resolve) => {
+    const async = await (0, import_util.maybeSync)(() => new Promise((resolve) => {
       setTimeout(() => {
         resolve(foo);
       }, 100);
     }))(false);
     expect(async).toBeUndefined();
-    const sync = await (0, _util.maybeSync)(() => new Promise((resolve) => {
+    const sync = await (0, import_util.maybeSync)(() => new Promise((resolve) => {
       setTimeout(() => {
         resolve(foo);
       }, 100);

package/dist/cjs/libs/render/cache/__tests__/cache.test.js

@@ -1,11 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const _spr = require("../spr");
-const _errorconfiguration = require("./error-configuration");
-const _cacheable = require("./cacheable");
-const _matchedcache = require("./matched-cache");
+var import_spr = require("../spr");
+var import_error_configuration = require("./error-configuration");
+var import_cacheable = require("./cacheable");
+var import_matched_cache = require("./matched-cache");
 const createCacheConfig = (config = {}) => ({
   excludes: null,
   includes: null,
@@ -19,8 +16,8 @@ const createCacheConfig = (config = {}) => ({
 jest.setTimeout(6e4);
 describe("cache", () => {
   it("should cache correctly", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
     const context = {
       entry: "",
       pathname: "",
@@ -35,9 +32,9 @@ describe("cache", () => {
     expect(cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.content).toBe("hello");
   });
   it("should ignore cache set when cache config not exist", async () => {
-    (0, _spr.destroyCache)();
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
     const context = {
       entry: "",
       pathname: "",
@@ -49,10 +46,10 @@ describe("cache", () => {
     expect(shouldCache).toBe(false);
   });
   it("should calcual cache key error", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
     const content = "hello";
-    for (const config of _errorconfiguration.errorConfiguration) {
+    for (const config of import_error_configuration.errorConfiguration) {
       const cacheConfig = createCacheConfig(config);
       const tmpEntry = Math.random().toString();
       const context = {
@@ -66,8 +63,8 @@ describe("cache", () => {
     }
   });
   it("should get nothing for diff requestKey", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
     const context = {
       entry: "",
       pathname: "",
@@ -94,8 +91,8 @@ describe("cache", () => {
     expect(cacheResult).toBe(null);
   });
   it("should get nothing for diff cacheHash", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
     const context = {
       entry: "",
       pathname: "",
@@ -124,9 +121,9 @@ describe("cache", () => {
     expect(cacheResult).toBe(null);
   });
   it("should get cache correctly", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
-    for (const cacheable of _cacheable.cacheabelAry) {
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
+    for (const cacheable of import_cacheable.cacheabelAry) {
       const context = {
         entry: "",
         pathname: cacheable.requestOpt.url,
@@ -140,9 +137,9 @@ describe("cache", () => {
     }
   });
   it("should match cache correctly", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
-    for (const cacheable of _matchedcache.matchedCacheableAry) {
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
+    for (const cacheable of import_matched_cache.matchedCacheableAry) {
       const [baseCacheable, matchOne, ...other] = cacheable;
       const { requestOpt = {}, cacheConfig, content } = baseCacheable;
       const context = {
@@ -173,8 +170,8 @@ describe("cache", () => {
     }
   });
   it("should stale cache correctly", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
     const context = {
       entry: "",
       pathname: "",
@@ -198,8 +195,8 @@ describe("cache", () => {
     expect(staleResult === null || staleResult === void 0 ? void 0 : staleResult.isStale).toBe(true);
   });
   it("should garbage cache correctly", async () => {
-    (0, _spr.destroyCache)();
-    const cache = (0, _spr.createCache)();
+    (0, import_spr.destroyCache)();
+    const cache = (0, import_spr.createCache)();
     const context = {
       entry: "",
       pathname: "",

package/dist/cjs/libs/render/cache/__tests__/cacheable.js

@@ -1,13 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "cacheabelAry", {
-  enumerable: true,
-  get: function() {
-    return cacheabelAry;
+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 cacheable_exports = {};
+__export(cacheable_exports, {
+  cacheabelAry: () => cacheabelAry
 });
+module.exports = __toCommonJS(cacheable_exports);
 const cacheabelAry = [
   {
     requestOpt: {
@@ -74,3 +87,7 @@ const cacheabelAry = [
     content: "level3"
   }
 ];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheabelAry
+});

package/dist/cjs/libs/render/cache/__tests__/error-configuration.js

@@ -1,13 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "errorConfiguration", {
-  enumerable: true,
-  get: function() {
-    return errorConfiguration;
+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 error_configuration_exports = {};
+__export(error_configuration_exports, {
+  errorConfiguration: () => errorConfiguration
 });
+module.exports = __toCommonJS(error_configuration_exports);
 const errorConfiguration = [
   {
     level: 1
@@ -52,3 +65,7 @@ const errorConfiguration = [
     }
   }
 ];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  errorConfiguration
+});

package/dist/cjs/libs/render/cache/__tests__/matched-cache.js

@@ -1,13 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "matchedCacheableAry", {
-  enumerable: true,
-  get: function() {
-    return matchedCacheableAry;
+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 matched_cache_exports = {};
+__export(matched_cache_exports, {
+  matchedCacheableAry: () => matchedCacheableAry
 });
+module.exports = __toCommonJS(matched_cache_exports);
 const matchedCacheableAry = [
   [
     {
@@ -154,3 +167,7 @@ const matchedCacheableAry = [
     }
   ]
 ];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  matchedCacheableAry
+});

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

@@ -1,19 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function() {
-    return _default;
+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 cache_exports = {};
+__export(cache_exports, {
+  default: () => cache_default
 });
-const _stream = require("stream");
-const _constants = require("../../../constants");
-const _spr = require("./spr");
-const _util = require("./util");
-const _default = (renderFn, ctx) => {
-  const sprCache = (0, _spr.createCache)();
+module.exports = __toCommonJS(cache_exports);
+var import_stream = require("stream");
+var import_constants = require("../../../constants");
+var import_spr = require("./spr");
+var import_util = require("./util");
+var cache_default = (renderFn, ctx) => {
+  const sprCache = (0, import_spr.createCache)();
   const doRender = async (context) => {
     const cacheContext = {
       entry: context.entryName,
@@ -29,7 +42,7 @@ const _default = (renderFn, ctx) => {
         return source;
       } else {
         let htmlForStream = "";
-        const cacheStream = new _stream.Transform({
+        const cacheStream = new import_stream.Transform({
           write(chunk, _, callback) {
             htmlForStream += chunk.toString();
             this.push(chunk);
@@ -55,7 +68,7 @@ const _default = (renderFn, ctx) => {
       const renderResult = await renderFn(context);
       return afterRender(renderResult, saveHtmlIntoCache);
     } else if (cacheFile.isStale) {
-      const render = (0, _util.withCoalescedInvoke)(() => renderFn(context)).bind(null, (0, _util.namespaceHash)("render", cacheFile.hash), []);
+      const render = (0, import_util.withCoalescedInvoke)(() => renderFn(context)).bind(null, (0, import_util.namespaceHash)("render", cacheFile.hash), []);
       render().then(async (res) => {
         if (res.value && res.isOrigin) {
           const { cacheConfig } = context;
@@ -69,7 +82,7 @@ const _default = (renderFn, ctx) => {
         }
       }).catch((e) => {
         sprCache.del(cacheContext, cacheHash);
-        ctx.error(_constants.ERROR_DIGEST.ERENDER, e);
+        ctx.error(import_constants.ERROR_DIGEST.ERENDER, e);
       });
     }
     ctx.res.setHeader("x-modern-spr", "1");

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

@@ -1,19 +1,36 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "createPageCaches", {
-  enumerable: true,
-  get: function() {
-    return createPageCaches;
+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 page_caches_exports = {};
+__export(page_caches_exports, {
+  createPageCaches: () => createPageCaches
 });
-const _lru = require("./lru");
+module.exports = __toCommonJS(page_caches_exports);
+var import_lru = require("./lru");
 async function createPageCaches(max) {
   const constructorOptions = {
     max
   };
-  const cacheInstance = new _lru.LRUCaches(constructorOptions);
+  const cacheInstance = new import_lru.LRUCaches(constructorOptions);
   await cacheInstance.init();
   return cacheInstance;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPageCaches
+});