@modern-js/server-utils 2.15.0 → 2.16.0

package/dist/esm/compilers/typescript/tsconfigPathsPlugin.js

@@ -1,246 +1,261 @@
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
+function _array_like_to_array(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
 }
-function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
 }
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
 }
 function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
-    }
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
 }
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+function _iterable_to_array(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
 }
-function _iterableToArrayLimit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i == null)
+    return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _s, _e;
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i)
+        break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
     try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
+      if (!_n && _i["return"] != null)
+        _i["return"]();
+    } finally {
+      if (_d)
+        throw _e;
     }
-    return _arr;
+  }
+  return _arr;
 }
-function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+function _non_iterable_spread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
-function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+function _unsupported_iterable_to_array(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array(o, minLen);
 }
 import * as os from "os";
 import path, { dirname, posix } from "path";
 import * as ts from "typescript";
 import { createMatchPath } from "@modern-js/utils/tsconfig-paths";
 var isRegExpKey = function(str) {
-    return str.startsWith("^") || str.endsWith("$");
+  return str.startsWith("^") || str.endsWith("$");
 };
 var resolveAliasPath = function(baseUrl, filePath) {
-    if (filePath.startsWith(".") || filePath.startsWith("..")) {
-        return path.resolve(baseUrl, filePath);
-    }
-    return filePath;
+  if (filePath.startsWith(".") || filePath.startsWith("..")) {
+    return path.resolve(baseUrl, filePath);
+  }
+  return filePath;
 };
 var createAliasMatcher = function(baseUrl, alias) {
-    var aliasPairs = Object.keys(alias).reduce(function(o, key) {
-        if (isRegExpKey(key)) {
-            var regexp = new RegExp(key);
-            var aliasPath = resolveAliasPath(baseUrl, alias[key]);
-            o.push([
-                regexp,
-                aliasPath
-            ]);
-        } else {
-            var aliasPath1 = resolveAliasPath(baseUrl, alias[key]);
-            o.push([
-                key,
-                aliasPath1
-            ]);
+  var aliasPairs = Object.keys(alias).reduce(function(o, key) {
+    if (isRegExpKey(key)) {
+      var regexp = new RegExp(key);
+      var aliasPath = resolveAliasPath(baseUrl, alias[key]);
+      o.push([
+        regexp,
+        aliasPath
+      ]);
+    } else {
+      var aliasPath1 = resolveAliasPath(baseUrl, alias[key]);
+      o.push([
+        key,
+        aliasPath1
+      ]);
+    }
+    return o;
+  }, []);
+  var cacheMap = /* @__PURE__ */ new Map();
+  return function(requestedModule) {
+    if (cacheMap.has(requestedModule)) {
+      return cacheMap.get(requestedModule);
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+      for (var _iterator = aliasPairs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+        if (_instanceof(key, RegExp)) {
+          if (key.test(requestedModule)) {
+            cacheMap.set(requestedModule, value);
+            return value;
+          }
         }
-        return o;
-    }, []);
-    var cacheMap = /* @__PURE__ */ new Map();
-    return function(requestedModule) {
-        if (cacheMap.has(requestedModule)) {
-            return cacheMap.get(requestedModule);
+        if (requestedModule === key) {
+          cacheMap.set(requestedModule, value);
+          return value;
         }
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = aliasPairs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], value = _step_value[1];
-                if (_instanceof(key, RegExp)) {
-                    if (key.test(requestedModule)) {
-                        cacheMap.set(requestedModule, value);
-                        return value;
-                    }
-                }
-                if (requestedModule === key) {
-                    cacheMap.set(requestedModule, value);
-                    return value;
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
         }
-    };
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  };
 };
 var isDynamicImport = function(tsBinary, node) {
-    return tsBinary.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+  return tsBinary.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
 };
-function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
-    var tsPaths = {};
-    var alias = {};
-    Object.keys(paths).forEach(function(key) {
-        if (Array.isArray(paths[key])) {
-            tsPaths[key] = paths[key];
-        } else {
-            alias[key] = paths[key];
+export function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
+  var tsPaths = {};
+  var alias = {};
+  Object.keys(paths).forEach(function(key) {
+    if (Array.isArray(paths[key])) {
+      tsPaths[key] = paths[key];
+    } else {
+      alias[key] = paths[key];
+    }
+  });
+  var matchAliasPath = createAliasMatcher(baseUrl, alias);
+  var matchTsPath = createMatchPath(baseUrl, tsPaths, [
+    "main"
+  ]);
+  var matchPath = function(requestedModule, readJSONSync, fileExists, extensions) {
+    var result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
+    if (result) {
+      return result;
+    }
+    return matchAliasPath(requestedModule);
+  };
+  if (Object.keys(paths).length === 0) {
+    return void 0;
+  }
+  return function(ctx) {
+    return function(sf) {
+      var visitNode = function(node) {
+        if (isDynamicImport(tsBinary, node)) {
+          var importPathWithQuotes = node.arguments[0].getText(sf);
+          var text = importPathWithQuotes.slice(1, importPathWithQuotes.length - 1);
+          var 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)
+          ]));
         }
-    });
-    var matchAliasPath = createAliasMatcher(baseUrl, alias);
-    var matchTsPath = createMatchPath(baseUrl, tsPaths, [
-        "main"
-    ]);
-    var matchPath = function(requestedModule, readJSONSync, fileExists, extensions) {
-        var result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
-        if (result) {
-            return result;
+        if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) {
+          try {
+            var _node_moduleSpecifier;
+            var importPathWithQuotes1 = node === null || node === void 0 ? void 0 : (_node_moduleSpecifier = node.moduleSpecifier) === null || _node_moduleSpecifier === void 0 ? void 0 : _node_moduleSpecifier.getText();
+            if (!importPathWithQuotes1) {
+              return node;
+            }
+            var text1 = importPathWithQuotes1.substring(1, importPathWithQuotes1.length - 1);
+            var result1 = getNotAliasedPath(sf, matchPath, text1);
+            if (!result1) {
+              return node;
+            }
+            var moduleSpecifier = tsBinary.factory.createStringLiteral(result1);
+            moduleSpecifier.parent = node.moduleSpecifier.parent;
+            var newNode;
+            if (tsBinary.isImportDeclaration(node)) {
+              newNode = tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
+            } else {
+              newNode = tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+            }
+            newNode.flags = node.flags;
+            return newNode;
+          } catch (e) {
+            return node;
+          }
         }
-        return matchAliasPath(requestedModule);
-    };
-    if (Object.keys(paths).length === 0) {
-        return void 0;
-    }
-    return function(ctx) {
-        return function(sf) {
-            var visitNode = function(node) {
-                if (isDynamicImport(tsBinary, node)) {
-                    var importPathWithQuotes = node.arguments[0].getText(sf);
-                    var text = importPathWithQuotes.slice(1, importPathWithQuotes.length - 1);
-                    var 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 {
-                        var _node_moduleSpecifier;
-                        var importPathWithQuotes1 = node === null || node === void 0 ? void 0 : (_node_moduleSpecifier = node.moduleSpecifier) === null || _node_moduleSpecifier === void 0 ? void 0 : _node_moduleSpecifier.getText();
-                        if (!importPathWithQuotes1) {
-                            return node;
-                        }
-                        var text1 = importPathWithQuotes1.substring(1, importPathWithQuotes1.length - 1);
-                        var result1 = getNotAliasedPath(sf, matchPath, text1);
-                        if (!result1) {
-                            return node;
-                        }
-                        var moduleSpecifier = tsBinary.factory.createStringLiteral(result1);
-                        moduleSpecifier.parent = node.moduleSpecifier.parent;
-                        var newNode;
-                        if (tsBinary.isImportDeclaration(node)) {
-                            newNode = tsBinary.factory.updateImportDeclaration(node, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
-                        } else {
-                            newNode = tsBinary.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
-                        }
-                        newNode.flags = node.flags;
-                        return newNode;
-                    } catch (e) {
-                        return node;
-                    }
-                }
-                return tsBinary.visitEachChild(node, visitNode, ctx);
-            };
-            return tsBinary.visitNode(sf, visitNode);
-        };
+        return tsBinary.visitEachChild(node, visitNode, ctx);
+      };
+      return tsBinary.visitNode(sf, visitNode);
     };
+  };
 }
 function getNotAliasedPath(sf, matcher, text) {
-    var result = matcher(text, void 0, void 0, [
-        ".ts",
-        ".tsx",
-        ".js",
-        ".jsx"
-    ]);
-    if (!result) {
-        return;
-    }
-    if (os.platform() === "win32") {
-        result = result.replace(/\\/g, "/");
-    }
-    if (!path.isAbsolute(result)) {
-        if (!result.startsWith(".") && !result.startsWith("..")) {
-            try {
-                var packagePath = require.resolve(result, {
-                    paths: [
-                        process.cwd()
-                    ].concat(_toConsumableArray(module.paths))
-                });
-                if (packagePath) {
-                    return result;
-                }
-            } catch (e) {}
+  var result = matcher(text, void 0, void 0, [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx"
+  ]);
+  if (!result) {
+    return;
+  }
+  if (os.platform() === "win32") {
+    result = result.replace(/\\/g, "/");
+  }
+  if (!path.isAbsolute(result)) {
+    if (!result.startsWith(".") && !result.startsWith("..")) {
+      try {
+        var packagePath = require.resolve(result, {
+          paths: [
+            process.cwd()
+          ].concat(_to_consumable_array(module.paths))
+        });
+        if (packagePath) {
+          return result;
         }
-        try {
-            var packagePath1 = require.resolve(text, {
-                paths: [
-                    process.cwd()
-                ].concat(_toConsumableArray(module.paths))
-            });
-            if (packagePath1) {
-                return text;
-            }
-        } catch (e) {}
+      } catch (e) {
+      }
+    }
+    try {
+      var packagePath1 = require.resolve(text, {
+        paths: [
+          process.cwd()
+        ].concat(_to_consumable_array(module.paths))
+      });
+      if (packagePath1) {
+        return text;
+      }
+    } catch (e) {
     }
-    var resolvedPath = posix.relative(dirname(sf.fileName), result) || "./";
-    return resolvedPath[0] === "." ? resolvedPath : "./".concat(resolvedPath);
+  }
+  var resolvedPath = posix.relative(dirname(sf.fileName), result) || "./";
+  return resolvedPath[0] === "." ? resolvedPath : "./".concat(resolvedPath);
 }
-export { tsconfigPathsBeforeHookFactory };

package/dist/esm/compilers/typescript/typescriptLoader.js

@@ -1,65 +1,67 @@
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
 }
 function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
 }
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  return Constructor;
 }
