@modern-js/prod-server 2.42.2-alpha.0 → 2.43.0

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

@@ -33,10 +33,10 @@ __export(render_exports, {
 module.exports = __toCommonJS(render_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
 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`;
@@ -51,7 +51,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
     return result;
   }
   const templatePath = entry;
-  const content = await (0, import_reader.readFile)(templatePath);
+  const content = await import_fileReader.fileReader.readFile(templatePath);
   if (!content) {
     return null;
   }
@@ -81,15 +81,7 @@ const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, s
         staticGenerate,
         nonce
       };
-      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, {
-        distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
-        template: content.toString(),
-        staticGenerate,
-        nonce
-      }, runner));
+      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, ssrRenderOptions, runner));
       return result;
     } catch (err) {
       ctx.error(import_constants.ERROR_DIGEST.ERENDER, err.stack || err.message);

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

@@ -33,9 +33,9 @@ __export(ssr_exports, {
 module.exports = __toCommonJS(ssr_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-var import_cache = __toESM(require("./cache"));
 var import_measure = require("./measure");
 var import_utils2 = require("./utils");
+var import_ssrCache = require("./ssrCache");
 const render = async (ctx, renderOptions, runner) => {
   var _ctx_res;
   const { urlPath, bundle, distDir, template, entryName, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
@@ -83,7 +83,7 @@ const render = async (ctx, renderOptions, runner) => {
   runner.extendSSRContext(context);
   const bundleJSContent = await Promise.resolve(require(bundleJS));
   const serverRender = bundleJSContent[import_utils.SERVER_RENDER_FUNCTION_NAME];
-  const content = await (0, import_cache.default)(serverRender, ctx)(context);
+  const content = await (0, import_ssrCache.ssrCache)(ctx.req, serverRender, context);
   const { url, status = 302 } = context.redirection;
   if (url) {
     return {

package/dist/cjs/libs/render/{cache/page-caches/lru.js → ssrCache/cacheMod.js}

@@ -26,41 +26,31 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var lru_exports = {};
-__export(lru_exports, {
-  LRUCaches: () => LRUCaches
+var cacheMod_exports = {};
+__export(cacheMod_exports, {
+  cacheMod: () => cacheMod
 });
-module.exports = __toCommonJS(lru_exports);
+module.exports = __toCommonJS(cacheMod_exports);
 var import_define_property = require("@swc/helpers/_/_define_property");
-var import_lru_cache = __toESM(require("lru-cache"));
-class LRUCaches {
-  init() {
-    return Promise.resolve();
-  }
-  keys() {
-    return this.caches.keys();
-  }
-  get(key) {
-    return Promise.resolve(this.caches.get(key) || null);
-  }
-  peek(key) {
-    return this.caches.peek(key) || null;
-  }
-  set(key, cache) {
-    this.caches.set(key, cache);
-    return Promise.resolve();
-  }
-  del(key) {
-    this.caches.del(key);
-  }
-  constructor(options) {
-    (0, import_define_property._)(this, "caches", void 0);
-    (0, import_define_property._)(this, "max", void 0);
-    this.max = options.max;
-    this.caches = new import_lru_cache.default(this.max);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const CACHE_FILENAME = "cache";
+class ServerCacheMod {
+  loadServerCacheMod(pwd = process.cwd()) {
+    const serverCacheFilepath = import_path.default.resolve(pwd, import_utils.SERVER_DIR, CACHE_FILENAME);
+    const mod = (0, import_utils.requireExistModule)(serverCacheFilepath, {
+      interop: false
+    });
+    this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+  }
+  constructor() {
+    (0, import_define_property._)(this, "customContainer", void 0);
+    (0, import_define_property._)(this, "cacheOption", void 0);
   }
 }
+const cacheMod = new ServerCacheMod();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  LRUCaches
+  cacheMod
 });

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

@@ -0,0 +1,81 @@
+"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 ssrCache_exports = {};
+__export(ssrCache_exports, {
+  ssrCache: () => ssrCache
+});
+module.exports = __toCommonJS(ssrCache_exports);
+var import_stream = require("stream");
+var import_storer = require("@modern-js/runtime-utils/storer");
+var import_cacheMod = require("./cacheMod");
+var import_manager = require("./manager");
+const cacheStorage = (0, import_storer.createMemoryStorage)("__ssr__cache");
+async function ssrCache(req, render, ssrContext) {
+  const { customContainer, cacheOption } = import_cacheMod.cacheMod;
+  const cacheControl = await matchCacheControl(req, cacheOption);
+  const cacheManager = new import_manager.CacheManager(customContainer ? customContainer : cacheStorage);
+  if (cacheControl) {
+    return cacheManager.getCacheResult(req, cacheControl, render, ssrContext);
+  } else {
+    const renderResult = await render(ssrContext);
+    if (typeof renderResult === "string") {
+      return renderResult;
+    } else {
+      const stream = new import_stream.Transform({
+        write(chunk, _, callback) {
+          this.push(chunk);
+          callback();
+        }
+      });
+      return renderResult(stream);
+    }
+  }
+}
+async function matchCacheControl(req, cacheOption) {
+  if (!cacheOption) {
+    return void 0;
+  } else if (isCacheControl(cacheOption)) {
+    return cacheOption;
+  } else if (isCacheOptionProvider(cacheOption)) {
+    return cacheOption(req);
+  } else {
+    const url = req.url;
+    const options = Object.entries(cacheOption);
+    for (const [key, option] of options) {
+      if (key === "*" || new RegExp(key).test(url)) {
+        if (typeof option === "function") {
+          return option(req);
+        } else {
+          return option;
+        }
+      }
+    }
+    return void 0;
+  }
+  function isCacheOptionProvider(option) {
+    return typeof option === "function";
+  }
+  function isCacheControl(option) {
+    return typeof option === "object" && option !== null && "maxAge" in option;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ssrCache
+});

package/dist/cjs/libs/render/ssrCache/manager.js

@@ -0,0 +1,104 @@
+"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 manager_exports = {};
+__export(manager_exports, {
+  CacheManager: () => CacheManager
+});
+module.exports = __toCommonJS(manager_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_stream = require("stream");
+class CacheManager {
+  async getCacheResult(req, cacheControl, render, ssrContext) {
+    const key = this.computedKey(req, cacheControl);
+    const value = await this.containter.get(key);
+    const { maxAge, staleWhileRevalidate } = cacheControl;
+    const ttl = maxAge + staleWhileRevalidate;
+    if (value) {
+      const cache = JSON.parse(value);
+      const interval = Date.now() - cache.cursor;
+      if (interval <= maxAge) {
+        return cache.val;
+      } else if (interval <= staleWhileRevalidate + maxAge) {
+        this.processCache(key, render, ssrContext, ttl);
+        return cache.val;
+      } else {
+        return this.processCache(key, render, ssrContext, ttl);
+      }
+    } else {
+      return this.processCache(key, render, ssrContext, ttl);
+    }
+  }
+  async processCache(key, render, ssrContext, ttl) {
+    const renderResult = await render(ssrContext);
+    if (typeof renderResult === "string") {
+      const current = Date.now();
+      const cache = {
+        val: renderResult,
+        cursor: current
+      };
+      await this.containter.set(key, JSON.stringify(cache), {
+        ttl
+      });
+      return renderResult;
+    } else {
+      let html;
+      const stream = new import_stream.Transform({
+        write(chunk, _, callback) {
+          html += chunk.toString();
+          this.push(chunk);
+          callback();
+        }
+      });
+      stream.on("close", () => {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        this.containter.set(key, JSON.stringify(cache), {
+          ttl
+        });
+      });
+      return renderResult(stream);
+    }
+  }
+  computedKey(req, cacheControl) {
+    const { url } = req;
+    const [pathname] = url.split("?");
+    const { customKey } = cacheControl;
+    const defaultKey = pathname.replace(/.+\/+$/, "");
+    if (customKey) {
+      if (typeof customKey === "string") {
+        return customKey;
+      } else {
+        return customKey(defaultKey);
+      }
+    } else {
+      return defaultKey;
+    }
+  }
+  constructor(containter) {
+    (0, import_define_property._)(this, "containter", void 0);
+    this.containter = containter;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheManager
+});

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

@@ -33,19 +33,19 @@ __export(static_exports, {
 module.exports = __toCommonJS(static_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-var import_reader = require("./reader");
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
 async function handleDirectory(ctx, entryPath, urlPath) {
   const { path: pathname } = ctx;
   const filepath = import_path.default.join(entryPath, trimLeft(pathname, urlPath));
-  let content = await (0, import_reader.readFile)(filepath);
+  let content = await import_fileReader.fileReader.readFile(filepath);
   let contentType = import_utils.mime.contentType(import_path.default.extname(filepath) || "");
   if (!content) {
     if (pathname.endsWith("/")) {
-      content = await (0, import_reader.readFile)(`${filepath}index.html`);
+      content = await import_fileReader.fileReader.readFile(`${filepath}index.html`);
     } else if (!pathname.includes(".")) {
-      content = await (0, import_reader.readFile)(`${filepath}.html`);
+      content = await import_fileReader.fileReader.readFile(`${filepath}.html`);
       if (!content) {
-        content = await (0, import_reader.readFile)(`${filepath}/index.html`);
+        content = await import_fileReader.fileReader.readFile(`${filepath}/index.html`);
       }
     }
     if (content) {

package/dist/cjs/server/index.js

@@ -121,6 +121,8 @@ class Server {
     });
   }
   async close() {
+    var _this_server_close, _this_server;
+    await ((_this_server_close = (_this_server = this.server).close) === null || _this_server_close === void 0 ? void 0 : _this_server_close.call(_this_server));
     this.app.close();
   }
   listen(options, listener) {

package/dist/cjs/server/modernServer.js

@@ -40,11 +40,11 @@ var import_route = require("../libs/route");
 var import_render = require("../libs/render");
 var import_serveFile = require("../libs/serveFile");
 var import_utils2 = require("../utils");
-var reader = __toESM(require("../libs/render/reader"));
 var import_proxy = require("../libs/proxy");
 var import_context = require("../libs/context");
 var import_constants = require("../constants");
 var import_hook_api = require("../libs/hook-api");
+var import_cacheMod = require("../libs/render/ssrCache/cacheMod");
 const SERVER_DIR = "./server";
 class ModernServer {
   // server prepare
@@ -52,7 +52,6 @@ class ModernServer {
     var _conf_bff, _this_conf_output;
     this.runner = runner;
     const { distDir, conf } = this;
-    this.initReader();
     (0, import_utils2.debug)("final server conf", this.conf);
     if ((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy) {
       const { handlers, handleUpgrade } = (0, import_proxy.createProxyHandler)(conf.bff.proxy);
@@ -61,12 +60,10 @@ class ModernServer {
         this.addHandler(handler);
       });
     }
-    app === null || app === void 0 ? void 0 : app.on("close", () => {
-      this.reader.close();
-    });
     const usageRoutes = this.filterRoutes(this.getRoutes());
     this.router.reset(usageRoutes);
     this.warmupSSRBundle();
+    import_cacheMod.cacheMod.loadServerCacheMod(this.pwd);
     await this.prepareFrameHandler();
     await this.prepareLoaderHandler(usageRoutes, distDir);
     this.routeRenderHandler = this.getRenderHandler();
@@ -122,9 +119,6 @@ class ModernServer {
     return (0, import_http.createServer)(handler);
   }
   /* —————————————————————— function will be overwrite —————————————————————— */
-  initReader() {
-    this.reader.init();
-  }
   async onServerChange({ filepath }) {
     const { pwd } = this;
     const { api, server } = import_constants.AGGRED_DIR;
@@ -508,7 +502,6 @@ class ModernServer {
     (0, import_define_property._)(this, "logger", void 0);
     (0, import_define_property._)(this, "metrics", void 0);
     (0, import_define_property._)(this, "runMode", void 0);
-    (0, import_define_property._)(this, "reader", reader);
     (0, import_define_property._)(this, "proxyTarget", void 0);
     (0, import_define_property._)(this, "routeRenderHandler", void 0);
     (0, import_define_property._)(this, "staticGenerate", void 0);

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

@@ -2,10 +2,10 @@ import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { cutNameByHyphen, mime } from "@modern-js/utils";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
 import { ERROR_DIGEST } from "../../constants";
 import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
 import { handleDirectory } from "./static";
-import { readFile } from "./reader";
 import * as ssr from "./ssr";
 import { injectServerData } from "./utils";
 var calcFallback = function(metaName) {
@@ -47,7 +47,7 @@ var createRenderHandler = function(param) {
             templatePath = entry;
             return [
               4,
-              readFile(templatePath)
+              fileReader.readFile(templatePath)
             ];
           case 3:
             content = _state.sent();
@@ -106,15 +106,7 @@ var createRenderHandler = function(param) {
             };
             return [
               4,
-              ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, {
-                distDir,
-                entryName: route.entryName,
-                urlPath: route.urlPath,
-                bundle: route.bundle,
-                template: content.toString(),
-                staticGenerate,
-                nonce
-              }, runner)
+              ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, ssrRenderOptions, runner)
             ];
           case 7:
             result1 = _state.sent();

package/dist/esm/libs/render/ssr.js

@@ -2,9 +2,9 @@ import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { fs, mime, LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
-import cache from "./cache";
 import { createLogger, createMetrics } from "./measure";
 import { injectServerDataStream, injectServerData } from "./utils";
+import { ssrCache } from "./ssrCache";
 var render = function() {
   var _ref = _async_to_generator(function(ctx, renderOptions, runner) {
     var _ctx_res, urlPath, bundle, distDir, template, entryName, staticGenerate, _renderOptions_enableUnsafeCtx, enableUnsafeCtx, nonce, bundleJS, loadableUri, loadableStats, routesManifestUri, routeManifest, context, bundleJSContent, serverRender, content, _context_redirection, url, _context_redirection_status, status;
@@ -63,7 +63,7 @@ var render = function() {
           serverRender = bundleJSContent[SERVER_RENDER_FUNCTION_NAME];
           return [
             4,
-            cache(serverRender, ctx)(context)
+            ssrCache(ctx.req, serverRender, context)
           ];
         case 2:
           content = _state.sent();

package/dist/esm/libs/render/ssrCache/cacheMod.js

@@ -0,0 +1,33 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import path from "path";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+var CACHE_FILENAME = "cache";
+var ServerCacheMod = /* @__PURE__ */ function() {
+  "use strict";
+  function ServerCacheMod2() {
+    _class_call_check(this, ServerCacheMod2);
+    _define_property(this, "customContainer", void 0);
+    _define_property(this, "cacheOption", void 0);
+  }
+  _create_class(ServerCacheMod2, [
+    {
+      key: "loadServerCacheMod",
+      value: function loadServerCacheMod() {
+        var pwd = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : process.cwd();
+        var serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+        var mod = requireExistModule(serverCacheFilepath, {
+          interop: false
+        });
+        this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+        this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+      }
+    }
+  ]);
+  return ServerCacheMod2;
+}();
+var cacheMod = new ServerCacheMod();
+export {
+  cacheMod
+};

package/dist/esm/libs/render/ssrCache/index.js

@@ -0,0 +1,146 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { Transform } from "stream";
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { cacheMod } from "./cacheMod";
+import { CacheManager } from "./manager";
+var cacheStorage = createMemoryStorage("__ssr__cache");
+function ssrCache(req, render, ssrContext) {
+  return _ssrCache.apply(this, arguments);
+}
+function _ssrCache() {
+  _ssrCache = _async_to_generator(function(req, render, ssrContext) {
+    var customContainer, cacheOption, cacheControl, cacheManager, renderResult, stream;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          customContainer = cacheMod.customContainer, cacheOption = cacheMod.cacheOption;
+          return [
+            4,
+            matchCacheControl(req, cacheOption)
+          ];
+        case 1:
+          cacheControl = _state.sent();
+          cacheManager = new CacheManager(customContainer ? customContainer : cacheStorage);
+          if (!cacheControl)
+            return [
+              3,
+              2
+            ];
+          return [
+            2,
+            cacheManager.getCacheResult(req, cacheControl, render, ssrContext)
+          ];
+        case 2:
+          return [
+            4,
+            render(ssrContext)
+          ];
+        case 3:
+          renderResult = _state.sent();
+          if (typeof renderResult === "string") {
+            return [
+              2,
+              renderResult
+            ];
+          } else {
+            stream = new Transform({
+              write: function write(chunk, _, callback) {
+                this.push(chunk);
+                callback();
+              }
+            });
+            return [
+              2,
+              renderResult(stream)
+            ];
+          }
+          _state.label = 4;
+        case 4:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _ssrCache.apply(this, arguments);
+}
+function matchCacheControl(req, cacheOption) {
+  return _matchCacheControl.apply(this, arguments);
+}
+function _matchCacheControl() {
+  _matchCacheControl = _async_to_generator(function(req, cacheOption) {
+    var url, options, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, option;
+    function isCacheOptionProvider(option2) {
+      return typeof option2 === "function";
+    }
+    function isCacheControl(option2) {
+      return typeof option2 === "object" && option2 !== null && "maxAge" in option2;
+    }
+    return _ts_generator(this, function(_state) {
+      if (!cacheOption) {
+        return [
+          2,
+          void 0
+        ];
+      } else if (isCacheControl(cacheOption)) {
+        return [
+          2,
+          cacheOption
+        ];
+      } else if (isCacheOptionProvider(cacheOption)) {
+        return [
+          2,
+          cacheOption(req)
+        ];
+      } else {
+        url = req.url;
+        options = Object.entries(cacheOption);
+        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+          for (_iterator = options[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], option = _step_value[1];
+            if (key === "*" || new RegExp(key).test(url)) {
+              if (typeof option === "function") {
+                return [
+                  2,
+                  option(req)
+                ];
+              } else {
+                return [
+                  2,
+                  option
+                ];
+              }
+            }
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return [
+          2,
+          void 0
+        ];
+      }
+      return [
+        2
+      ];
+    });
+  });
+  return _matchCacheControl.apply(this, arguments);
+}
+export {
+  ssrCache
+};