@modern-js/prod-server 2.31.2 → 2.32.1

package/dist/esm/libs/context/context.js

@@ -27,8 +27,8 @@ export var ModernServerContext = /* @__PURE__ */ function() {
     this.req = req;
     this.res = res;
     this.options = options || {};
-    this.serverTiming = new ServerTiming(res, cutNameByHyphen(((_options = options) === null || _options === void 0 ? void 0 : _options.metaName) || "modern-js"));
     this.bind();
+    this.serverTiming = new ServerTiming(this.res, cutNameByHyphen(((_options = options) === null || _options === void 0 ? void 0 : _options.metaName) || "modern-js"));
   }
   _create_class(ModernServerContext2, [
     {
@@ -63,7 +63,10 @@ export var ModernServerContext = /* @__PURE__ */ function() {
           return _this.getReqHeader(key);
         };
         res.set = function(key, value) {
-          return _this.res.setHeader(key, value);
+          if (!res.headersSent) {
+            res.setHeader(key, value);
+          }
+          return res;
         };
         res.send = function(body) {
           _this.send(body);

package/dist/esm/libs/preload/flushServerHeader.js

@@ -0,0 +1,70 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { parseLinks } from "./parseLinks";
+import { transformLinks2String } from "./transformLinks2String";
+export function transformToRegExp(input) {
+  if (typeof input === "string") {
+    return new RegExp(input);
+  }
+  return input;
+}
+export function shouldFlushServerHeader(serverConf, userAgent, disablePreload) {
+  var _ref = serverConf || {}, ssrConf = _ref.ssr;
+  if (disablePreload) {
+    return false;
+  }
+  if (typeof ssrConf === "object" && ssrConf.preload) {
+    if (typeof ssrConf.preload === "object") {
+      var userAgentFilter = ssrConf.preload.userAgentFilter;
+      if (userAgentFilter && userAgent) {
+        return !transformToRegExp(userAgentFilter).test(userAgent);
+      }
+      return true;
+    }
+    return true;
+  }
+  return false;
+}
+export function flushServerHeader(_) {
+  return _flushServerHeader.apply(this, arguments);
+}
+function _flushServerHeader() {
+  _flushServerHeader = _async_to_generator(function(param) {
+    var serverConf, ctx, distDir, template, headers, _ref, ssrConf, res, links, link, key, _headers, value;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverConf = param.serverConf, ctx = param.ctx, distDir = param.distDir, template = param.template, headers = param.headers;
+          _ref = serverConf || {}, ssrConf = _ref.ssr;
+          if (typeof ssrConf !== "object") {
+            return [
+              2
+            ];
+          }
+          res = ctx.res;
+          return [
+            4,
+            parseLinks({
+              template: template,
+              distDir: distDir,
+              pathname: ctx.path
+            })
+          ];
+        case 1:
+          links = _state.sent();
+          link = transformLinks2String(links, ssrConf.preload);
+          res.set("link", link);
+          for (var key2 in headers || {}) {
+            ;
+            value = (_headers = headers) === null || _headers === void 0 ? void 0 : _headers[key2];
+            value && res.set(key2, value);
+          }
+          res.flushHeaders();
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _flushServerHeader.apply(this, arguments);
+}

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

@@ -0,0 +1,2 @@
+export * from "./parseLinks";
+export * from "./flushServerHeader";

package/dist/esm/libs/preload/parseLinks.js

@@ -0,0 +1,170 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, fs } from "@modern-js/utils";
+import { parse as htmlParse } from "node-html-parser";
+import { matchRoutes } from "@modern-js/utils/runtime/remix-router";
+import { matchEntry } from "@modern-js/utils/runtime-node";
+export function parseLinks(_) {
+  return _parseLinks.apply(this, arguments);
+}
+function _parseLinks() {
+  _parseLinks = _async_to_generator(function(param) {
+    var pathname, distDir, template, links;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          pathname = param.pathname, distDir = param.distDir, template = param.template;
+          return [
+            4,
+            parseLinksFromRoutes(pathname, distDir)
+          ];
+        case 1:
+          links = _state.sent();
+          return [
+            2,
+            links.length > 0 ? links : parseLinksFromHtml(template)
+          ];
+      }
+    });
+  });
+  return _parseLinks.apply(this, arguments);
+}
+function parseLinksFromHtml(html) {
+  var root = htmlParse(html);
+  var scripts = root.querySelectorAll("script").filter(function(elem) {
+    return Boolean(elem.getAttribute("src"));
+  });
+  var css = root.querySelectorAll("link").filter(function(elem) {
+    var href = elem.getAttribute("href");
+    var rel = elem.getAttribute("rel");
+    return href && rel === "stylesheet";
+  });
+  var images = root.querySelectorAll("img").filter(function(elem) {
+    return Boolean(elem.getAttribute("src"));
+  });
+  return scripts.map(function(elem) {
+    var src = elem.getAttribute("src");
+    return {
+      uri: src,
+      as: "script"
+    };
+  }).concat(css.map(function(elem) {
+    var href = elem.getAttribute("href");
+    return {
+      uri: href,
+      as: "style"
+    };
+  })).concat(images.map(function(elem) {
+    var src = elem.getAttribute("src");
+    return {
+      uri: src,
+      as: "image"
+    };
+  }));
+}
+function parseLinksFromRoutes(pathname, distDir) {
+  return _parseLinksFromRoutes.apply(this, arguments);
+}
+function _parseLinksFromRoutes() {
+  _parseLinksFromRoutes = _async_to_generator(function(pathname, distDir) {
+    var noopLinks, nestedRoutesSpec, routesJsonPath, routeManifestPath, routesJson, serverRoutes, entry, _routeAssets_entryName, _matches, _assets_filter, _assets, _assets_filter1, _assets1, routes, entryName, entryRoutes, routesManifest, routeAssets, matches, entryAssets, assets, cssLinks, scriptLinks;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          noopLinks = [];
+          nestedRoutesSpec = path.join(distDir, NESTED_ROUTE_SPEC_FILE);
+          routesJsonPath = path.join(distDir, ROUTE_SPEC_FILE);
+          routeManifestPath = path.join(distDir, ROUTE_MANIFEST_FILE);
+          if (!fs.existsSync(nestedRoutesSpec) || !fs.existsSync(routesJsonPath) || !fs.existsSync(routeManifestPath)) {
+            return [
+              2,
+              noopLinks
+            ];
+          }
+          return [
+            4,
+            import(routesJsonPath)
+          ];
+        case 1:
+          routesJson = _state.sent();
+          serverRoutes = routesJson.routes;
+          entry = matchEntry(pathname, serverRoutes);
+          if (!entry)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            import(nestedRoutesSpec)
+          ];
+        case 2:
+          routes = _state.sent();
+          entryName = entry.entryName;
+          if (!entryName) {
+            return [
+              2,
+              noopLinks
+            ];
+          }
+          entryRoutes = routes[entryName];
+          if (!entryRoutes) {
+            return [
+              2,
+              noopLinks
+            ];
+          }
+          return [
+            4,
+            import(routeManifestPath)
+          ];
+        case 3:
+          routesManifest = _state.sent();
+          routeAssets = routesManifest.routeAssets;
+          matches = matchRoutes(entryRoutes, pathname, entry.urlPath);
+          entryAssets = (_routeAssets_entryName = routeAssets[entryName]) === null || _routeAssets_entryName === void 0 ? void 0 : _routeAssets_entryName.assets;
+          assets = (_matches = matches) === null || _matches === void 0 ? void 0 : _matches.reduce(function(acc, match) {
+            var routeId = match.route.id;
+            if (routeId) {
+              var _matchedManifest;
+              var matchedManifest = routeAssets[routeId];
+              var assets2 = (_matchedManifest = matchedManifest) === null || _matchedManifest === void 0 ? void 0 : _matchedManifest.assets;
+              if (Array.isArray(assets2)) {
+                var _acc;
+                (_acc = acc).push.apply(_acc, _to_consumable_array(assets2));
+              }
+            }
+            return acc;
+          }, []).concat(entryAssets || []);
+          cssLinks = (_assets = assets) === null || _assets === void 0 ? void 0 : (_assets_filter = _assets.filter(function(asset) {
+            return asset.endsWith(".css");
+          })) === null || _assets_filter === void 0 ? void 0 : _assets_filter.map(function(uri) {
+            return {
+              uri: uri,
+              as: "style"
+            };
+          });
+          scriptLinks = (_assets1 = assets) === null || _assets1 === void 0 ? void 0 : (_assets_filter1 = _assets1.filter(function(asset) {
+            return asset.endsWith(".js");
+          })) === null || _assets_filter1 === void 0 ? void 0 : _assets_filter1.map(function(uri) {
+            return {
+              uri: uri,
+              as: "script"
+            };
+          });
+          return [
+            2,
+            (cssLinks || []).concat(scriptLinks || [])
+          ];
+        case 4:
+          return [
+            2,
+            noopLinks
+          ];
+      }
+    });
+  });
+  return _parseLinksFromRoutes.apply(this, arguments);
+}

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

