First commit

node_modules/tsconfig-paths/src/config-loader.ts

@@ -0,0 +1,97 @@
+import * as TsConfigLoader from "./tsconfig-loader";
+import * as path from "path";
+import { options } from "./options";
+
+export interface ExplicitParams {
+  baseUrl: string;
+  paths: { [key: string]: Array<string> };
+  mainFields?: Array<string>;
+  addMatchAll?: boolean;
+}
+
+export type TsConfigLoader = (
+  params: TsConfigLoader.TsConfigLoaderParams
+) => TsConfigLoader.TsConfigLoaderResult;
+
+export interface ConfigLoaderParams {
+  cwd: string;
+  explicitParams?: ExplicitParams;
+  tsConfigLoader?: TsConfigLoader;
+}
+
+export interface ConfigLoaderSuccessResult {
+  resultType: "success";
+  configFileAbsolutePath: string;
+  baseUrl: string;
+  absoluteBaseUrl: string;
+  paths: { [key: string]: Array<string> };
+  mainFields?: Array<string>;
+  addMatchAll?: boolean;
+}
+
+export interface ConfigLoaderFailResult {
+  resultType: "failed";
+  message: string;
+}
+
+export type ConfigLoaderResult =
+  | ConfigLoaderSuccessResult
+  | ConfigLoaderFailResult;
+
+export function loadConfig(cwd: string = options.cwd): ConfigLoaderResult {
+  return configLoader({ cwd: cwd });
+}
+
+export function configLoader({
+  cwd,
+  explicitParams,
+  tsConfigLoader = TsConfigLoader.tsConfigLoader,
+}: ConfigLoaderParams): ConfigLoaderResult {
+  if (explicitParams) {
+    // tslint:disable-next-line:no-shadowed-variable
+    const absoluteBaseUrl = path.isAbsolute(explicitParams.baseUrl)
+      ? explicitParams.baseUrl
+      : path.join(cwd, explicitParams.baseUrl);
+
+    return {
+      resultType: "success",
+      configFileAbsolutePath: "",
+      baseUrl: explicitParams.baseUrl,
+      absoluteBaseUrl,
+      paths: explicitParams.paths,
+      mainFields: explicitParams.mainFields,
+      addMatchAll: explicitParams.addMatchAll,
+    };
+  }
+
+  // Load tsconfig and create path matching function
+  const loadResult = tsConfigLoader({
+    cwd,
+    getEnv: (key: string) => process.env[key],
+  });
+
+  if (!loadResult.tsConfigPath) {
+    return {
+      resultType: "failed",
+      message: "Couldn't find tsconfig.json",
+    };
+  }
+
+  if (!loadResult.baseUrl) {
+    return {
+      resultType: "failed",
+      message: "Missing baseUrl in compilerOptions",
+    };
+  }
+
+  const tsConfigDir = path.dirname(loadResult.tsConfigPath);
+  const absoluteBaseUrl = path.join(tsConfigDir, loadResult.baseUrl);
+
+  return {
+    resultType: "success",
+    configFileAbsolutePath: loadResult.tsConfigPath,
+    baseUrl: loadResult.baseUrl,
+    absoluteBaseUrl,
+    paths: loadResult.paths || {},
+  };
+}

node_modules/tsconfig-paths/src/filesystem.ts

