@modern-js/utils 2.22.0 → 2.22.1-alpha.1

package/dist/getBrowserslist.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getBrowserslist_exports = {};
+__export(getBrowserslist_exports, {
+  defaults: () => defaults,
+  getBrowserslist: () => getBrowserslist
+});
+module.exports = __toCommonJS(getBrowserslist_exports);
+var import_compiled = require("./compiled");
+const defaults = ["> 0.01%", "not dead", "not op_mini all"];
+const getBrowserslist = (appDirectory) => import_compiled.browserslist.loadConfig({ path: appDirectory }) || defaults;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaults,
+  getBrowserslist
+});

package/dist/getCoreJsVersion.d.ts

@@ -0,0 +1 @@
+export declare const getCoreJsVersion: (corejsPkgPath: string) => string;

package/dist/getCoreJsVersion.js

@@ -0,0 +1,46 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getCoreJsVersion_exports = {};
+__export(getCoreJsVersion_exports, {
+  getCoreJsVersion: () => getCoreJsVersion
+});
+module.exports = __toCommonJS(getCoreJsVersion_exports);
+var fs = __toESM(require("../compiled/fs-extra"));
+const getCoreJsVersion = (corejsPkgPath) => {
+  try {
+    const { version } = fs.readJSONSync(corejsPkgPath);
+    const [major, minor] = version.split(".");
+    return `${major}.${minor}`;
+  } catch (err) {
+    return "3";
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCoreJsVersion
+});

package/dist/getEntryOptions.d.ts

@@ -0,0 +1 @@
+export declare const getEntryOptions: <T>(name: string, baseOptions?: T | undefined, optionsByEntries?: Record<string, T> | undefined, packageName?: string) => T | undefined;

package/dist/getEntryOptions.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getEntryOptions_exports = {};
+__export(getEntryOptions_exports, {
+  getEntryOptions: () => getEntryOptions
+});
+module.exports = __toCommonJS(getEntryOptions_exports);
+var import_is = require("./is");
+var import_constants = require("./constants");
+const getEntryOptions = (name, baseOptions, optionsByEntries, packageName) => {
+  if (optionsByEntries) {
+    let optionsByEntry = getOptionsByEntryName(name, optionsByEntries);
+    if (optionsByEntry === void 0 && name === import_constants.MAIN_ENTRY_NAME && packageName) {
+      optionsByEntry = getOptionsByEntryName(packageName, optionsByEntries);
+    }
+    return optionsByEntry !== void 0 ? (0, import_is.isPlainObject)(optionsByEntry) && (0, import_is.isPlainObject)(baseOptions) ? __spreadValues(__spreadValues({}, baseOptions), optionsByEntry) : optionsByEntry : baseOptions;
+  } else {
+    return baseOptions;
+  }
+};
+const getOptionsByEntryName = (name, optionsByEntries) => optionsByEntries.hasOwnProperty(name) ? optionsByEntries[name] : void 0;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEntryOptions
+});

package/dist/getPackageManager.d.ts

@@ -0,0 +1 @@
+export declare function getPackageManager(cwd?: string): Promise<"npm" | "yarn" | "pnpm">;

package/dist/getPackageManager.js