@@ -0,0 +1,118 @@
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { transformToRegExp } from "./flushServerHeader";
+export function transformLinks2String(links, preload) {
+  var addInclude = function addInclude2(links2, include2) {
+    var _include;
+    var images = [
+      "gif",
+      "jpg",
+      "jpeg",
+      "png",
+      "webp",
+      "bmp",
+      "tiff",
+      "anpg",
+      "ico"
+    ];
+    var videos = [
+      "mp4",
+      "webm",
+      "ogm",
+      "ogv",
+      "ogg"
+    ];
+    var fonts = [
+      "woff",
+      "woff2",
+      "eot",
+      "ttf",
+      "otf"
+    ];
+    var includes = ((_include = include2) === null || _include === void 0 ? void 0 : _include.map(function(item) {
+      if (typeof item === "string") {
+        var type = function() {
+          if (item.endsWith(".js")) {
+            return "script";
+          }
+          if (item.endsWith(".css")) {
+            return "style";
+          }
+          if (images.some(function(image) {
+            return item.endsWith(".".concat(image));
+          })) {
+            return "image";
+          }
+          if (videos.some(function(video) {
+            return item.endsWith(".".concat(video));
+          })) {
+            return "video";
+          }
+          if (fonts.some(function(font) {
+            return item.endsWith(".".concat(font));
+          })) {
+            return "font";
+          }
+        }();
+        return {
+          uri: item,
+          as: type
+        };
+      }
+      return {
+        uri: item.url,
+        as: item.type
+      };
+    })) || [];
+    return links2.concat(includes);
+  };
+  var removeExclude = function removeExclude2(links2, exclude2) {
+    return exclude2 ? links2.filter(function(param) {
+      var uri = param.uri;
+      return !transformToRegExp(exclude2).test(uri);
+    }) : links2;
+  };
+  var addAttributes = function addAttributes2(links2, attributes2) {
+    var parseAttributes = function(_attributes) {
+      return Object.entries(_attributes || {}).reduce(function(results, param) {
+        var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+        if (typeof value === "boolean") {
+          value && results.push("; ".concat(key));
+          return results;
+        }
+        results.push("; ".concat(key, "=").concat(value));
+        return results;
+      }, []).join("");
+    };
+    return links2.map(function(param) {
+      var uri = param.uri, as = param.as;
+      if (as) {
+        var attributesStr = function() {
+          var _ref = attributes2 || {}, style = _ref.style, script = _ref.script, image = _ref.image, font = _ref.font;
+          switch (as) {
+            case "script":
+              return parseAttributes(script);
+            case "style":
+              return parseAttributes(style);
+            case "image":
+              return parseAttributes(image);
+            case "font":
+              return parseAttributes(font);
+            default:
+              return "";
+          }
+        }();
+        return "<".concat(uri, ">; rel=preload; as=").concat(as).concat(attributesStr);
+      }
+      return "<".concat(uri, ">; rel=preload");
+    });
+  };
+  if (typeof preload === "boolean") {
+    return links.map(function(param) {
+      var uri = param.uri, as = param.as;
+      return as ? "<".concat(uri, ">; rel=preload; as=").concat(as) : "<".concat(uri, ">; rel=preload");
+    }).join(", ");
+  }
+  var include = preload.include, exclude = preload.exclude, attributes = preload.attributes;
+  var resolveLinks = addAttributes(removeExclude(addInclude(links, include), exclude), attributes);
+  return resolveLinks.join(", ");
+}

