@modern-js/server-utils 2.0.0-beta.2 → 2.0.0-beta.4

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

@@ -1,105 +1,148 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 stdin_exports = {};
+__export(stdin_exports, {
+  compileByTs: () => compileByTs
 });
-exports.compileByTs = void 0;
-var _path = _interopRequireDefault(require("path"));
-var _utils = require("@modern-js/utils");
-var _typescript = _interopRequireDefault(require("typescript"));
-var _typescriptLoader = require("./typescript-loader");
-var _tsconfigPathsPlugin = require("./tsconfig-paths-plugin");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-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; }
-const readTsConfigByFile = tsConfigFile => {
-  const parsedCmd = _typescript.default.getParsedCommandLineOfConfigFile(tsConfigFile, undefined, _typescript.default.sys);
-  const {
-    options,
-    fileNames,
-    projectReferences
-  } = parsedCmd;
-  return {
-    options,
-    fileNames,
-    projectReferences
-  };
+module.exports = __toCommonJS(stdin_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");
+var __defProp2 = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.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 __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());
+  });
 };
-const copyFiles = async (from, to, tsconfigPath) => {
-  if (await _utils.fs.pathExists(from)) {
-    const basename = _path.default.basename(from);
-    const targetDir = _path.default.join(to, basename);
-    await _utils.fs.copy(from, targetDir, {
-      filter: src => !['.ts'].includes(_path.default.extname(src)) && src !== tsconfigPath
+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 = (from, to, tsconfigPath) => __async(void 0, null, function* () {
+  if (yield import_utils.fs.pathExists(from)) {
+    const basename = import_path.default.basename(from);
+    const targetDir = import_path.default.join(to, basename);
+    yield import_utils.fs.copy(from, targetDir, {
+      filter: (src) => ![".ts"].includes(import_path.default.extname(src)) && src !== tsconfigPath
     });
   }
-};
-const compileByTs = async (appDirectory, config, compileOptions) => {
-  _utils.logger.info(`Running ts compile...`);
-  const {
-    sourceDirs,
-    distDir,
-    tsconfigPath
-  } = compileOptions;
+});
+const compileByTs = (appDirectory, config, compileOptions) => __async(void 0, null, function* () {
+  import_utils.logger.info(`Running ts compile...`);
+  const { sourceDirs, distDir, tsconfigPath } = compileOptions;
   if (!tsconfigPath) {
     return;
   }
-  const ts = new _typescriptLoader.TypescriptLoader({
+  const ts2 = new import_typescript_loader.TypescriptLoader({
     appDirectory
   }).load();
-  const createProgram = ts.createIncrementalProgram || ts.createProgram;
-  const formatHost = getFormatHost(ts);
-  const {
-    alias
-  } = config;
-  const aliasOption = (0, _utils.getAliasConfig)(alias, {
+  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(_path.default.sep).join(_path.default.posix.sep));
-  const rootNames = fileNames.filter(fileName => {
-    return fileName.endsWith('.d.ts') || sourcePosixPaths.some(sourceDir => {
+  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(ts, {
+  const program = createProgram.call(ts2, {
     rootNames,
     projectReferences,
-    options: _objectSpread({
+    options: __spreadValues({
       rootDir: appDirectory,
       outDir: distDir
     }, options)
   });
-  const tsconfigPathsPlugin = (0, _tsconfigPathsPlugin.tsconfigPathsBeforeHookFactory)(ts, absoluteBaseUrl, paths);
-  const emitResult = program.emit(undefined, undefined, undefined, undefined, {
+  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 = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  const allDiagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
   if (allDiagnostics.length > 0) {
-    _utils.logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
-    // eslint-disable-next-line no-process-exit
+    import_utils.logger.error(
+      ts2.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost)
+    );
     process.exit(1);
   }
   for (const source of sourceDirs) {
-    await copyFiles(source, distDir, tsconfigPath);
+    yield copyFiles(source, distDir, tsconfigPath);
   }
-  _utils.logger.info(`Ts compile succeed`);
-};
-exports.compileByTs = compileByTs;
-const getFormatHost = ts => {
+  import_utils.logger.info(`Ts compile succeed`);
+});
+const getFormatHost = (ts2) => {
   return {
-    getCanonicalFileName: path => path,
-    getCurrentDirectory: ts.sys.getCurrentDirectory,
-    getNewLine: () => ts.sys.newLine
+    getCanonicalFileName: (path2) => path2,
+    getCurrentDirectory: ts2.sys.getCurrentDirectory,
+    getNewLine: () => ts2.sys.newLine
   };
-};
+};

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

@@ -1,22 +1,41 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 stdin_exports = {};
+__export(stdin_exports, {
+  tsconfigPathsBeforeHookFactory: () => tsconfigPathsBeforeHookFactory
 });
-exports.tsconfigPathsBeforeHookFactory = tsconfigPathsBeforeHookFactory;
-var os = _interopRequireWildcard(require("os"));
-var _path = _interopRequireWildcard(require("path"));
-var ts = _interopRequireWildcard(require("typescript"));
-var _tsconfigPaths = require("@modern-js/utils/tsconfig-paths");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-const isRegExpKey = str => {
-  return str.startsWith('^') || str.endsWith('$');
+module.exports = __toCommonJS(stdin_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) => {
-  // exclude absolute path and alias
-  if (filePath.startsWith('.') || filePath.startsWith('..')) {
-    return _path.default.resolve(baseUrl, filePath);
+  if (filePath.startsWith(".") || filePath.startsWith("..")) {
+    return import_path.default.resolve(baseUrl, filePath);
   }
   return filePath;
 };
@@ -32,10 +51,8 @@ const createAliasMatcher = (baseUrl, alias) => {
     }
     return o;
   }, []);
-  const cacheMap = new Map();
-
-  // eslint-disable-next-line consistent-return
-  return requestedModule => {
+  const cacheMap = /* @__PURE__ */ new Map();
+  return (requestedModule) => {
     if (cacheMap.has(requestedModule)) {
       return cacheMap.get(requestedModule);
     }
@@ -59,7 +76,7 @@ const isDynamicImport = (tsBinary, node) => {
 function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
   const tsPaths = {};
   const alias = {};
-  Object.keys(paths).forEach(key => {
+  Object.keys(paths).forEach((key) => {
     if (Array.isArray(paths[key])) {
       tsPaths[key] = paths[key];
     } else {
@@ -67,37 +84,55 @@ function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
     }
   });
   const matchAliasPath = createAliasMatcher(baseUrl, alias);
-  const matchTsPath = (0, _tsconfigPaths.createMatchPath)(baseUrl, tsPaths, ['main']);
+  const matchTsPath = (0, import_tsconfig_paths.createMatchPath)(baseUrl, tsPaths, ["main"]);
   const matchPath = (requestedModule, readJSONSync, fileExists, extensions) => {
-    const result = matchTsPath(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 undefined;
+    return void 0;
   }
-  return ctx => {
-    return sf => {
-      const visitNode = node => {
+  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 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)]));
+          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;
-            const importPathWithQuotes = node === null || node === void 0 ? void 0 : (_node$moduleSpecifier = node.moduleSpecifier) === null || _node$moduleSpecifier === void 0 ? void 0 : _node$moduleSpecifier.getText();
+            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 text = importPathWithQuotes.substring(
+              1,
+              importPathWithQuotes.length - 1
+            );
             const result = getNotAliasedPath(sf, matchPath, text);
             if (!result) {
               return node;
@@ -106,13 +141,28 @@ function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
             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);
+              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 = tsBinary.factory.updateExportDeclaration(
+                node,
+                node.decorators,
+                node.modifiers,
+                node.isTypeOnly,
+                node.exportClause,
+                moduleSpecifier,
+                node.assertClause
+              );
             }
             newNode.flags = node.flags;
             return newNode;
-          } catch (_unused) {
+          } catch (e) {
             return node;
           }
         }
@@ -122,44 +172,41 @@ function tsconfigPathsBeforeHookFactory(tsBinary, baseUrl, paths) {
     };
   };
 }
-
-// fork from https://github.com/nestjs/nest-cli/blob/HEAD/lib/compiler/hooks/tsconfig-paths.hook.ts
 function getNotAliasedPath(sf, matcher, text) {
-  let result = matcher(text, undefined, undefined, ['.ts', '.tsx', '.js', '.jsx']);
+  let result = matcher(text, void 0, void 0, [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx"
+  ]);
   if (!result) {
     return;
   }
-  if (os.platform() === 'win32') {
-    result = result.replace(/\\/g, '/');
+  if (os.platform() === "win32") {
+    result = result.replace(/\\/g, "/");
   }
-  if (!_path.default.isAbsolute(result)) {
-    // handle alias to alias
-    if (!result.startsWith('.') && !result.startsWith('..')) {
+  if (!import_path.default.isAbsolute(result)) {
+    if (!result.startsWith(".") && !result.startsWith("..")) {
       try {
-        // Installed packages (node modules) should take precedence over root files with the same name.
-        // Ref: https://github.com/nestjs/nest-cli/issues/838
         const packagePath = require.resolve(result, {
           paths: [process.cwd(), ...module.paths]
         });
         if (packagePath) {
-          // eslint-disable-next-line consistent-return
           return result;
         }
-      } catch (_unused2) {}
+      } catch (e) {
+      }
     }
     try {
-      // Installed packages (node modules) should take precedence over root files with the same name.
-      // Ref: https://github.com/nestjs/nest-cli/issues/838
       const packagePath = require.resolve(text, {
         paths: [process.cwd(), ...module.paths]
       });
       if (packagePath) {
-        // eslint-disable-next-line consistent-return
         return text;
       }
-    } catch (_unused3) {}
+    } catch (e) {
+    }
   }
-  const resolvedPath = _path.posix.relative((0, _path.dirname)(sf.fileName), result) || './';
-  // eslint-disable-next-line consistent-return
-  return resolvedPath[0] === '.' ? resolvedPath : `./${resolvedPath}`;
-}
+  const resolvedPath = import_path.posix.relative((0, import_path.dirname)(sf.fileName), result) || "./";
+  return resolvedPath[0] === "." ? resolvedPath : `./${resolvedPath}`;
+}

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

@@ -1,16 +1,27 @@
-"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 __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 stdin_exports = {};
+__export(stdin_exports, {
+  TypescriptLoader: () => TypescriptLoader
 });
-exports.TypescriptLoader = void 0;
-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; }
+module.exports = __toCommonJS(stdin_exports);
 class TypescriptLoader {
-  constructor({
-    appDirectory
-  }) {
-    _defineProperty(this, "tsBinary", void 0);
-    _defineProperty(this, "appDirectory", void 0);
+  constructor({ appDirectory }) {
     this.appDirectory = appDirectory;
   }
   load() {
@@ -18,14 +29,15 @@ class TypescriptLoader {
       return this.tsBinary;
     }
     try {
-      const tsPath = require.resolve('typescript', {
+      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.');
+      throw new Error(
+        'TypeScript could not be found! Please, install "typescript" package.'
+      );
     }
   }
 }
-exports.TypescriptLoader = TypescriptLoader;

package/dist/js/node/index.js

@@ -1,27 +1,25 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {
-  compile: true
+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 });
 };
-Object.defineProperty(exports, "compile", {
-  enumerable: true,
-  get: function () {
-    return _common.compile;
+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 stdin_exports = {};
+__export(stdin_exports, {
+  compile: () => import_common.compile
 });
-var _babel = require("./compilers/babel");
-Object.keys(_babel).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _babel[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _babel[key];
-    }
-  });
-});
-var _common = require("./common");
+module.exports = __toCommonJS(stdin_exports);
+__reExport(stdin_exports, require("./compilers/babel"), module.exports);
+var import_common = require("./common");