@@ -0,0 +1,87 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getPackageManager_exports = {};
+__export(getPackageManager_exports, {
+  getPackageManager: () => getPackageManager
+});
+module.exports = __toCommonJS(getPackageManager_exports);
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_compiled = require("./compiled");
+var import_nodeEnv = require("./nodeEnv");
+const MAX_TIMES = 5;
+function getPackageManager() {
+  return __async(this, arguments, function* (cwd = process.cwd()) {
+    let appDirectory = cwd;
+    let times = 0;
+    while (import_os.default.homedir() !== appDirectory && times < MAX_TIMES) {
+      times++;
+      if (import_compiled.fs.existsSync(import_path.default.resolve(appDirectory, "pnpm-lock.yaml"))) {
+        return "pnpm";
+      }
+      if (import_compiled.fs.existsSync(import_path.default.resolve(appDirectory, "yarn.lock"))) {
+        return "yarn";
+      }
+      if (import_compiled.fs.existsSync(import_path.default.resolve(appDirectory, "package-lock.json"))) {
+        return "npm";
+      }
+      appDirectory = import_path.default.join(appDirectory, "..");
+    }
+    if (yield (0, import_nodeEnv.canUsePnpm)()) {
+      return "pnpm";
+    }
+    if (yield (0, import_nodeEnv.canUseYarn)()) {
+      return "yarn";
+    }
+    return "npm";
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPackageManager
+});

package/dist/getPort.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Get available free port.
+ * @param port - Current port want to use.
+ * @param tryLimits - Maximum number of retries.
+ * @param strictPort - Whether to throw an error when the port is occupied.
+ * @returns Available port number.
+ */
+export declare const getPort: (port: string | number, {
+  tryLimits,
+  strictPort
+}?: {
+  tryLimits?: number | undefined;
+  strictPort?: boolean | undefined;
+}) => Promise<number>;

package/dist/getPort.js

@@ -0,0 +1,112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getPort_exports = {};
+__export(getPort_exports, {
+  getPort: () => getPort
+});
+module.exports = __toCommonJS(getPort_exports);
+var import_net = __toESM(require("net"));
+var import_compiled = require("./compiled");
+var import_logger = require("./logger");
+const getPort = (_0, ..._1) => __async(void 0, [_0, ..._1], function* (port, {
+  tryLimits = 20,
+  strictPort = false
+} = {}) {
+  if (typeof port === "string") {
+    port = parseInt(port, 10);
+  }
+  if (strictPort) {
+    tryLimits = 1;
+  }
+  const original = port;
+  let found = false;
+  let attempts = 0;
+  while (!found && attempts <= tryLimits) {
+    try {
+      yield new Promise((resolve, reject) => {
+        const server = import_net.default.createServer();
+        server.unref();
+        server.on("error", reject);
+        server.listen(
+          {
+            port,
+            host: "0.0.0.0"
+          },
+          () => {
+            found = true;
+            server.close(resolve);
+          }
+        );
+      });
+    } catch (e) {
+      if (e.code !== "EADDRINUSE") {
+        throw e;
+      }
+      port++;
+      attempts++;
+    }
+  }
+  if (port !== original) {
+    if (strictPort) {
+      throw new Error(
+        `Port "${original}" is occupied, please choose another one.`
+      );
+    } else {
+      import_logger.logger.info(
+        `Something is already running on port ${original}. ${import_compiled.chalk.yellow(
+          `Use port ${port} instead.`
+        )}`
+      );
+    }
+  }
+  return port;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPort
+});

package/dist/getServerConfig.d.ts

@@ -0,0 +1 @@
+export declare const getServerConfig: (appDirectory: string, configFile: string) => Promise<string | false>;

package/dist/getServerConfig.js

@@ -0,0 +1,67 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getServerConfig_exports = {};
+__export(getServerConfig_exports, {
+  getServerConfig: () => getServerConfig
+});
+module.exports = __toCommonJS(getServerConfig_exports);
+var path = __toESM(require("path"));
+var import_constants = require("./constants");
+var import_findExists = require("./findExists");
+const getServerConfig = (appDirectory, configFile) => __async(void 0, null, function* () {
+  const configFilePath = (0, import_findExists.findExists)(
+    import_constants.CONFIG_FILE_EXTENSIONS.map(
+      (extension) => path.resolve(appDirectory, `${configFile}${extension}`)
+    )
+  );
+  return configFilePath;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getServerConfig
+});

package/dist/getTargetDir.d.ts

@@ -0,0 +1 @@
+export declare const getTargetDir: (from: string, baseDir: string, targetBaseDir: string) => string;

package/dist/getTargetDir.js

@@ -0,0 +1,41 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getTargetDir_exports = {};
+__export(getTargetDir_exports, {
+  getTargetDir: () => getTargetDir
+});
+module.exports = __toCommonJS(getTargetDir_exports);
+var path = __toESM(require("path"));
+const getTargetDir = (from, baseDir, targetBaseDir) => {
+  const relativePath = path.relative(baseDir, from);
+  return path.resolve(targetBaseDir, relativePath);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTargetDir
+});

package/dist/import.d.ts

@@ -0,0 +1,5 @@
+declare const lazy: (moduleName: string, requireFn: (id: string) => unknown) => any;
+export { lazy as lazyImport };
+export declare const Import: {
+  lazy: (moduleName: string, requireFn: (id: string) => unknown) => any;
+};

