@modern-js/utils 2.69.7 → 3.0.0-alpha.1

package/dist/esm-node/cli/config.mjs

@@ -0,0 +1,5 @@
+const isOverriddenConfigKey = (key)=>[
+        'removeConsole',
+        'baseUrl'
+    ].includes(key);
+export { isOverriddenConfigKey };

package/dist/esm-node/cli/constants.mjs

@@ -0,0 +1,29 @@
+import { DEFAULT_ENTRY_NAME, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_PLUGIN_BFF, SERVER_PLUGIN_POLYFILL, SERVER_RENDER_FUNCTION_NAME } from "../universal/constants.mjs";
+const JS_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.jsx',
+    '.tsx'
+];
+const SERVER_WORKER_BUNDLE_DIRECTORY = 'worker';
+const ENTRY_NAME_PATTERN = '^[a-zA-Z0-9_-]+$';
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const API_DIR = 'api';
+const DEFAULT_API_PREFIX = '/api';
+const SERVER_DIR = 'server';
+const SHARED_DIR = 'shared';
+const CONFIG_CACHE_DIR = './node_modules/.cache/bundle-require';
+const CONFIG_FILE_EXTENSIONS = [
+    '.js',
+    '.ts',
+    '.mjs'
+];
+const OUTPUT_CONFIG_FILE = 'modern.config.json';
+const DEFAULT_RUNTIME_CONFIG = 'modern.runtime';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const LOADER_ROUTES_DIR = "loader-routes";
+const DEFAULT_DEV_HOST = '0.0.0.0';
+const INTERNAL_RUNTIME_PLUGINS = {
+    '@modern-js/runtime': '@modern-js/runtime/cli'
+};
+export { API_DIR, CONFIG_CACHE_DIR, CONFIG_FILE_EXTENSIONS, DEFAULT_API_PREFIX, DEFAULT_DEV_HOST, DEFAULT_ENTRY_NAME, DEFAULT_RUNTIME_CONFIG, ENTRY_NAME_PATTERN, INTERNAL_RUNTIME_PLUGINS, JS_EXTENSIONS, LOADABLE_STATS_FILE, LOADER_ROUTES_DIR, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, OUTPUT_CONFIG_FILE, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_DIR, SERVER_PLUGIN_BFF, SERVER_PLUGIN_POLYFILL, SERVER_RENDER_FUNCTION_NAME, SERVER_WORKER_BUNDLE_DIRECTORY, SHARED_DIR };

package/dist/esm-node/cli/ensure.mjs

@@ -0,0 +1,9 @@
+import path from "path";
+const ensureAbsolutePath = (base, filePath)=>path.isAbsolute(filePath) ? filePath : path.resolve(base, filePath);
+const ensureArray = (params)=>{
+    if (Array.isArray(params)) return params;
+    return [
+        params
+    ];
+};
+export { ensureAbsolutePath, ensureArray };

package/dist/esm-node/cli/fs.mjs

@@ -0,0 +1,9 @@
+import { fs } from "../compiled.mjs";
+const findExists = (files)=>{
+    for (const file of files)if (fs.existsSync(file) && fs.statSync(file).isFile()) return file;
+    return false;
+};
+const emptyDir = async (dir)=>{
+    if (await fs.pathExists(dir)) await fs.emptyDir(dir);
+};
+export { emptyDir, findExists };

package/dist/esm-node/cli/get/config.mjs

@@ -0,0 +1,14 @@
+import { isPlainObject } from "../is/index.mjs";
+const getEntryOptions = (name, isMainEntry, baseOptions, optionsByEntries, packageName)=>{
+    if (!optionsByEntries) return baseOptions;
+    {
+        let optionsByEntry = getOptionsByEntryName(name, optionsByEntries);
+        if (void 0 === optionsByEntry && isMainEntry && packageName) optionsByEntry = getOptionsByEntryName(packageName, optionsByEntries);
+        return void 0 !== optionsByEntry ? isPlainObject(optionsByEntry) && isPlainObject(baseOptions) ? {
+            ...baseOptions,
+            ...optionsByEntry
+        } : optionsByEntry : baseOptions;
+    }
+};
+const getOptionsByEntryName = (name, optionsByEntries)=>optionsByEntries.hasOwnProperty(name) ? optionsByEntries[name] : void 0;
+export { getEntryOptions };

