text: "use strict";
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  Object.defineProperty(exports, "__esModule", { value: true });
  var path_1 = require("path");
  var fs_1 = require("fs");
  var os_1 = require("os");
  var sourceMapSupport = require("source-map-support");
  var mkdirp = require("mkdirp");
  var crypto = require("crypto");
  var yn = require("yn");
  var arrify = require("arrify");
  var bufferFrom = require("buffer-from");
  var make_error_1 = require("make-error");
  var util = require("util");
  /**
   * @internal
   */
  exports.INSPECT_CUSTOM = util.inspect.custom || 'inspect';
  /**
   * Debugging `ts-node`.
   */
  var shouldDebug = yn(process.env.TS_NODE_DEBUG);
  var debug = shouldDebug ? console.log.bind(console, 'ts-node') : function () { return undefined; };
  var debugFn = shouldDebug ?
      function (key, fn) {
          return function (x) {
              debug(key, x);
              return fn(x);
          };
      } :
      function (_, fn) { return fn; };
  /**
   * Export the current version.
   */
  exports.VERSION = require('../package.json').version;
  /**
   * Default register options.
   */
  exports.DEFAULTS = {
      files: yn(process.env['TS_NODE_FILES']),
      cache: yn(process.env['TS_NODE_CACHE'], { default: true }),
      pretty: yn(process.env['TS_NODE_PRETTY']),
      cacheDirectory: process.env['TS_NODE_CACHE_DIRECTORY'],
      compiler: process.env['TS_NODE_COMPILER'],
      compilerOptions: parse(process.env['TS_NODE_COMPILER_OPTIONS']),
      ignore: split(process.env['TS_NODE_IGNORE']),
      project: process.env['TS_NODE_PROJECT'],
      skipIgnore: yn(process.env['TS_NODE_SKIP_IGNORE']),
      skipProject: yn(process.env['TS_NODE_SKIP_PROJECT']),
      ignoreDiagnostics: split(process.env['TS_NODE_IGNORE_DIAGNOSTICS']),
      typeCheck: yn(process.env['TS_NODE_TYPE_CHECK']),
      transpileOnly: yn(process.env['TS_NODE_TRANSPILE_ONLY'])
  };
  /**
   * Default TypeScript compiler options required by `ts-node`.
   */
  var DEFAULT_COMPILER_OPTIONS = {
      sourceMap: true,
      inlineSourceMap: false,
      inlineSources: true,
      declaration: false,
      noEmit: false,
      outDir: '$$ts-node$$'
  };
  /**
   * Split a string array of values.
   */
  function split(value) {
      return typeof value === 'string' ? value.split(/ *, */g) : undefined;
  }
  exports.split = split;
  /**
   * Parse a string as JSON.
   */
  function parse(value) {
      return typeof value === 'string' ? JSON.parse(value) : undefined;
  }
  exports.parse = parse;
  /**
   * Replace backslashes with forward slashes.
   */
  function normalizeSlashes(value) {
      return value.replace(/\\/g, '/');
  }
  exports.normalizeSlashes = normalizeSlashes;
  /**
   * TypeScript diagnostics error.
   */
  var TSError = /** @class */ (function (_super) {
      __extends(TSError, _super);
      function TSError(diagnosticText, diagnosticCodes) {
          var _this = _super.call(this, "\u2A2F Unable to compile TypeScript:\n" + diagnosticText) || this;
          _this.diagnosticText = diagnosticText;
          _this.diagnosticCodes = diagnosticCodes;
          _this.name = 'TSError';
          return _this;
      }
      /**
       * @internal
       */
      TSError.prototype[exports.INSPECT_CUSTOM] = function () {
          return this.diagnosticText;
      };
      return TSError;
  }(make_error_1.BaseError));
  exports.TSError = TSError;
  /**
   * Return a default temp directory based on home directory of user.
   */
  function getTmpDir() {
      var hash = crypto.createHash('sha256').update(os_1.homedir(), 'utf8').digest('hex');
      return path_1.join(os_1.tmpdir(), "ts-node-" + hash);
  }
  /**
   * Register TypeScript compiler.
   */
  function register(opts) {
      if (opts === void 0) { opts = {}; }
      var options = Object.assign({}, exports.DEFAULTS, opts);
      var cacheDirectory = options.cacheDirectory || getTmpDir();
      var originalJsHandler = require.extensions['.js'];
      var ignoreDiagnostics = arrify(options.ignoreDiagnostics).concat([
          6059,
          18002,
          18003 // "No inputs were found in config file."
      ]).map(Number);
      var memoryCache = {
          contents: Object.create(null),
          versions: Object.create(null),
          outputs: Object.create(null)
      };
      var ignore = options.skipIgnore ? [] : arrify(options.ignore || '/node_modules/').map(function (str) { return new RegExp(str); });
      // Install source map support and read from memory cache.
      sourceMapSupport.install({
          environment: 'node',
          retrieveFile: function (path) {
              return memoryCache.outputs[path];
          }
      });
      // Require the TypeScript compiler and configuration.
      var cwd = process.cwd();
      var compilerOptions = options.compilerOptions, project = options.project, skipProject = options.skipProject;
      var compiler = options.compiler || 'typescript';
      var typeCheck = options.typeCheck === true || options.transpileOnly !== true;
      var ts = require(compiler);
      var transformers = options.transformers || undefined;
      var readFile = options.readFile || ts.sys.readFile;
      var fileExists = options.fileExists || ts.sys.fileExists;
      var config = readConfig(cwd, ts, fileExists, readFile, compilerOptions, project, skipProject);
      var configDiagnosticList = filterDiagnostics(config.errors, ignoreDiagnostics);
      var extensions = ['.ts', '.tsx'];
      var fileNames = options.files ? config.fileNames : [];
      var cachedir = path_1.join(path_1.resolve(cwd, cacheDirectory), getCompilerDigest({
          version: ts.version,
          options: config.options,
          fileNames: fileNames,
          typeCheck: typeCheck,
          ignoreDiagnostics: ignoreDiagnostics,
          compiler: compiler
      }));
      var diagnosticHost = {
          getNewLine: function () { return os_1.EOL; },
          getCurrentDirectory: function () { return cwd; },
          getCanonicalFileName: function (path) { return path; }
      };
      var formatDiagnostics = options.pretty
          ? ts.formatDiagnosticsWithColorAndContext
          : ts.formatDiagnostics;
      function createTSError(diagnostics) {
          var diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
          var diagnosticCodes = diagnostics.map(function (x) { return x.code; });
          return new TSError(diagnosticText, diagnosticCodes);
      }
      // Render the configuration errors and exit the script.
      if (configDiagnosticList.length)
          throw createTSError(configDiagnosticList);
      // Enable `allowJs` when flag is set.
      if (config.options.allowJs) {
          extensions.push('.js');
          extensions.push('.jsx');
      }
      // Initialize files from TypeScript into project.
      for (var _i = 0, fileNames_1 = fileNames; _i < fileNames_1.length; _i++) {
          var path = fileNames_1[_i];
          memoryCache.versions[path] = 1;
      }
      /**
       * Get the extension for a transpiled file.
       */
      var getExtension = config.options.jsx === ts.JsxEmit.Preserve ?
          (function (path) { return /\.[tj]sx$/.test(path) ? '.jsx' : '.js'; }) :
          (function (_) { return '.js'; });
      /**
       * Create the basic required function using transpile mode.
       */
      var getOutput = function (code, fileName, lineOffset) {
          if (lineOffset === void 0) { lineOffset = 0; }
          var result = ts.transpileModule(code, {
              fileName: fileName,
              transformers: transformers,
              compilerOptions: config.options,
              reportDiagnostics: true
          });
          var diagnosticList = result.diagnostics ?
              filterDiagnostics(result.diagnostics, ignoreDiagnostics) :
              [];
          if (diagnosticList.length)
              throw createTSError(diagnosticList);
          return [result.outputText, result.sourceMapText];
      };
      var getTypeInfo = function (_code, _fileName, _position) {
          throw new TypeError("Type information is unavailable without \"--type-check\"");
      };
      // Use full language services when the fast option is disabled.
      if (typeCheck) {
          // Set the file contents into cache.
          var updateMemoryCache_1 = function (code, fileName) {
              if (memoryCache.contents[fileName] !== code) {
                  memoryCache.contents[fileName] = code;
                  memoryCache.versions[fileName] = (memoryCache.versions[fileName] || 0) + 1;
              }
          };
          // Create the compiler host for type checking.
          var serviceHost = {
              getScriptFileNames: function () { return Object.keys(memoryCache.versions); },
              getScriptVersion: function (fileName) {
                  var version = memoryCache.versions[fileName];
                  // We need to return `undefined` and not a string here because TypeScript will use
                  // `getScriptVersion` and compare against their own version - which can be `undefined`.
                  // If we don't return `undefined` it results in `undefined === "undefined"` and run
                  // `createProgram` again (which is very slow). Using a `string` assertion here to avoid
                  // TypeScript errors from the function signature (expects `(x: string) => string`).
                  return version === undefined ? undefined : String(version);
              },
              getScriptSnapshot: function (fileName) {
                  // Read contents into TypeScript memory cache.
                  if (!Object.prototype.hasOwnProperty.call(memoryCache.contents, fileName)) {
                      memoryCache.contents[fileName] = readFile(fileName);
                  }
                  var contents = memoryCache.contents[fileName];
                  if (contents === undefined)
                      return;
                  return ts.ScriptSnapshot.fromString(contents);
              },
              fileExists: debugFn('fileExists', fileExists),
              readFile: debugFn('readFile', readFile),
              readDirectory: debugFn('readDirectory', ts.sys.readDirectory),
              getDirectories: debugFn('getDirectories', ts.sys.getDirectories),
              directoryExists: debugFn('directoryExists', ts.sys.directoryExists),
              getNewLine: function () { return os_1.EOL; },
              getCurrentDirectory: function () { return cwd; },
              getCompilationSettings: function () { return config.options; },
              getDefaultLibFileName: function () { return ts.getDefaultLibFilePath(config.options); },
              getCustomTransformers: function () { return transformers; }
          };
          var service_1 = ts.createLanguageService(serviceHost);
          getOutput = function (code, fileName, lineOffset) {
              if (lineOffset === void 0) { lineOffset = 0; }
              // Must set memory cache before attempting to read file.
              updateMemoryCache_1(code, fileName);
              var output = service_1.getEmitOutput(fileName);
              // Get the relevant diagnostics - this is 3x faster than `getPreEmitDiagnostics`.
              var diagnostics = service_1.getCompilerOptionsDiagnostics()
                  .concat(service_1.getSyntacticDiagnostics(fileName))
                  .concat(service_1.getSemanticDiagnostics(fileName));
              var diagnosticList = filterDiagnostics(diagnostics, ignoreDiagnostics);
              if (diagnosticList.length)
                  throw createTSError(diagnosticList);
              if (output.emitSkipped) {
                  throw new TypeError(path_1.relative(cwd, fileName) + ": Emit skipped");
              }
              // Throw an error when requiring `.d.ts` files.
              if (output.outputFiles.length === 0) {
                  throw new TypeError('Unable to require `.d.ts` file.\n' +
                      'This is usually the result of a faulty configuration or import. ' +
                      'Make sure there is a `.js`, `.json` or another executable extension and ' +
                      'loader (attached before `ts-node`) available alongside ' +
                      ("`" + path_1.basename(fileName) + "`."));
              }
              return [output.outputFiles[1].text, output.outputFiles[0].text];
          };
          getTypeInfo = function (code, fileName, position) {
              updateMemoryCache_1(code, fileName);
              var info = service_1.getQuickInfoAtPosition(fileName, position);
              var name = ts.displayPartsToString(info ? info.displayParts : []);
              var comment = ts.displayPartsToString(info ? info.documentation : []);
              return { name: name, comment: comment };
          };
      }
      var compile = readThrough(cachedir, options.cache === true, memoryCache, getOutput, getExtension);
      var register = { cwd: cwd, compile: compile, getTypeInfo: getTypeInfo, extensions: extensions, cachedir: cachedir, ts: ts };
      // Register the extensions.
      extensions.forEach(function (extension) {
          registerExtension(extension, ignore, register, originalJsHandler);
      });
      return register;
  }
  exports.register = register;
  /**
   * Check if the filename should be ignored.
   */
  function shouldIgnore(filename, ignore) {
      var relname = normalizeSlashes(filename);
      return ignore.some(function (x) { return x.test(relname); });
  }
  /**
   * Register the extension for node.
   */
  function registerExtension(ext, ignore, register, originalHandler) {
      var old = require.extensions[ext] || originalHandler;
      require.extensions[ext] = function (m, filename) {
          if (shouldIgnore(filename, ignore)) {
              return old(m, filename);
          }
          var _compile = m._compile;
          m._compile = function (code, fileName) {
              debug('module._compile', fileName);
              return _compile.call(this, register.compile(code, fileName), fileName);
          };
          return old(m, filename);
      };
  }
  /**
   * Do post-processing on config options to support `ts-node`.
   */
  function fixConfig(ts, config) {
      // Delete options that *should not* be passed through.
      delete config.options.out;
      delete config.options.outFile;
      delete config.options.declarationDir;
      delete config.options.declarationMap;
      delete config.options.emitDeclarationOnly;
      // Target ES5 output by default (instead of ES3).
      if (config.options.target === undefined) {
          config.options.target = ts.ScriptTarget.ES5;
      }
      // Target CommonJS modules by default (instead of magically switching to ES6 when the target is ES6).
      if (config.options.module === undefined) {
          config.options.module = ts.ModuleKind.CommonJS;
      }
      return config;
  }
  /**
   * Load TypeScript configuration.
   */
  function readConfig(cwd, ts, fileExists, readFile, compilerOptions, project, noProject) {
      var config = { compilerOptions: {} };
      var basePath = normalizeSlashes(cwd);
      var configFileName = undefined;
      // Read project configuration when available.
      if (!noProject) {
          configFileName = project
              ? normalizeSlashes(path_1.resolve(cwd, project))
              : ts.findConfigFile(normalizeSlashes(cwd), fileExists);
          if (configFileName) {
              var result = ts.readConfigFile(configFileName, readFile);
              // Return diagnostics.
              if (result.error) {
                  return { errors: [result.error], fileNames: [], options: {} };
              }
              config = result.config;
              basePath = normalizeSlashes(path_1.dirname(configFileName));
          }
      }
      // Override default configuration options `ts-node` requires.
      config.compilerOptions = Object.assign({}, config.compilerOptions, compilerOptions, DEFAULT_COMPILER_OPTIONS);
      return fixConfig(ts, ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, configFileName));
  }
  /**
   * Wrap the function with caching.
   */
  function readThrough(cachedir, shouldCache, memoryCache, compile, getExtension) {
      if (shouldCache === false) {
          return function (code, fileName, lineOffset) {
              debug('readThrough', fileName);
              var _a = compile(code, fileName, lineOffset), value = _a[0], sourceMap = _a[1];
              var output = updateOutput(value, fileName, sourceMap, getExtension);
              memoryCache.outputs[fileName] = output;
              return output;
          };
      }
      // Make sure the cache directory exists before continuing.
      mkdirp.sync(cachedir);
      return function (code, fileName, lineOffset) {
          debug('readThrough', fileName);
          var cachePath = path_1.join(cachedir, getCacheName(code, fileName));
          var extension = getExtension(fileName);
          var outputPath = "" + cachePath + extension;
          try {
              var output_1 = fs_1.readFileSync(outputPath, 'utf8');
              if (isValidCacheContent(output_1)) {
                  memoryCache.outputs[fileName] = output_1;
                  return output_1;
              }
          }
          catch (err) { /* Ignore. */ }
          var _a = compile(code, fileName, lineOffset), value = _a[0], sourceMap = _a[1];
          var output = updateOutput(value, fileName, sourceMap, getExtension);
          memoryCache.outputs[fileName] = output;
          fs_1.writeFileSync(outputPath, output);
          return output;
      };
  }
  /**
   * Update the output remapping the source map.
   */
  function updateOutput(outputText, fileName, sourceMap, getExtension) {
      var base64Map = bufferFrom(updateSourceMap(sourceMap, fileName), 'utf8').toString('base64');
      var sourceMapContent = "data:application/json;charset=utf-8;base64," + base64Map;
      var sourceMapLength = (path_1.basename(fileName) + ".map").length + (getExtension(fileName).length - path_1.extname(fileName).length);
      return outputText.slice(0, -sourceMapLength) + sourceMapContent;
  }
  /**
   * Update the source map contents for improved output.
   */
  function updateSourceMap(sourceMapText, fileName) {
      var sourceMap = JSON.parse(sourceMapText);
      sourceMap.file = fileName;
      sourceMap.sources = [fileName];
      delete sourceMap.sourceRoot;
      return JSON.stringify(sourceMap);
  }
  /**
   * Get the file name for the cache entry.
   */
  function getCacheName(sourceCode, fileName) {
      return crypto.createHash('sha256')
          .update(path_1.extname(fileName), 'utf8')
          .update('\x00', 'utf8')
          .update(sourceCode, 'utf8')
          .digest('hex');
  }
  /**
   * Ensure the given cached content is valid by sniffing for a base64 encoded '}'
   * at the end of the content, which should exist if there is a valid sourceMap present.
   */
  function isValidCacheContent(contents) {
      return /(?:9|0=|Q==)$/.test(contents.slice(-3));
  }
  /**
   * Create a hash of the current configuration.
   */
  function getCompilerDigest(obj) {
      return crypto.createHash('sha256').update(JSON.stringify(obj), 'utf8').digest('hex');
  }
  /**
   * Filter diagnostics.
   */
  function filterDiagnostics(diagnostics, ignore) {
      return diagnostics.filter(function (x) { return ignore.indexOf(x.code) === -1; });
  }
  //# sourceMappingURL=index.js.map