@modern-js/utils 2.12.0 → 2.12.1-alpha.1

package/dist/esm/path.js

@@ -0,0 +1,85 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import path from "path";
+import os from "os";
+import fs from "fs";
+import { nanoid, upath, lodash as _ } from "./compiled";
+var isPathString = function(test) {
+    return path.posix.basename(test) !== test || path.win32.basename(test) !== test;
+};
+var isRelativePath = function(test) {
+    return /^\.\.?($|[\\/])/.test(test);
+};
+var normalizeOutputPath = function(s) {
+    return s.replace(/\\/g, "\\\\");
+};
+var normalizeToPosixPath = function(p) {
+    return upath.normalizeSafe(path.normalize(p || "")).replace(/^([a-zA-Z]+):/, function(_2, m) {
+        return "/".concat(m.toLowerCase());
+    });
+};
+var getTemplatePath = function(prefix) {
+    var _path;
+    var tmpRoot = fs.realpathSync(os.tmpdir());
+    var parts = [
+        tmpRoot
+    ];
+    prefix && parts.push(prefix);
+    parts.push(nanoid());
+    return (_path = path).resolve.apply(_path, _toConsumableArray(parts));
+};
+function compilePathMatcherRegExp(match) {
+    if (typeof match !== "string") {
+        return match;
+    }
+    var escaped = _.escapeRegExp(match);
+    return new RegExp("(?<=\\W|^)".concat(escaped, "(?=\\W|$)"));
+}
+var _joinPathParts = function(_part, i, parts) {
+    return _(parts).filter(function(part) {
+        return ![
+            "/",
+            "\\"
+        ].includes(part);
+    }).tap(function(parts2) {
+        return parts2.unshift("");
+    }).slice(0, i + 2).join("/");
+};
+function upwardPaths(start) {
+    return _(start).split(/[/\\]/).filter(Boolean).map(_joinPathParts).reverse().push("/").value();
+}
+function getRealTemporaryDirectory() {
+    var ret = null;
+    try {
+        ret = os.tmpdir();
+        ret = fs.realpathSync(ret);
+    } catch (e) {}
+    return ret;
+}
+function splitPathString(str) {
+    return str.split(/[\\/]/);
+}
+export { _joinPathParts, compilePathMatcherRegExp, getRealTemporaryDirectory, getTemplatePath, isPathString, isRelativePath, normalizeOutputPath, normalizeToPosixPath, splitPathString, upwardPaths };

package/dist/esm/pathSerializer.js

@@ -0,0 +1,85 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import os from "os";
+import _ from "../compiled/lodash";
+import { compilePathMatcherRegExp, normalizeToPosixPath, getRealTemporaryDirectory, splitPathString, upwardPaths } from "./path";
+var matchUpwardPathsAsUnknown = function(p) {
+    return _(upwardPaths(normalizeToPosixPath(p))).map(function(match) {
+        return {
+            match: match,
+            mark: "unknown"
+        };
+    }).slice(1, -1).value();
+};
+function applyPathMatcher(matcher, str) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var regex = compilePathMatcherRegExp(matcher.match);
+    var replacer = function(substring) {
+        for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            args[_key - 1] = arguments[_key];
+        }
+        var _matcher;
+        if (options.minPartials && splitPathString(substring).length < options.minPartials) {
+            return substring;
+        }
+        var ret = typeof matcher.mark === "string" ? matcher.mark : (_matcher = matcher).mark.apply(_matcher, [
+            substring
+        ].concat(_toConsumableArray(args)));
+        return "<".concat(_.snakeCase(ret).toUpperCase(), ">");
+    };
+    return str.replace(regex, replacer);
+}
+function applyMatcherReplacement(matchers, str) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    return matchers.reduce(function(ret, matcher) {
+        return applyPathMatcher(matcher, ret, options);
+    }, str);
+}
+var createDefaultPathMatchers = function(root) {
+    var _ret;
+    var ret = [
+        {
+            match: RegExp("(?<=\\/)(\\.pnpm\\/.+?\\/node_modules)(?=\\/)"),
+            mark: "pnpmInner"
+        }
+    ];
+    var tmpdir = getRealTemporaryDirectory();
+    tmpdir && ret.push({
+        match: tmpdir,
+        mark: "temp"
+    });
+    ret.push({
+        match: os.tmpdir(),
+        mark: "temp"
+    });
+    ret.push({
+        match: os.homedir(),
+        mark: "home"
+    });
+    (_ret = ret).push.apply(_ret, _toConsumableArray(matchUpwardPathsAsUnknown(root)));
+    return ret;
+};
+export { applyMatcherReplacement, applyPathMatcher, createDefaultPathMatchers, matchUpwardPathsAsUnknown };

package/dist/esm/plugin.js