package/dist/esm-node/cli/get/data.mjs

@@ -0,0 +1,57 @@
+import os from "os";
+import path from "path";
+import { browserslist, fs, json5 } from "../../compiled.mjs";
+import { isDepExists } from "../is/index.mjs";
+import { canUsePnpm, canUseYarn } from "../package.mjs";
+const MAX_TIMES = 5;
+async function getPackageManager(cwd = process.cwd()) {
+    let appDirectory = cwd;
+    let times = 0;
+    while(os.homedir() !== appDirectory && times < MAX_TIMES){
+        times++;
+        if (fs.existsSync(path.resolve(appDirectory, 'pnpm-lock.yaml'))) return 'pnpm';
+        if (fs.existsSync(path.resolve(appDirectory, 'yarn.lock'))) return 'yarn';
+        if (fs.existsSync(path.resolve(appDirectory, 'package-lock.json'))) return 'npm';
+        appDirectory = path.join(appDirectory, '..');
+    }
+    if (await canUsePnpm()) return 'pnpm';
+    if (await canUseYarn()) return 'yarn';
+    return 'npm';
+}
+const getCoreJsVersion = (corejsPkgPath)=>{
+    try {
+        const { version } = fs.readJSONSync(corejsPkgPath);
+        const [major, minor] = version.split('.');
+        return `${major}.${minor}`;
+    } catch (err) {
+        return '3';
+    }
+};
+const defaults = [
+    'chrome >= 87',
+    'edge >= 88',
+    'firefox >= 78',
+    'safari >= 14'
+];
+const getBrowserslist = (appDirectory)=>browserslist.loadConfig({
+        path: appDirectory
+    }) || defaults;
+function getInternalPlugins(appDirectory, internalPlugins = {}) {
+    return [
+        ...Object.keys(internalPlugins).filter((name)=>{
+            const config = internalPlugins[name];
+            if ('string' != typeof config && true === config.forced) return true;
+            return isDepExists(appDirectory, name);
+        }).map((name)=>{
+            const config = internalPlugins[name];
+            if ('string' != typeof config) return config.path;
+            return config;
+        })
+    ];
+}
+const readTsConfig = (root)=>readTsConfigByFile(path.resolve(root, './tsconfig.json'));
+const readTsConfigByFile = (filename)=>{
+    const content = fs.readFileSync(path.resolve(filename), 'utf-8');
+    return json5.parse(content);
+};
+export { defaults, getBrowserslist, getCoreJsVersion, getInternalPlugins, getPackageManager, readTsConfig, readTsConfigByFile };

package/dist/esm-node/cli/get/index.mjs

@@ -0,0 +1,18 @@
+import path from "path";
+import { CONFIG_FILE_EXTENSIONS } from "../constants.mjs";
+import { findExists } from "../fs.mjs";
+export * from "./data.mjs";
+export * from "./config.mjs";
+const getServerConfig = async (appDirectory, configFile)=>{
+    const configFilePath = findExists(CONFIG_FILE_EXTENSIONS.map((extension)=>path.resolve(appDirectory, `${configFile}${extension}`)));
+    return configFilePath;
+};
+const getMeta = (metaName = 'modern-js')=>{
+    const meta = metaName.toLowerCase().split('-')[0];
+    return meta;
+};
+const getTargetDir = (from, baseDir, targetBaseDir)=>{
+    const relativePath = path.relative(baseDir, from);
+    return path.resolve(targetBaseDir, relativePath);
+};
+export { getMeta, getServerConfig, getTargetDir };

package/dist/esm-node/cli/index.mjs

@@ -0,0 +1,22 @@
+export * from "./constants.mjs";
+export * from "./get/index.mjs";
+export * from "./is/index.mjs";
+export * from "./alias.mjs";
+export * from "./applyOptionsChain.mjs";
+export * from "./babel.mjs";
+export * from "./commands.mjs";
+export * from "./common.mjs";
+export * from "./ensure.mjs";
+export * from "./fs.mjs";
+export * from "./logger.mjs";
+export * from "./monorepo.mjs";
+export * from "./package.mjs";
+export * from "./path.mjs";
+export * from "./port.mjs";
+export * from "./prettyInstructions.mjs";
+export * from "./require.mjs";
+export * from "./runtimeExports.mjs";
+export * from "./watch.mjs";
+export * from "./config.mjs";
+export * from "./version.mjs";
+export * from "./route.mjs";

