@modern-js/utils 2.26.0 → 2.27.0

package/dist/esm/cli/prettyInstructions.js

@@ -1,14 +1,17 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import os from "os";
 import { chalk } from "../compiled";
 import { isDev, isSingleEntry } from "./is";
 import { DEFAULT_DEV_HOST } from "./constants";
-const normalizeUrl = (url) => url.replace(/([^:]\/)\/+/g, "$1");
-const getIpv4Interfaces = () => {
-  const interfaces = os.networkInterfaces();
-  const ipv4Interfaces = [];
-  Object.keys(interfaces).forEach((key) => {
-    interfaces[key].forEach((detail) => {
-      const familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
+var normalizeUrl = function(url) {
+  return url.replace(/([^:]\/)\/+/g, "$1");
+};
+var getIpv4Interfaces = function() {
+  var interfaces = os.networkInterfaces();
+  var ipv4Interfaces = [];
+  Object.keys(interfaces).forEach(function(key) {
+    interfaces[key].forEach(function(detail) {
+      var familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
       if (detail.family === familyV4Value) {
         ipv4Interfaces.push(detail);
       }
@@ -16,57 +19,65 @@ const getIpv4Interfaces = () => {
   });
   return ipv4Interfaces;
 };
-export const getAddressUrls = (protocol = "http", port, host) => {
-  const LOCAL_LABEL = "Local:  ";
-  const NETWORK_LABEL = "Network:  ";
-  const isLocalhost = (url) => {
+export var getAddressUrls = function() {
+  var protocol = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "http", port = arguments.length > 1 ? arguments[1] : void 0, host = arguments.length > 2 ? arguments[2] : void 0;
+  var LOCAL_LABEL = "Local:  ";
+  var NETWORK_LABEL = "Network:  ";
+  var isLocalhost = function(url) {
     return url === null || url === void 0 ? void 0 : url.includes("localhost");
   };
   if (host && host !== DEFAULT_DEV_HOST) {
     return [
       {
         label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
-        url: `${protocol}://${host}:${port}`
+        url: "".concat(protocol, "://").concat(host, ":").concat(port)
       }
     ];
   }
-  const ipv4Interfaces = getIpv4Interfaces();
-  return ipv4Interfaces.reduce((memo, detail) => {
+  var ipv4Interfaces = getIpv4Interfaces();
+  return ipv4Interfaces.reduce(function(memo, detail) {
     if (isLocalhost(detail.address) || detail.internal) {
       memo.push({
         label: LOCAL_LABEL,
-        url: `${protocol}://localhost:${port}`
+        url: "".concat(protocol, "://localhost:").concat(port)
       });
     } else {
       memo.push({
         label: NETWORK_LABEL,
-        url: `${protocol}://${detail.address}:${port}`
+        url: "".concat(protocol, "://").concat(detail.address, ":").concat(port)
       });
     }
     return memo;
   }, []);
 };
-export const prettyInstructions = (appContext, config) => {
+export var prettyInstructions = function(appContext, config) {
   var _appContext_builder_context_devServer, _appContext_builder, _config_dev;
-  const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
-  const isHttps = isDev() && ((_appContext_builder_context_devServer = (_appContext_builder = appContext.builder) === null || _appContext_builder === void 0 ? void 0 : _appContext_builder.context.devServer) === null || _appContext_builder_context_devServer === void 0 ? void 0 : _appContext_builder_context_devServer.https);
-  const urls = getAddressUrls(isHttps ? "https" : "http", port, (_config_dev = config.dev) === null || _config_dev === void 0 ? void 0 : _config_dev.host);
-  const routes = !apiOnly ? serverRoutes.filter((route) => route.entryName) : serverRoutes;
-  let message = "App running at:\n\n";
+  var entrypoints = appContext.entrypoints, serverRoutes = appContext.serverRoutes, port = appContext.port, apiOnly = appContext.apiOnly, checkedEntries = appContext.checkedEntries;
+  var isHttps = isDev() && ((_appContext_builder_context_devServer = (_appContext_builder = appContext.builder) === null || _appContext_builder === void 0 ? void 0 : _appContext_builder.context.devServer) === null || _appContext_builder_context_devServer === void 0 ? void 0 : _appContext_builder_context_devServer.https);
+  var urls = getAddressUrls(isHttps ? "https" : "http", port, (_config_dev = config.dev) === null || _config_dev === void 0 ? void 0 : _config_dev.host);
+  var routes = !apiOnly ? serverRoutes.filter(function(route) {
+    return route.entryName;
+  }) : serverRoutes;
+  var message = "App running at:\n\n";
   if (isSingleEntry(entrypoints) || apiOnly) {
-    message += urls.map(({ label, url }) => `  ${chalk.bold(`> ${label.padEnd(10)}`)}${chalk.cyanBright(normalizeUrl(`${url}/${routes[0].urlPath}`))}
-`).join("");
+    message += urls.map(function(param) {
+      var label = param.label, url = param.url;
+      return "  ".concat(chalk.bold("> ".concat(label.padEnd(10)))).concat(chalk.cyanBright(normalizeUrl("".concat(url, "/").concat(routes[0].urlPath))), "\n");
+    }).join("");
   } else {
-    const maxNameLength = Math.max(...routes.map((r) => r.entryName.length));
-    urls.forEach(({ label, url }) => {
-      message += `  ${chalk.bold(`> ${label}`)}
-`;
-      routes.forEach(({ entryName, urlPath, isSSR }) => {
+    var _Math;
+    var maxNameLength = (_Math = Math).max.apply(_Math, _to_consumable_array(routes.map(function(r) {
+      return r.entryName.length;
+    })));
+    urls.forEach(function(param) {
+      var label = param.label, url = param.url;
+      message += "  ".concat(chalk.bold("> ".concat(label)), "\n");
+      routes.forEach(function(param2) {
+        var entryName = param2.entryName, urlPath = param2.urlPath, isSSR = param2.isSSR;
         if (!checkedEntries.includes(entryName)) {
           return;
         }
-        message += `    ${chalk.yellowBright(isSSR ? "λ" : "○")}  ${chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}
-`;
+        message += "    ".concat(chalk.yellowBright(isSSR ? "λ" : "○"), "  ").concat(chalk.yellowBright(entryName.padEnd(maxNameLength + 8))).concat(chalk.cyanBright(normalizeUrl("".concat(url, "/").concat(urlPath))), "\n");
       });
     });
     message += "\n";

package/dist/esm/cli/require.js

@@ -1,27 +1,30 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { findExists } from "./fs";
-export const compatRequire = (filePath, interop = true) => {
-  const mod = require(filePath);
-  const rtnESMDefault = interop && (mod === null || mod === void 0 ? void 0 : mod.__esModule);
+export var compatRequire = function(filePath) {
+  var interop = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+  var mod = require(filePath);
+  var rtnESMDefault = interop && (mod === null || mod === void 0 ? void 0 : mod.__esModule);
   return rtnESMDefault ? mod.default : mod;
 };
-export const dynamicImport = new Function("modulePath", "return import(modulePath)");
-export const requireExistModule = (filename, opt) => {
-  const final = {
+export var dynamicImport = new Function("modulePath", "return import(modulePath)");
+export var requireExistModule = function(filename, opt) {
+  var final = _object_spread({
     extensions: [
       ".ts",
       ".js"
     ],
-    interop: true,
-    ...opt
-  };
-  const exist = findExists(final.extensions.map((ext) => `${filename}${ext}`));
+    interop: true
+  }, opt);
+  var exist = findExists(final.extensions.map(function(ext) {
+    return "".concat(filename).concat(ext);
+  }));
   if (!exist) {
     return null;
   }
   return compatRequire(exist, final.interop);
 };
-export const cleanRequireCache = (filelist) => {
-  filelist.forEach((filepath) => {
+export var cleanRequireCache = function(filelist) {
+  filelist.forEach(function(filepath) {
     delete require.cache[filepath];
   });
 };
@@ -30,11 +33,13 @@ export function deleteRequireCache(path) {
     delete require.cache[path];
   }
   if (module.children) {
-    module.children = module.children.filter((item) => item.filename !== path);
+    module.children = module.children.filter(function(item) {
+      return item.filename !== path;
+    });
   }
 }
-export const tryResolve = (name, resolvePath) => {
-  let filePath = "";
+export var tryResolve = function(name, resolvePath) {
+  var filePath = "";
   try {
     filePath = require.resolve(name, {
       paths: [
@@ -44,7 +49,7 @@ export const tryResolve = (name, resolvePath) => {
     delete require.cache[filePath];
   } catch (err) {
     if (err.code === "MODULE_NOT_FOUND") {
-      throw new Error(`Can not find module ${name}.`);
+      throw new Error("Can not find module ".concat(name, "."));
     }
     throw err;
   }

package/dist/esm/cli/runtimeExports.js

@@ -1,35 +1,41 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import path from "path";
 import { fs } from "../compiled";
 import { normalizeOutputPath } from "./path";
-const memo = (fn) => {
-  const cache = /* @__PURE__ */ new Map();
-  return (...params) => {
-    const stringifiedParams = JSON.stringify(params);
-    const cachedResult = cache.get(stringifiedParams);
+var memo = function(fn) {
+  var cache = /* @__PURE__ */ new Map();
+  return function() {
+    for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+      params[_key] = arguments[_key];
+    }
+    var stringifiedParams = JSON.stringify(params);
+    var cachedResult = cache.get(stringifiedParams);
     if (cachedResult) {
       return cachedResult;
     }
-    const res = fn(...params);
+    var res = fn.apply(void 0, _to_consumable_array(params));
     cache.set(stringifiedParams, res);
     return res;
   };
 };
-export const createRuntimeExportsUtils = memo((pwd = "", namespace = "index") => {
-  const entryExportFile = path.join(pwd, `.runtime-exports/${namespace}.js`);
-  const addExport = (statement) => {
+export var createRuntimeExportsUtils = memo(function() {
+  var pwd = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "", namespace = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "index";
+  var entryExportFile = path.join(pwd, ".runtime-exports/".concat(namespace, ".js"));
+  var addExport = function(statement) {
     statement = normalizeOutputPath(statement);
     try {
       fs.ensureFileSync(entryExportFile);
       if (!fs.readFileSync(entryExportFile, "utf8").includes(statement)) {
-        fs.appendFileSync(entryExportFile, `${statement}
-`);
+        fs.appendFileSync(entryExportFile, "".concat(statement, "\n"));
       }
-    } catch {
+    } catch (e) {
     }
   };
-  const getPath = () => entryExportFile;
+  var getPath = function() {
+    return entryExportFile;
+  };
   return {
-    addExport,
-    getPath
+    addExport: addExport,
+    getPath: getPath
   };
 });

package/dist/esm/cli/watch.js

@@ -1,40 +1,107 @@
+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 { chokidar } from "../compiled";
-export const WatchChangeType = {
+export var WatchChangeType = {
   ADD: "add",
   UNLINK: "unlink",
   CHANGE: "change"
 };
-export const watch = (watchDir, runTask, ignored = []) => {
-  let ready = false;
-  const watcher = chokidar.watch(watchDir, {
-    ignored
+export var watch = function(watchDir, runTask) {
+  var ignored = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
+  var ready = false;
+  var watcher = chokidar.watch(watchDir, {
+    ignored: ignored
   });
-  watcher.on("ready", () => ready = true);
-  watcher.on("change", async (filePath) => {
-    const changedFilePath = path.resolve(filePath);
-    await runTask({
-      changedFilePath,
-      changeType: WatchChangeType.CHANGE
-    });
+  watcher.on("ready", function() {
+    return ready = true;
   });
-  watcher.on("add", async (filePath) => {
-    const changedFilePath = path.resolve(filePath);
-    if (ready) {
-      await runTask({
-        changedFilePath,
-        changeType: WatchChangeType.ADD
+  watcher.on("change", function() {
+    var _ref = _async_to_generator(function(filePath) {
+      var changedFilePath;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            changedFilePath = path.resolve(filePath);
+            return [
+              4,
+              runTask({
+                changedFilePath: changedFilePath,
+                changeType: WatchChangeType.CHANGE
+              })
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
       });
-    }
-  });
-  watcher.on("unlink", async (filePath) => {
-    const changedFilePath = path.resolve(filePath);
-    await runTask({
-      changedFilePath,
-      changeType: WatchChangeType.UNLINK
     });
-  });
-  watcher.on("error", (err) => {
+    return function(filePath) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  watcher.on("add", function() {
+    var _ref = _async_to_generator(function(filePath) {
+      var changedFilePath;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            changedFilePath = path.resolve(filePath);
+            if (!ready)
+              return [
+                3,
+                2
+              ];
+            return [
+              4,
+              runTask({
+                changedFilePath: changedFilePath,
+                changeType: WatchChangeType.ADD
+              })
+            ];
+          case 1:
+            _state.sent();
+            _state.label = 2;
+          case 2:
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(filePath) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  watcher.on("unlink", function() {
+    var _ref = _async_to_generator(function(filePath) {
+      var changedFilePath;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            changedFilePath = path.resolve(filePath);
+            return [
+              4,
+              runTask({
+                changedFilePath: changedFilePath,
+                changeType: WatchChangeType.UNLINK
+              })
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(filePath) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  watcher.on("error", function(err) {
     throw err;
   });
   return watcher;

package/dist/esm/compiled.js

@@ -28,6 +28,6 @@ export { default as browserslist } from "../compiled/browserslist";
 export { default as recursiveReaddir } from "../compiled/recursive-readdir";
 export { program, Command } from "../compiled/commander";
 export { Signale } from "../compiled/signale";
-export const mime = Import.lazy("../compiled/mime-types", require);
-export const chokidar = Import.lazy("../compiled/chokidar", require);
-export const inquirer = Import.lazy("../compiled/inquirer", require);
+export var mime = Import.lazy("../compiled/mime-types", require);
+export var chokidar = Import.lazy("../compiled/chokidar", require);
+export var inquirer = Import.lazy("../compiled/inquirer", require);

package/dist/esm/import.js

@@ -1,8 +1,8 @@
-const lazy = (moduleName, requireFn) => {
-  const importLazyLocal = require("../compiled/import-lazy")(requireFn);
+var lazy = function(moduleName, requireFn) {
+  var importLazyLocal = require("../compiled/import-lazy")(requireFn);
   return importLazyLocal(moduleName);
 };
 export { lazy as lazyImport };
-export const Import = {
-  lazy
+export var Import = {
+  lazy: lazy
 };

package/dist/esm/runtime/nestedRoutes.js

@@ -1,19 +1,39 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Suspense } from "react";
 import { createRoutesFromElements, Route } from "react-router-dom";
-export const transformNestedRoutes = (routes) => {
-  const routeElements = [];
-  for (const route of routes) {
-    const routeElement = renderNestedRoute(route);
-    routeElements.push(routeElement);
+export var transformNestedRoutes = function(routes) {
+  var routeElements = [];
+  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+  try {
+    for (var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var route = _step.value;
+      var routeElement = renderNestedRoute(route);
+      routeElements.push(routeElement);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
   }
   return createRoutesFromElements(routeElements);
 };
-export const renderNestedRoute = (nestedRoute, options = {}) => {
-  const { children, index, id, component, isRoot, lazyImport, config, handle } = nestedRoute;
-  const Component = component;
-  const { parent, DeferredDataComponent, props = {} } = options;
-  const routeProps = {
+export var renderNestedRoute = function(nestedRoute) {
+  var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var children = nestedRoute.children, index = nestedRoute.index, id = nestedRoute.id, component = nestedRoute.component, isRoot = nestedRoute.isRoot, lazyImport = nestedRoute.lazyImport, config = nestedRoute.config, handle = nestedRoute.handle;
+  var Component = component;
+  var parent = options.parent, DeferredDataComponent = options.DeferredDataComponent, _options_props = options.props, props = _options_props === void 0 ? {} : _options_props;
+  var routeProps = {
     caseSensitive: nestedRoute.caseSensitive,
     path: nestedRoute.path,
     id: nestedRoute.id,
@@ -21,22 +41,19 @@ export const renderNestedRoute = (nestedRoute, options = {}) => {
     action: nestedRoute.action,
     hasErrorBoundary: nestedRoute.hasErrorBoundary,
     shouldRevalidate: nestedRoute.shouldRevalidate,
-    handle: {
-      ...handle,
-      ...typeof config === "object" ? config === null || config === void 0 ? void 0 : config.handle : {}
-    },
+    handle: _object_spread({}, handle, typeof config === "object" ? config === null || config === void 0 ? void 0 : config.handle : {}),
     index: nestedRoute.index,
     element: nestedRoute.element,
     errorElement: nestedRoute.errorElement
   };
   if (nestedRoute.error) {
-    const errorElement = /* @__PURE__ */ _jsx(nestedRoute.error, {});
+    var errorElement = /* @__PURE__ */ _jsx(nestedRoute.error, {});
     routeProps.errorElement = errorElement;
   }
-  let element;
+  var element;
   if (Component) {
     if ((parent === null || parent === void 0 ? void 0 : parent.loading) && lazyImport) {
-      const Loading = parent.loading;
+      var Loading = parent.loading;
       if (isLoadableComponent(Component)) {
         element = /* @__PURE__ */ _jsx(Component, {
           fallback: /* @__PURE__ */ _jsx(Loading, {})
@@ -52,9 +69,7 @@ export const renderNestedRoute = (nestedRoute, options = {}) => {
     } else if (isRoot) {
       element = /* @__PURE__ */ _jsxs(_Fragment, {
         children: [
-          /* @__PURE__ */ _jsx(Component, {
-            ...props
-          }),
+          /* @__PURE__ */ _jsx(Component, _object_spread({}, props)),
           typeof document === "undefined" && DeferredDataComponent && /* @__PURE__ */ _jsx(DeferredDataComponent, {
             nonce: props === null || props === void 0 ? void 0 : props.nonce
           })
@@ -74,32 +89,30 @@ export const renderNestedRoute = (nestedRoute, options = {}) => {
   if (element) {
     routeProps.element = element;
   }
-  const childElements = children === null || children === void 0 ? void 0 : children.map((childRoute) => {
+  var childElements = children === null || children === void 0 ? void 0 : children.map(function(childRoute) {
     return renderNestedRoute(childRoute, {
       parent: nestedRoute
     });
   });
-  const routeElement = index ? /* @__PURE__ */ _jsx(Route, {
-    ...routeProps,
+  var routeElement = index ? /* @__PURE__ */ _jsx(Route, _object_spread_props(_object_spread({}, routeProps), {
     index: true
-  }, id) : /* @__PURE__ */ _jsx(Route, {
-    ...routeProps,
+  }), id) : /* @__PURE__ */ _jsx(Route, _object_spread_props(_object_spread({}, routeProps), {
     index: false,
     children: childElements
-  }, id);
+  }), id);
   return routeElement;
 };
 function createLoader(route) {
-  const { loader } = route;
+  var loader = route.loader;
   if (loader) {
-    return (args) => {
+    return function(args) {
       if (typeof route.lazyImport === "function") {
         route.lazyImport();
       }
       return loader(args);
     };
   } else {
-    return () => {
+    return function() {
       if (typeof route.lazyImport === "function") {
         route.lazyImport();
       }

package/dist/esm/runtime-browser/parsed.js

@@ -1,15 +1,15 @@
-export const parsedJSONFromElement = (id) => {
-  const elements = document.querySelectorAll(`#${id}`);
+export var parsedJSONFromElement = function(id) {
+  var elements = document.querySelectorAll("#".concat(id));
   if (elements.length === 0) {
     return void 0;
   }
-  const element = elements[elements.length - 1];
+  var element = elements[elements.length - 1];
   if (element) {
     try {
-      const parsed = JSON.parse((element === null || element === void 0 ? void 0 : element.textContent) || "");
+      var parsed = JSON.parse((element === null || element === void 0 ? void 0 : element.textContent) || "");
       return parsed;
     } catch (e) {
-      console.error(`parse ${id} error`, e);
+      console.error("parse ".concat(id, " error"), e);
       return void 0;
     }
   }

package/dist/esm/runtime-node/index.js

@@ -1,5 +1,5 @@
 import { createStorage } from "./storage";
-const { run, useContext: useHeaders } = createStorage();
+var _createStorage = createStorage(), run = _createStorage.run, useHeaders = _createStorage.useContext;
 export { run, useHeaders };
 export { serializeJson } from "./serialize";
 export * from "./nestedRoutes";

package/dist/esm/runtime-node/nestedRoutes.js

@@ -1,7 +1,7 @@
 function sortByUrlPath(entries) {
   entries.sort(function(a, b) {
-    const length1 = a.urlPath.length;
-    const length2 = b.urlPath.length;
+    var length1 = a.urlPath.length;
+    var length2 = b.urlPath.length;
     if (length1 < length2) {
       return 1;
     }
@@ -12,7 +12,9 @@ function sortByUrlPath(entries) {
   });
   return entries;
 }
-export const matchEntry = (pathname, entries) => {
+export var matchEntry = function(pathname, entries) {
   sortByUrlPath(entries);
-  return entries.find((entry) => pathname.startsWith(entry.urlPath));
+  return entries.find(function(entry) {
+    return pathname.startsWith(entry.urlPath);
+  });
 };

package/dist/esm/runtime-node/serialize.js

@@ -1,5 +1,5 @@
 import serialize from "serialize-javascript";
-export const serializeJson = (data) => {
+export var serializeJson = function(data) {
   return serialize(data, {
     isJSON: true
   });

package/dist/esm/runtime-node/storage.js

@@ -1,16 +1,15 @@
 import * as ah from "async_hooks";
-const createStorage = () => {
-  let storage;
+var createStorage = function() {
+  var storage;
   if (typeof ah.AsyncLocalStorage !== "undefined") {
     storage = new ah.AsyncLocalStorage();
   }
-  const run = (context, cb) => {
+  var run = function(context, cb) {
     if (!storage) {
-      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
-        `);
+      throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
     }
-    return new Promise((resolve, reject) => {
-      storage.run(context, () => {
+    return new Promise(function(resolve, reject) {
+      storage.run(context, function() {
         try {
           return resolve(cb());
         } catch (error) {
@@ -19,20 +18,19 @@ const createStorage = () => {
       });
     });
   };
-  const useContext = () => {
+  var useContext = function() {
     if (!storage) {
-      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
-        `);
+      throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
     }
-    const context = storage.getStore();
+    var context = storage.getStore();
     if (!context) {
-      throw new Error(`Can't call useContext out of scope, make sure @modern-js/utils is a single version in node_modules`);
+      throw new Error("Can't call useContext out of scope, make sure @modern-js/utils is a single version in node_modules");
     }
     return context;
   };
   return {
-    run,
-    useContext
+    run: run,
+    useContext: useContext
   };
 };
 export { createStorage };

package/dist/esm/universal/constants.js

@@ -1,3 +1,3 @@
-export const ROUTE_MANIFEST = `_MODERNJS_ROUTE_MANIFEST`;
-export const HMR_SOCK_PATH = "/webpack-hmr";
-export const HTML_CHUNKSMAP_SEPARATOR = "<!--<?- chunksMap.js ?>-->";
+export var ROUTE_MANIFEST = "_MODERNJS_ROUTE_MANIFEST";
+export var HMR_SOCK_PATH = "/webpack-hmr";
+export var HTML_CHUNKSMAP_SEPARATOR = "<!--<?- chunksMap.js ?>-->";