@danielx/civet 0.11.11 → 0.11.12

package/dist/ts-service/index.js

@@ -144,9 +144,9 @@ function remapFileName(fileName, transpilers) {
 }
 
 // source/ts-service/host.civet
-var import_node_path3 = __toESM(require("node:path"));
-var import_typescript5 = __toESM(require("typescript"));
-var import_typescript6 = require("typescript");
+var import_node_path4 = __toESM(require("node:path"));
+var import_typescript6 = __toESM(require("typescript"));
+var import_typescript7 = require("typescript");
 
 // source/ts-service/config.civet
 var import_typescript4 = __toESM(require("typescript"));
@@ -258,9 +258,132 @@ function parseTsConfigForCivet(projectPath, transpilers, options = {}) {
   return parsed;
 }
 
+// source/ts-service/resolve.civet
+var import_node_path3 = __toESM(require("node:path"));
+var import_typescript5 = __toESM(require("typescript"));
+function resolveTranspiledModuleName({
+  name,
+  containingFile,
+  compilerOptions,
+  resolutionMode,
+  transpilers,
+  resolveTypeScript,
+  fileExists,
+  directoryExists
+}) {
+  const resolvedModule = (sourcePath, transpiler) => {
+    return {
+      resolvedFileName: sourcePath + transpiler.target,
+      extension: transpiler.target,
+      isExternalLibraryImport: false
+    };
+  };
+  const tsResolved = resolveTypeScript();
+  if (tsResolved.resolvedModule) {
+    return tsResolved;
+  }
+  const moduleResolution = import_typescript5.default.getEmitModuleResolutionKind(compilerOptions);
+  const isRelative = import_typescript5.default.isExternalModuleNameRelative(name);
+  let allowImplicitExtension = isRelative && !(resolutionMode === import_typescript5.default.ModuleKind.ESNext && (moduleResolution === import_typescript5.default.ModuleResolutionKind.Node16 || moduleResolution === import_typescript5.default.ModuleResolutionKind.NodeNext));
+  let allowDirectoryIndex = (!isRelative || allowImplicitExtension) && moduleResolution !== import_typescript5.default.ModuleResolutionKind.Classic;
+  const tryResolveSource = (sourcePath) => {
+    if (fileExists(sourcePath)) {
+      const candidateExtension = getExtensionFromPath(sourcePath);
+      let ref;
+      if (ref = transpilers.get(candidateExtension)) {
+        const candidateTranspiler = ref;
+        return resolvedModule(sourcePath, candidateTranspiler);
+      }
+    }
+    if (allowImplicitExtension) {
+      for (const [ext, t] of transpilers) {
+        const candidate = sourcePath + ext;
+        if (fileExists(candidate)) {
+          return resolvedModule(candidate, t);
+        }
+      }
+    }
+    if (allowDirectoryIndex && directoryExists(sourcePath)) {
+      for (const [_, t] of transpilers) {
+        const index = import_node_path3.default.join(sourcePath, "index" + t.extension);
+        if (fileExists(index)) {
+          return resolvedModule(index, t);
+        }
+      }
+    }
+    return;
+  };
+  if (!isRelative) {
+    let ref1;
+    if (ref1 = compilerOptions.paths) {
+      const paths = ref1;
+      let ref2;
+      if (ref2 = compilerOptions.baseUrl ?? compilerOptions.pathsBasePath) {
+        const pathsBase = ref2;
+        let bestPrefixLength = -1;
+        let bestCandidates = [];
+        for (const [pattern, replacements] of Object.entries(paths)) {
+          const starIndex = pattern.indexOf("*");
+          let matched;
+          let prefixLength;
+          if (starIndex >= 0) {
+            const prefix = pattern.slice(0, starIndex);
+            const suffix = pattern.slice(starIndex + 1);
+            if (name.startsWith(prefix) && name.endsWith(suffix) && name.length >= prefix.length + suffix.length) {
+              matched = name.slice(prefix.length, name.length - suffix.length);
+              prefixLength = prefix.length;
+            } else {
+              continue;
+            }
+          } else {
+            if (!(name === pattern)) {
+              continue;
+            }
+            matched = "";
+            prefixLength = pattern.length;
+          }
+          if (prefixLength < bestPrefixLength) {
+            continue;
+          }
+          if (prefixLength > bestPrefixLength) {
+            bestPrefixLength = prefixLength;
+            bestCandidates = [];
+          }
+          for (const replacement of replacements) {
+            let ref3;
+            if (starIndex >= 0) {
+              ref3 = replacement.replace("*", () => matched);
+            } else {
+              ref3 = replacement;
+            }
+            ;
+            const target = ref3;
+            bestCandidates.push(import_node_path3.default.resolve(pathsBase, target));
+          }
+        }
+        for (const candidate of bestCandidates) {
+          let ref4;
+          if (ref4 = tryResolveSource(candidate)) {
+            const resolved2 = ref4;
+            return { resolvedModule: resolved2 };
+          }
+        }
+      }
+    }
+  }
+  if (!isRelative) {
+    return tsResolved;
+  }
+  const relativeSourcePath = import_node_path3.default.resolve(import_node_path3.default.dirname(containingFile), name);
+  const resolved = tryResolveSource(relativeSourcePath);
+  if (resolved) {
+    return { resolvedModule: resolved };
+  }
+  return tsResolved;
+}
+
 // source/ts-service/host.civet
 var import_node_assert = __toESM(require("node:assert"));