-function _defineProperty(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
 }
-var TypescriptLoader = /*#__PURE__*/ function() {
-    "use strict";
-    function TypescriptLoader(param) {
-        var appDirectory = param.appDirectory;
-        _classCallCheck(this, TypescriptLoader);
-        _defineProperty(this, "tsBinary", void 0);
-        _defineProperty(this, "appDirectory", void 0);
-        this.appDirectory = appDirectory;
-    }
-    _createClass(TypescriptLoader, [
-        {
-            key: "load",
-            value: function load() {
-                if (this.tsBinary) {
-                    return this.tsBinary;
-                }
-                try {
-                    var tsPath = require.resolve("typescript", {
-                        paths: [
-                            this.appDirectory || process.cwd()
-                        ]
-                    });
-                    var ts = require(tsPath);
-                    return ts;
-                } catch (error) {
-                    throw new Error('TypeScript could not be found! Please, install "typescript" package.');
-                }
-            }
+export var TypescriptLoader = /* @__PURE__ */ function() {
+  "use strict";
+  function TypescriptLoader2(param) {
+    var appDirectory = param.appDirectory;
+    _class_call_check(this, TypescriptLoader2);
+    _define_property(this, "tsBinary", void 0);
+    _define_property(this, "appDirectory", void 0);
+    this.appDirectory = appDirectory;
+  }
+  _create_class(TypescriptLoader2, [
+    {
+      key: "load",
+      value: function load() {
+        if (this.tsBinary) {
+          return this.tsBinary;
+        }
+        try {
+          var tsPath = require.resolve("typescript", {
+            paths: [
+              this.appDirectory || process.cwd()
+            ]
+          });
+          var ts = require(tsPath);
+          return ts;
+        } catch (error) {
+          throw new Error('TypeScript could not be found! Please, install "typescript" package.');
         }
-    ]);
-    return TypescriptLoader;
+      }
+    }
+  ]);
+  return TypescriptLoader2;
 }();
-export { TypescriptLoader };

package/dist/esm/index.js

@@ -1,3 +1,2 @@
 export * from "./compilers/babel";
-import { compile } from "./common";
-export { compile };
+export { compile } from "./common";

package/dist/esm-node/common/index.js

@@ -2,26 +2,26 @@ import * as path from "path";
 import { fs } from "@modern-js/utils";
 import { compileByTs } from "../compilers/typescript";
 import { compileByBabel } from "../compilers/babel";
-const FILE_EXTENSIONS = [".js", ".ts", ".mjs", ".ejs"];
+export 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))
-  );
+  filenames.forEach((filename) => validateAbsolutePath(filename, messageFunc(filename)));
 };
-const compile = async (appDirectory, modernConfig, compileOptions) => {
-  var _a;
+export const compile = async (appDirectory, modernConfig, compileOptions) => {
+  var _modernConfig_server;
   const { sourceDirs, distDir, tsconfigPath } = compileOptions;
-  validateAbsolutePaths(
-    sourceDirs,
-    (dir) => `source dir ${dir} is not an absolute path.`
-  );
+  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 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 fs.pathExists(tsconfigPath);
   if (!isTsProject || compiler === "babel") {
     await compileByBabel(appDirectory, modernConfig, compileOptions);
@@ -29,7 +29,3 @@ const compile = async (appDirectory, modernConfig, compileOptions) => {
     await compileByTs(appDirectory, modernConfig, compileOptions);
   }
 };
-export {
-  FILE_EXTENSIONS,
-  compile
-};