@@ -0,0 +1,87 @@
+import * as fs from "fs";
+
+/**
+ * Typing for the fields of package.json we care about
+ */
+export interface PackageJson {
+  [key: string]: string;
+}
+
+/**
+ * A function that json from a file
+ */
+export interface ReadJsonSync {
+  // tslint:disable-next-line:no-any
+  (packageJsonPath: string): any | undefined;
+}
+
+export interface FileExistsSync {
+  (name: string): boolean;
+}
+
+export interface FileExistsAsync {
+  (path: string, callback: (err?: Error, exists?: boolean) => void): void;
+}
+
+export interface ReadJsonAsyncCallback {
+  // tslint:disable-next-line:no-any
+  (err?: Error, content?: any): void;
+}
+
+export interface ReadJsonAsync {
+  (path: string, callback: ReadJsonAsyncCallback): void;
+}
+
+export function fileExistsSync(path: string): boolean {
+  try {
+    const stats = fs.statSync(path);
+    return stats.isFile();
+  } catch (err) {
+    // If error, assume file did not exist
+    return false;
+  }
+}
+
+/**
+ * Reads package.json from disk
+ * @param file Path to package.json
+ */
+// tslint:disable-next-line:no-any
+export function readJsonFromDiskSync(packageJsonPath: string): any | undefined {
+  if (!fs.existsSync(packageJsonPath)) {
+    return undefined;
+  }
+  return require(packageJsonPath);
+}
+
+export function readJsonFromDiskAsync(
+  path: string,
+  // tslint:disable-next-line:no-any
+  callback: (err?: Error, content?: any) => void
+): void {
+  fs.readFile(path, "utf8", (err, result) => {
+    // If error, assume file did not exist
+    if (err || !result) {
+      return callback();
+    }
+    const json = JSON.parse(result);
+    return callback(undefined, json);
+  });
+}
+
+export function fileExistsAsync(
+  path2: string,
+  callback2: (err?: Error, exists?: boolean) => void
+): void {
+  fs.stat(path2, (err: Error, stats: fs.Stats) => {
+    if (err) {
+      // If error assume file does not exist
+      return callback2(undefined, false);
+    }
+    callback2(undefined, stats ? stats.isFile() : false);
+  });
+}
+
+export function removeExtension(path: string): string {
+  return path.substring(0, path.lastIndexOf(".")) || path;
+}

node_modules/tsconfig-paths/src/index.ts

@@ -0,0 +1,24 @@
+// register is used from register.js in root dir
+export {
+  createMatchPath,
+  matchFromAbsolutePaths,
+  MatchPath,
+} from "./match-path-sync";
+export {
+  createMatchPathAsync,
+  matchFromAbsolutePathsAsync,
+  MatchPathAsync,
+} from "./match-path-async";
+export { register } from "./register";
+export {
+  loadConfig,
+  ConfigLoaderResult,
+  ConfigLoaderSuccessResult,
+  ConfigLoaderFailResult,
+} from "./config-loader";
+export {
+  ReadJsonSync,
+  ReadJsonAsync,
+  FileExistsSync,
+  FileExistsAsync,
+} from "./filesystem";

node_modules/tsconfig-paths/src/mapping-entry.ts

@@ -0,0 +1,64 @@
+import * as path from "path";
+
+export interface MappingEntry {
+  readonly pattern: string;
+  readonly paths: ReadonlyArray<string>;
+}
+
+export interface Paths {
+  readonly [key: string]: ReadonlyArray<string>;
+}
+
+/**
+ * Converts an absolute baseUrl and paths to an array of absolute mapping entries.
+ * The array is sorted by longest prefix.
+ * Having an array with entries allows us to keep a sorting order rather than
+ * sort by keys each time we use the mappings.
+ * @param absoluteBaseUrl
+ * @param paths
+ * @param addMatchAll
+ */
+export function getAbsoluteMappingEntries(
+  absoluteBaseUrl: string,
+  paths: Paths,
+  addMatchAll: boolean
+): ReadonlyArray<MappingEntry> {
+  // Resolve all paths to absolute form once here, and sort them by
+  // longest prefix once here, this saves time on each request later.
+  // We need to put them in an array to preserve the sorting order.
+  const sortedKeys = sortByLongestPrefix(Object.keys(paths));
+  const absolutePaths: Array<MappingEntry> = [];
+  for (const key of sortedKeys) {
+    absolutePaths.push({
+      pattern: key,
+      paths: paths[key].map((pathToResolve) =>
+        path.join(absoluteBaseUrl, pathToResolve)
+      ),
+    });
+  }
+  // If there is no match-all path specified in the paths section of tsconfig, then try to match
+  // all paths relative to baseUrl, this is how typescript works.
+  if (!paths["*"] && addMatchAll) {
+    absolutePaths.push({
+      pattern: "*",
+      paths: [`${absoluteBaseUrl.replace(/\/$/, "")}/*`],
+    });
+  }
+
+  return absolutePaths;
+}
+
+/**
+ * Sort path patterns.
+ * If a module name can be matched with multiple patterns then pattern with the longest prefix will be picked.
+ */
+function sortByLongestPrefix(arr: Array<string>): Array<string> {
+  return arr
+    .concat()
+    .sort((a: string, b: string) => getPrefixLength(b) - getPrefixLength(a));
+}
+
+function getPrefixLength(pattern: string): number {
+  const prefixLength = pattern.indexOf("*");
+  return pattern.substr(0, prefixLength).length;
+}

