@modern-js/server-utils 2.35.1 → 2.37.0

package/dist/cjs/common/index.js

@@ -1,25 +1,39 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  FILE_EXTENSIONS: function() {
-    return FILE_EXTENSIONS;
-  },
-  compile: function() {
-    return compile;
+    __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 common_exports = {};
+__export(common_exports, {
+  FILE_EXTENSIONS: () => FILE_EXTENSIONS,
+  compile: () => compile
 });
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _path = /* @__PURE__ */ _interop_require_wildcard._(require("path"));
-const _utils = require("@modern-js/utils");
+module.exports = __toCommonJS(common_exports);
+var path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
 const FILE_EXTENSIONS = [
   ".js",
   ".ts",
@@ -27,7 +41,7 @@ const FILE_EXTENSIONS = [
   ".ejs"
 ];
 const validateAbsolutePath = (filename, message) => {
-  if (!_path.isAbsolute(filename)) {
+  if (!path.isAbsolute(filename)) {
     throw new Error(message);
   }
 };
@@ -40,12 +54,17 @@ const compile = async (appDirectory, modernConfig, compileOptions) => {
   validateAbsolutePaths(sourceDirs, (dir) => `source dir ${dir} is not an absolute path.`);
   validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
   const compiler = modernConfig === null || modernConfig === void 0 ? void 0 : (_modernConfig_server = modernConfig.server) === null || _modernConfig_server === void 0 ? void 0 : _modernConfig_server.compiler;
-  const isTsProject = tsconfigPath && await _utils.fs.pathExists(tsconfigPath);
+  const isTsProject = tsconfigPath && await import_utils.fs.pathExists(tsconfigPath);
   if (!isTsProject || compiler === "babel") {
-    const { compileByBabel } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../compilers/babel")));
+    const { compileByBabel } = await Promise.resolve().then(() => __toESM(require("../compilers/babel")));
     await compileByBabel(appDirectory, modernConfig, compileOptions);
   } else {
-    const { compileByTs } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../compilers/typescript")));
+    const { compileByTs } = await Promise.resolve().then(() => __toESM(require("../compilers/typescript")));
     await compileByTs(appDirectory, modernConfig, compileOptions);
   }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FILE_EXTENSIONS,
+  compile
+});

package/dist/cjs/compilers/babel/index.js

@@ -1,42 +1,52 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  readTsConfig: function() {
-    return readTsConfig;
-  },
-  existTsConfigFile: function() {
-    return existTsConfigFile;
-  },
-  resolveBabelConfig: function() {
-    return resolveBabelConfig;
-  },
-  compileByBabel: function() {
-    return compileByBabel;
+    __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 babel_exports = {};
+__export(babel_exports, {
+  compileByBabel: () => compileByBabel,
+  existTsConfigFile: () => existTsConfigFile,
+  readTsConfig: () => readTsConfig,
+  resolveBabelConfig: () => resolveBabelConfig
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _path = /* @__PURE__ */ _interop_require_wildcard._(require("path"));
-const _utils = require("@modern-js/utils");
-const _babelcompiler = require("@modern-js/babel-compiler");
-const _common = require("../../common");
-const _preset = require("./preset");
-_export_star._(require("@babel/core"), exports);
+module.exports = __toCommonJS(babel_exports);
+var path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_babel_compiler = require("@modern-js/babel-compiler");
+var import_common = require("../../common");
+var import_preset = require("./preset");
+__reExport(babel_exports, require("@babel/core"), module.exports);
 const readTsConfig = (tsconfigPath, noExistReturn = null) => {
-  if (!_utils.fs.existsSync(tsconfigPath)) {
+  if (!import_utils.fs.existsSync(tsconfigPath)) {
     return noExistReturn;
   }
-  const content = _utils.fs.readFileSync(tsconfigPath, "utf-8");
-  return _utils.json5.parse(content);
+  const content = import_utils.fs.readFileSync(tsconfigPath, "utf-8");
+  return import_utils.json5.parse(content);
 };
 const existTsConfigFile = (tsconfigAbsolutePath) => {
   const tsconfig = readTsConfig(tsconfigAbsolutePath);
@@ -44,60 +54,37 @@ const existTsConfigFile = (tsconfigAbsolutePath) => {
 };
 const resolveBabelConfig = (appDirectory, config, option) => {
   const { alias, babelConfig } = config;
-  const aliasConfig = (0, _utils.getAliasConfig)(alias, {
+  const aliasConfig = (0, import_utils.getAliasConfig)(alias, {
     appDirectory,
     ...option
   });
-  const babelChain = (0, _preset.getBabelChain)({
+  const defaultBabelConfig = (0, import_preset.getBabelConfig)({
     appDirectory,
-    enableReactPreset: true,
-    enableTypescriptPreset: true,
     alias: aliasConfig
-  }, {
-    type: option.type,
-    syntax: option.syntax
   });
-  const envOptions = babelChain.preset("@babel/preset-env").options();
-  babelChain.preset("@babel/preset-env").use(require.resolve("@babel/preset-env"), [
-    {
-      ...envOptions[0],
-      loose: true
-    }
-  ]);
-  babelChain.plugin("babel-plugin-transform-typescript-metadata").use(require.resolve("babel-plugin-transform-typescript-metadata"), []);
-  babelChain.plugin("@babel/plugin-proposal-decorators").use(require.resolve("@babel/plugin-proposal-decorators"), [
-    {
-      legacy: true
-    }
-  ]);
-  const internalBabelConfig = {
-    ...babelChain.toJSON()
-  };
-  return (0, _preset.applyUserBabelConfig)(internalBabelConfig, babelConfig);
+  return (0, import_preset.applyUserBabelConfig)(defaultBabelConfig, babelConfig);
 };
 const compileByBabel = async (appDirectory, config, compileOptions) => {
   const { sourceDirs, distDir, tsconfigPath } = compileOptions;
   const results = await Promise.all(sourceDirs.map(async (sourceDir) => {
     const babelConfig = resolveBabelConfig(appDirectory, config, {
-      tsconfigPath: tsconfigPath ? tsconfigPath : "",
-      syntax: "es6+",
-      type: "commonjs"
+      tsconfigPath: tsconfigPath ? tsconfigPath : ""
     });
-    if (await _utils.fs.pathExists(sourceDir)) {
-      const basename = _path.basename(sourceDir);
-      const targetDir = _path.join(distDir, basename);
-      await _utils.fs.copy(sourceDir, targetDir, {
+    if (await import_utils.fs.pathExists(sourceDir)) {
+      const basename = path.basename(sourceDir);
+      const targetDir = path.join(distDir, basename);
+      await import_utils.fs.copy(sourceDir, targetDir, {
         filter: (src) => ![
           ".ts",
           ".js"
-        ].includes(_path.extname(src)) && src !== tsconfigPath
+        ].includes(path.extname(src)) && src !== tsconfigPath
       });
     }
-    return (0, _babelcompiler.compiler)({
+    return (0, import_babel_compiler.compiler)({
       rootDir: appDirectory,
       distDir,
       sourceDir,
-      extensions: _common.FILE_EXTENSIONS
+      extensions: import_common.FILE_EXTENSIONS
     }, babelConfig);
   }));
   results.forEach((result) => {
@@ -106,3 +93,11 @@ const compileByBabel = async (appDirectory, config, compileOptions) => {
     }
   });
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileByBabel,
+  existTsConfigFile,
+  readTsConfig,
+  resolveBabelConfig,
+  ...require("@babel/core")
+});

package/dist/cjs/compilers/babel/preset/alias.js

@@ -1,17 +1,39 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "aliasPlugin", {
-  enumerable: true,
-  get: function() {
-    return aliasPlugin;
+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 alias_exports = {};
+__export(alias_exports, {
+  aliasPlugin: () => aliasPlugin
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _tsconfigpaths = require("@modern-js/utils/tsconfig-paths");
-const _utils = require("@modern-js/utils");
+module.exports = __toCommonJS(alias_exports);
+var import_path = __toESM(require("path"));
+var import_tsconfig_paths = require("@modern-js/utils/tsconfig-paths");
+var import_utils = require("@modern-js/utils");
 const { resolvePath } = require("@modern-js/babel-plugin-module-resolver");
 const defaultPaths = {
   "@": [
@@ -26,7 +48,7 @@ const aliasPlugin = (alias) => {
   };
   let tsPaths = {};
   if (isTsProject) {
-    tsPaths = (0, _utils.getUserAlias)(mergedPaths);
+    tsPaths = (0, import_utils.getUserAlias)(mergedPaths);
   }
   tsPaths = Object.keys(tsPaths).reduce((o, key) => {
     if (typeof tsPaths[key] === "string") {
@@ -46,7 +68,7 @@ const aliasPlugin = (alias) => {
     if (sourcePath === "." || sourcePath === "./") {
       return sourcePath;
     }
-    const matchPath = (0, _tsconfigpaths.createMatchPath)(absoluteBaseUrl, tsPaths, [
+    const matchPath = (0, import_tsconfig_paths.createMatchPath)(absoluteBaseUrl, tsPaths, [
       "index"
     ]);
     const result = matchPath(sourcePath, void 0, void 0, [
@@ -56,9 +78,9 @@ const aliasPlugin = (alias) => {
       ".tsx"
     ]);
     if (result) {
-      const relativePath = _path.default.relative(_path.default.dirname(currentFile), _path.default.dirname(result));
-      const fileName = _path.default.basename(result);
-      const filePath = _path.default.normalize(`${relativePath.length === 0 ? "." : relativePath}/${fileName}`).replace(/\\/, "/");
+      const relativePath = import_path.default.relative(import_path.default.dirname(currentFile), import_path.default.dirname(result));
+      const fileName = import_path.default.basename(result);
+      const filePath = import_path.default.normalize(`${relativePath.length === 0 ? "." : relativePath}/${fileName}`).replace(/\\/, "/");
       return filePath.startsWith(".") ? filePath : `./${filePath}`;
     }
     return resolvePath(sourcePath, currentFile, opts);
@@ -73,7 +95,7 @@ const aliasPlugin = (alias) => {
     ".mjs"
   ];
   return [
-    "@modern-js/babel-plugin-module-resolver",
+    require.resolve("@modern-js/babel-plugin-module-resolver"),
     {
       root: absoluteBaseUrl,
       alias: mergedPaths,
@@ -82,3 +104,7 @@ const aliasPlugin = (alias) => {
     }
   ];
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aliasPlugin
+});

package/dist/cjs/compilers/babel/preset/index.js

@@ -1,57 +1,69 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  getBabelChain: function() {
-    return getBabelChain;
-  },
-  applyUserBabelConfig: function() {
-    return _utils.applyUserBabelConfig;
+    __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 preset_exports = {};
+__export(preset_exports, {
+  applyUserBabelConfig: () => import_utils.applyUserBabelConfig,
+  getBabelConfig: () => getBabelConfig
 });
-const _export_star = require("@swc/helpers/_/_export_star");
-const _babelpresetbase = require("@modern-js/babel-preset-base");
-const _alias = require("./alias");
-_export_star._(require("./types"), exports);
-const _utils = require("@modern-js/utils");
-const getBabelChain = (libPresetOption, syntaxOption) => {
-  const { appDirectory, jsxTransformRuntime, enableReactPreset, enableTypescriptPreset, styledComponentsOptions } = libPresetOption;
-  const { syntax, type } = syntaxOption;
-  const chain = (0, _babelpresetbase.getBaseBabelChain)({
-    appDirectory,
-    type,
-    syntax,
-    presets: {
-      envOptions: true,
-      reactOptions: enableReactPreset,
-      typescriptOptions: enableTypescriptPreset ? {
-        allowDeclareFields: true,
-        allExtensions: true
-      } : false
+module.exports = __toCommonJS(preset_exports);
+var import_node = require("@rsbuild/babel-preset/node");
+var import_alias = require("./alias");
+__reExport(preset_exports, require("./types"), module.exports);
+var import_utils = require("@modern-js/utils");
+const getBabelConfig = (libPresetOption) => {
+  var _config_presets, _config_plugins;
+  const config = (0, import_node.getBabelConfigForNode)({
+    presetEnv: {
+      loose: true,
+      modules: "commonjs"
     },
-    plugins: {
-      transformRuntime: {
-        corejs: false,
-        // for es5 code need helper functions
-        helpers: syntaxOption.syntax === "es5"
-      },
-      styledComponentsOptions
-    },
-    jsxTransformRuntime
+    pluginDecorators: {
+      version: "legacy"
+    }
   });
+  (_config_presets = config.presets) === null || _config_presets === void 0 ? void 0 : _config_presets.push([
+    require.resolve("@babel/preset-react"),
+    {
+      runtime: "automatic"
+    }
+  ]);
   if (libPresetOption.alias) {
-    const [name, opt] = (0, _alias.aliasPlugin)(libPresetOption.alias);
-    chain.plugin(name).use(require.resolve(name), [
-      opt
-    ]);
+    var _config_plugins1;
+    (_config_plugins1 = config.plugins) === null || _config_plugins1 === void 0 ? void 0 : _config_plugins1.push((0, import_alias.aliasPlugin)(libPresetOption.alias));
   }
-  return chain;
+  (_config_plugins = config.plugins) === null || _config_plugins === void 0 ? void 0 : _config_plugins.push(require.resolve("babel-plugin-transform-typescript-metadata"));
+  return config;
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyUserBabelConfig,
+  getBabelConfig,
+  ...require("./types")
+});

package/dist/cjs/compilers/babel/preset/types.js

@@ -1,4 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/compilers/typescript/index.js

@@ -1,18 +1,40 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "compileByTs", {
-  enumerable: true,
-  get: function() {
-    return compileByTs;
+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 typescript_exports = {};
+__export(typescript_exports, {
+  compileByTs: () => compileByTs
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-const _typescriptLoader = require("./typescriptLoader");
-const _tsconfigPathsPlugin = require("./tsconfigPathsPlugin");
+module.exports = __toCommonJS(typescript_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_typescriptLoader = require("./typescriptLoader");
+var import_tsconfigPathsPlugin = require("./tsconfigPathsPlugin");
 const readTsConfigByFile = (tsConfigFile, tsInstance) => {
   const parsedCmd = tsInstance.getParsedCommandLineOfConfigFile(tsConfigFile, void 0, tsInstance.sys);
   const { options, fileNames, projectReferences } = parsedCmd;
@@ -23,35 +45,35 @@ const readTsConfigByFile = (tsConfigFile, tsInstance) => {
   };
 };
 const copyFiles = async (from, to, appDirectory, tsconfigPath) => {
-  if (await _utils.fs.pathExists(from)) {
-    const relativePath = _path.default.relative(appDirectory, from);
-    const targetDir = _path.default.join(to, relativePath);
-    await _utils.fs.copy(from, targetDir, {
+  if (await import_utils.fs.pathExists(from)) {
+    const relativePath = import_path.default.relative(appDirectory, from);
+    const targetDir = import_path.default.join(to, relativePath);
+    await import_utils.fs.copy(from, targetDir, {
       filter: (src) => ![
         ".ts"
-      ].includes(_path.default.extname(src)) && src !== tsconfigPath
+      ].includes(import_path.default.extname(src)) && src !== tsconfigPath
     });
   }
 };
 const compileByTs = async (appDirectory, config, compileOptions) => {
-  _utils.logger.info(`Running ts compile...`);
+  import_utils.logger.info(`Running ts compile...`);
   const { sourceDirs, distDir, tsconfigPath } = compileOptions;
   if (!tsconfigPath) {
     return;
   }
-  const ts = new _typescriptLoader.TypescriptLoader({
+  const ts = new import_typescriptLoader.TypescriptLoader({
     appDirectory
   }).load();
   const createProgram = ts.createIncrementalProgram || ts.createProgram;
   const formatHost = getFormatHost(ts);
   const { alias } = config;
-  const aliasOption = (0, _utils.getAliasConfig)(alias, {
+  const aliasOption = (0, import_utils.getAliasConfig)(alias, {
     appDirectory,
     tsconfigPath
   });
   const { paths = {}, absoluteBaseUrl = "./" } = aliasOption;
   const { options, fileNames, projectReferences } = readTsConfigByFile(tsconfigPath, ts);
-  const sourcePosixPaths = sourceDirs.map((sourceDir) => sourceDir.split(_path.default.sep).join(_path.default.posix.sep));
+  const sourcePosixPaths = sourceDirs.map((sourceDir) => sourceDir.split(import_path.default.sep).join(import_path.default.posix.sep));
   const rootNames = fileNames.filter((fileName) => {
     return fileName.endsWith(".d.ts") || sourcePosixPaths.some((sourceDir) => {
       return fileName.includes(sourceDir);
@@ -66,7 +88,7 @@ const compileByTs = async (appDirectory, config, compileOptions) => {
       ...options
     }
   });
-  const tsconfigPathsPlugin = (0, _tsconfigPathsPlugin.tsconfigPathsBeforeHookFactory)(ts, absoluteBaseUrl, paths);
+  const tsconfigPathsPlugin = (0, import_tsconfigPathsPlugin.tsconfigPathsBeforeHookFactory)(ts, absoluteBaseUrl, paths);
   const emitResult = program.emit(void 0, void 0, void 0, void 0, {
     before: [
       tsconfigPathsPlugin
@@ -75,7 +97,7 @@ const compileByTs = async (appDirectory, config, compileOptions) => {
   const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
   const { noEmitOnError } = options;
   if (allDiagnostics.length > 0) {
-    _utils.logger.error(ts.formatDiagnosticsWithColorAndContext([
+    import_utils.logger.error(ts.formatDiagnosticsWithColorAndContext([
       ...new Set(allDiagnostics)
     ], formatHost));
     if (typeof noEmitOnError === "undefined" || noEmitOnError === true) {
@@ -85,12 +107,16 @@ const compileByTs = async (appDirectory, config, compileOptions) => {
   for (const source of sourceDirs) {
     await copyFiles(source, distDir, appDirectory, tsconfigPath);
   }
-  _utils.logger.info(`Ts compile succeed`);
+  import_utils.logger.info(`Ts compile succeed`);
 };
 const getFormatHost = (ts) => {
   return {
-    getCanonicalFileName: (path) => path,
+    getCanonicalFileName: (path2) => path2,
     getCurrentDirectory: ts.sys.getCurrentDirectory,
     getNewLine: () => ts.sys.newLine
   };
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileByTs
+});