package/dist/esm-node/cli/is/config.mjs

@@ -0,0 +1,34 @@
+import { MAIN_ENTRY_NAME } from "../constants.mjs";
+import { isEmpty } from "./type.mjs";
+const isSSR = (config)=>{
+    const { server } = config;
+    if (server?.ssr) return true;
+    if (server?.ssrByEntries && !isEmpty(server.ssrByEntries)) {
+        for (const name of Object.keys(server.ssrByEntries))if (server.ssrByEntries[name]) return true;
+    }
+    return false;
+};
+const isUseSSRBundle = (config)=>{
+    const { output } = config;
+    if (output?.ssg || output?.ssgByEntries && Object.keys(output?.ssgByEntries).length > 0) return true;
+    return isSSR(config);
+};
+const isUseRsc = (config)=>config?.server?.rsc;
+const isServiceWorker = (config)=>{
+    const { output, deploy } = config;
+    if (deploy?.worker?.ssr && (output?.ssg || isSSR(config))) return true;
+    return false;
+};
+const isSSGEntry = (config, entryName, entrypoints)=>{
+    const { output, source } = config;
+    const single = isSingleEntry(entrypoints, source?.mainEntryName);
+    if (single) {
+        const byEntries = output?.ssgByEntries;
+        return Boolean(output?.ssg) || byEntries && !isEmpty(byEntries);
+    }
+    const byEntries = output?.ssgByEntries;
+    if (!byEntries || isEmpty(byEntries)) return false;
+    return Boolean(byEntries[entryName]);
+};
+const isSingleEntry = (entrypoints, mainEntryName = MAIN_ENTRY_NAME)=>1 === entrypoints.length && entrypoints[0].entryName === mainEntryName;
+export { isSSGEntry, isSSR, isServiceWorker, isSingleEntry, isUseRsc, isUseSSRBundle };

package/dist/esm-node/cli/is/env.mjs

@@ -0,0 +1,6 @@
+const getNodeEnv = ()=>process.env.NODE_ENV || 'development';
+const isDev = ()=>'development' === getNodeEnv();
+const isProd = ()=>'production' === getNodeEnv();
+const isTest = ()=>'test' === getNodeEnv();
+const isBrowser = ()=>"u" > typeof window;
+export { getNodeEnv, isBrowser, isDev, isProd, isTest };

package/dist/esm-node/cli/is/index.mjs

@@ -0,0 +1,4 @@
+export * from "./env.mjs";
+export * from "./type.mjs";
+export * from "./config.mjs";
+export * from "./project.mjs";

package/dist/esm-node/cli/is/project.mjs

