@modern-js/server-core 2.47.0 → 2.47.1-alpha.0

package/dist/cjs/base/middlewares/renderHandler/ssrCache.js

@@ -0,0 +1,173 @@
+"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_define_property = require("@swc/helpers/_/_define_property");
+var import_stream = require("stream");
+var import_utils = require("@modern-js/utils");
+var import_storer = require("@modern-js/runtime-utils/storer");
+var import_stream2 = require("../../adapters/node/polyfills/stream");
+var import_utils2 = require("../../utils");
+class CacheManager {
+  async getCacheResult(req, cacheControl, render, ssrContext) {
+    const key = this.computedKey(req, cacheControl);
+    const value = await this.container.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 (!renderResult) {
+      return "";
+    } else if (typeof renderResult === "string") {
+      const current = Date.now();
+      const cache = {
+        val: renderResult,
+        cursor: current
+      };
+      await this.container.set(key, JSON.stringify(cache), {
+        ttl
+      });
+      return renderResult;
+    } else {
+      const body = (
+        // TODO: remove node:stream, move it to ssr entry.
+        renderResult instanceof import_stream.Readable ? (0, import_stream2.createReadableStreamFromReadable)(renderResult) : renderResult
+      );
+      let html = "";
+      const stream = (0, import_utils2.createTransformStream)((chunk) => {
+        html += chunk;
+        return chunk;
+      });
+      stream.readable.getReader().closed.then(() => {
+        const current = Date.now();
+        const cache = {
+          val: html,
+          cursor: current
+        };
+        this.container.set(key, JSON.stringify(cache), {
+          ttl
+        });
+      });
+      body.pipeThrough(stream);
+      return stream.readable;
+    }
+  }
+  computedKey(req, cacheControl) {
+    const pathname = (0, import_utils2.getPathname)(req);
+    const { customKey } = cacheControl;
+    const defaultKey = pathname.replace(/.+\/+$/, "");
+    if (customKey) {
+      if (typeof customKey === "string") {
+        return customKey;
+      } else {
+        return customKey(defaultKey);
+      }
+    } else {
+      return defaultKey;
+    }
+  }
+  constructor(container) {
+    (0, import_define_property._)(this, "container", void 0);
+    this.container = container;
+  }
+}
+const CACHE_FILENAME = "cache";
+class ServerCache {
+  async loadCacheMod(pwd = process.cwd()) {
+    const path = await (0, import_utils2.getPathModule)();
+    const serverCacheFilepath = path.resolve(pwd, import_utils.SERVER_DIR, CACHE_FILENAME);
+    const mod = (0, import_utils.requireExistModule)(serverCacheFilepath, {
+      interop: false
+    });
+    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
+    if (this.cacheOption && !(mod === null || mod === void 0 ? void 0 : mod.customContainer)) {
+      const cacheStorage = (0, import_storer.createMemoryStorage)("__ssr__cache");
+      this.customContainer = cacheStorage;
+    } else {
+      this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
+    }
+    if (this.customContainer) {
+      this.cacheManger = new CacheManager(this.customContainer);
+    }
+  }
+  matchCacheControl(req) {
+    const { cacheOption } = this;
+    if (!cacheOption || !req) {
+      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;
+    }
+  }
+  getCache(req, cacheControl, render, ssrContext) {
+    if (this.cacheManger) {
+      return this.cacheManger.getCacheResult(req, cacheControl, render, ssrContext);
+    } else {
+      return render(ssrContext);
+    }
+  }
+  constructor() {
+    (0, import_define_property._)(this, "customContainer", void 0);
+    (0, import_define_property._)(this, "cacheOption", void 0);
+    (0, import_define_property._)(this, "cacheManger", void 0);
+  }
+}
+const ssrCache = new ServerCache();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ssrCache
+});

package/dist/cjs/base/middlewares/renderHandler/ssrRender.js

