@modern-js/server-utils 2.4.1-beta.0 → 2.5.1-alpha.0

package/CHANGELOG.md

@@ -1,13 +1,22 @@
 # @modern-js/server-utils
 
-## 2.4.1-beta.0
+## 2.5.0
 
 ### Patch Changes
 
+- 89ca6cc: refactor: merge build-config into scripts/build
+
+  refactor: 把 build-config 合并进 scripts/build
+
+- 30614fa: chore: modify package.json entry fields and build config
+  chore: 更改 package.json entry 字段以及构建配置
+- Updated dependencies [89ca6cc]
+- Updated dependencies [30614fa]
+- Updated dependencies [1b0ce87]
 - Updated dependencies [11c053b]
-  - @modern-js/utils@2.4.1-beta.0
-  - @modern-js/babel-preset-lib@2.4.1-beta.0
-  - @modern-js/babel-compiler@2.4.1-beta.0
+  - @modern-js/babel-preset-lib@2.5.0
+  - @modern-js/babel-compiler@2.5.0
+  - @modern-js/utils@2.5.0
 
 ## 2.4.0
 

package/dist/cjs/common/index.js

@@ -0,0 +1,65 @@
+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(
+  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
+});
+module.exports = __toCommonJS(common_exports);
+var path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_typescript = require("../compilers/typescript");
+var import_babel = require("../compilers/babel");
+const FILE_EXTENSIONS = [".js", ".ts", ".mjs", ".ejs"];
+const validateAbsolutePath = (filename, message) => {
+  if (!path.isAbsolute(filename)) {
+    throw new Error(message);
+  }
+};
+const validateAbsolutePaths = (filenames, messageFunc) => {
+  filenames.forEach(
+    (filename) => validateAbsolutePath(filename, messageFunc(filename))
+  );
+};
+const compile = async (appDirectory, modernConfig, compileOptions) => {
+  var _a;
+  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+  validateAbsolutePaths(
+    sourceDirs,
+    (dir) => `source dir ${dir} is not an absolute path.`
+  );
+  validateAbsolutePath(distDir, `dist dir ${distDir} is not an absolute path.`);
+  const compiler = (_a = modernConfig == null ? void 0 : modernConfig.server) == null ? void 0 : _a.compiler;
+  const isTsProject = tsconfigPath && await import_utils.fs.pathExists(tsconfigPath);
+  if (!isTsProject || compiler === "babel") {
+    await (0, import_babel.compileByBabel)(appDirectory, modernConfig, compileOptions);
+  } else {
+    await (0, import_typescript.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

@@ -0,0 +1,147 @@
+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 __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(
+  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,
+  getBabelConfig: () => getBabelConfig,
+  readTsConfig: () => readTsConfig,
+  resolveBabelConfig: () => resolveBabelConfig
+});
+module.exports = __toCommonJS(babel_exports);
+var path = __toESM(require("path"));
+var import_babel_preset_lib = require("@modern-js/babel-preset-lib");
+var import_utils = require("@modern-js/utils");
+var import_babel_compiler = require("@modern-js/babel-compiler");
+var import_common = require("../../common");
+__reExport(babel_exports, require("@babel/core"), module.exports);
+const readTsConfig = (tsconfigPath, noExistReturn = null) => {
+  if (!import_utils.fs.existsSync(tsconfigPath)) {
+    return noExistReturn;
+  }
+  const content = import_utils.fs.readFileSync(tsconfigPath, "utf-8");
+  return import_utils.json5.parse(content);
+};
+const existTsConfigFile = (tsconfigAbsolutePath) => {
+  const tsconfig = readTsConfig(tsconfigAbsolutePath);
+  return Boolean(tsconfig);
+};
+const getBabelConfig = (libPresetOption, syntaxOption) => {
+  const chain = (0, import_babel_preset_lib.getBabelChain)(libPresetOption, syntaxOption);
+  return {
+    sourceType: "unambiguous",
+    ...chain.toJSON()
+  };
+};
+const resolveBabelConfig = (appDirectory, config, option) => {
+  const { globalVars, alias, babelConfig, define } = config;
+  const globalDefineVars = define && Object.entries(define).reduce((object, [key, value]) => {
+    object[key] = JSON.stringify(value);
+    return object;
+  }, {});
+  const aliasConfig = (0, import_utils.getAliasConfig)(alias, {
+    appDirectory,
+    ...option
+  });
+  const babelChain = (0, import_babel_preset_lib.getBabelChain)(
+    {
+      appDirectory,
+      enableReactPreset: true,
+      enableTypescriptPreset: true,
+      alias: aliasConfig,
+      envVars: [],
+      globalVars: {
+        ...globalVars,
+        ...globalDefineVars
+      }
+    },
+    {
+      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 }
+  ]);
+  babelChain.plugin("@babel/plugin-proposal-class-properties").use(require.resolve("@babel/plugin-proposal-class-properties"), [
+    {
+      loose: true
+    }
+  ]);
+  const internalBabelConfig = { ...babelChain.toJSON() };
+  return (0, import_babel_preset_lib.applyUserBabelConfig)(internalBabelConfig, 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"
+      });
+      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
+        });
+      }
+      return (0, import_babel_compiler.compiler)(
+        {
+          rootDir: appDirectory,
+          distDir,
+          sourceDir,
+          extensions: import_common.FILE_EXTENSIONS
+        },
+        babelConfig
+      );
+    })
+  );
+  results.forEach((result) => {
+    if (result.code === 1) {
+      throw new Error(result.message);
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileByBabel,
+  existTsConfigFile,
+  getBabelConfig,
+  readTsConfig,
+  resolveBabelConfig
+});

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

@@ -0,0 +1,117 @@
+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(
+  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
+});
+module.exports = __toCommonJS(typescript_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_typescript = __toESM(require("typescript"));
+var import_typescript_loader = require("./typescript-loader");
+var import_tsconfig_paths_plugin = require("./tsconfig-paths-plugin");
+const readTsConfigByFile = (tsConfigFile) => {
+  const parsedCmd = import_typescript.default.getParsedCommandLineOfConfigFile(
+    tsConfigFile,
+    void 0,
+    import_typescript.default.sys
+  );
+  const { options, fileNames, projectReferences } = parsedCmd;
+  return { options, fileNames, projectReferences };
+};
+const copyFiles = async (from, to, appDirectory, tsconfigPath) => {
+  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(import_path.default.extname(src)) && src !== tsconfigPath
+    });
+  }
+};
+const compileByTs = async (appDirectory, config, compileOptions) => {
+  import_utils.logger.info(`Running ts compile...`);
+  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
+  if (!tsconfigPath) {
+    return;
+  }
+  const ts2 = new import_typescript_loader.TypescriptLoader({
+    appDirectory
+  }).load();
+  const createProgram = ts2.createIncrementalProgram || ts2.createProgram;
+  const formatHost = getFormatHost(ts2);
+  const { alias } = config;
+  const aliasOption = (0, import_utils.getAliasConfig)(alias, {
+    appDirectory,
+    tsconfigPath
+  });
+  const { paths = {}, absoluteBaseUrl = "./" } = aliasOption;
+  const { options, fileNames, projectReferences } = readTsConfigByFile(tsconfigPath);
+  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);
+    });
+  });
+  const program = createProgram.call(ts2, {
+    rootNames,
+    projectReferences,
+    options: {
+      rootDir: appDirectory,
+      outDir: distDir,
+      ...options
+    }
+  });
+  const tsconfigPathsPlugin = (0, import_tsconfig_paths_plugin.tsconfigPathsBeforeHookFactory)(
+    ts2,
+    absoluteBaseUrl,
+    paths
+  );
+  const emitResult = program.emit(void 0, void 0, void 0, void 0, {
+    before: [tsconfigPathsPlugin]
+  });
+  const allDiagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  if (allDiagnostics.length > 0) {
+    import_utils.logger.error(
+      ts2.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost)
+    );
+    process.exit(1);
+  }
+  for (const source of sourceDirs) {
+    await copyFiles(source, distDir, appDirectory, tsconfigPath);
+  }
+  import_utils.logger.info(`Ts compile succeed`);
+};
+const getFormatHost = (ts2) => {
+  return {
+    getCanonicalFileName: (path2) => path2,
+    getCurrentDirectory: ts2.sys.getCurrentDirectory,
+    getNewLine: () => ts2.sys.newLine
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileByTs
+});