-var { isExternalModuleNameRelative } = import_typescript5.default;
 function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, docFactory, _logger = console, libDir) {
   const { rootDir } = compilationSettings;
   (0, import_node_assert.default)(rootDir, "TSHost requires a rootDir in compilationSettings");
@@ -273,7 +396,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
   const pathMap = /* @__PURE__ */ new Map();
   const snapshotMap = /* @__PURE__ */ new Map();
   let projectVersion = 0;
-  const resolutionCache = import_typescript5.default.createModuleResolutionCache(rootDir, (fileName) => fileName, compilationSettings);
+  const resolutionCache = import_typescript6.default.createModuleResolutionCache(rootDir, (fileName) => fileName, compilationSettings);
   const baseReadFile = baseHost.readFile.bind(baseHost);
   const baseFileExists = baseHost.fileExists.bind(baseHost);
   const baseDirectoryExists = baseHost.directoryExists?.bind(baseHost) ?? (() => false);
@@ -282,7 +405,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     /** Mogrifies transpilable extensions inside `package.json#imports` on read. */
     readFile(filename) {
       const contents = getPathSource(filename);
-      if (contents && import_node_path3.default.basename(filename) === "package.json") {
+      if (contents && import_node_path4.default.basename(filename) === "package.json") {
         return mogrifyPackageJsonImports(contents, transpilers);
       }
       return contents;
@@ -297,7 +420,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
      */
     getDefaultLibFileName(options) {
       if (libDir) {
-        return import_node_path3.default.join(libDir, import_typescript5.default.getDefaultLibFileName(options));
+        return import_node_path4.default.join(libDir, import_typescript6.default.getDefaultLibFileName(options));
       }
       return baseHost.getDefaultLibFileName(options);
     },
@@ -305,7 +428,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
       if (libDir) {
         return libDir;
       }
-      return baseHost.getDefaultLibLocation?.() ?? import_node_path3.default.dirname(baseHost.getDefaultLibFileName(compilationSettings));
+      return baseHost.getDefaultLibLocation?.() ?? import_node_path4.default.dirname(baseHost.getDefaultLibFileName(compilationSettings));
     },
     getModuleResolutionCache() {
       return resolutionCache;
@@ -317,128 +440,43 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
      * synthetic `<src>.<target>` so subsequent `getScriptSnapshot` calls
      * hit the transpiler.
      */
-    resolveModuleNames(moduleNames, containingFile, _reusedNames, _redirectedReference, compilerOptions, _containingSourceFile) {
-      return moduleNames.map((name) => {
-        const { resolvedModule } = import_typescript5.default.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache);
-        if (resolvedModule) {
-          return resolvedModule;
-        }
-        const extension = getExtensionFromPath(name);
-        let transpiler = transpilers.get(extension);
-        if (transpiler || !extension) {
-          const exists = transpiler ? pathExists : baseDirectoryExists;
-          const resolvedModule2 = (resolved2) => {
-            if (!transpiler) {
-              for (const [_, t] of transpilers) {
-                const index = import_node_path3.default.join(resolved2, "index" + t.extension);
-                if (pathExists(index)) {
-                  transpiler = t;
-                  resolved2 = index;
-                  break;
-                }
-              }
-              if (!transpiler) {
-                return;
-              }
-            }
-            const { target } = transpiler;
-            return {
-              resolvedFileName: resolved2 + target,
-              extension: target,
-              isExternalLibraryImport: false
-            };
-          };
-          const { paths, pathsBasePath } = compilationSettings;
-          const baseUrl = compilationSettings.baseUrl;
-          if (!isExternalModuleNameRelative(name)) {
-            if (paths) {
-              const pathsBase = baseUrl ?? pathsBasePath;
-              let best = "";
-              let bestPrefix = "";
-              for (const [pattern, replacements] of Object.entries(paths)) {
-                if (pattern.endsWith("*")) {
-                  const prefix = pattern.slice(0, -1);
-                  if (name.startsWith(prefix)) {
-                    for (const replacement of replacements) {
-                      const resolved2 = import_node_path3.default.resolve(
-                        pathsBase,
-                        replacement.replace("*", name.slice(prefix.length))
-                      );
-                      if (exists(resolved2) && prefix.length > bestPrefix.length) {
-                        best = resolved2;
-                        bestPrefix = prefix;
-                      }
-                    }
-                  }
-                } else if (name === pattern) {
-                  for (const replacement of replacements) {
-                    const resolved2 = import_node_path3.default.resolve(pathsBase, replacement);
-                    if (exists(resolved2) && pattern.length > bestPrefix.length) {
-                      best = resolved2;
-                      bestPrefix = pattern;
-                    }
-                  }
-                }
-              }
-              if (best) {
-                return resolvedModule2(best);
-              }
-            }
-            if (baseUrl) {
-              const resolved2 = import_node_path3.default.resolve(baseUrl, name);
-              if (exists(resolved2)) {
-                return resolvedModule2(resolved2);
-              }
-            }
-          } else {
-          }
-          const resolved = import_node_path3.default.resolve(import_node_path3.default.dirname(containingFile), name);
-          if (exists(resolved)) {
-            return resolvedModule2(resolved);
-          }
-        }
-        return void 0;
+    resolveModuleNames(moduleNames, containingFile, _reusedNames, redirectedReference, compilerOptions, containingSourceFile) {
+      return moduleNames.map((name, index) => {
+        const resolutionMode = containingSourceFile && import_typescript6.default.getModeForResolutionAtIndex(containingSourceFile, index, compilerOptions);
+        return resolveTranspiledModuleName({
+          name,
+          containingFile,
+          compilerOptions,
+          resolutionMode,
+          transpilers,
+          resolveTypeScript: () => {
+            return import_typescript6.default.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache, redirectedReference, resolutionMode);
+          },
+          fileExists: pathExists,
+          directoryExists: baseDirectoryExists
+        }).resolvedModule;
       });
     },
-    resolveModuleNameLiterals(literals, containingFile, _redirectedReference, compilerOptions) {
-      return literals.map((literal) => {
+    resolveModuleNameLiterals(literals, containingFile, redirectedReference, compilerOptions, containingSourceFile) {
+      return literals.map((literal, index) => {
         const name = literal.text;
-        for (const [ext, t] of transpilers) {
-          if (name.endsWith(ext)) {
-            const resolved = import_node_path3.default.resolve(import_node_path3.default.dirname(containingFile), name);
-            if (pathExists(resolved)) {
-              return {
-                resolvedModule: {
-                  resolvedFileName: resolved + t.target,
-                  extension: t.target,
-                  isExternalLibraryImport: false
-                }
-              };
-            }
-          }
-        }
-        if (!getExtensionFromPath(name)) {
-          const resolved = import_node_path3.default.resolve(import_node_path3.default.dirname(containingFile), name);
-          if (baseDirectoryExists(resolved)) {
-            for (const [_, t] of transpilers) {
-              const index = import_node_path3.default.join(resolved, "index" + t.extension);
-              if (pathExists(index)) {
-                return {
-                  resolvedModule: {
-                    resolvedFileName: index + t.target,
-                    extension: t.target,
-                    isExternalLibraryImport: false
-                  }
-                };
-              }
-            }
-          }
-        }
-        return { resolvedModule: import_typescript5.default.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache).resolvedModule };
+        const resolutionMode = containingSourceFile && import_typescript6.default.getModeForResolutionAtIndex(containingSourceFile, index, compilerOptions);
+        return resolveTranspiledModuleName({
+          name,
+          containingFile,
+          compilerOptions,
+          resolutionMode,
+          transpilers,
+          resolveTypeScript: () => {
+            return import_typescript6.default.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache, redirectedReference, resolutionMode);
+          },
+          fileExists: pathExists,
+          directoryExists: baseDirectoryExists
+        });
       });
     },
     addOrUpdateDocument(doc) {
-      const rawPath = import_node_path3.default.normalize(docFactory.uriToPath(doc.uri));
+      const rawPath = import_node_path4.default.normalize(docFactory.uriToPath(doc.uri));
       const p = getCanonicalFileName(rawPath);
       snapshotMap.delete(p);
       projectVersion++;
@@ -549,7 +587,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     return void 0;
   }
   function getTranspiledPath(p) {
-    p = import_node_path3.default.normalize(p);
+    p = import_node_path4.default.normalize(p);
     const extension = getExtensionFromPath(p);
     const transpiler = transpilers.get(extension);
     if (transpiler) {
@@ -561,7 +599,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     return getCanonicalFileName(getTranspiledPath(p));
   }
   function getOrCreatePathSnapshot(p) {
-    const rawPath = import_node_path3.default.normalize(p);
+    const rawPath = import_node_path4.default.normalize(p);
     p = getCanonicalFileName(rawPath);
     let snapshot = snapshotMap.get(p);
     if (snapshot) {
@@ -643,7 +681,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     return transpiledCode;
   }
   function initTranspiledDoc(p) {
-    const scriptPath = import_node_path3.default.normalize(p);
+    const scriptPath = import_node_path4.default.normalize(p);
     p = getCanonicalFileName(scriptPath);
     const uri = docFactory.pathToUri(scriptPath);
     const transpiledDoc = docFactory.create(uri, "none", -1, "");
@@ -654,16 +692,16 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
 }
 
 // source/ts-service/service.civet
-var import_node_path4 = __toESM(require("node:path"));
-var import_typescript7 = __toESM(require("typescript"));
-var import_typescript8 = require("typescript");
+var import_node_path5 = __toESM(require("node:path"));
+var import_typescript8 = __toESM(require("typescript"));
+var import_typescript9 = require("typescript");
 var {
   createCompilerHost,
   createLanguageService
-} = import_typescript7.default;
+} = import_typescript8.default;
 function TSService(projectPath, options) {
   const { plugins = [], docFactory, libDir, discoverProjectFiles = true, extraCompilerOptions } = options;
-  const system = options.system ?? import_typescript7.default.sys;
+  const system = options.system ?? import_typescript8.default.sys;
   const logger = options.logger ?? console;
   const transpilers = buildTranspilers(plugins);
   function registerPlugin(plugin) {
@@ -688,7 +726,7 @@ function TSService(projectPath, options) {
   const host = TSHost(hostOptions, parsedConfig.fileNames, baseHost, transpilers, docFactory, logger, libDir);
   const service = createLanguageService(host);
   const loadPlugins = async function() {
-    const civetFolder = import_node_path4.default.join(projectPath, "./.civet/");
+    const civetFolder = import_node_path5.default.join(projectPath, "./.civet/");
     let civetFiles;
     try {
       civetFiles = system.readDirectory(civetFolder);
@@ -725,7 +763,7 @@ function TSService(projectPath, options) {
   });
 }
 function createBaseHost(options, system) {
-  if (system === import_typescript7.default.sys) {
+  if (system === import_typescript8.default.sys) {
     return createCompilerHost(options);
   }
   const getCanonicalFileName2 = (fileName) => {
@@ -739,10 +777,10 @@ function createBaseHost(options, system) {
       if (!(sourceText != null)) {
         return;
       }
-      return import_typescript7.default.createSourceFile(fileName, sourceText, languageVersion);
+      return import_typescript8.default.createSourceFile(fileName, sourceText, languageVersion);
     },
     getDefaultLibFileName(options2) {
-      return import_node_path4.default.join("/typescript/lib", import_typescript7.default.getDefaultLibFileName(options2));
+      return import_node_path5.default.join("/typescript/lib", import_typescript8.default.getDefaultLibFileName(options2));
     },
     writeFile(fileName, content) {
       return system.writeFile?.(fileName, content);
@@ -750,8 +788,8 @@ function createBaseHost(options, system) {
     getCurrentDirectory() {
       return system.getCurrentDirectory();
     },
-    getDirectories(path7) {
-      return system.getDirectories?.(path7) ?? [];
+    getDirectories(path8) {
+      return system.getDirectories?.(path8) ?? [];
     },
     fileExists(fileName) {
       return system.fileExists(fileName);
@@ -766,14 +804,17 @@ function createBaseHost(options, system) {
     getNewLine() {
       return system.newLine;
     },
-    directoryExists(path7) {
-      return system.directoryExists?.(path7) ?? false;
+    directoryExists(path8) {
+      if (!(system.directoryExists != null)) {
+        return false;
+      }
+      return system.directoryExists(path8);
     },
-    readDirectory(path7, extensions, excludes, includes, depth) {
-      return system.readDirectory(path7, extensions, excludes, includes, depth);
+    readDirectory(path8, extensions, excludes, includes, depth) {
+      return system.readDirectory(path8, extensions, excludes, includes, depth);
     },
-    realpath(path7) {
-      return system.realpath ? system.realpath(path7) : path7;
+    realpath(path8) {
+      return system.realpath ? system.realpath(path8) : path8;
     }
   };
 }
@@ -814,12 +855,12 @@ function createInMemoryDocFactory() {
 var import_civet = require("@danielx/civet");
 var import_civet2 = __toESM(require("@danielx/civet"));
 var import_package = __toESM(require("@danielx/civet/package.json"));
-var import_typescript9 = require("typescript");
+var import_typescript10 = require("typescript");
 
 // source/cache.civet
 var crypto = __toESM(require("node:crypto"));
 var fs = __toESM(require("node:fs"));
-var path5 = __toESM(require("node:path"));
+var path6 = __toESM(require("node:path"));
 function hashParts(parts) {
   const hash = crypto.createHash("sha1");
   for (const part of parts) {
@@ -843,7 +884,7 @@ function stableStringify(value) {
   });
 }
 function makeCacheKey(input) {
-  const resolved = path5.resolve(input.sourcePath).replace(/\\/g, "/");
+  const resolved = path6.resolve(input.sourcePath).replace(/\\/g, "/");
   return hashParts([
     input.source,
     input.compilerName,
@@ -873,7 +914,7 @@ function createDiskCache(dir) {
   }
   return {
     get(key) {
-      const target = path5.join(dir, key);
+      const target = path6.join(dir, key);
       try {
         const content = fs.readFileSync(target, "utf8");
         try {
@@ -887,7 +928,7 @@ function createDiskCache(dir) {
       }
     },
     set(key, value) {
-      const target = path5.join(dir, key);
+      const target = path6.join(dir, key);
       try {
         const tmp = `${target}.tmp.${process.pid}`;
         fs.writeFileSync(tmp, value);
@@ -994,7 +1035,7 @@ var import_civet3 = require("@danielx/civet");
 var import_civet4 = __toESM(require("@danielx/civet"));
 var import_package2 = __toESM(require("@danielx/civet/package.json"));
 var import_node_module = require("node:module");
-var import_typescript10 = require("typescript");
+var import_typescript11 = require("typescript");
 var heraRequire = (0, import_node_module.createRequire)(
   /* c8 ignore start -- one branch fires per build target; tests cover only one */
   typeof __filename !== "undefined" ? __filename : ""
@@ -1113,19 +1154,18 @@ function makeHeraPlugin(options = {}) {
 }
 
 // source/ts-service/typecheck.civet
-var import_typescript11 = __toESM(require("typescript"));
+var import_typescript12 = __toESM(require("typescript"));
 var fs2 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 function makeIncrementalTypecheckProgram(projectPath, options) {
   const transpilers = buildTranspilers(options.plugins);
-  const extraExtensions = Array.from(transpilers.keys());
   const parsed = parseTsConfigForCivet(projectPath, transpilers, { tsConfig: options.tsConfig });
   const compilerOptions = {
     ...parsed.options,
     ...options.extraCompilerOptions
   };
-  compilerOptions.jsx ??= import_typescript11.default.JsxEmit.Preserve;
-  const baseHost = import_typescript11.default.createIncrementalCompilerHost(compilerOptions);
+  compilerOptions.jsx ??= import_typescript12.default.JsxEmit.Preserve;
+  const baseHost = import_typescript12.default.createIncrementalCompilerHost(compilerOptions);
   const fileMetaData = /* @__PURE__ */ new Map();
   const hashText = (text) => {
     return baseHost.createHash?.(text) ?? text.length.toString();
@@ -1169,7 +1209,7 @@ function makeIncrementalTypecheckProgram(projectPath, options) {
         parseErrors: result.errors,
         fatal: false
       });
-      const sf2 = import_typescript11.default.createSourceFile(fileName, result.code, langVersion, true);
+      const sf2 = import_typescript12.default.createSourceFile(fileName, result.code, langVersion, true);
       sf2.version = hashText(result.code);
       return sf2;
     }
@@ -1180,6 +1220,7 @@ function makeIncrementalTypecheckProgram(projectPath, options) {
     return sf;
   };
   const origFileExists = baseHost.fileExists.bind(baseHost);
+  const origDirectoryExists = baseHost.directoryExists?.bind(baseHost) ?? (() => false);
   baseHost.fileExists = (fileName) => {
     const exts = getTranspiledExtensionsFromPath(fileName);
     if (exts) {
@@ -1193,43 +1234,56 @@ function makeIncrementalTypecheckProgram(projectPath, options) {
   const origReadFile = baseHost.readFile.bind(baseHost);
   baseHost.readFile = (fileName) => {
     const contents = origReadFile(fileName);
-    if (contents && path6.basename(fileName) === "package.json") {
+    if (contents && path7.basename(fileName) === "package.json") {
       return mogrifyPackageJsonImports(contents, transpilers);
     }
     return contents;
   };
-  baseHost.resolveModuleNameLiterals = (literals, containingFile, _redirected, opts) => {
-    return literals.map((lit) => {
+  baseHost.resolveModuleNameLiterals = (literals, containingFile, redirectedReference, opts, containingSourceFile) => {
+    return literals.map((lit, index) => {
       const name = lit.text;
-      for (const ext of extraExtensions) {
-        if (name.endsWith(ext)) {
-          const t = transpilers.get(ext);
-          const containingDir = path6.dirname(containingFile);
-          const resolved = path6.resolve(containingDir, name);
-          if (origFileExists(resolved)) {
-            return {
-              resolvedModule: {
-                resolvedFileName: resolved + t.target,
-                extension: t.target,
-                isExternalLibraryImport: false
-              }
-            };
-          }
-        }
-      }
-      return { resolvedModule: import_typescript11.default.resolveModuleName(name, containingFile, opts, baseHost).resolvedModule };
+      const resolutionMode = containingSourceFile && import_typescript12.default.getModeForResolutionAtIndex(containingSourceFile, index, opts);
+      return resolveTranspiledModuleName({
+        name,
+        containingFile,
+        compilerOptions: opts,
+        resolutionMode,
+        transpilers,
+        resolveTypeScript: () => {
+          return import_typescript12.default.resolveModuleName(name, containingFile, opts, baseHost, void 0, redirectedReference, resolutionMode);
+        },
+        fileExists: origFileExists,
+        directoryExists: origDirectoryExists
+      });
+    });
+  };
+  baseHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, opts, containingSourceFile) => {
+    return moduleNames.map((name, index) => {
+      const resolutionMode = containingSourceFile && import_typescript12.default.getModeForResolutionAtIndex(containingSourceFile, index, opts);
+      return resolveTranspiledModuleName({
+        name,
+        containingFile,
+        compilerOptions: opts,
+        resolutionMode,
+        transpilers,
+        resolveTypeScript: () => {
+          return import_typescript12.default.resolveModuleName(name, containingFile, opts, baseHost, void 0, redirectedReference, resolutionMode);
+        },
+        fileExists: origFileExists,
+        directoryExists: origDirectoryExists
+      }).resolvedModule;
     });
   };
   const programOptions = {
     rootNames: parsed.fileNames,
     options: compilerOptions,
     host: baseHost,
-    configFileParsingDiagnostics: import_typescript11.default.getConfigFileParsingDiagnostics(parsed)
+    configFileParsingDiagnostics: import_typescript12.default.getConfigFileParsingDiagnostics(parsed)
   };
   if (parsed.projectReferences) {
     programOptions.projectReferences = parsed.projectReferences;
   }
-  const builder = import_typescript11.default.createIncrementalProgram(programOptions);
+  const builder = import_typescript12.default.createIncrementalProgram(programOptions);
   return {
     builder,
     host: baseHost,