node_modules/tsconfig-paths/src/match-path-async.ts

@@ -0,0 +1,223 @@
+import * as path from "path";
+import * as TryPath from "./try-path";
+import * as MappingEntry from "./mapping-entry";
+import * as Filesystem from "./filesystem";
+
+/**
+ * Function that can match a path async
+ */
+export interface MatchPathAsync {
+  (
+    requestedModule: string,
+    readJson: Filesystem.ReadJsonAsync | undefined,
+    fileExists: Filesystem.FileExistsAsync | undefined,
+    extensions: ReadonlyArray<string> | undefined,
+    callback: MatchPathAsyncCallback
+  ): void;
+}
+
+export interface MatchPathAsyncCallback {
+  (err?: Error, path?: string): void;
+}
+
+/**
+ * See the sync version for docs.
+ */
+export function createMatchPathAsync(
+  absoluteBaseUrl: string,
+  paths: { [key: string]: Array<string> },
+  mainFields: string[] = ["main"],
+  addMatchAll: boolean = true
+): MatchPathAsync {
+  const absolutePaths = MappingEntry.getAbsoluteMappingEntries(
+    absoluteBaseUrl,
+    paths,
+    addMatchAll
+  );
+
+  return (
+    requestedModule: string,
+    readJson: Filesystem.ReadJsonAsync | undefined,
+    fileExists: Filesystem.FileExistsAsync | undefined,
+    extensions: ReadonlyArray<string> | undefined,
+    callback: MatchPathAsyncCallback
+  ) =>
+    matchFromAbsolutePathsAsync(
+      absolutePaths,
+      requestedModule,
+      readJson,
+      fileExists,
+      extensions,
+      callback,
+      mainFields
+    );
+}
+
+/**
+ * See the sync version for docs.
+ */
+export function matchFromAbsolutePathsAsync(
+  absolutePathMappings: ReadonlyArray<MappingEntry.MappingEntry>,
+  requestedModule: string,
+  readJson: Filesystem.ReadJsonAsync = Filesystem.readJsonFromDiskAsync,
+  fileExists: Filesystem.FileExistsAsync = Filesystem.fileExistsAsync,
+  extensions: ReadonlyArray<string> = Object.keys(require.extensions),
+  callback: MatchPathAsyncCallback,
+  mainFields: string[] = ["main"]
+): void {
+  const tryPaths = TryPath.getPathsToTry(
+    extensions,
+    absolutePathMappings,
+    requestedModule
+  );
+
+  if (!tryPaths) {
+    return callback();
+  }
+
+  findFirstExistingPath(
+    tryPaths,
+    readJson,
+    fileExists,
+    callback,
+    0,
+    mainFields
+  );
+}
+
+function findFirstExistingMainFieldMappedFile(
+  packageJson: Filesystem.PackageJson,
+  mainFields: string[],
+  packageJsonPath: string,
+  fileExistsAsync: Filesystem.FileExistsAsync,
+  doneCallback: (err?: Error, filepath?: string) => void,
+  index: number = 0
+): void {
+  if (index >= mainFields.length) {
+    return doneCallback(undefined, undefined);
+  }
+
+  const tryNext = () =>
+    findFirstExistingMainFieldMappedFile(
+      packageJson,
+      mainFields,
+      packageJsonPath,
+      fileExistsAsync,
+      doneCallback,
+      index + 1
+    );
+
+  const mainFieldMapping = packageJson[mainFields[index]];
+  if (typeof mainFieldMapping !== "string") {
+    // Skip mappings that are not pointers to replacement files
+    return tryNext();
+  }
+
+  const mappedFilePath = path.join(
+    path.dirname(packageJsonPath),
+    mainFieldMapping
+  );
+  fileExistsAsync(mappedFilePath, (err?: Error, exists?: boolean) => {
+    if (err) {
+      return doneCallback(err);
+    }
+    if (exists) {
+      return doneCallback(undefined, mappedFilePath);
+    }
+    return tryNext();
+  });
+}
+
+// Recursive loop to probe for physical files
+function findFirstExistingPath(
+  tryPaths: ReadonlyArray<TryPath.TryPath>,
+  readJson: Filesystem.ReadJsonAsync,
+  fileExists: Filesystem.FileExistsAsync,
+  doneCallback: MatchPathAsyncCallback,
+  index: number = 0,
+  mainFields: string[] = ["main"]
+): void {
+  const tryPath = tryPaths[index];
+  if (
+    tryPath.type === "file" ||
+    tryPath.type === "extension" ||
+    tryPath.type === "index"
+  ) {
+    fileExists(tryPath.path, (err: Error, exists: boolean) => {
+      if (err) {
+        return doneCallback(err);
+      }
+      if (exists) {
+        // Not sure why we don't just return the full path? Why strip it?
+        return doneCallback(undefined, TryPath.getStrippedPath(tryPath));
+      }
+      if (index === tryPaths.length - 1) {
+        return doneCallback();
+      }
+      // Continue with the next path
+      return findFirstExistingPath(
+        tryPaths,
+        readJson,
+        fileExists,
+        doneCallback,
+        index + 1,
+        mainFields
+      );
+    });
+  } else if (tryPath.type === "package") {
+    readJson(tryPath.path, (err, packageJson) => {
+      if (err) {
+        return doneCallback(err);
+      }
+      if (packageJson) {
+        return findFirstExistingMainFieldMappedFile(
+          packageJson,
+          mainFields,
+          tryPath.path,
+          fileExists,
+          (mainFieldErr?: Error, mainFieldMappedFile?: string) => {
+            if (mainFieldErr) {
+              return doneCallback(mainFieldErr);
+            }
+            if (mainFieldMappedFile) {
+              // Not sure why we don't just return the full path? Why strip it?
+              return doneCallback(
+                undefined,
+                Filesystem.removeExtension(mainFieldMappedFile)
+              );
+            }
+
+            // No field in package json was a valid option. Continue with the next path.
+            return findFirstExistingPath(
+              tryPaths,
+              readJson,
+              fileExists,
+              doneCallback,
+              index + 1,
+              mainFields
+            );
+          }
+        );
+      }
+
+      // This is async code, we need to return unconditionally, otherwise the code still falls
+      // through and keeps recursing. While this might work in general, libraries that use neo-async
+      // like Webpack will actually not allow you to call the same callback twice.
+      //
+      // An example of where this caused issues:
+      // https://github.com/dividab/tsconfig-paths-webpack-plugin/issues/11
+      //
+      // Continue with the next path
+      return findFirstExistingPath(
+        tryPaths,
+        readJson,
+        fileExists,
+        doneCallback,
+        index + 1,
+        mainFields
+      );
+    });
+  } else {
+    TryPath.exhaustiveTypeException(tryPath.type);
+  }
+}

