Deployed the page to Github Pages.

node_modules/ts-node/dist-raw/README.md

@@ -0,0 +1,13 @@
+The `dist-raw` directory contains JS sources that are distributed verbatim, not compiled nor typechecked via TS.
+
+To implement ESM support, we unfortunately must duplicate some of node's built-in functionality that is not
+exposed via an API.  We have copy-pasted the necessary code from https://github.com/nodejs/node/tree/master/lib
+then modified it to suite our needs.
+
+Formatting may be intentionally bad to keep the diff as small as possible, to make it easier to merge
+upstream changes and understand our modifications.  For example, when we need to wrap node's source code
+in a factory function, we will not indent the function body, to avoid whitespace changes in the diff.
+
+One obvious problem with this approach: the code has been pulled from one version of node, whereas users of ts-node
+run multiple versions of node.
+Users running node 12 may see that ts-node behaves like node 14, for example.

node_modules/ts-node/dist-raw/node-cjs-loader-utils.js

@@ -0,0 +1,136 @@
+// Copied from several files in node's source code.
+// https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/modules/cjs/loader.js
+// Each function and variable below must have a comment linking to the source in node's github repo.
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports.assertScriptCanLoadAsCJSImpl = assertScriptCanLoadAsCJSImpl;
+
+// copied from Module._extensions['.js']
+// https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/modules/cjs/loader.js#L1211-L1217
+function assertScriptCanLoadAsCJSImpl(filename) {
+  const pkg = readPackageScope(filename);
+  // Function require shouldn't be used in ES modules.
+  if (pkg && pkg.data && pkg.data.type === 'module') {
+    const parentPath = module.parent && module.parent.filename;
+    const packageJsonPath = path.resolve(pkg.path, 'package.json');
+    throw createErrRequireEsm(filename, parentPath, packageJsonPath);
+  }
+}
+
+// Copied from https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/modules/cjs/loader.js#L285-L301
+function readPackageScope(checkPath) {
+  const rootSeparatorIndex = checkPath.indexOf(path.sep);
+  let separatorIndex;
+  while (
+    (separatorIndex = checkPath.lastIndexOf(path.sep)) > rootSeparatorIndex
+  ) {
+    checkPath = checkPath.slice(0, separatorIndex);
+    if (checkPath.endsWith(path.sep + 'node_modules'))
+      return false;
+    const pjson = readPackage(checkPath);
+    if (pjson) return {
+      path: checkPath,
+      data: pjson
+    };
+  }
+  return false;
+}
+
+// Copied from https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/modules/cjs/loader.js#L249
+const packageJsonCache = new Map();
+
+// Copied from https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/modules/cjs/loader.js#L251-L283
+function readPackage(requestPath) {
+  const jsonPath = path.resolve(requestPath, 'package.json');
+
+  const existing = packageJsonCache.get(jsonPath);
+  if (existing !== undefined) return existing;
+
+  const json = internalModuleReadJSON(path.toNamespacedPath(jsonPath));
+  if (json === undefined) {
+    packageJsonCache.set(jsonPath, false);
+    return false;
+  }
+
+  // TODO Related to `--experimental-policy`?  Disabling for now
+  // if (manifest) {
+  //   const jsonURL = pathToFileURL(jsonPath);
+  //   manifest.assertIntegrity(jsonURL, json);
+  // }
+
+  try {
+    const parsed = JSON.parse(json);
+    const filtered = {
+      name: parsed.name,
+      main: parsed.main,
+      exports: parsed.exports,
+      type: parsed.type
+    };
+    packageJsonCache.set(jsonPath, filtered);
+    return filtered;
+  } catch (e) {
+    e.path = jsonPath;
+    e.message = 'Error parsing ' + jsonPath + ': ' + e.message;
+    throw e;
+  }
+}
+
+// In node's core, this is implemented in C
+// https://github.com/nodejs/node/blob/e9f293750760d59243020d0376edf242c9a26b67/src/node_file.cc#L845-L939
+function internalModuleReadJSON(path) {
+  try {
+    return fs.readFileSync(path, 'utf8')
+  } catch (e) {
+    if (e.code === 'ENOENT') return undefined
+    throw e
+  }
+}
+
+// Native ERR_REQUIRE_ESM Error is declared here:
+//   https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/errors.js#L1294-L1313
+// Error class factory is implemented here:
+//   function E: https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/errors.js#L323-L341
+//   function makeNodeErrorWithCode: https://github.com/nodejs/node/blob/2d5d77306f6dff9110c1f77fefab25f973415770/lib/internal/errors.js#L251-L278
+// The code below should create an error that matches the native error as closely as possible.
+// Third-party libraries which attempt to catch the native ERR_REQUIRE_ESM should recognize our imitation error.
+function createErrRequireEsm(filename, parentPath, packageJsonPath) {
+  const code = 'ERR_REQUIRE_ESM'
+  const err = new Error(getMessage(filename, parentPath, packageJsonPath))
+  // Set `name` to be used in stack trace, generate stack trace with that name baked in, then re-declare the `name` field.
+  // This trick is copied from node's source.
+  err.name = `Error [${ code }]`
+  err.stack
+  Object.defineProperty(err, 'name', {
+    value: 'Error',
+    enumerable: false,
+    writable: true,
+    configurable: true
+  })
+  err.code = code
+  return err
+
+  // Copy-pasted from https://github.com/nodejs/node/blob/b533fb3508009e5f567cc776daba8fbf665386a6/lib/internal/errors.js#L1293-L1311
+  // so that our error message is identical to the native message.
+  function getMessage(filename, parentPath = null, packageJsonPath = null) {
+    const ext = path.extname(filename)
+    let msg = `Must use import to load ES Module: ${filename}`;
+    if (parentPath && packageJsonPath) {
+      const path = require('path');
+      const basename = path.basename(filename) === path.basename(parentPath) ?
+        filename : path.basename(filename);
+      msg +=
+        '\nrequire() of ES modules is not supported.\nrequire() of ' +
+        `${filename} ${parentPath ? `from ${parentPath} ` : ''}` +
+        `is an ES module file as it is a ${ext} file whose nearest parent ` +
+        `package.json contains "type": "module" which defines all ${ext} ` +
+        'files in that package scope as ES modules.\nInstead ' +
+        'change the requiring code to use ' +
+        'import(), or remove "type": "module" from ' +
+        `${packageJsonPath}.\n`;
+      return msg;
+    }
+    return msg;
+  }
+}