@@ -0,0 +1,183 @@
+"use strict";
+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 ssrRender_exports = {};
+__export(ssrRender_exports, {
+  ssrRender: () => ssrRender
+});
+module.exports = __toCommonJS(ssrRender_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_stream = require("stream");
+var import_utils = require("@modern-js/utils");
+var isbot = __toESM(require("isbot"));
+var import_utils2 = require("../../utils");
+var import_constants = require("../../constants");
+var import_request = require("../../utils/request");
+var import_stream2 = require("../../adapters/node/polyfills/stream");
+var import_serverTiming = require("./serverTiming");
+var import_ssrCache = require("./ssrCache");
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};
+async function ssrRender(request, { routeInfo, pwd, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq }) {
+  const { entryName } = routeInfo;
+  const path = await (0, import_utils2.getPathModule)();
+  const jsBundlePath = path.join(pwd, routeInfo.bundle);
+  const loadableUri = path.join(pwd, import_utils.LOADABLE_STATS_FILE);
+  let loadableStats = {};
+  try {
+    loadableStats = await Promise.resolve().then(() => __toESM(require(loadableUri)));
+  } catch (_) {
+  }
+  const routesManifestUri = path.join(pwd, import_utils.ROUTE_MANIFEST_FILE);
+  let routeManifest;
+  try {
+    routeManifest = await Promise.resolve().then(() => __toESM(require(routesManifestUri)));
+  } catch (_) {
+  }
+  const host = (0, import_request.getHost)(request);
+  const isSpider = isbot.default(request.headers.get("user-agent"));
+  const responseProxy = new ResponseProxy();
+  const query = (0, import_request.parseQuery)(request);
+  const headers = (0, import_request.parseHeaders)(request);
+  const ssrContext = {
+    request: {
+      baseUrl: routeInfo.urlPath,
+      params: {},
+      // eslint-disable-next-line node/no-unsupported-features/node-builtins, node/prefer-global/url
+      pathname: new URL(request.url).pathname,
+      host,
+      query,
+      url: request.url,
+      headers
+    },
+    response: {
+      setHeader(key, value) {
+        responseProxy.headers.set(key, value);
+      },
+      status(code) {
+        responseProxy.status = code;
+      }
+    },
+    redirection: {},
+    template: html,
+    loadableStats,
+    routeManifest,
+    entryName,
+    staticGenerate,
+    logger,
+    serverTiming: new import_serverTiming.ServerTiming(responseProxy.headers, metaName),
+    reporter: reporter || defaultReporter,
+    /** @deprecated node req */
+    req: void 0,
+    /** @deprecated node res  */
+    res: void 0,
+    isSpider,
+    nonce
+  };
+  const jsBundle = await Promise.resolve().then(() => __toESM(require(jsBundlePath)));
+  const incomingMessage = nodeReq ? nodeReq : new IncomingMessgeProxy(request);
+  const cacheControl = await import_ssrCache.ssrCache.matchCacheControl(incomingMessage);
+  let ssrResult;
+  const render = jsBundle[import_utils.SERVER_RENDER_FUNCTION_NAME];
+  if (cacheControl) {
+    ssrResult = await import_ssrCache.ssrCache.getCache(request, cacheControl, render, ssrContext);
+  } else {
+    ssrResult = await render(ssrContext);
+  }
+  const { redirection } = ssrContext;
+  if (redirection.url) {
+    const { headers: headers2 } = responseProxy;
+    headers2.set("Location", redirection.url);
+    return new Response(null, {
+      status: redirection.status || 302,
+      headers: {
+        Location: redirection.url
+      }
+    });
+  }
+  const serverData = {
+    router: {
+      baseUrl: routeInfo.urlPath,
+      // TODO: parse
+      params: {}
+    }
+  };
+  const data = ssrResult instanceof import_stream.Readable ? (0, import_stream2.createReadableStreamFromReadable)(ssrResult) : ssrResult;
+  const body = injectServerData(data, serverData);
+  return new Response(body, {
+    status: responseProxy.status,
+    headers: responseProxy.headers
+  });
+}
+function injectServerData(data, serverData) {
+  const { head } = import_constants.REPLACE_REG.before;
+  const searchValue = new RegExp(head);
+  const replcaeCb = (beforeHead) => `${beforeHead}<script type="application/json" id="__MODERN_SERVER_DATA__">${JSON.stringify(serverData)}</script>`;
+  if (typeof data === "string") {
+    return data.replace(searchValue, replcaeCb);
+  } else {
+    const stream = (0, import_utils2.createTransformStream)((before) => {
+      return before.replace(searchValue, replcaeCb);
+    });
+    data.pipeThrough(stream);
+    return stream.readable;
+  }
+}
+class ResponseProxy {
+  constructor() {
+    (0, import_define_property._)(this, "headers", new Headers());
+    (0, import_define_property._)(this, "status", 200);
+    this.headers.set("content-type", "text/html; charset=UTF-8");
+  }
+}
+class IncomingMessgeProxy {
+  constructor(req) {
+    (0, import_define_property._)(this, "headers", {});
+    (0, import_define_property._)(this, "method", void 0);
+    (0, import_define_property._)(this, "url", void 0);
+    req.headers.forEach((value, key) => {
+      this.headers[key] = value;
+    });
+    this.method = req.method;
+    this.url = new URL(req.url).pathname;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ssrRender
+});

