@modern-js/server-utils 1.2.12-alpha.0 → 1.15.1-beta.0

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

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tsconfigPathsBeforeHookFactory = tsconfigPathsBeforeHookFactory;
+
+var os = _interopRequireWildcard(require("os"));
+
+var _path = _interopRequireWildcard(require("path"));
+
+var _tsconfigPaths = require("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('$');
+};
+
+const resolveAliasPath = (baseUrl, filePath) => {
+  if (_path.default.isAbsolute(filePath)) {
+    return filePath;
+  }
+
+  return _path.default.resolve(baseUrl, 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;
+  }, []);
+  return requestedModule => {
+    for (const [key, value] of aliasPairs) {
+      if (key instanceof RegExp) {
+        if (key.test(requestedModule)) {
+          return value;
+        }
+      }
+
+      if (requestedModule === key) {
+        return value;
+      }
+    }
+  };
+};
+
+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, _tsconfigPaths.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 undefined;
+  }
+
+  return ctx => {
+    return sf => {
+      const visitNode = node => {
+        if (tsBinary.isImportDeclaration(node) || tsBinary.isExportDeclaration(node) && node.moduleSpecifier) {
+          try {
+            const importPathWithQuotes = node.moduleSpecifier && node.moduleSpecifier.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;
+
+            if (tsBinary.isImportDeclaration(node)) {
+              return tsBinary.factory.updateImportDeclaration(node, node.decorators, node.modifiers, node.importClause, moduleSpecifier, node.assertClause);
+            } else {
+              return tsBinary.factory.updateExportDeclaration(node, node.decorators, node.modifiers, node.isTypeOnly, node.exportClause, moduleSpecifier, node.assertClause);
+            }
+          } catch (_unused) {
+            return node;
+          }
+        }
+
+        return tsBinary.visitEachChild(node, visitNode, ctx);
+      };
+
+      return tsBinary.visitNode(sf, visitNode);
+    };
+  };
+} // 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']);
+
+  if (!result) {
+    return;
+  }
+
+  if (os.platform() === 'win32') {
+    result = result.replace(/\\/g, '/');
+  }
+
+  if (!_path.default.isAbsolute(result)) {
+    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) {
+        return text;
+      }
+    } catch (_unused2) {}
+  }
+
+  const resolvedPath = _path.posix.relative((0, _path.dirname)(sf.fileName), result) || './';
+  return resolvedPath[0] === '.' ? resolvedPath : './' + resolvedPath;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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; }
+
+class TypescriptLoader {
+  constructor({
+    appDirectory
+  }) {
+    _defineProperty(this, "tsBinary", void 0);
+
+    _defineProperty(this, "appDirectory", void 0);
+
+    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.');
+    }
+  }
+
+}
+
+exports.TypescriptLoader = TypescriptLoader;

package/dist/js/node/index.js

@@ -3,11 +3,21 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  compile: true
+};
+Object.defineProperty(exports, "compile", {
+  enumerable: true,
+  get: function () {
+    return _common.compile;
+  }
+});
 
-var _babel = require("./babel");
+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,
@@ -15,4 +25,6 @@ Object.keys(_babel).forEach(function (key) {
       return _babel[key];
     }
   });
-});
+});
+
+var _common = require("./common");

package/dist/js/treeshaking/common/index.js