node_modules/ts-node/dist-raw/node-createrequire.js

@@ -0,0 +1,29 @@
+// Extracted from https://github.com/nodejs/node/blob/ec2ffd6b9d255e19818b6949d2f7dc7ac70faee9/lib/internal/modules/cjs/loader.js
+// then modified to suit our needs
+
+const path = require('path');
+const Module = require('module');
+
+exports.createRequireFromPath = createRequireFromPath;
+
+function createRequireFromPath(filename) {
+  // Allow a directory to be passed as the filename
+  const trailingSlash =
+    filename.endsWith('/') || (isWindows && filename.endsWith('\\'));
+
+  const proxyPath = trailingSlash ?
+    path.join(filename, 'noop.js') :
+    filename;
+
+  const m = new Module(proxyPath);
+  m.filename = proxyPath;
+
+  m.paths = Module._nodeModulePaths(m.path);
+  return makeRequireFunction(m, proxyPath);
+}
+
+// This trick is much smaller than copy-pasting from https://github.com/nodejs/node/blob/ec2ffd6b9d255e19818b6949d2f7dc7ac70faee9/lib/internal/modules/cjs/helpers.js#L32-L101
+function makeRequireFunction(module, filename) {
+  module._compile('module.exports = require;', filename)
+  return mod.exports
+}

node_modules/ts-node/dist-raw/node-esm-resolve-implementation.js