package/dist/esm/libs/proxy.js

@@ -1,79 +1,91 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { createProxyMiddleware } from "http-proxy-middleware";
+import { HttpProxyMiddleware } from "http-proxy-middleware/dist/http-proxy-middleware";
 import { debug } from "../utils";
 export function formatProxyOptions(proxyOptions) {
-  var formattedProxy = [];
-  if (!Array.isArray(proxyOptions)) {
-    if ("target" in proxyOptions) {
-      formattedProxy.push(proxyOptions);
-    } else {
-      Array.prototype.push.apply(formattedProxy, Object.keys(proxyOptions).reduce(function(total, source) {
-        var option = proxyOptions[source];
-        total.push(_object_spread({
-          context: source,
-          changeOrigin: true,
-          logLevel: "warn"
-        }, typeof option === "string" ? {
-          target: option
-        } : option));
-        return total;
-      }, []));
-    }
+  var ret = [];
+  if (Array.isArray(proxyOptions)) {
+    var _ret;
+    (_ret = ret).push.apply(_ret, _to_consumable_array(proxyOptions));
+  } else if ("target" in proxyOptions) {
+    ret.push(proxyOptions);
   } else {
-    var _formattedProxy;
-    (_formattedProxy = formattedProxy).push.apply(_formattedProxy, _to_consumable_array(proxyOptions));
-  }
-  return formattedProxy;
-}
-export var createProxyHandler = function(proxyOptions) {
-  debug("createProxyHandler", proxyOptions);
-  var middlewares = [];
-  var handlers = [];
-  var handleUpgrade = function(req, socket, head) {
-    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
     try {
-      for (var _iterator2 = middlewares[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-        var middleware = _step2.value;
-        if (typeof middleware.upgrade === "function") {
-          middleware.upgrade(req, socket, head);
+      for (var _iterator = Object.entries(proxyOptions)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var _step_value = _sliced_to_array(_step.value, 2), context = _step_value[0], options = _step_value[1];
+        var opts = {
+          context: context,
+          changeOrigin: true,
+          logLevel: "warn"
+        };
+        if (typeof options === "string") {
+          opts.target = options;
+        } else {
+          Object.assign(opts, options);
         }
+        ret.push(opts);
       }
     } catch (err) {
-      _didIteratorError2 = true;
-      _iteratorError2 = err;
+      _didIteratorError = true;
+      _iteratorError = err;
     } finally {
       try {
-        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-          _iterator2.return();
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
         }
       } finally {
-        if (_didIteratorError2) {
-          throw _iteratorError2;
+        if (_didIteratorError) {
+          throw _iteratorError;
         }
       }
     }
+  }
+  var handleError = function(err, _req, _res, _target) {
+    console.error(err);
   };
-  if (!proxyOptions) {
-    return {
-      handlers: handlers,
-      handleUpgrade: handleUpgrade
-    };
+  var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = ret[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var opts1 = _step1.value;
+      var _opts;
+      var _onError;
+      (_onError = (_opts = opts1).onError) !== null && _onError !== void 0 ? _onError : _opts.onError = handleError;
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
   }
+  return ret;
+}
+export var createProxyHandler = function(proxyOptions) {
+  debug("createProxyHandler", proxyOptions);
   var formattedOptionsList = formatProxyOptions(proxyOptions);
+  var proxies = [];
+  var handlers = [];
   var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
   try {
     var _loop = function() {
-      var options = _step.value;
-      var middleware = createProxyMiddleware(options.context, options);
+      var opts = _step.value;
+      var proxy = new HttpProxyMiddleware(opts.context, opts);
       var handler = function() {
         var _ref = _async_to_generator(function(ctx, next) {
           var req, res, bypassUrl;
           return _ts_generator(this, function(_state) {
             req = ctx.req, res = ctx.res;
-            bypassUrl = typeof options.bypass === "function" ? options.bypass(req, res, options) : null;
+            bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
             if (typeof bypassUrl === "boolean") {
               ctx.status = 404;
               next();
@@ -81,7 +93,7 @@ export var createProxyHandler = function(proxyOptions) {
               ctx.url = bypassUrl;
               next();
             } else {
-              middleware(req, res, next);
+              proxy.middleware(req, res, next);
             }
             return [
               2
@@ -92,7 +104,7 @@ export var createProxyHandler = function(proxyOptions) {
           return _ref.apply(this, arguments);
         };
       }();
-      middlewares.push(middleware);
+      proxies.push(proxy);
       handlers.push(handler);
     };
     for (var _iterator = formattedOptionsList[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)
@@ -111,6 +123,32 @@ export var createProxyHandler = function(proxyOptions) {
       }
     }
   }
+  var handleUpgrade = function(server) {
+    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = proxies[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var proxy = _step2.value;
+        var raw = proxy;
+        if (raw.proxyOptions.ws === true && !raw.wsInternalSubscribed) {
+          server.on("upgrade", raw.handleUpgrade);
+          raw.wsInternalSubscribed = true;
+        }
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+  };
   return {
     handlers: handlers,
     handleUpgrade: handleUpgrade

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

@@ -3,15 +3,16 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { cutNameByHyphen, mime } from "@modern-js/utils";
 import { ERROR_DIGEST } from "../../constants";
+import { flushServerHeader, shouldFlushServerHeader } from "../preload";
 import { handleDirectory } from "./static";
 import { readFile } from "./reader";
 import * as ssr from "./ssr";
 import { injectServerData } from "./utils";
 export var createRenderHandler = function(param) {
-  var distDir = param.distDir, staticGenerate = param.staticGenerate, forceCSR = param.forceCSR, nonce = param.nonce, ssrRender = param.ssrRender, _param_metaName = param.metaName, metaName = _param_metaName === void 0 ? "modern-js" : _param_metaName;
+  var distDir = param.distDir, staticGenerate = param.staticGenerate, conf = param.conf, forceCSR = param.forceCSR, nonce = param.nonce, ssrRender = param.ssrRender, _param_metaName = param.metaName, metaName = _param_metaName === void 0 ? "modern-js" : _param_metaName;
   return function() {
     var _render = _async_to_generator(function(param2) {
-      var ctx, route, runner, entryPath, urlPath, entry, result, templatePath, content, useCSR, ssrRenderOptions, result1, err;
+      var ctx, route, runner, entryPath, urlPath, entry, result, templatePath, content, useCSR, userAgent, disablePreload, ssrRenderOptions, result1, err;
       return _ts_generator(this, function(_state) {
         switch (_state.label) {
           case 0:
@@ -67,6 +68,19 @@ export var createRenderHandler = function(param) {
               ,
               7
             ]);
+            userAgent = ctx.getReqHeader("User-Agent");
+            disablePreload = Boolean(ctx.headers["x-".concat(cutNameByHyphen(metaName), "-disable-preload")]);
+            if (shouldFlushServerHeader(conf.server, userAgent, disablePreload)) {
+              flushServerHeader({
+                serverConf: conf.server,
+                ctx: ctx,
+                distDir: distDir,
+                template: content.toString(),
+                headers: {
+                  "Content-Type": mime.contentType(path.extname(templatePath))
+                }
+              });
+            }
             ssrRenderOptions = {
               distDir: distDir,
               entryName: route.entryName,
@@ -97,7 +111,7 @@ export var createRenderHandler = function(param) {
           case 6:
             err = _state.sent();
             ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
-            ctx.res.setHeader("x-modern-ssr-fallback", "1");
+            ctx.res.set("x-modern-ssr-fallback", "1");
             return [
               3,
               7

package/dist/esm/libs/serverTiming.js

@@ -18,7 +18,7 @@ export var ServerTiming = /* @__PURE__ */ function() {
         var _name = "bd-".concat(this.meta, "-").concat(name);
         var serverTiming = this.res.getHeader(SERVER_TIMING) || this.res.getHeader(SERVER_TIMING.toLocaleLowerCase());
         var value = "".concat(_name, ";").concat(desc ? 'decs="'.concat(desc, '";') : "", " dur=").concat(dur);
-        this.res.setHeader(SERVER_TIMING, serverTiming ? "".concat(serverTiming, ", ").concat(value) : value);
+        this.res.set(SERVER_TIMING, serverTiming ? "".concat(serverTiming, ", ").concat(value) : value);
         return this;
       }
     }

package/dist/esm/renderHtml.js

@@ -11,9 +11,9 @@ import { Readable } from "stream";
 import { Socket } from "net";
 import { Server } from "./server";
 import { isRedirect } from "./utils";
-var IncomingMessageLike = /* @__PURE__ */ function(Readable1) {
+var IncomingMessageLike = /* @__PURE__ */ function(Readable2) {
   "use strict";
-  _inherits(IncomingMessageLike2, Readable1);
+  _inherits(IncomingMessageLike2, Readable2);
   var _super = _create_super(IncomingMessageLike2);
   function IncomingMessageLike2(param) {
     var method = param.method, url = param.url, headers = param.headers;
@@ -33,9 +33,9 @@ var IncomingMessageLike = /* @__PURE__ */ function(Readable1) {
   }
   return IncomingMessageLike2;
 }(Readable);
-var ServerResponseLike = /* @__PURE__ */ function(OutgoingMessage1) {
+var ServerResponseLike = /* @__PURE__ */ function(OutgoingMessage2) {
   "use strict";
-  _inherits(ServerResponseLike2, OutgoingMessage1);
+  _inherits(ServerResponseLike2, OutgoingMessage2);
   var _super = _create_super(ServerResponseLike2);
   function ServerResponseLike2() {
     _class_call_check(this, ServerResponseLike2);
@@ -60,9 +60,9 @@ var ServerResponseLike = /* @__PURE__ */ function(OutgoingMessage1) {
   ]);
   return ServerResponseLike2;
 }(OutgoingMessage);
-var CustomServer = /* @__PURE__ */ function(Server1) {
+var CustomServer = /* @__PURE__ */ function(Server2) {
   "use strict";
-  _inherits(CustomServer2, Server1);
+  _inherits(CustomServer2, Server2);
   var _super = _create_super(CustomServer2);
   function CustomServer2() {
     _class_call_check(this, CustomServer2);