package/dist/cjs/base/serverBase.js

@@ -0,0 +1,167 @@
+"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 serverBase_exports = {};
+__export(serverBase_exports, {
+  ServerBase: () => ServerBase
+});
+module.exports = __toCommonJS(serverBase_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_utils = require("@modern-js/utils");
+var import_hono = require("hono");
+var import_core = require("../core");
+var import_utils2 = require("./utils");
+class ServerBase {
+  /**
+  * 初始化顺序
+  * - 获取 server runtime config
+  * - 设置 context
+  * - 创建 hooksRunner
+  * - 合并插件，内置插件和 serverConfig 中配置的插件
+  * - 执行 config hook
+  * - 获取最终的配置
+  * - 设置配置到 context
+  * - 执行 prepare hook
+  */
+  async init() {
+    const { options } = this;
+    await this.initServerConfig(options);
+    await this.injectContext(options);
+    this.runner = await this.createHookRunner();
+    await this.initConfig(this.runner, options);
+    await this.injectContext(options);
+    await this.runner.prepare();
+    return this;
+  }
+  async createHookRunner() {
+    import_core.serverManager.clear();
+    const { options } = this;
+    const { internalPlugins = import_utils.INTERNAL_SERVER_PLUGINS, pwd, plugins = [] } = options;
+    const serverPlugins = this.serverConfig.plugins || [];
+    const loadedPlugins = (0, import_core.loadPlugins)(options.appContext.appDirectory || pwd, [
+      ...serverPlugins,
+      ...plugins
+    ], {
+      internalPlugins
+    });
+    (0, import_utils2.debug)("plugins", loadedPlugins);
+    loadedPlugins.forEach((p) => {
+      import_core.serverManager.usePlugin(p);
+    });
+    const hooksRunner = await import_core.serverManager.init();
+    return hooksRunner;
+  }
+  async initServerConfig(options) {
+    const { pwd, serverConfigFile } = options;
+    const serverConfigPath = await (0, import_utils2.getServerConfigPath)(pwd, serverConfigFile);
+    const serverConfig = (0, import_utils2.requireConfig)(serverConfigPath);
+    this.serverConfig = serverConfig;
+  }
+  async injectContext(options) {
+    const appContext = await this.initAppContext();
+    const { config, pwd } = options;
+    import_core.ConfigContext.set(config);
+    import_core.AppContext.set({
+      ...appContext,
+      serverBase: this,
+      distDirectory: pwd
+    });
+  }
+  async initAppContext() {
+    const path = await (0, import_utils2.getPathModule)();
+    const { options } = this;
+    const { pwd, plugins = [], appContext } = options;
+    const serverPlugins = plugins.map((p) => ({
+      server: p
+    }));
+    return {
+      appDirectory: (appContext === null || appContext === void 0 ? void 0 : appContext.appDirectory) || "",
+      apiDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory,
+      lambdaDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.lambdaDirectory,
+      sharedDirectory: (appContext === null || appContext === void 0 ? void 0 : appContext.sharedDirectory) || path.resolve(appContext.appDirectory || "", import_utils.SHARED_DIR),
+      distDirectory: pwd,
+      plugins: serverPlugins
+    };
+  }
+  /**
+  * Execute config hooks
+  * @param runner
+  * @param options
+  */
+  runConfigHook(runner, serverConfig) {
+    const newServerConfig = runner.config(serverConfig || {});
+    return newServerConfig;
+  }
+  async initConfig(runner, options) {
+    const path = await (0, import_utils2.getPathModule)();
+    const { pwd, config } = options;
+    const { serverConfig } = this;
+    const finalServerConfig = this.runConfigHook(runner, serverConfig);
+    const resolvedConfigPath = (0, import_utils.ensureAbsolutePath)(pwd, path.join(config.output.path || "dist", import_utils.OUTPUT_CONFIG_FILE));
+    options.config = (0, import_utils2.loadConfig)({
+      cliConfig: config,
+      serverConfig: finalServerConfig,
+      resolvedConfigPath
+    });
+  }
+  get all() {
+    return this.app.all;
+  }
+  get use() {
+    return this.app.use;
+  }
+  get get() {
+    return this.app.get;
+  }
+  get post() {
+    return this.app.post;
+  }
+  get put() {
+    return this.app.put;
+  }
+  get delete() {
+    return this.app.delete;
+  }
+  get patch() {
+    return this.app.patch;
+  }
+  get handle() {
+    return this.app.fetch;
+  }
+  get request() {
+    return this.app.request;
+  }
+  get notFound() {
+    return this.app.notFound;
+  }
+  get onError() {
+    return this.app.onError;
+  }
+  constructor(options) {
+    (0, import_define_property._)(this, "options", void 0);
+    (0, import_define_property._)(this, "runner", void 0);
+    (0, import_define_property._)(this, "app", void 0);
+    (0, import_define_property._)(this, "serverConfig", {});
+    this.options = options;
+    this.app = new import_hono.Hono();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerBase
+});

package/dist/cjs/base/utils/debug.js

@@ -0,0 +1,29 @@
+"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 debug_exports = {};
+__export(debug_exports, {
+  debug: () => debug
+});
+module.exports = __toCommonJS(debug_exports);
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.createDebugger)("prod-server");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debug
+});