package/dist/cjs/compilers/typescript/tsconfig-paths-plugin.js

@@ -0,0 +1,216 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tsconfig_paths_plugin_exports = {};
+__export(tsconfig_paths_plugin_exports, {
+  tsconfigPathsBeforeHookFactory: () => tsconfigPathsBeforeHookFactory
+});
+module.exports = __toCommonJS(tsconfig_paths_plugin_exports);
+var os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var ts = __toESM(require("typescript"));
+var import_tsconfig_paths = require("@modern-js/utils/tsconfig-paths");
+const isRegExpKey = (str) => {
+  return str.startsWith("^") || str.endsWith("$");
+};
+const resolveAliasPath = (baseUrl, filePath) => {
+  if (filePath.startsWith(".") || filePath.startsWith("..")) {
+    return import_path.default.resolve(baseUrl, filePath);
+  }
+  return filePath;
+};
+const createAliasMatcher = (baseUrl, alias) => {
+  const aliasPairs = Object.keys(alias).reduce((o, key) => {
+    if (isRegExpKey(key)) {
+      const regexp = new RegExp(key);
+      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+      o.push([regexp, aliasPath]);
+    } else {
+      const aliasPath = resolveAliasPath(baseUrl, alias[key]);
+      o.push([key, aliasPath]);
+    }
+    return o;
+  }, []);
+  const cacheMap = /* @__PURE__ */ new Map();
+  return (requestedModule) => {
+    if (cacheMap.has(requestedModule)) {
+      return cacheMap.get(requestedModule);
+    }
+    for (const [key, value] of aliasPairs) {
+      if (key instanceof RegExp) {
+        if (key.test(requestedModule)) {
+          cacheMap.set(requestedModule, value);
+          return value;
+        }
+      }
+      if (requestedModule === key) {
+        cacheMap.set(requestedModule, value);
+        return value;
+      }
+    }
+  };
+};
+const isDynamicImport = (tsBinary, node) => {
+  return tsBinary.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+};
+function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
+  const tsPaths = {};
+  const alias = {};
+  Object.keys(paths).forEach((key) => {
+    if (Array.isArray(paths[key])) {
+      tsPaths[key] = paths[key];
+    } else {
+      alias[key] = paths[key];
+    }
+  });
+  const matchAliasPath = createAliasMatcher(baseUrl, alias);
+  const matchTsPath = (0, import_tsconfig_paths.createMatchPath)(baseUrl, tsPaths, ["main"]);
+  const matchPath = (requestedModule, readJSONSync, fileExists, extensions) => {
+    const result = matchTsPath(
+      requestedModule,
+      readJSONSync,
+      fileExists,
+      extensions
+    );
+    if (result) {
+      return result;
+    }
+    return matchAliasPath(requestedModule);
+  };
+  if (Object.keys(paths).length === 0) {
+    return void 0;
+  }
+  return (ctx) => {
+    return (sf) => {
+      const visitNode = (node) => {
+        var _a;
+        if (isDynamicImport(tsBinary, node)) {
+          const importPathWithQuotes = node.arguments[0].getText(sf);
+          const text = importPathWithQuotes.slice(
+            1,
+            importPathWithQuotes.length - 1
+          );
+          const result = getNotAliasedPath(sf, matchPath, text);
+          if (!result) {
+            return node;
+          }
+          return tsBinary.factory.updateCallExpression(
+            node,
+            node.expression,
+            node.typeArguments,
+            tsBinary.factory.createNodeArray([
+              tsBinary.factory.createStringLiteral(result)
+            ])
+          );
+        }
+        if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) {
+          try {
+            const importPathWithQuotes = (_a = node == null ? void 0 : node.moduleSpecifier) == null ? void 0 : _a.getText();
+            if (!importPathWithQuotes) {
+              return node;
+            }
+            const text = importPathWithQuotes.substring(
+              1,
+              importPathWithQuotes.length - 1
+            );
+            const result = getNotAliasedPath(sf, matchPath, text);
+            if (!result) {
+              return node;
+            }
+            const moduleSpecifier = tsBinary.factory.createStringLiteral(result);
+            moduleSpecifier.parent = node.moduleSpecifier.parent;
+            let newNode;
+            if (tsBinary.isImportDeclaration(node)) {
+              newNode = tsBinary.factory.updateImportDeclaration(
+                node,
+                node.decorators,
+                node.modifiers,
+                node.importClause,
+                moduleSpecifier,
+                node.assertClause
+              );
+            } else {
+              newNode = tsBinary.factory.updateExportDeclaration(
+                node,
+                node.decorators,
+                node.modifiers,
+                node.isTypeOnly,
+                node.exportClause,
+                moduleSpecifier,
+                node.assertClause
+              );
+            }
+            newNode.flags = node.flags;
+            return newNode;
+          } catch {
+            return node;
+          }
+        }
+        return tsBinary.visitEachChild(node, visitNode, ctx);
+      };
+      return tsBinary.visitNode(sf, visitNode);
+    };
+  };
+}
+function getNotAliasedPath(sf, matcher, text) {
+  let result = matcher(text, void 0, void 0, [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx"
+  ]);
+  if (!result) {
+    return;
+  }
+  if (os.platform() === "win32") {
+    result = result.replace(/\\/g, "/");
+  }
+  if (!import_path.default.isAbsolute(result)) {
+    if (!result.startsWith(".") && !result.startsWith("..")) {
+      try {
+        const packagePath = require.resolve(result, {
+          paths: [process.cwd(), ...module.paths]
+        });
+        if (packagePath) {
+          return result;
+        }
+      } catch {
+      }
+    }
+    try {
+      const packagePath = require.resolve(text, {
+        paths: [process.cwd(), ...module.paths]
+      });
+      if (packagePath) {
+        return text;
+      }
+    } catch {
+    }
+  }
+  const resolvedPath = import_path.posix.relative((0, import_path.dirname)(sf.fileName), result) || "./";
+  return resolvedPath[0] === "." ? resolvedPath : `./${resolvedPath}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tsconfigPathsBeforeHookFactory
+});

package/dist/cjs/compilers/typescript/typescript-loader.js

@@ -0,0 +1,47 @@
+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 typescript_loader_exports = {};
+__export(typescript_loader_exports, {
+  TypescriptLoader: () => TypescriptLoader
+});
+module.exports = __toCommonJS(typescript_loader_exports);
+class TypescriptLoader {
+  constructor({ appDirectory }) {
+    this.appDirectory = appDirectory;
+  }
+  load() {
+    if (this.tsBinary) {
+      return this.tsBinary;
+    }
+    try {
+      const tsPath = require.resolve("typescript", {
+        paths: [this.appDirectory || process.cwd()]
+      });
+      const ts = require(tsPath);
+      return ts;
+    } catch (error) {
+      throw new Error(
+        'TypeScript could not be found! Please, install "typescript" package.'
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypescriptLoader
+});

package/dist/cjs/index.js

@@ -0,0 +1,29 @@
+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 __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 = {};
+__export(src_exports, {
+  compile: () => import_common.compile
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./compilers/babel"), module.exports);
+var import_common = require("./common");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile
+});