@@ -0,0 +1,45 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import { INTERNAL_CLI_PLUGINS } from "./constants";
+import { isDepExists } from "./is";
+function getInternalPlugins(appDirectory) {
+    var internalPlugins = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : INTERNAL_CLI_PLUGINS;
+    return _toConsumableArray(Object.keys(internalPlugins).filter(function(name) {
+        var config = internalPlugins[name];
+        if (typeof config !== "string" && config.forced === true) {
+            return true;
+        }
+        return isDepExists(appDirectory, name);
+    }).map(function(name) {
+        var config = internalPlugins[name];
+        if (typeof config !== "string") {
+            return config.path;
+        } else {
+            return config;
+        }
+    }));
+}
+export { getInternalPlugins };

package/dist/esm/prettyInstructions.js

@@ -0,0 +1,96 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import os from "os";
+import { chalk } from "./compiled";
+import { isDev, isSingleEntry } from "./is";
+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);
+            }
+        });
+    });
+    return ipv4Interfaces;
+};
+var getAddressUrls = function() {
+    var protocol = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "http", port = arguments.length > 1 ? arguments[1] : void 0;
+    var ipv4Interfaces = getIpv4Interfaces();
+    return ipv4Interfaces.reduce(function(memo, detail) {
+        var label = "Network:  ";
+        var url = "".concat(protocol, "://").concat(detail.address, ":").concat(port);
+        if (detail.address.includes("localhost") || detail.internal) {
+            label = "Local:  ";
+            url = "".concat(protocol, "://localhost:").concat(port);
+        }
+        memo.push({
+            label: label,
+            url: url
+        });
+        return memo;
+    }, []);
+};
+var prettyInstructions = function(appContext, config) {
+    var entrypoints = appContext.entrypoints, serverRoutes = appContext.serverRoutes, port = appContext.port, apiOnly = appContext.apiOnly, checkedEntries = appContext.checkedEntries;
+    var urls = getAddressUrls(config.dev.https && isDev() ? "https" : "http", port);
+    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(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 {
+        var _Math;
+        var maxNameLength = (_Math = Math).max.apply(_Math, _toConsumableArray(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(param) {
+                var entryName = param.entryName, urlPath = param.urlPath, isSSR = param.isSSR;
+                if (!checkedEntries.includes(entryName)) {
+                    return;
+                }
+                message += "    ".concat(chalk.yellowBright(isSSR ? "λ" : "○"), "  ").concat(chalk.yellowBright(entryName.padEnd(maxNameLength + 8))).concat(chalk.cyanBright(normalizeUrl("".concat(url, "/").concat(urlPath))), "\n");
+            });
+        });
+        message += "\n";
+        message += chalk.cyanBright("  λ (Server) server-side renders at runtime\n");
+        message += chalk.cyanBright("  ○ (Static) client-side renders as static HTML\n");
+    }
+    return message;
+};
+export { getAddressUrls, getIpv4Interfaces, prettyInstructions };

package/dist/esm/printBuildError.js

@@ -0,0 +1,24 @@
+import { chalk } from "./compiled";
+import { logger } from "./logger";
+function printBuildError(err) {
+    var message = err != null && err.message;
+    var stack = err != null && err.stack;
+    if (stack && typeof message === "string" && message.indexOf("from Terser") !== -1) {
+        try {
+            var matched = /(.+)\[(.+):(.+),(.+)\]\[.+\]/.exec(stack);
+            if (!matched) {
+                throw new Error("Using errors for control flow is bad.");
+            }
+            var problemPath = matched[2];
+            var line = matched[3];
+            var column = matched[4];
+            logger.error("Failed to minify the code from this file: \n\n ".concat(chalk.yellow("	".concat(problemPath, ":").concat(line).concat(column !== "0" ? ":" + column : "")), "\n"));
+        } catch (ignored) {
+            logger.error("Failed to minify the bundle. ".concat(err, "\n"));
+        }
+    } else {
+        logger.error((message || err) + "\n");
+    }
+    logger.log();
+}
+export { printBuildError };

package/dist/esm/react.js

@@ -0,0 +1,43 @@
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+import path from "path";
+import { fs, semver } from ".";
+var isBeyondReact17 = function(cwd) {
+    var pkgPath = path.join(cwd, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+        return false;
+    }
+    var pkgInfo = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    var deps = _objectSpread({}, pkgInfo.devDependencies, pkgInfo.dependencies);
+    if (typeof deps.react !== "string") {
+        return false;
+    }
+    return semver.satisfies(semver.minVersion(deps.react), ">=17.0.0");
+};
+export { isBeyondReact17 };

package/dist/esm/readTsConfig.js

@@ -0,0 +1,10 @@
+import path from "path";
+import { fs, json5 } from "./compiled";
+var readTsConfig = function(root) {
+    return readTsConfigByFile(path.resolve(root, "./tsconfig.json"));
+};
+var readTsConfigByFile = function(filename) {
+    var content = fs.readFileSync(path.resolve(filename), "utf-8");
+    return json5.parse(content);
+};
+export { readTsConfig, readTsConfigByFile };

package/dist/esm/removeSlash.js

@@ -0,0 +1,10 @@
+var removeLeadingSlash = function(s) {
+    return s.replace(/^\/+/, "");
+};
+var removeTailSlash = function(s) {
+    return s.replace(/\/+$/, "");
+};
+var removeSlash = function(s) {
+    return removeLeadingSlash(removeTailSlash(s));
+};
+export { removeLeadingSlash, removeSlash, removeTailSlash };