@@ -0,0 +1,104 @@
+import path from "path";
+import { fs, minimist, semver } from "../../compiled.mjs";
+import { getArgv } from "../commands.mjs";
+import { createDebugger } from "../common.mjs";
+import { ensureArray } from "../ensure.mjs";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+const index_js_namespaceObject = __rspack_createRequire_require("../../../compiled/pkg-up/index.js");
+var index_js_default = /*#__PURE__*/ __webpack_require__.n(index_js_namespaceObject);
+const debug = createDebugger('judge-depExists');
+const isDepExists = (appDirectory, name)=>{
+    const pkgPath = path.resolve(appDirectory, './package.json');
+    if (!fs.existsSync(pkgPath)) {
+        debug("can't find package.json under: %s", appDirectory);
+        return false;
+    }
+    const json = require(pkgPath);
+    const { dependencies = {}, devDependencies = {} } = json;
+    return dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name);
+};
+const isPackageInstalled = (name, resolvePaths)=>{
+    try {
+        require.resolve(name, {
+            paths: ensureArray(resolvePaths)
+        });
+        return true;
+    } catch (err) {
+        return false;
+    }
+};
+const isApiOnly = async (appDirectory, entryDir, apiDir)=>{
+    const existApi = await fs.pathExists(apiDir ?? path.join(appDirectory, 'api'));
+    const existSrc = await fs.pathExists(path.join(appDirectory, entryDir ?? 'src'));
+    const options = minimist(getArgv());
+    if (options['api-only']) return true;
+    return existApi && !existSrc;
+};
+const isWebOnly = async ()=>{
+    const options = minimist(getArgv());
+    return Boolean(options['web-only']);
+};
+const isVersionBeyond17 = (version)=>semver.gte(semver.minVersion(version), '17.0.0');
+const getReactVersion = (cwd)=>{
+    const pkgPath = index_js_default().sync({
+        cwd
+    });
+    if (!pkgPath) return false;
+    const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const deps = {
+        ...pkgInfo.devDependencies,
+        ...pkgInfo.dependencies
+    };
+    if ('string' != typeof deps.react) return false;
+    try {
+        const reactPath = require.resolve('react/package.json', {
+            paths: [
+                cwd
+            ]
+        });
+        const reactVersion = JSON.parse(fs.readFileSync(reactPath, 'utf8')).version;
+        return reactVersion;
+    } catch (error) {
+        console.error('Failed to resolve React version:', error);
+        return false;
+    }
+};
+const isBeyondReact17 = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return isVersionBeyond17(reactVersion);
+};
+const isSupportAutomaticJsx = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return semver.satisfies(semver.minVersion(reactVersion), '>=16.14.0');
+};
+const isReact18 = (cwd = process.cwd())=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return semver.gte(semver.minVersion(reactVersion), '18.0.0');
+};
+const isTypescript = (root)=>fs.existsSync(path.resolve(root, './tsconfig.json'));
+export { getReactVersion, isApiOnly, isBeyondReact17, isDepExists, isPackageInstalled, isReact18, isSupportAutomaticJsx, isTypescript, isVersionBeyond17, isWebOnly };

package/dist/esm-node/cli/is/type.mjs

@@ -0,0 +1,26 @@
+function isString(str) {
+    return 'string' == typeof str;
+}
+function isUndefined(obj) {
+    return void 0 === obj;
+}
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+function isFunction(func) {
+    return 'function' == typeof func;
+}
+function isObject(obj) {
+    return null !== obj && 'object' == typeof obj;
+}
+function isPlainObject(obj) {
+    return isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj);
+}
+function isPromise(obj) {
+    return Boolean(obj) && ('object' == typeof obj || 'function' == typeof obj) && 'function' == typeof obj.then;
+}
+function isRegExp(obj) {
+    return '[object RegExp]' === Object.prototype.toString.call(obj);
+}
+const isEmpty = (o)=>0 === Object.entries(o).length && o.constructor === Object;
+export { isArray, isEmpty, isFunction, isObject, isPlainObject, isPromise, isRegExp, isString, isUndefined };

package/dist/esm-node/cli/logger.mjs

@@ -0,0 +1,2 @@
+import { createLogger, logger } from "rslog";
+export { createLogger, logger };

package/dist/esm-node/cli/monorepo.mjs

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+import { glob, yaml } from "../compiled.mjs";
+const PACKAGE_MAX_DEPTH = 5;
+const WORKSPACE_FILES = {
+    YARN: 'package.json',
+    PNPM: 'pnpm-workspace.yaml',
+    LERNA: 'lerna.json'
+};
+const isLerna = (root)=>fs.existsSync(path.join(root, WORKSPACE_FILES.LERNA));
+const isYarnWorkspaces = (root)=>{
+    const pkg = path.join(root, WORKSPACE_FILES.YARN);
+    if (!fs.existsSync(pkg)) return false;
+    const json = JSON.parse(fs.readFileSync(pkg, 'utf8'));
+    return Boolean(json.workspaces?.packages);
+};
+const isPnpmWorkspaces = (root)=>fs.existsSync(path.join(root, WORKSPACE_FILES.PNPM));
+const isMonorepo = (root)=>isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
+const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH)=>{
+    let inMonorepo = false;
+    let monorepoRoot = appDirectory;
+    for(let depth = 0; depth < maxDepth; depth++){
+        if (isMonorepo(appDirectory)) {
+            inMonorepo = true;
+            break;
+        }
+        monorepoRoot = path.dirname(appDirectory);
+    }
+    return inMonorepo ? monorepoRoot : void 0;
+};
+const getMonorepoPackages = (root)=>{
+    let packages = [];
+    if (isYarnWorkspaces(root)) {
+        const json = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+        ({ packages } = json.workspaces);
+    } else if (isLerna(root)) {
+        const json = JSON.parse(fs.readFileSync(path.resolve(root, 'lerna.json'), 'utf8'));
+        ({ packages } = json);
+    } else ({ packages } = yaml.load(fs.readFileSync(path.join(root, WORKSPACE_FILES.PNPM), 'utf8')));
+    if (packages) return packages.map((name)=>glob.sync(path.join(root, `${name}/`), {
+            ignore: [
+                '**/node_modules/**'
+            ]
+        })).reduce((acc, val)=>acc.concat(val), []).filter((filepath)=>fs.existsSync(path.resolve(filepath, 'package.json'))).map((filepath)=>({
+            path: filepath,
+            name: JSON.parse(fs.readFileSync(path.resolve(filepath, 'package.json'), 'utf8')).name
+        }));
+    return [];
+};
+export { findMonorepoRoot, getMonorepoPackages, isLerna, isMonorepo, isPnpmWorkspaces, isYarnWorkspaces };