@@ -0,0 +1,82 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import * as path from 'path';
+import { fs } from '@modern-js/utils';
+import recursive from 'recursive-readdir';
+import { compileByTs } from "../compilers/typescript";
+import { compileByBabel } from "../compilers/babel";
+export var FILE_EXTENSIONS = ['.js', '.ts', '.mjs', '.ejs'];
+export var TS_CONFIG_FILENAME = 'tsconfig.json';
+export var compile = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(appDirectory, modernConfig, compileOptions) {
+    var tsConifgPath, isTsProject;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            tsConifgPath = path.join(appDirectory, TS_CONFIG_FILENAME);
+            _context.next = 3;
+            return fs.pathExists(tsConifgPath);
+
+          case 3:
+            isTsProject = _context.sent;
+
+            if (!isTsProject) {
+              _context.next = 9;
+              break;
+            }
+
+            _context.next = 7;
+            return compileByTs(appDirectory, modernConfig, compileOptions);
+
+          case 7:
+            _context.next = 11;
+            break;
+
+          case 9:
+            _context.next = 11;
+            return compileByBabel(appDirectory, modernConfig, compileOptions);
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function compile(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var recursiveReadTsFiles = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(dirname) {
+    var ignoreFunc, files;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            ignoreFunc = function ignoreFunc(filename) {
+              var extname = path.extname(filename);
+              return !['.ts', '.d.ts'].includes(extname);
+            };
+
+            _context2.next = 3;
+            return recursive(dirname, [ignoreFunc]);
+
+          case 3:
+            files = _context2.sent;
+            return _context2.abrupt("return", files);
+
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function recursiveReadTsFiles(_x4) {
+    return _ref2.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,160 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as path from 'path';
+import { getBabelChain, applyUserBabelConfig } from '@modern-js/babel-preset-lib';
+import { fs, json5, getAlias, applyOptionsChain } from '@modern-js/utils';
+import { compiler } from '@modern-js/babel-compiler';
+import { FILE_EXTENSIONS } from "../../common";
+export * from '@babel/core';
+export var readTsConfig = function readTsConfig(tsconfigPath) {
+  var noExistReturn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+  // 如果不存在，则返回 noExistReturn
+  if (!fs.existsSync(tsconfigPath)) {
+    return noExistReturn;
+  }
+
+  var content = fs.readFileSync(tsconfigPath, 'utf-8');
+  return json5.parse(content);
+};
+export var existTsConfigFile = function existTsConfigFile(tsconfigAbsolutePath) {
+  var tsconfig = readTsConfig(tsconfigAbsolutePath);
+  return Boolean(tsconfig);
+};
+export var getBabelConfig = function getBabelConfig(libPresetOption, syntaxOption) {
+  var chain = getBabelChain(libPresetOption, syntaxOption);
+  return _objectSpread({
+    sourceType: 'unambiguous'
+  }, chain.toJSON());
+};
+export var resolveBabelConfig = function resolveBabelConfig(appDirectory, modernConfig, option // FIXME: babel type can't pass type checking
+) {
+  var _modernConfig$source = modernConfig.source,
+      envVars = _modernConfig$source.envVars,
+      globalVars = _modernConfig$source.globalVars,
+      _modernConfig$source$ = _modernConfig$source.jsxTransformRuntime,
+      jsxTransformRuntime = _modernConfig$source$ === void 0 ? 'automatic' : _modernConfig$source$,
+      userLodashOption = modernConfig.tools.lodash; // alias config
+
+  var aliasConfig = getAlias(modernConfig.source.alias, _objectSpread({
+    appDirectory: appDirectory
+  }, option)); // lodash config
+
+  var lodashOptions = applyOptionsChain({
+    id: ['lodash', 'ramda']
+  }, // TODO: 需要处理类型问题
+  userLodashOption); // babel config
+
+  var babelChain = getBabelChain({
+    appDirectory: appDirectory,
+    enableReactPreset: true,
+    enableTypescriptPreset: true,
+    alias: aliasConfig,
+    envVars: envVars,
+    globalVars: globalVars,
+    lodashOptions: lodashOptions,
+    jsxTransformRuntime: jsxTransformRuntime
+  }, {
+    type: option.type,
+    syntax: option.syntax
+  });
+  var envOptions = babelChain.preset('@babel/preset-env').options();
+  babelChain.preset('@babel/preset-env').use(require.resolve('@babel/preset-env'), [_objectSpread(_objectSpread({}, 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
+  }]); // resolve "Definitely assigned fields cannot be initialized here, but only in the constructor."
+
+  babelChain.plugin('@babel/plugin-proposal-class-properties').use(require.resolve('@babel/plugin-proposal-class-properties'), [{
+    loose: true
+  }]);
+
+  var internalBabelConfig = _objectSpread({}, babelChain.toJSON());
+
+  var userBabelConfig = modernConfig.tools.babel;
+  return applyUserBabelConfig(internalBabelConfig, userBabelConfig);
+};
+export var compileByBabel = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(appDirectory, modernConfig, compileOptions) {
+    var patterns, results;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            patterns = compileOptions.patterns;
+            _context2.next = 3;
+            return Promise.all(patterns.map( /*#__PURE__*/function () {
+              var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(pattern) {
+                var from, to, tsconfigPath, babelConfig, basename, targetDir;
+                return _regeneratorRuntime().wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        from = pattern.from, to = pattern.to, tsconfigPath = pattern.tsconfigPath;
+                        babelConfig = resolveBabelConfig(appDirectory, modernConfig, {
+                          tsconfigPath: tsconfigPath ? tsconfigPath : '',
+                          syntax: 'es6+',
+                          type: 'commonjs'
+                        });
+                        _context.next = 4;
+                        return fs.pathExists(from);
+
+                      case 4:
+                        if (!_context.sent) {
+                          _context.next = 9;
+                          break;
+                        }
+
+                        basename = path.basename(from);
+                        targetDir = path.join(to, basename);
+                        _context.next = 9;
+                        return fs.copy(from, targetDir, {
+                          filter: function filter(src) {
+                            return !['.ts', '.js'].includes(path.extname(src)) && src !== tsconfigPath;
+                          }
+                        });
+
+                      case 9:
+                        return _context.abrupt("return", compiler({
+                          rootDir: appDirectory,
+                          distDir: to,
+                          sourceDir: from,
+                          extensions: FILE_EXTENSIONS
+                        }, babelConfig));
+
+                      case 10:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+              return function (_x4) {
+                return _ref2.apply(this, arguments);
+              };
+            }()));
+
+          case 3:
+            results = _context2.sent;
+            results.forEach(function (result) {
+              if (result.code === 1) {
+                throw new Error(result.message);
+              }
+            });
+
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function compileByBabel(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,189 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+// from to tsconfigpath
+// root dir
+import path from 'path';
+import { logger, getAlias, fs } from '@modern-js/utils';
+import { TS_CONFIG_FILENAME } from "../../common";
+import { TypescriptLoader } from "./typescript-loader";
+import { tsconfigPathsBeforeHookFactory } from "./tsconfig-paths-plugin";
+import ts from 'typescript';
+
+var readTsConfigByFile = function readTsConfigByFile(tsConfigFile) {
+  var parsedCmd = ts.getParsedCommandLineOfConfigFile(tsConfigFile, undefined, ts.sys);
+  var _ref = parsedCmd,
+      options = _ref.options,
+      fileNames = _ref.fileNames,
+      projectReferences = _ref.projectReferences;
+  return {
+    options: options,
+    fileNames: fileNames,
+    projectReferences: projectReferences
+  };
+};
+
+var copyFiles = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(from, to, tsconfigPath) {
+    var basename, targetDir;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fs.pathExists(from);
+
+          case 2:
+            if (!_context.sent) {
+              _context.next = 7;
+              break;
+            }
+
+            basename = path.basename(from);
+            targetDir = path.join(to, basename);
+            _context.next = 7;
+            return fs.copy(from, targetDir, {
+              filter: function filter(src) {
+                return !['.ts'].includes(path.extname(src)) && src !== tsconfigPath;
+              }
+            });
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function copyFiles(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}(); // TODO: 分离特殊的业务逻辑，通用化
+
+
+export var compileByTs = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(appDirectory, modernConfig, compileOptions) {
+    var rootTsconfigPath, patterns, ts, createProgram, formatHost, _iterator, _step, _loop;
+
+    return _regeneratorRuntime().wrap(function _callee2$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            logger.info("Running ts compile...");
+            rootTsconfigPath = path.join(appDirectory, TS_CONFIG_FILENAME);
+            patterns = compileOptions.patterns;
+            ts = new TypescriptLoader({
+              appDirectory: appDirectory
+            }).load();
+            createProgram = ts.createIncrementalProgram || ts.createProgram;
+            formatHost = getFormatHost(ts);
+            _iterator = _createForOfIteratorHelper(patterns);
+            _context3.prev = 7;
+            _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+              var pattern, _pattern$tsconfigPath, tsconfigPath, from, to, basename, targetDir, alias, aliasOption, _aliasOption$paths, paths, _aliasOption$absolute, absoluteBaseUrl, _readTsConfigByFile, options, fileNames, projectReferences, rootNames, program, tsconfigPathsPlugin, emitResult, allDiagnostics;
+
+              return _regeneratorRuntime().wrap(function _loop$(_context2) {
+                while (1) {
+                  switch (_context2.prev = _context2.next) {
+                    case 0:
+                      pattern = _step.value;
+                      _pattern$tsconfigPath = pattern.tsconfigPath, tsconfigPath = _pattern$tsconfigPath === void 0 ? rootTsconfigPath : _pattern$tsconfigPath, from = pattern.from, to = pattern.to;
+                      basename = path.basename(from);
+                      targetDir = path.join(to, basename);
+                      logger.info("Compile ".concat(from));
+                      alias = modernConfig.source.alias;
+                      aliasOption = getAlias(alias || {}, {
+                        appDirectory: appDirectory,
+                        tsconfigPath: tsconfigPath
+                      });
+                      _aliasOption$paths = aliasOption.paths, paths = _aliasOption$paths === void 0 ? {} : _aliasOption$paths, _aliasOption$absolute = aliasOption.absoluteBaseUrl, absoluteBaseUrl = _aliasOption$absolute === void 0 ? './' : _aliasOption$absolute;
+                      _readTsConfigByFile = readTsConfigByFile(tsconfigPath), options = _readTsConfigByFile.options, fileNames = _readTsConfigByFile.fileNames, projectReferences = _readTsConfigByFile.projectReferences;
+                      rootNames = fileNames.filter(function (fileName) {
+                        return fileName.endsWith('.d.ts') || fileName.includes(from);
+                      });
+                      program = createProgram.call(ts, {
+                        rootNames: rootNames,
+                        projectReferences: projectReferences,
+                        options: _objectSpread(_objectSpread({}, options), {}, {
+                          outDir: targetDir
+                        })
+                      });
+                      tsconfigPathsPlugin = tsconfigPathsBeforeHookFactory(ts, absoluteBaseUrl, paths);
+                      emitResult = program.emit(undefined, undefined, undefined, undefined, {
+                        before: [tsconfigPathsPlugin]
+                      });
+                      allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+
+                      if (allDiagnostics.length > 0) {
+                        logger.error(ts.formatDiagnosticsWithColorAndContext(allDiagnostics, formatHost));
+                        process.exit(1);
+                      }
+
+                      _context2.next = 17;
+                      return copyFiles(from, to, tsconfigPath);
+
+                    case 17:
+                    case "end":
+                      return _context2.stop();
+                  }
+                }
+              }, _loop);
+            });
+
+            _iterator.s();
+
+          case 10:
+            if ((_step = _iterator.n()).done) {
+              _context3.next = 14;
+              break;
+            }
+
+            return _context3.delegateYield(_loop(), "t0", 12);
+
+          case 12:
+            _context3.next = 10;
+            break;
+
+          case 14:
+            _context3.next = 19;
+            break;
+
+          case 16:
+            _context3.prev = 16;
+            _context3.t1 = _context3["catch"](7);
+
+            _iterator.e(_context3.t1);
+
+          case 19:
+            _context3.prev = 19;
+
+            _iterator.f();
+
+            return _context3.finish(19);
+
+          case 22:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee2, null, [[7, 16, 19, 22]]);
+  }));
+
+  return function compileByTs(_x4, _x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+var getFormatHost = function getFormatHost(ts) {
+  return {
+    getCanonicalFileName: function getCanonicalFileName(path) {
+      return path;
+    },
+    getCurrentDirectory: ts.sys.getCurrentDirectory,
+    getNewLine: function getNewLine() {
+      return ts.sys.newLine;
+    }
+  };
+};