package/dist/esm/resolve.js

@@ -0,0 +1,42 @@
+import { ensureArray } from "./ensureArray";
+var tryResolve = function(name, resolvePath) {
+    var filePath = "";
+    try {
+        filePath = require.resolve(name, {
+            paths: [
+                resolvePath
+            ]
+        });
+        delete require.cache[filePath];
+    } catch (err) {
+        if (err.code === "MODULE_NOT_FOUND") {
+            throw new Error("Can not find module ".concat(name, "."));
+        }
+        throw err;
+    }
+    return filePath;
+};
+var isPackageInstalled = function(name, resolvePaths) {
+    try {
+        require.resolve(name, {
+            paths: ensureArray(resolvePaths)
+        });
+        return true;
+    } catch (err) {
+        return false;
+    }
+};
+var getAntdMajorVersion = function(appDirectory) {
+    try {
+        var pkgJsonPath = require.resolve("antd/package.json", {
+            paths: [
+                appDirectory
+            ]
+        });
+        var version = require(pkgJsonPath).version;
+        return Number(version.split(".")[0]);
+    } catch (err) {
+        return null;
+    }
+};
+export { getAntdMajorVersion, isPackageInstalled, tryResolve };

package/dist/esm/routes.js

@@ -0,0 +1,19 @@
+import path from "path";
+import { normalizeToPosixPath } from "./path";
+import { MAIN_ENTRY_NAME } from "./constants";
+var getPathWithoutExt = function(filename) {
+    var extname = path.extname(filename);
+    return filename.slice(0, -extname.length);
+};
+var getRouteId = function(componentPath, routesDir, entryName) {
+    var relativePath = normalizeToPosixPath(path.relative(routesDir, componentPath));
+    var pathWithoutExt = getPathWithoutExt(relativePath);
+    var id = "";
+    if (entryName === MAIN_ENTRY_NAME) {
+        id = pathWithoutExt;
+    } else {
+        id = "".concat(entryName, "_").concat(pathWithoutExt);
+    }
+    return id;
+};
+export { getPathWithoutExt, getRouteId };

package/dist/esm/runtimeExports.js

@@ -0,0 +1,65 @@
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+import path from "path";
+import { fs } from "./compiled";
+import { normalizeOutputPath } from "./path";
+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;
+        }
+        var res = fn.apply(void 0, _toConsumableArray(params));
+        cache.set(stringifiedParams, res);
+        return res;
+    };
+};
+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, "".concat(statement, "\n"));
+            }
+        } catch (e) {}
+    };
+    var getPath = function() {
+        return entryExportFile;
+    };
+    return {
+        addExport: addExport,
+        getPath: getPath
+    };
+});
+export { createRuntimeExportsUtils };

package/dist/esm/ssr.js

@@ -0,0 +1,3 @@
+import { createStorage } from "./storage";
+var _createStorage = createStorage(), run = _createStorage.run, useHeaders = _createStorage.useContext;
+export { run, useHeaders };

package/dist/esm/storage.js

@@ -0,0 +1,36 @@
+import * as ah from "async_hooks";
+var createStorage = function() {
+    var storage;
+    if (typeof ah.AsyncLocalStorage !== "undefined") {
+        storage = new ah.AsyncLocalStorage();
+    }
+    var run = function(context, cb) {
+        if (!storage) {
+            throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
+        }
+        return new Promise(function(resolve, reject) {
+            storage.run(context, function() {
+                try {
+                    return resolve(cb());
+                } catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    var useContext = function() {
+        if (!storage) {
+            throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
+        }
+        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");
+        }
+        return context;
+    };
+    return {
+        run: run,
+        useContext: useContext
+    };
+};
+export { createStorage };

package/dist/esm/testUtils.js

@@ -0,0 +1,13 @@
+var initSnapshotSerializer = function(root) {
+    expect.addSnapshotSerializer({
+        test: function(val) {
+            return typeof val === "string" && (val.includes("modern.js") || val.includes("node_modules") || val.includes(root));
+        },
+        print: function(val) {
+            return(// eslint-disable-next-line no-nested-ternary
+            typeof val === "string" ? // eslint-disable-next-line no-nested-ternary
+            val.includes("node_modules") ? '"'.concat(val.replace(/.+node_modules/, "").replace(/\\/g, "/"), '"') : val.includes("modern.js") ? '"'.concat(val.replace(/.+modern\.js/, "").replace(/\\/g, "/"), '"') : '"'.concat(val.replace(root, "").replace(/\\/g, "/"), '"') : val);
+        }
+    });
+};
+export { initSnapshotSerializer };

package/dist/esm/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/esm/universal/constants.js

@@ -0,0 +1,3 @@
+var ROUTE_MANIFEST = "_MODERNJS_ROUTE_MANIFEST";
+var HMR_SOCK_PATH = "/webpack-hmr";
+export { HMR_SOCK_PATH, ROUTE_MANIFEST };