package/dist/import.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var import_exports = {};
+__export(import_exports, {
+  Import: () => Import,
+  lazyImport: () => lazy
+});
+module.exports = __toCommonJS(import_exports);
+const lazy = (moduleName, requireFn) => {
+  const importLazyLocal = require("../compiled/import-lazy")(requireFn);
+  return importLazyLocal(moduleName);
+};
+const Import = { lazy };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Import,
+  lazyImport
+});

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+export * from './compiled';
+export * from './commands';
+export * from './FileSizeReporter';
+export * from './printBuildError';
+export * from './debug';
+export * from './findExists';
+export * from './is';
+export * from './compatRequire';
+export * from './logger';
+export * from './constants';
+export * from './ensureArray';
+export * from './ensureAbsolutePath';
+export * from './clearConsole';
+export * from './applyOptionsChain';
+export * from './getBrowserslist';
+export * from './removeSlash';
+export * from './getEntryOptions';
+export * from './getPort';
+export * from './monorepo';
+export * from './getPackageManager';
+export * from './runtimeExports';
+export * from './readTsConfig';
+export * from './path';
+export * from './pathSerializer';
+export * from './generateMetaTags';
+export * from './prettyInstructions';
+export * from './alias';
+export * from './import';
+export * from './watch';
+export * from './nodeEnv';
+export * from './wait';
+export * from './emptyDir';
+export * from './getServerConfig';
+export * from './resolve';
+export * from './analyzeProject';
+export * from './chainId';
+export * from './version';
+export * from './plugin';
+export * from './routes';
+export * from './testUtils';
+export * from './getCoreJsVersion';
+export * from './react';
+export * from './getTargetDir';
+export * from './babel';

package/dist/index.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./compiled"), module.exports);
+__reExport(src_exports, require("./commands"), module.exports);
+__reExport(src_exports, require("./FileSizeReporter"), module.exports);
+__reExport(src_exports, require("./printBuildError"), module.exports);
+__reExport(src_exports, require("./debug"), module.exports);
+__reExport(src_exports, require("./findExists"), module.exports);
+__reExport(src_exports, require("./is"), module.exports);
+__reExport(src_exports, require("./compatRequire"), module.exports);
+__reExport(src_exports, require("./logger"), module.exports);
+__reExport(src_exports, require("./constants"), module.exports);
+__reExport(src_exports, require("./ensureArray"), module.exports);
+__reExport(src_exports, require("./ensureAbsolutePath"), module.exports);
+__reExport(src_exports, require("./clearConsole"), module.exports);
+__reExport(src_exports, require("./applyOptionsChain"), module.exports);
+__reExport(src_exports, require("./getBrowserslist"), module.exports);
+__reExport(src_exports, require("./removeSlash"), module.exports);
+__reExport(src_exports, require("./getEntryOptions"), module.exports);
+__reExport(src_exports, require("./getPort"), module.exports);
+__reExport(src_exports, require("./monorepo"), module.exports);
+__reExport(src_exports, require("./getPackageManager"), module.exports);
+__reExport(src_exports, require("./runtimeExports"), module.exports);
+__reExport(src_exports, require("./readTsConfig"), module.exports);
+__reExport(src_exports, require("./path"), module.exports);
+__reExport(src_exports, require("./pathSerializer"), module.exports);
+__reExport(src_exports, require("./generateMetaTags"), module.exports);
+__reExport(src_exports, require("./prettyInstructions"), module.exports);
+__reExport(src_exports, require("./alias"), module.exports);
+__reExport(src_exports, require("./import"), module.exports);
+__reExport(src_exports, require("./watch"), module.exports);
+__reExport(src_exports, require("./nodeEnv"), module.exports);
+__reExport(src_exports, require("./wait"), module.exports);
+__reExport(src_exports, require("./emptyDir"), module.exports);
+__reExport(src_exports, require("./getServerConfig"), module.exports);
+__reExport(src_exports, require("./resolve"), module.exports);
+__reExport(src_exports, require("./analyzeProject"), module.exports);
+__reExport(src_exports, require("./chainId"), module.exports);
+__reExport(src_exports, require("./version"), module.exports);
+__reExport(src_exports, require("./plugin"), module.exports);
+__reExport(src_exports, require("./routes"), module.exports);
+__reExport(src_exports, require("./testUtils"), module.exports);
+__reExport(src_exports, require("./getCoreJsVersion"), module.exports);
+__reExport(src_exports, require("./react"), module.exports);
+__reExport(src_exports, require("./getTargetDir"), module.exports);
+__reExport(src_exports, require("./babel"), module.exports);