@@ -0,0 +1,742 @@
+// Copied from https://raw.githubusercontent.com/nodejs/node/v13.12.0/lib/internal/modules/esm/resolve.js
+// Then modified to suite our needs.
+// Formatting is intentionally bad to keep the diff as small as possible, to make it easier to merge
+// upstream changes and understand our modifications.
+'use strict';
+
+const {
+  ArrayIsArray,
+  JSONParse,
+  JSONStringify,
+  ObjectGetOwnPropertyNames,
+  ObjectPrototypeHasOwnProperty,
+  SafeMap,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  StringPrototypeIndexOf,
+  StringPrototypeSlice,
+  StringPrototypeStartsWith,
+  StringPrototypeSubstr,
+} = {
+  ArrayIsArray: Array.isArray,
+  JSONParse: JSON.parse,
+  JSONStringify: JSON.stringify,
+  ObjectGetOwnPropertyNames: Object.getOwnPropertyNames,
+  ObjectPrototypeHasOwnProperty: (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop),
+  SafeMap: Map,
+  StringPrototypeEndsWith: (str, ...rest) => String.prototype.endsWith.apply(str, rest),
+  StringPrototypeIncludes: (str, ...rest) => String.prototype.includes.apply(str, rest),
+  StringPrototypeIndexOf: (str, ...rest) => String.prototype.indexOf.apply(str, rest),
+  StringPrototypeSlice: (str, ...rest) => String.prototype.slice.apply(str, rest),
+  StringPrototypeStartsWith: (str, ...rest) => String.prototype.startsWith.apply(str, rest),
+  StringPrototypeSubstr: (str, ...rest) => String.prototype.substr.apply(str, rest),
+} // node pulls from `primordials` object
+
+// const internalFS = require('internal/fs/utils');
+// const { NativeModule } = require('internal/bootstrap/loaders');
+const Module = require('module')
+const NativeModule = {
+  canBeRequiredByUsers(specifier) {
+    return Module.builtinModules.includes(specifier)
+  }
+}
+const {
+  closeSync,
+  fstatSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  Stats,
+} = require('fs');
+// const { getOptionValue } = require('internal/options');
+const { getOptionValue } = require('./node-options');
+const { sep } = require('path');
+
+const preserveSymlinks = getOptionValue('--preserve-symlinks');
+const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
+const typeFlag = getOptionValue('--input-type');
+// const { URL, pathToFileURL, fileURLToPath } = require('internal/url');
+const { URL, pathToFileURL, fileURLToPath } = require('url');
+const {
+  ERR_INPUT_TYPE_NOT_ALLOWED,
+  ERR_INVALID_MODULE_SPECIFIER,
+  ERR_INVALID_PACKAGE_CONFIG,
+  ERR_INVALID_PACKAGE_TARGET,
+  ERR_MODULE_NOT_FOUND,
+  ERR_PACKAGE_PATH_NOT_EXPORTED,
+  ERR_UNSUPPORTED_ESM_URL_SCHEME,
+// } = require('internal/errors').codes;
+} = {
+  ERR_INPUT_TYPE_NOT_ALLOWED: createErrorCtor('ERR_INPUT_TYPE_NOT_ALLOWED'),
+  ERR_INVALID_MODULE_SPECIFIER: createErrorCtor('ERR_INVALID_MODULE_SPECIFIER'),
+  ERR_INVALID_PACKAGE_CONFIG: createErrorCtor('ERR_INVALID_PACKAGE_CONFIG'),
+  ERR_INVALID_PACKAGE_TARGET: createErrorCtor('ERR_INVALID_PACKAGE_TARGET'),
+  ERR_MODULE_NOT_FOUND: createErrorCtor('ERR_MODULE_NOT_FOUND'),
+  ERR_PACKAGE_PATH_NOT_EXPORTED: createErrorCtor('ERR_PACKAGE_PATH_NOT_EXPORTED'),
+  ERR_UNSUPPORTED_ESM_URL_SCHEME: createErrorCtor('ERR_UNSUPPORTED_ESM_URL_SCHEME'),
+}
+function createErrorCtor(name) {
+  return class CustomError extends Error {
+    constructor(...args) {
+      super([name, ...args].join(' '))
+    }
+  }
+}
+
+function createResolve(opts) {
+// TODO receive cached fs implementations here
+const {tsExtensions, jsExtensions, preferTsExts} = opts;
+
+const realpathCache = new SafeMap();
+const packageJSONCache = new SafeMap();  /* string -> PackageConfig */
+
+function tryStatSync(path) {
+  try {
+    return statSync(path);
+  } catch {
+    return new Stats();
+  }
+}
+
+function readIfFile(path) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+  } catch {
+    return undefined;
+  }
+  try {
+    if (!fstatSync(fd).isFile()) return undefined;
+    return readFileSync(fd, 'utf8');
+  } finally {
+    closeSync(fd);
+  }
+}
+
+function getPackageConfig(path, base) {
+  const existing = packageJSONCache.get(path);
+  if (existing !== undefined) {
+    if (!existing.isValid) {
+      throw new ERR_INVALID_PACKAGE_CONFIG(path, fileURLToPath(base), false);
+    }
+    return existing;
+  }
+
+  const source = readIfFile(path);
+  if (source === undefined) {
+    const packageConfig = {
+      exists: false,
+      main: undefined,
+      name: undefined,
+      isValid: true,
+      type: 'none',
+      exports: undefined
+    };
+    packageJSONCache.set(path, packageConfig);
+    return packageConfig;
+  }
+
+  let packageJSON;
+  try {
+    packageJSON = JSONParse(source);
+  } catch {
+    const packageConfig = {
+      exists: true,
+      main: undefined,
+      name: undefined,
+      isValid: false,
+      type: 'none',
+      exports: undefined
+    };
+    packageJSONCache.set(path, packageConfig);
+    return packageConfig;
+  }
+
+  let { main, name, type } = packageJSON;
+  const { exports } = packageJSON;
+  if (typeof main !== 'string') main = undefined;
+  if (typeof name !== 'string') name = undefined;
+  // Ignore unknown types for forwards compatibility
+  if (type !== 'module' && type !== 'commonjs') type = 'none';
+
+  const packageConfig = {
+    exists: true,
+    main,
+    name,
+    isValid: true,
+    type,
+    exports
+  };
+  packageJSONCache.set(path, packageConfig);
+  return packageConfig;
+}
+
+function getPackageScopeConfig(resolved, base) {
+  let packageJSONUrl = new URL('./package.json', resolved);
+  while (true) {
+    const packageJSONPath = packageJSONUrl.pathname;
+    if (StringPrototypeEndsWith(packageJSONPath, 'node_modules/package.json'))
+      break;
+    const packageConfig = getPackageConfig(fileURLToPath(packageJSONUrl), base);
+    if (packageConfig.exists) return packageConfig;
+
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new URL('../package.json', packageJSONUrl);
+
+    // Terminates at root where ../package.json equals ../../package.json
+    // (can't just check "/package.json" for Windows support).
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) break;
+  }
+  const packageConfig = {
+    exists: false,
+    main: undefined,
+    name: undefined,
+    isValid: true,
+    type: 'none',
+    exports: undefined
+  };
+  packageJSONCache.set(fileURLToPath(packageJSONUrl), packageConfig);
+  return packageConfig;
+}
+
+/*
+ * Legacy CommonJS main resolution:
+ * 1. let M = pkg_url + (json main field)
+ * 2. TRY(M, M.js, M.json, M.node)
+ * 3. TRY(M/index.js, M/index.json, M/index.node)
+ * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
+ * 5. NOT_FOUND
+ */
+function fileExists(url) {
+  return tryStatSync(fileURLToPath(url)).isFile();
+}
+
+function legacyMainResolve(packageJSONUrl, packageConfig) {
+  let guess;
+  if (packageConfig.main !== undefined) {
+    // Note: fs check redundances will be handled by Descriptor cache here.
+    if (fileExists(guess = new URL(`./${packageConfig.main}`,
+                                   packageJSONUrl))) {
+      return guess;
+    }
+    if (fileExists(guess = new URL(`./${packageConfig.main}.js`,
+                                   packageJSONUrl))) {
+      return guess;
+    }
+    if (fileExists(guess = new URL(`./${packageConfig.main}.json`,
+                                   packageJSONUrl))) {
+      return guess;
+    }
+    if (fileExists(guess = new URL(`./${packageConfig.main}.node`,
+                                   packageJSONUrl))) {
+      return guess;
+    }
+    if (fileExists(guess = new URL(`./${packageConfig.main}/index.js`,
+                                   packageJSONUrl))) {
+      return guess;
+    }
+    if (fileExists(guess = new URL(`./${packageConfig.main}/index.json`,
+                                   packageJSONUrl))) {
+      return guess;
+    }
+    if (fileExists(guess = new URL(`./${packageConfig.main}/index.node`,
+                                   packageJSONUrl))) {
+      return guess;
+    }
+    // Fallthrough.
+  }
+  if (fileExists(guess = new URL('./index.js', packageJSONUrl))) {
+    return guess;
+  }
+  // So fs.
+  if (fileExists(guess = new URL('./index.json', packageJSONUrl))) {
+    return guess;
+  }
+  if (fileExists(guess = new URL('./index.node', packageJSONUrl))) {
+    return guess;
+  }
+  // Not found.
+  return undefined;
+}
+
+function resolveExtensionsWithTryExactName(search) {
+  if (fileExists(search)) return search;
+  const resolvedReplacementExtension = resolveReplacementExtensions(search);
+  if(resolvedReplacementExtension) return resolvedReplacementExtension;
+  return resolveExtensions(search);
+}
+
+const extensions = Array.from(new Set([
+  ...(preferTsExts ? tsExtensions : []),
+  '.js',
+  ...jsExtensions,
+  '.json', '.node', '.mjs',
+  ...tsExtensions
+]));
+
+function resolveExtensions(search) {
+  for (let i = 0; i < extensions.length; i++) {
+    const extension = extensions[i];
+    const guess = new URL(`${search.pathname}${extension}`, search);
+    if (fileExists(guess)) return guess;
+  }
+  return undefined;
+}
+
+/**
+ * TS's resolver can resolve foo.js to foo.ts, by replacing .js extension with several source extensions.
+ * IMPORTANT: preserve ordering according to preferTsExts; this affects resolution behavior!
+ */
+const replacementExtensions = extensions.filter(ext => ['.js', '.jsx', '.ts', '.tsx'].includes(ext));
+
+function resolveReplacementExtensions(search) {
+  if (search.pathname.match(/\.js$/)) {
+    const pathnameWithoutExtension = search.pathname.slice(0, search.pathname.length - 3);
+    for (let i = 0; i < replacementExtensions.length; i++) {
+      const extension = replacementExtensions[i];
+      const guess = new URL(`${pathnameWithoutExtension}${extension}`, search);
+      if (fileExists(guess)) return guess;
+    }
+  }
+  return undefined;
+}
+
+function resolveIndex(search) {
+  return resolveExtensions(new URL('index', search));
+}
+
+function finalizeResolution(resolved, base) {
+  if (getOptionValue('--experimental-specifier-resolution') === 'node') {
+    let file = resolveExtensionsWithTryExactName(resolved);
+    if (file !== undefined) return file;
+    if (!StringPrototypeEndsWith(resolved.pathname, '/')) {
+      file = resolveIndex(new URL(`${resolved.pathname}/`, base));
+    } else {
+      file = resolveIndex(resolved);
+    }
+    if (file !== undefined) return file;
+    throw new ERR_MODULE_NOT_FOUND(
+      resolved.pathname, fileURLToPath(base), 'module');
+  }
+
+  if (StringPrototypeEndsWith(resolved.pathname, '/')) return resolved;
+
+  const file = resolveReplacementExtensions(resolved) || resolved;
+
+  const path = fileURLToPath(file);
+
+  if (!tryStatSync(path).isFile()) {
+  throw new ERR_MODULE_NOT_FOUND(
+    path || resolved.pathname, fileURLToPath(base), 'module');
+  }
+
+  return file;
+}
+
+function throwExportsNotFound(subpath, packageJSONUrl, base) {
+  throw new ERR_PACKAGE_PATH_NOT_EXPORTED(
+    fileURLToPath(packageJSONUrl), subpath, fileURLToPath(base));
+}
+
+function throwSubpathInvalid(subpath, packageJSONUrl, base) {
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    fileURLToPath(packageJSONUrl), subpath, fileURLToPath(base));
+}
+
+function throwExportsInvalid(
+  subpath, target, packageJSONUrl, base) {
+  if (typeof target === 'object' && target !== null) {
+    target = JSONStringify(target, null, '');
+  } else if (ArrayIsArray(target)) {
+    target = `[${target}]`;
+  } else {
+    target = `${target}`;
+  }
+  throw new ERR_INVALID_PACKAGE_TARGET(
+    fileURLToPath(packageJSONUrl), null, subpath, target, fileURLToPath(base));
+}
+
+function resolveExportsTargetString(
+  target, subpath, match, packageJSONUrl, base) {
+  if (target[0] !== '.' || target[1] !== '/' ||
+      (subpath !== '' && target[target.length - 1] !== '/')) {
+    throwExportsInvalid(match, target, packageJSONUrl, base);
+  }
+
+  const resolved = new URL(target, packageJSONUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL('.', packageJSONUrl).pathname;
+
+  if (!StringPrototypeStartsWith(resolvedPath, packagePath) ||
+      StringPrototypeIncludes(
+        resolvedPath, '/node_modules/', packagePath.length - 1)) {
+    throwExportsInvalid(match, target, packageJSONUrl, base);
+  }
+
+  if (subpath === '') return resolved;
+  const subpathResolved = new URL(subpath, resolved);
+  const subpathResolvedPath = subpathResolved.pathname;
+  if (!StringPrototypeStartsWith(subpathResolvedPath, resolvedPath) ||
+      StringPrototypeIncludes(subpathResolvedPath,
+                              '/node_modules/', packagePath.length - 1)) {
+    throwSubpathInvalid(match + subpath, packageJSONUrl, base);
+  }
+  return subpathResolved;
+}
+
+function isArrayIndex(key /* string */) { /* -> boolean */
+  const keyNum = +key;
+  if (`${keyNum}` !== key) return false;
+  return keyNum >= 0 && keyNum < 0xFFFF_FFFF;
+}
+
+function resolveExportsTarget(
+  packageJSONUrl, target, subpath, packageSubpath, base) {
+  if (typeof target === 'string') {
+    const resolved = resolveExportsTargetString(
+      target, subpath, packageSubpath, packageJSONUrl, base);
+    return finalizeResolution(resolved, base);
+  } else if (ArrayIsArray(target)) {
+    if (target.length === 0)
+      throwExportsInvalid(packageSubpath, target, packageJSONUrl, base);
+
+    let lastException;
+    for (let i = 0; i < target.length; i++) {
+      const targetItem = target[i];
+      let resolved;
+      try {
+        resolved = resolveExportsTarget(
+          packageJSONUrl, targetItem, subpath, packageSubpath, base);
+      } catch (e) {
+        lastException = e;
+        if (e.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED' ||
+            e.code === 'ERR_INVALID_PACKAGE_TARGET') {
+          continue;
+        }
+        throw e;
+      }
+
+      return finalizeResolution(resolved, base);
+    }
+    throw lastException;
+  } else if (typeof target === 'object' && target !== null) {
+    const keys = ObjectGetOwnPropertyNames(target);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG(
+          fileURLToPath(packageJSONUrl),
+          '"exports" cannot contain numeric property keys');
+      }
+    }
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (key === 'node' || key === 'import' || key === 'default') {
+        const conditionalTarget = target[key];
+        try {
+          return resolveExportsTarget(
+            packageJSONUrl, conditionalTarget, subpath, packageSubpath, base);
+        } catch (e) {
+          if (e.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') continue;
+          throw e;
+        }
+      }
+    }
+    throwExportsNotFound(packageSubpath, packageJSONUrl, base);
+  }
+  throwExportsInvalid(packageSubpath, target, packageJSONUrl, base);
+}
+
+function isConditionalExportsMainSugar(exports, packageJSONUrl, base) {
+  if (typeof exports === 'string' || ArrayIsArray(exports)) return true;
+  if (typeof exports !== 'object' || exports === null) return false;
+
+  const keys = ObjectGetOwnPropertyNames(exports);
+  let isConditionalSugar = false;
+  let i = 0;
+  for (let j = 0; j < keys.length; j++) {
+    const key = keys[j];
+    const curIsConditionalSugar = key === '' || key[0] !== '.';
+    if (i++ === 0) {
+      isConditionalSugar = curIsConditionalSugar;
+    } else if (isConditionalSugar !== curIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG(
+        fileURLToPath(packageJSONUrl),
+        '"exports" cannot contain some keys starting with \'.\' and some not.' +
+        ' The exports object must either be an object of package subpath keys' +
+        ' or an object of main entry condition name keys only.');
+    }
+  }
+  return isConditionalSugar;
+}
+
+
+function packageMainResolve(packageJSONUrl, packageConfig, base) {
+  if (packageConfig.exists) {
+    const exports = packageConfig.exports;
+    if (exports !== undefined) {
+      if (isConditionalExportsMainSugar(exports, packageJSONUrl, base)) {
+        return resolveExportsTarget(packageJSONUrl, exports, '', '', base);
+      } else if (typeof exports === 'object' && exports !== null) {
+        const target = exports['.'];
+        if (target !== undefined)
+          return resolveExportsTarget(packageJSONUrl, target, '', '', base);
+      }
+
+      throw new ERR_PACKAGE_PATH_NOT_EXPORTED(packageJSONUrl, '.');
+    }
+    if (packageConfig.main !== undefined) {
+      const resolved = new URL(packageConfig.main, packageJSONUrl);
+      const path = fileURLToPath(resolved);
+      if (tryStatSync(path).isFile()) return resolved;
+    }
+    if (getOptionValue('--experimental-specifier-resolution') === 'node') {
+      if (packageConfig.main !== undefined) {
+        return finalizeResolution(
+          new URL(packageConfig.main, packageJSONUrl), base);
+      } else {
+        return finalizeResolution(
+          new URL('index', packageJSONUrl), base);
+      }
+    }
+    if (packageConfig.type !== 'module') {
+      return legacyMainResolve(packageJSONUrl, packageConfig);
+    }
+  }
+
+  throw new ERR_MODULE_NOT_FOUND(
+    fileURLToPath(new URL('.', packageJSONUrl)), fileURLToPath(base));
+}
+
+
+function packageExportsResolve(
+  packageJSONUrl, packageSubpath, packageConfig, base) /* -> URL */ {
+  const exports = packageConfig.exports;
+  if (exports === undefined ||
+      isConditionalExportsMainSugar(exports, packageJSONUrl, base)) {
+    throwExportsNotFound(packageSubpath, packageJSONUrl, base);
+  }
+
+
+  if (ObjectPrototypeHasOwnProperty(exports, packageSubpath)) {
+    const target = exports[packageSubpath];
+    const resolved = resolveExportsTarget(
+      packageJSONUrl, target, '', packageSubpath, base);
+    return finalizeResolution(resolved, base);
+  }
+
+  let bestMatch = '';
+  const keys = ObjectGetOwnPropertyNames(exports);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key[key.length - 1] !== '/') continue;
+    if (StringPrototypeStartsWith(packageSubpath, key) &&
+        key.length > bestMatch.length) {
+      bestMatch = key;
+    }
+  }
+
+  if (bestMatch) {
+    const target = exports[bestMatch];
+    const subpath = StringPrototypeSubstr(packageSubpath, bestMatch.length);
+    const resolved = resolveExportsTarget(
+      packageJSONUrl, target, subpath, packageSubpath, base);
+    return finalizeResolution(resolved, base);
+  }
+
+  throwExportsNotFound(packageSubpath, packageJSONUrl, base);
+}
+
+function getPackageType(url) {
+  const packageConfig = getPackageScopeConfig(url, url);
+  return packageConfig.type;
+}
+
+function packageResolve(specifier /* string */, base /* URL */) { /* -> URL */
+  let separatorIndex = StringPrototypeIndexOf(specifier, '/');
+  let validPackageName = true;
+  let isScoped = false;
+  if (specifier[0] === '@') {
+    isScoped = true;
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false;
+    } else {
+      separatorIndex = StringPrototypeIndexOf(
+        specifier, '/', separatorIndex + 1);
+    }
+  }
+
+  const packageName = separatorIndex === -1 ?
+    specifier : StringPrototypeSlice(specifier, 0, separatorIndex);
+
+  // Package name cannot have leading . and cannot have percent-encoding or
+  // separators.
+  for (let i = 0; i < packageName.length; i++) {
+    if (packageName[i] === '%' || packageName[i] === '\\') {
+      validPackageName = false;
+      break;
+    }
+  }
+
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      specifier, undefined, fileURLToPath(base));
+  }
+
+  const packageSubpath = separatorIndex === -1 ?
+    '' : '.' + StringPrototypeSlice(specifier, separatorIndex);
+
+  // ResolveSelf
+  const packageConfig = getPackageScopeConfig(base, base);
+  if (packageConfig.exists) {
+    // TODO(jkrems): Find a way to forward the pair/iterator already generated
+    // while executing GetPackageScopeConfig
+    let packageJSONUrl;
+    for (const [ filename, packageConfigCandidate ] of packageJSONCache) {
+      if (packageConfig === packageConfigCandidate) {
+        packageJSONUrl = pathToFileURL(filename);
+        break;
+      }
+    }
+    if (packageJSONUrl !== undefined &&
+        packageConfig.name === packageName &&
+        packageConfig.exports !== undefined) {
+      if (packageSubpath === './') {
+        return new URL('./', packageJSONUrl);
+      } else if (packageSubpath === '') {
+        return packageMainResolve(packageJSONUrl, packageConfig, base);
+      } else {
+        return packageExportsResolve(
+          packageJSONUrl, packageSubpath, packageConfig, base);
+      }
+    }
+  }
+
+  let packageJSONUrl =
+    new URL('./node_modules/' + packageName + '/package.json', base);
+  let packageJSONPath = fileURLToPath(packageJSONUrl);
+  let lastPath;
+  do {
+    const stat = tryStatSync(
+      StringPrototypeSlice(packageJSONPath, 0, packageJSONPath.length - 13));
+    if (!stat.isDirectory()) {
+      lastPath = packageJSONPath;
+      packageJSONUrl = new URL((isScoped ?
+        '../../../../node_modules/' : '../../../node_modules/') +
+        packageName + '/package.json', packageJSONUrl);
+      packageJSONPath = fileURLToPath(packageJSONUrl);
+      continue;
+    }
+
+    // Package match.
+    const packageConfig = getPackageConfig(packageJSONPath, base);
+    if (packageSubpath === './') {
+      return new URL('./', packageJSONUrl);
+    } else if (packageSubpath === '') {
+      return packageMainResolve(packageJSONUrl, packageConfig, base);
+    } else if (packageConfig.exports !== undefined) {
+      return packageExportsResolve(
+        packageJSONUrl, packageSubpath, packageConfig, base);
+    } else {
+      return finalizeResolution(
+        new URL(packageSubpath, packageJSONUrl), base);
+    }
+    // Cross-platform root check.
+  } while (packageJSONPath.length !== lastPath.length);
+
+  // eslint can't handle the above code.
+  // eslint-disable-next-line no-unreachable
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base));
+}
+
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === '') return false;
+  if (specifier[0] === '/') return true;
+  if (specifier[0] === '.') {
+    if (specifier.length === 1 || specifier[1] === '/') return true;
+    if (specifier[1] === '.') {
+      if (specifier.length === 2 || specifier[2] === '/') return true;
+    }
+  }
+  return false;
+}
+
+function moduleResolve(specifier /* string */, base /* URL */) { /* -> URL */
+  // Order swapped from spec for minor perf gain.
+  // Ok since relative URLs cannot parse as URLs.
+  let resolved;
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    resolved = new URL(specifier, base);
+  } else {
+    try {
+      resolved = new URL(specifier);
+    } catch {
+      return packageResolve(specifier, base);
+    }
+  }
+  return finalizeResolution(resolved, base);
+}
+
+function defaultResolve(specifier, { parentURL } = {}, defaultResolveUnused) {
+  let parsed;
+  try {
+    parsed = new URL(specifier);
+    if (parsed.protocol === 'data:') {
+      return {
+        url: specifier
+      };
+    }
+  } catch {}
+  if (parsed && parsed.protocol === 'nodejs:')
+    return { url: specifier };
+  if (parsed && parsed.protocol !== 'file:' && parsed.protocol !== 'data:')
+    throw new ERR_UNSUPPORTED_ESM_URL_SCHEME();
+  if (NativeModule.canBeRequiredByUsers(specifier)) {
+    return {
+      url: 'nodejs:' + specifier
+    };
+  }
+  if (parentURL && StringPrototypeStartsWith(parentURL, 'data:')) {
+    // This is gonna blow up, we want the error
+    new URL(specifier, parentURL);
+  }
+
+  const isMain = parentURL === undefined;
+  if (isMain) {
+    parentURL = pathToFileURL(`${process.cwd()}/`).href;
+
+    // This is the initial entry point to the program, and --input-type has
+    // been passed as an option; but --input-type can only be used with
+    // --eval, --print or STDIN string input. It is not allowed with file
+    // input, to avoid user confusion over how expansive the effect of the
+    // flag should be (i.e. entry point only, package scope surrounding the
+    // entry point, etc.).
+    if (typeFlag)
+      throw new ERR_INPUT_TYPE_NOT_ALLOWED();
+  }
+
+  let url = moduleResolve(specifier, new URL(parentURL));
+
+  if (isMain ? !preserveSymlinksMain : !preserveSymlinks) {
+    const urlPath = fileURLToPath(url);
+    const real = realpathSync(urlPath, {
+      // [internalFS.realpathCacheKey]: realpathCache
+    });
+    const old = url;
+    url = pathToFileURL(real + (urlPath.endsWith(sep) ? '/' : ''));
+    url.search = old.search;
+    url.hash = old.hash;
+  }
+
+  return { url: `${url}` };
+}
+
+return {
+  defaultResolve,
+  getPackageType
+};
+}
+module.exports = {
+  createResolve
+}