package/dist/cjs/base/utils/entry.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 __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 entry_exports = {};
+__export(entry_exports, {
+  sortRoutes: () => sortRoutes
+});
+module.exports = __toCommonJS(entry_exports);
+const sortRoutes = (route1, route2) => {
+  return route2.urlPath.length - route1.urlPath.length;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sortRoutes
+});

package/dist/cjs/base/utils/env.js

@@ -0,0 +1,45 @@
+"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 env_exports = {};
+__export(env_exports, {
+  checkIsProd: () => checkIsProd,
+  getRuntimeEnv: () => getRuntimeEnv
+});
+module.exports = __toCommonJS(env_exports);
+const getRuntimeEnv = () => {
+  var _global_process_release, _global_process, _global;
+  if (((_global = global) === null || _global === void 0 ? void 0 : (_global_process = _global.process) === null || _global_process === void 0 ? void 0 : (_global_process_release = _global_process.release) === null || _global_process_release === void 0 ? void 0 : _global_process_release.name) === "node") {
+    return "node";
+  }
+  return "other";
+};
+const checkIsProd = () => {
+  const env = getRuntimeEnv();
+  switch (env) {
+    case "node":
+      return process.env.NODE_ENV === "production";
+    default:
+      return false;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIsProd,
+  getRuntimeEnv
+});

package/dist/cjs/base/utils/error.js

@@ -0,0 +1,65 @@
+"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 error_exports = {};
+__export(error_exports, {
+  createErrorHtml: () => createErrorHtml
+});
+module.exports = __toCommonJS(error_exports);
+const ERROR_PAGE_TEXT = {
+  404: "This page could not be found.",
+  500: "Internal Server Error."
+};
+const createErrorHtml = (status) => {
+  const text = ERROR_PAGE_TEXT[status] || "";
+  const title = `${status}: ${text}`;
+  return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>${title}</title>
+    <style>
+      html,body {
+        margin: 0;
+      }
+
+      .page-container {
+        color: #000;
+        background: #fff;
+        height: 100vh;
+        text-align: center;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="page-container">
+    <h1>${status}</h1>
+    <div>${text}</div>
+  </body>
+  </html>
+  `;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createErrorHtml
+});