node_modules/tsconfig-paths/src/match-path-sync.ts

@@ -0,0 +1,143 @@
+import * as path from "path";
+import * as Filesystem from "./filesystem";
+import * as MappingEntry from "./mapping-entry";
+import * as TryPath from "./try-path";
+
+/**
+ * Function that can match a path
+ */
+export interface MatchPath {
+  (
+    requestedModule: string,
+    readJson?: Filesystem.ReadJsonSync,
+    fileExists?: (name: string) => boolean,
+    extensions?: ReadonlyArray<string>
+  ): string | undefined;
+}
+
+/**
+ * Creates a function that can resolve paths according to tsconfig paths property.
+ * @param absoluteBaseUrl Absolute version of baseUrl as specified in tsconfig.
+ * @param paths The paths as specified in tsconfig.
+ * @param mainFields A list of package.json field names to try when resolving module files.
+ * @param addMatchAll Add a match-all "*" rule if none is present
+ * @returns a function that can resolve paths.
+ */
+export function createMatchPath(
+  absoluteBaseUrl: string,
+  paths: { [key: string]: Array<string> },
+  mainFields: string[] = ["main"],
+  addMatchAll: boolean = true
+): MatchPath {
+  const absolutePaths = MappingEntry.getAbsoluteMappingEntries(
+    absoluteBaseUrl,
+    paths,
+    addMatchAll
+  );
+
+  return (
+    requestedModule: string,
+    readJson?: Filesystem.ReadJsonSync,
+    fileExists?: Filesystem.FileExistsSync,
+    extensions?: Array<string>
+  ) =>
+    matchFromAbsolutePaths(
+      absolutePaths,
+      requestedModule,
+      readJson,
+      fileExists,
+      extensions,
+      mainFields
+    );
+}
+
+/**
+ * Finds a path from tsconfig that matches a module load request.
+ * @param absolutePathMappings The paths to try as specified in tsconfig but resolved to absolute form.
+ * @param requestedModule The required module name.
+ * @param readJson Function that can read json from a path (useful for testing).
+ * @param fileExists Function that checks for existence of a file at a path (useful for testing).
+ * @param extensions File extensions to probe for (useful for testing).
+ * @param mainFields A list of package.json field names to try when resolving module files.
+ * @returns the found path, or undefined if no path was found.
+ */
+export function matchFromAbsolutePaths(
+  absolutePathMappings: ReadonlyArray<MappingEntry.MappingEntry>,
+  requestedModule: string,
+  readJson: Filesystem.ReadJsonSync = Filesystem.readJsonFromDiskSync,
+  fileExists: Filesystem.FileExistsSync = Filesystem.fileExistsSync,
+  extensions: Array<string> = Object.keys(require.extensions),
+  mainFields: string[] = ["main"]
+): string | undefined {
+  const tryPaths = TryPath.getPathsToTry(
+    extensions,
+    absolutePathMappings,
+    requestedModule
+  );
+
+  if (!tryPaths) {
+    return undefined;
+  }
+
+  return findFirstExistingPath(tryPaths, readJson, fileExists, mainFields);
+}
+
+function findFirstExistingMainFieldMappedFile(
+  packageJson: Filesystem.PackageJson,
+  mainFields: string[],
+  packageJsonPath: string,
+  fileExists: Filesystem.FileExistsSync
+): string | undefined {
+  for (let index = 0; index < mainFields.length; index++) {
+    const mainFieldName = mainFields[index];
+    const candidateMapping = packageJson[mainFieldName];
+    if (candidateMapping && typeof candidateMapping === "string") {
+      const candidateFilePath = path.join(
+        path.dirname(packageJsonPath),
+        candidateMapping
+      );
+      if (fileExists(candidateFilePath)) {
+        return candidateFilePath;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function findFirstExistingPath(
+  tryPaths: ReadonlyArray<TryPath.TryPath>,
+  readJson: Filesystem.ReadJsonSync = Filesystem.readJsonFromDiskSync,
+  fileExists: Filesystem.FileExistsSync,
+  mainFields: string[] = ["main"]
+): string | undefined {
+  for (const tryPath of tryPaths) {
+    if (
+      tryPath.type === "file" ||
+      tryPath.type === "extension" ||
+      tryPath.type === "index"
+    ) {
+      if (fileExists(tryPath.path)) {
+        // Not sure why we don't just return the full path? Why strip it?
+        return TryPath.getStrippedPath(tryPath);
+      }
+    } else if (tryPath.type === "package") {
+      const packageJson: Filesystem.PackageJson = readJson(tryPath.path);
+      if (packageJson) {
+        const mainFieldMappedFile = findFirstExistingMainFieldMappedFile(
+          packageJson,
+          mainFields,
+          tryPath.path,
+          fileExists
+        );
+        if (mainFieldMappedFile) {
+          // Not sure why we don't just return the full path? Why strip it?
+          return Filesystem.removeExtension(mainFieldMappedFile);
+        }
+      }
+    } else {
+      TryPath.exhaustiveTypeException(tryPath.type);
+    }
+  }
+  return undefined;
+}

node_modules/tsconfig-paths/src/options.ts

@@ -0,0 +1,18 @@
+import * as minimist from "minimist";
+
+const argv = minimist(process.argv.slice(2), {
+  string: ["project"],
+  alias: {
+    project: ["P"],
+  },
+});
+
+const project = argv && argv.project;
+
+export interface Options {
+  cwd: string;
+}
+
+export const options: Options = {
+  cwd: project || process.cwd(),
+};

node_modules/tsconfig-paths/src/register.ts

@@ -0,0 +1,97 @@
+import { createMatchPath } from "./match-path-sync";
+import { configLoader, ExplicitParams } from "./config-loader";
+import { options } from "./options";
+
+const noOp = (): void => void 0;
+
+function getCoreModules(
+  builtinModules: string[] | undefined
+): { [key: string]: boolean } {
+  builtinModules = builtinModules || [
+    "assert",
+    "buffer",
+    "child_process",
+    "cluster",
+    "crypto",
+    "dgram",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "https",
+    "net",
+    "os",
+    "path",
+    "punycode",
+    "querystring",
+    "readline",
+    "stream",
+    "string_decoder",
+    "tls",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "zlib",
+  ];
+
+  const coreModules: { [key: string]: boolean } = {};
+  for (let module of builtinModules) {
+    coreModules[module] = true;
+  }
+
+  return coreModules;
+}
+
+/**
+ * Installs a custom module load function that can adhere to paths in tsconfig.
+ * Returns a function to undo paths registration.
+ */
+export function register(explicitParams: ExplicitParams): () => void {
+  const configLoaderResult = configLoader({
+    cwd: options.cwd,
+    explicitParams,
+  });
+
+  if (configLoaderResult.resultType === "failed") {
+    console.warn(
+      `${configLoaderResult.message}. tsconfig-paths will be skipped`
+    );
+
+    return noOp;
+  }
+
+  const matchPath = createMatchPath(
+    configLoaderResult.absoluteBaseUrl,
+    configLoaderResult.paths,
+    configLoaderResult.mainFields,
+    configLoaderResult.addMatchAll
+  );
+
+  // Patch node's module loading
+  // tslint:disable-next-line:no-require-imports variable-name
+  const Module = require("module");
+  const originalResolveFilename = Module._resolveFilename;
+  const coreModules = getCoreModules(Module.builtinModules);
+  // tslint:disable-next-line:no-any
+  Module._resolveFilename = function (request: string, _parent: any): string {
+    const isCoreModule = coreModules.hasOwnProperty(request);
+    if (!isCoreModule) {
+      const found = matchPath(request);
+      if (found) {
+        const modifiedArguments = [found, ...[].slice.call(arguments, 1)]; // Passes all arguments. Even those that is not specified above.
+        // tslint:disable-next-line:no-invalid-this
+        return originalResolveFilename.apply(this, modifiedArguments);
+      }
+    }
+    // tslint:disable-next-line:no-invalid-this
+    return originalResolveFilename.apply(this, arguments);
+  };
+
+  return () => {
+    // Return node's module loading to original state.
+    Module._resolveFilename = originalResolveFilename;
+  };
+}

node_modules/tsconfig-paths/src/try-path.ts

@@ -0,0 +1,107 @@
+import * as path from "path";
+import { MappingEntry } from "./mapping-entry";
+import { dirname } from "path";
+import { removeExtension } from "./filesystem";
+
+export interface TryPath {
+  readonly type: "file" | "extension" | "index" | "package";
+  readonly path: string;
+}
+
+/**
+ * Builds a list of all physical paths to try by:
+ * 1. Check for file named exactly as request.
+ * 2. Check for files named as request ending in any of the extensions.
+ * 3. Check for file specified in package.json's main property.
+ * 4. Check for files named as request ending in "index" with any of the extensions.
+ */
+export function getPathsToTry(
+  extensions: ReadonlyArray<string>,
+  absolutePathMappings: ReadonlyArray<MappingEntry>,
+  requestedModule: string
+): ReadonlyArray<TryPath> | undefined {
+  if (
+    !absolutePathMappings ||
+    !requestedModule ||
+    requestedModule[0] === "." ||
+    requestedModule[0] === path.sep
+  ) {
+    return undefined;
+  }
+
+  const pathsToTry: Array<TryPath> = [];
+  for (const entry of absolutePathMappings) {
+    const starMatch =
+      entry.pattern === requestedModule
+        ? ""
+        : matchStar(entry.pattern, requestedModule);
+    if (starMatch !== undefined) {
+      for (const physicalPathPattern of entry.paths) {
+        const physicalPath = physicalPathPattern.replace("*", starMatch);
+        pathsToTry.push({ type: "file", path: physicalPath });
+        pathsToTry.push(
+          ...extensions.map(
+            (e) => ({ type: "extension", path: physicalPath + e } as TryPath)
+          )
+        );
+        pathsToTry.push({
+          type: "package",
+          path: path.join(physicalPath, "/package.json"),
+        });
+        const indexPath = path.join(physicalPath, "/index");
+        pathsToTry.push(
+          ...extensions.map(
+            (e) => ({ type: "index", path: indexPath + e } as TryPath)
+          )
+        );
+      }
+    }
+  }
+  return pathsToTry.length === 0 ? undefined : pathsToTry;
+}
+
+// Not sure why we don't just return the full found path?
+export function getStrippedPath(tryPath: TryPath): string {
+  return tryPath.type === "index"
+    ? dirname(tryPath.path)
+    : tryPath.type === "file"
+    ? tryPath.path
+    : tryPath.type === "extension"
+    ? removeExtension(tryPath.path)
+    : tryPath.type === "package"
+    ? tryPath.path
+    : exhaustiveTypeException(tryPath.type);
+}
+
+export function exhaustiveTypeException(check: never): never {
+  throw new Error(`Unknown type ${check}`);
+}
+
+/**
+ * Matches pattern with a single star against search.
+ * Star must match at least one character to be considered a match.
+ * @param patttern for example "foo*"
+ * @param search for example "fooawesomebar"
+ * @returns the part of search that * matches, or undefined if no match.
+ */
+function matchStar(pattern: string, search: string): string | undefined {
+  if (search.length < pattern.length) {
+    return undefined;
+  }
+  if (pattern === "*") {
+    return search;
+  }
+  const star = pattern.indexOf("*");
+  if (star === -1) {
+    return undefined;
+  }
+  const part1 = pattern.substring(0, star);
+  const part2 = pattern.substring(star + 1);
+  if (search.substr(0, star) !== part1) {
+    return undefined;
+  }
+  if (search.substr(search.length - part2.length) !== part2) {
+    return undefined;
+  }
+  return search.substr(star, search.length - part2.length);
+}

node_modules/tsconfig-paths/src/tsconfig-loader.ts

@@ -0,0 +1,172 @@
+import * as path from "path";
+import * as fs from "fs";
+// tslint:disable:no-require-imports
+import JSON5 = require("json5");
+import StripBom = require("strip-bom");
+// tslint:enable:no-require-imports
+
+/**
+ * Typing for the parts of tsconfig that we care about
+ */
+export interface Tsconfig {
+  extends?: string;
+  compilerOptions?: {
+    baseUrl?: string;
+    paths?: { [key: string]: Array<string> };
+    strict?: boolean;
+  };
+}
+
+export interface TsConfigLoaderResult {
+  tsConfigPath: string | undefined;
+  baseUrl: string | undefined;
+  paths: { [key: string]: Array<string> } | undefined;
+}
+
+export interface TsConfigLoaderParams {
+  getEnv: (key: string) => string | undefined;
+  cwd: string;
+  loadSync?(
+    cwd: string,
+    filename?: string,
+    baseUrl?: string
+  ): TsConfigLoaderResult;
+}
+
+export function tsConfigLoader({
+  getEnv,
+  cwd,
+  loadSync = loadSyncDefault,
+}: TsConfigLoaderParams): TsConfigLoaderResult {
+  const TS_NODE_PROJECT = getEnv("TS_NODE_PROJECT");
+  const TS_NODE_BASEURL = getEnv("TS_NODE_BASEURL");
+
+  // tsconfig.loadSync handles if TS_NODE_PROJECT is a file or directory
+  // and also overrides baseURL if TS_NODE_BASEURL is available.
+  const loadResult = loadSync(cwd, TS_NODE_PROJECT, TS_NODE_BASEURL);
+  return loadResult;
+}
+
+function loadSyncDefault(
+  cwd: string,
+  filename?: string,
+  baseUrl?: string
+): TsConfigLoaderResult {
+  // Tsconfig.loadSync uses path.resolve. This is why we can use an absolute path as filename
+
+  const configPath = resolveConfigPath(cwd, filename);
+
+  if (!configPath) {
+    return {
+      tsConfigPath: undefined,
+      baseUrl: undefined,
+      paths: undefined,
+    };
+  }
+  const config = loadTsconfig(configPath);
+
+  return {
+    tsConfigPath: configPath,
+    baseUrl:
+      baseUrl ||
+      (config && config.compilerOptions && config.compilerOptions.baseUrl),
+    paths: config && config.compilerOptions && config.compilerOptions.paths,
+  };
+}
+
+function resolveConfigPath(cwd: string, filename?: string): string | undefined {
+  if (filename) {
+    const absolutePath = fs.lstatSync(filename).isDirectory()
+      ? path.resolve(filename, "./tsconfig.json")
+      : path.resolve(cwd, filename);
+
+    return absolutePath;
+  }
+
+  if (fs.statSync(cwd).isFile()) {
+    return path.resolve(cwd);
+  }
+
+  const configAbsolutePath = walkForTsConfig(cwd);
+  return configAbsolutePath ? path.resolve(configAbsolutePath) : undefined;
+}
+
+export function walkForTsConfig(
+  directory: string,
+  existsSync: (path: string) => boolean = fs.existsSync
+): string | undefined {
+  const configPath = path.join(directory, "./tsconfig.json");
+  if (existsSync(configPath)) {
+    return configPath;
+  }
+
+  const parentDirectory = path.join(directory, "../");
+
+  // If we reached the top
+  if (directory === parentDirectory) {
+    return undefined;
+  }
+
+  return walkForTsConfig(parentDirectory, existsSync);
+}
+
+export function loadTsconfig(
+  configFilePath: string,
+  existsSync: (path: string) => boolean = fs.existsSync,
+  readFileSync: (filename: string) => string = (filename: string) =>
+    fs.readFileSync(filename, "utf8")
+): Tsconfig | undefined {
+  if (!existsSync(configFilePath)) {
+    return undefined;
+  }
+
+  const configString = readFileSync(configFilePath);
+  const cleanedJson = StripBom(configString);
+  const config: Tsconfig = JSON5.parse(cleanedJson);
+  let extendedConfig = config.extends;
+
+  if (extendedConfig) {
+    if (
+      typeof extendedConfig === "string" &&
+      extendedConfig.indexOf(".json") === -1
+    ) {
+      extendedConfig += ".json";
+    }
+    const currentDir = path.dirname(configFilePath);
+    let extendedConfigPath = path.join(currentDir, extendedConfig);
+    if (
+      extendedConfig.indexOf("/") !== -1 &&
+      extendedConfig.indexOf(".") !== -1 &&
+      !existsSync(extendedConfigPath)
+    ) {
+      extendedConfigPath = path.join(
+        currentDir,
+        "node_modules",
+        extendedConfig
+      );
+    }
+
+    const base =
+      loadTsconfig(extendedConfigPath, existsSync, readFileSync) || {};
+
+    // baseUrl should be interpreted as relative to the base tsconfig,
+    // but we need to update it so it is relative to the original tsconfig being loaded
+    if (base.compilerOptions && base.compilerOptions.baseUrl) {
+      const extendsDir = path.dirname(extendedConfig);
+      base.compilerOptions.baseUrl = path.join(
+        extendsDir,
+        base.compilerOptions.baseUrl
+      );
+    }
+
+    return {
+      ...base,
+      ...config,
+      compilerOptions: {
+        ...base.compilerOptions,
+        ...config.compilerOptions,
+      },
+    };
+  }
+  return config;
+}

node_modules/tsconfig-paths/src/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../base-tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "sourceMap": false,
+    "declaration": true,
+    "outDir": "../lib"
+  }
+}