package/dist/esm-node/cli/package.mjs

@@ -0,0 +1,51 @@
+import { execa } from "../compiled.mjs";
+async function getPnpmVersion() {
+    const { stdout } = await execa('pnpm', [
+        '--version'
+    ]);
+    return stdout;
+}
+async function canUseNpm() {
+    try {
+        await execa('npm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUseYarn() {
+    try {
+        await execa('yarn', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUsePnpm() {
+    try {
+        await execa('pnpm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function removeModuleSyncFromExports(exports) {
+    if ('object' != typeof exports || null === exports) return exports;
+    if (Array.isArray(exports)) return exports.map(removeModuleSyncFromExports);
+    const result = {};
+    for (const [key, value] of Object.entries(exports))if ('module-sync' !== key) result[key] = removeModuleSyncFromExports(value);
+    return result;
+}
+export { canUseNpm, canUsePnpm, canUseYarn, getPnpmVersion, removeModuleSyncFromExports };

package/dist/esm-node/cli/path.mjs

@@ -0,0 +1,35 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { nanoid, upath } from "../compiled.mjs";
+const isPathString = (test)=>path.posix.basename(test) !== test || path.win32.basename(test) !== test;
+const isRelativePath = (test)=>/^\.\.?($|[\\/])/.test(test);
+const normalizeOutputPath = (s)=>s.replace(/\\/g, '\\\\');
+const normalizeToPosixPath = (p)=>upath.normalizeSafe(path.normalize(p || '')).replace(/^([a-zA-Z]+):/, (_, m)=>`/${m.toLowerCase()}`);
+const getTemplatePath = (prefix)=>{
+    const tmpRoot = fs.realpathSync(os.tmpdir());
+    const parts = [
+        tmpRoot
+    ];
+    prefix && parts.push(prefix);
+    parts.push(nanoid());
+    return path.resolve(...parts);
+};
+function getRealTemporaryDirectory() {
+    let ret = null;
+    try {
+        ret = os.tmpdir();
+        ret = fs.realpathSync(ret);
+    } catch  {}
+    return ret;
+}
+function splitPathString(str) {
+    return str.split(/[\\/]/);
+}
+const removeLeadingSlash = (s)=>s.replace(/^\/+/, '');
+const removeTailSlash = (s)=>s.replace(/\/+$/, '');
+const removeSlash = (s)=>removeLeadingSlash(removeTailSlash(s));
+function formatImportPath(str) {
+    return str.replace(/\\/g, '/');
+}
+export { formatImportPath, getRealTemporaryDirectory, getTemplatePath, isPathString, isRelativePath, normalizeOutputPath, normalizeToPosixPath, removeLeadingSlash, removeSlash, removeTailSlash, splitPathString };

package/dist/esm-node/cli/port.mjs

@@ -0,0 +1,35 @@
+import net from "net";
+import { chalk } from "../compiled.mjs";
+import { logger } from "./logger.mjs";
+const getPort = async (expectPort, { tryLimits = 20, strictPort = false, slient = false } = {})=>{
+    let port = expectPort;
+    if ('string' == typeof port) port = parseInt(port, 10);
+    if (strictPort) tryLimits = 1;
+    const original = port;
+    let found = false;
+    let attempts = 0;
+    while(!found && attempts <= tryLimits)try {
+        await new Promise((resolve, reject)=>{
+            const server = net.createServer();
+            server.unref();
+            server.on('error', reject);
+            server.listen({
+                port,
+                host: '0.0.0.0'
+            }, ()=>{
+                found = true;
+                server.close(resolve);
+            });
+        });
+    } catch (e) {
+        if ('EADDRINUSE' !== e.code) throw e;
+        port++;
+        attempts++;
+    }
+    if (port !== original) {
+        if (strictPort) throw new Error(`Port "${original}" is occupied, please choose another one.`);
+        else if (!slient) logger.info(`Port ${original} is in use. ${chalk.yellow(`using port ${port}.`)}`);
+    }
+    return port;
+};
+export { getPort };

package/dist/esm-node/cli/prettyInstructions.mjs

@@ -0,0 +1,68 @@
+import { isIPv6 } from "net";
+import os from "os";
+import { chalk } from "../compiled.mjs";
+import { DEFAULT_DEV_HOST } from "./constants.mjs";
+import { isDev, isSingleEntry } from "./is/index.mjs";
+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 = 'string' == typeof detail.family ? 'IPv4' : 4;
+            if (detail.family === familyV4Value) ipv4Interfaces.push(detail);
+        });
+    });
+    return ipv4Interfaces;
+};
+const getHostInUrl = (host)=>{
+    if (isIPv6(host)) return '::' === host ? '[::1]' : `[${host}]`;
+    return host;
+};
+const getAddressUrls = (protocol = 'http', port, host)=>{
+    const LOCAL_LABEL = 'Local:  ';
+    const NETWORK_LABEL = 'Network:  ';
+    const isLocalhost = (url)=>url?.includes('localhost');
+    if (host && host !== DEFAULT_DEV_HOST) return [
+        {
+            label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+            url: `${protocol}://${getHostInUrl(host)}:${port}`
+        }
+    ];
+    const ipv4Interfaces = getIpv4Interfaces();
+    return ipv4Interfaces.reduce((memo, detail)=>{
+        if (isLocalhost(detail.address) || detail.internal) memo.push({
+            label: LOCAL_LABEL,
+            url: `${protocol}://localhost:${port}`
+        });
+        else memo.push({
+            label: NETWORK_LABEL,
+            url: `${protocol}://${detail.address}:${port}`
+        });
+        return memo;
+    }, []);
+};
+const prettyInstructions = (appContext, config)=>{
+    const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+    const isHttps = isDev() && (config?.dev?.https || config?.tools?.devServer?.https);
+    const urls = getAddressUrls(isHttps ? 'https' : 'http', port, config.dev?.host);
+    const routes = apiOnly ? serverRoutes : serverRoutes.filter((route)=>route.entryName);
+    let message = '\n';
+    if (isSingleEntry(entrypoints, config.source?.mainEntryName) || apiOnly) message += urls.map(({ label, url })=>`  ${chalk.bold(`> ${label.padEnd(10)}`)}${chalk.cyanBright(normalizeUrl(`${url}/${routes[0].urlPath}`))}\n`).join('');
+    else {
+        const maxNameLength = Math.max(...routes.map((r)=>r.entryName.length));
+        urls.forEach(({ label, url })=>{
+            message += `  ${chalk.bold(`> ${label}`)}${0 === routes.length ? chalk.cyanBright(url) : ''}\n`;
+            routes.forEach(({ entryName, urlPath, isSSR })=>{
+                if (!checkedEntries.includes(entryName)) return;
+                message += `    ${chalk.yellowBright(isSSR ? 'λ' : '○')}  ${chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${chalk.cyanBright(normalizeUrl(`${url}/${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');
+    }
+    if (config.dev?.cliShortcuts) message += `  ${chalk.dim('> press')} ${chalk.bold('h + enter')} ${chalk.dim('to show shortcuts')}\n`;
+    return message;
+};
+export { getAddressUrls, prettyInstructions };