node_modules/ts-node/dist-raw/node-options.js

@@ -0,0 +1,83 @@
+// Replacement for node's internal 'internal/options' module
+
+exports.getOptionValue = getOptionValue;
+function getOptionValue(opt) {
+  parseOptions();
+  return options[opt];
+}
+
+let options;
+function parseOptions() {
+  if (!options) {
+    options = {
+      '--preserve-symlinks': false,
+      '--preserve-symlinks-main': false,
+      '--input-type': undefined,
+      '--experimental-specifier-resolution': 'explicit',
+      ...parseArgv(getNodeOptionsEnvArgv()),
+      ...parseArgv(process.execArgv)
+    }
+  }
+}
+
+function parseArgv(argv) {
+  return require('arg')({
+    '--preserve-symlinks': Boolean,
+    '--preserve-symlinks-main': Boolean,
+    '--input-type': String,
+    '--experimental-specifier-resolution': String
+  }, {
+    argv,
+    permissive: true
+  });
+}
+
+function getNodeOptionsEnvArgv() {
+  const errors = [];
+  const envArgv = ParseNodeOptionsEnvVar(process.env.NODE_OPTIONS || '', errors);
+  if (errors.length !== 0) {
+    // TODO: handle errors somehow
+  }
+  return envArgv;
+}
+
+// Direct JS port of C implementation: https://github.com/nodejs/node/blob/67ba825037b4082d5d16f922fb9ce54516b4a869/src/node_options.cc#L1024-L1063
+function ParseNodeOptionsEnvVar(node_options, errors) {
+  const env_argv = [];
+
+  let is_in_string = false;
+  let will_start_new_arg = true;
+  for (let index = 0; index < node_options.length; ++index) {
+      let c = node_options[index];
+
+      // Backslashes escape the following character
+      if (c === '\\' && is_in_string) {
+          if (index + 1 === node_options.length) {
+              errors.push("invalid value for NODE_OPTIONS " +
+                  "(invalid escape)\n");
+              return env_argv;
+          } else {
+              c = node_options[++index];
+          }
+      } else if (c === ' ' && !is_in_string) {
+          will_start_new_arg = true;
+          continue;
+      } else if (c === '"') {
+          is_in_string = !is_in_string;
+          continue;
+      }
+
+      if (will_start_new_arg) {
+          env_argv.push(c);
+          will_start_new_arg = false;
+      } else {
+          env_argv[env_argv.length - 1] += c;
+      }
+  }
+
+  if (is_in_string) {
+      errors.push("invalid value for NODE_OPTIONS " +
+          "(unterminated string)\n");
+  }
+  return env_argv;
+}