typescript 5.2.0-dev.20230707 → 5.2.0-dev.20230709

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.2";
-      version = `${versionMajorMinor}.0-dev.20230707`;
+      version = `${versionMajorMinor}.0-dev.20230709`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -1464,8 +1464,8 @@ var ts = (() => {
     }
     return false;
   }
-  function createGetCanonicalFileName(useCaseSensitiveFileNames) {
-    return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
+  function createGetCanonicalFileName(useCaseSensitiveFileNames2) {
+    return useCaseSensitiveFileNames2 ? identity : toFileNameLowerCase;
   }
   function patternText({ prefix, suffix }) {
     return `${prefix}*${suffix}`;
@@ -5425,10 +5425,10 @@ ${lanes.join("\n")}
       pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === 250 /* Low */ ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingInterval === 250 /* Low */ ? "pollLowPollingIntervalQueue" : "pollPollingIntervalQueue", pollingIntervalQueue(pollingInterval));
     }
   }
-  function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) {
+  function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2) {
     const fileWatcherCallbacks = createMultiMap();
     const dirWatchers = /* @__PURE__ */ new Map();
-    const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     return nonPollingWatchFile;
     function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) {
       const filePath = toCanonicalName(fileName);
@@ -5504,8 +5504,8 @@ ${lanes.join("\n")}
       pollScheduled = host.setTimeout(pollQueue, 2e3 /* High */, "pollQueue");
     }
   }
-  function createSingleWatcherPerName(cache, useCaseSensitiveFileNames, name, callback, createWatcher) {
-    const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+  function createSingleWatcherPerName(cache, useCaseSensitiveFileNames2, name, callback, createWatcher) {
+    const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     const path = toCanonicalFileName(name);
     const existing = cache.get(path);
     if (existing) {
@@ -5555,7 +5555,7 @@ ${lanes.join("\n")}
   }
   function createDirectoryWatcherSupportingRecursive({
     watchDirectory,
-    useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
     getCurrentDirectory,
     getAccessibleSortedChildDirectories,
     fileSystemEntryExists,
@@ -5567,8 +5567,8 @@ ${lanes.join("\n")}
     const callbackCache = createMultiMap();
     const cacheToUpdateChildWatches = /* @__PURE__ */ new Map();
     let timerToUpdateChildWatches;
-    const filePathComparer = getStringComparer(!useCaseSensitiveFileNames);
-    const toCanonicalFilePath = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const filePathComparer = getStringComparer(!useCaseSensitiveFileNames2);
+    const toCanonicalFilePath = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     return (dirName, callback, recursive, options) => recursive ? createDirectoryWatcher(dirName, options, callback) : watchDirectory(dirName, callback, recursive, options);
     function createDirectoryWatcher(dirName, options, callback) {
       const dirPath = toCanonicalFilePath(dirName);
@@ -5735,12 +5735,12 @@ ${lanes.join("\n")}
       }
     }
     function isIgnoredPath(path, options) {
-      return some(ignoredPaths, (searchPath) => isInPath(path, searchPath)) || isIgnoredByWatchOptions(path, options, useCaseSensitiveFileNames, getCurrentDirectory);
+      return some(ignoredPaths, (searchPath) => isInPath(path, searchPath)) || isIgnoredByWatchOptions(path, options, useCaseSensitiveFileNames2, getCurrentDirectory);
     }
     function isInPath(path, searchPath) {
       if (stringContains(path, searchPath))
         return true;
-      if (useCaseSensitiveFileNames)
+      if (useCaseSensitiveFileNames2)
         return false;
       return stringContains(toCanonicalFilePath(path), searchPath);
     }
@@ -5758,14 +5758,14 @@ ${lanes.join("\n")}
       }
     };
   }
-  function isIgnoredByWatchOptions(pathToCheck, options, useCaseSensitiveFileNames, getCurrentDirectory) {
-    return ((options == null ? void 0 : options.excludeDirectories) || (options == null ? void 0 : options.excludeFiles)) && (matchesExclude(pathToCheck, options == null ? void 0 : options.excludeFiles, useCaseSensitiveFileNames, getCurrentDirectory()) || matchesExclude(pathToCheck, options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames, getCurrentDirectory()));
+  function isIgnoredByWatchOptions(pathToCheck, options, useCaseSensitiveFileNames2, getCurrentDirectory) {
+    return ((options == null ? void 0 : options.excludeDirectories) || (options == null ? void 0 : options.excludeFiles)) && (matchesExclude(pathToCheck, options == null ? void 0 : options.excludeFiles, useCaseSensitiveFileNames2, getCurrentDirectory()) || matchesExclude(pathToCheck, options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames2, getCurrentDirectory()));
   }
-  function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory) {
+  function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames2, getCurrentDirectory) {
     return (eventName, relativeFileName) => {
       if (eventName === "rename") {
         const fileName = !relativeFileName ? directoryName : normalizePath(combinePaths(directoryName, relativeFileName));
-        if (!relativeFileName || !isIgnoredByWatchOptions(fileName, options, useCaseSensitiveFileNames, getCurrentDirectory)) {
+        if (!relativeFileName || !isIgnoredByWatchOptions(fileName, options, useCaseSensitiveFileNames2, getCurrentDirectory)) {
           callback(fileName);
         }
       }
@@ -5778,7 +5778,7 @@ ${lanes.join("\n")}
     clearTimeout: clearTimeout2,
     fsWatchWorker,
     fileSystemEntryExists,
-    useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
     getCurrentDirectory,
     fsSupportsRecursiveFsWatch,
     getAccessibleSortedChildDirectories,
@@ -5850,7 +5850,7 @@ ${lanes.join("\n")}
           );
         case 5 /* UseFsEventsOnParentDirectory */:
           if (!nonPollingWatchFile) {
-            nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames);
+            nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames2);
           }
           return nonPollingWatchFile(fileName, callback, pollingInterval, getFallbackOptions(options));
         default:
@@ -5899,7 +5899,7 @@ ${lanes.join("\n")}
         return fsWatch(
           directoryName,
           1 /* Directory */,
-          createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory),
+          createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames2, getCurrentDirectory),
           recursive,
           500 /* Medium */,
           getFallbackOptions(options)
@@ -5907,7 +5907,7 @@ ${lanes.join("\n")}
       }
       if (!hostRecursiveDirectoryWatcher) {
         hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
-          useCaseSensitiveFileNames,
+          useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
           getCurrentDirectory,
           fileSystemEntryExists,
           getAccessibleSortedChildDirectories,
@@ -5953,7 +5953,7 @@ ${lanes.join("\n")}
           return fsWatch(
             directoryName,
             1 /* Directory */,
-            createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory),
+            createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames2, getCurrentDirectory),
             recursive,
             500 /* Medium */,
             getFallbackOptions(watchDirectoryOptions)
@@ -5981,7 +5981,7 @@ ${lanes.join("\n")}
     function pollingWatchFile(fileName, callback, pollingInterval, options) {
       return createSingleWatcherPerName(
         pollingWatches,
-        useCaseSensitiveFileNames,
+        useCaseSensitiveFileNames2,
         fileName,
         callback,
         (cb) => pollingWatchFileWorker(fileName, cb, pollingInterval, options)
@@ -5990,7 +5990,7 @@ ${lanes.join("\n")}
     function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
       return createSingleWatcherPerName(
         recursive ? fsWatchesRecursive : fsWatches,
-        useCaseSensitiveFileNames,
+        useCaseSensitiveFileNames2,
         fileOrDirectory,
         callback,
         (cb) => fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, cb, recursive, fallbackPollingInterval, fallbackOptions)
@@ -6149,7 +6149,7 @@ ${lanes.join("\n")}
           const Buffer2 =   require("buffer").Buffer;
           const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
           const platform = _os.platform();
-          const useCaseSensitiveFileNames = isFileSystemCaseSensitive();
+          const useCaseSensitiveFileNames2 = isFileSystemCaseSensitive();
           const fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync;
           const executingFilePath = __filename.endsWith("sys.js") ? _path.join(_path.dirname(__dirname), "__fake__.js") : __filename;
           const fsSupportsRecursiveFsWatch = process.platform === "win32" || process.platform === "darwin";
@@ -6160,7 +6160,7 @@ ${lanes.join("\n")}
             setTimeout,
             clearTimeout,
             fsWatchWorker,
-            useCaseSensitiveFileNames,
+            useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
             getCurrentDirectory,
             fileSystemEntryExists,
             // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
@@ -6177,7 +6177,7 @@ ${lanes.join("\n")}
           const nodeSystem = {
             args: process.argv.slice(2),
             newLine: _os.EOL,
-            useCaseSensitiveFileNames,
+            useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
             write(s) {
               process.stdout.write(s);
             },
@@ -6306,12 +6306,12 @@ ${lanes.join("\n")}
             for (const node of profile.nodes) {
               if (node.callFrame.url) {
                 const url = normalizeSlashes(node.callFrame.url);
-                if (containsPath(fileUrlRoot, url, useCaseSensitiveFileNames)) {
+                if (containsPath(fileUrlRoot, url, useCaseSensitiveFileNames2)) {
                   node.callFrame.url = getRelativePathToDirectoryOrUrl(
                     fileUrlRoot,
                     url,
                     fileUrlRoot,
-                    createGetCanonicalFileName(useCaseSensitiveFileNames),
+                    createGetCanonicalFileName(useCaseSensitiveFileNames2),
                     /*isAbsolutePathAnUrl*/
                     true
                   );
@@ -6491,7 +6491,7 @@ ${lanes.join("\n")}
             }
           }
           function readDirectory(path, extensions, excludes, includes, depth) {
-            return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
+            return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
           function fileSystemEntryExists(path, entryKind) {
             const originalStackTraceLimit = Error.stackTraceLimit;
@@ -18402,7 +18402,7 @@ ${lanes.join("\n")}
   function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
     return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
   }
-  function getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory) {
+  function getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
     path = normalizePath(path);
     currentDirectory = normalizePath(currentDirectory);
     const absolutePath = combinePaths(currentDirectory, path);
@@ -18411,22 +18411,22 @@ ${lanes.join("\n")}
       includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
       includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
       excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-      basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+      basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames2)
     };
   }
-  function getRegexFromPattern(pattern, useCaseSensitiveFileNames) {
-    return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i");
+  function getRegexFromPattern(pattern, useCaseSensitiveFileNames2) {
+    return new RegExp(pattern, useCaseSensitiveFileNames2 ? "" : "i");
   }
-  function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath) {
+  function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
     path = normalizePath(path);
     currentDirectory = normalizePath(currentDirectory);
-    const patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory);
-    const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map((pattern) => getRegexFromPattern(pattern, useCaseSensitiveFileNames));
-    const includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames);
-    const excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
+    const patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames2, currentDirectory);
+    const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map((pattern) => getRegexFromPattern(pattern, useCaseSensitiveFileNames2));
+    const includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames2);
+    const excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames2);
     const results = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
     const visited = /* @__PURE__ */ new Map();
-    const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     for (const basePath of patterns.basePaths) {
       visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
     }
@@ -18468,7 +18468,7 @@ ${lanes.join("\n")}
       }
     }
   }
-  function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+  function getBasePaths(path, includes, useCaseSensitiveFileNames2) {
     const basePaths = [path];
     if (includes) {
       const includeBasePaths = [];
@@ -18476,9 +18476,9 @@ ${lanes.join("\n")}
         const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
         includeBasePaths.push(getIncludeBasePath(absolute));
       }
-      includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames));
+      includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames2));
       for (const includeBasePath of includeBasePaths) {
-        if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames))) {
+        if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames2))) {
           basePaths.push(includeBasePath);
         }
       }
@@ -37269,19 +37269,19 @@ ${lanes.join("\n")}
     const wildcardFiles = arrayFrom(wildcardFileMap.values());
     return literalFiles.concat(wildcardFiles, arrayFrom(wildCardJsonFileMap.values()));
   }
-  function isExcludedFile(pathToCheck, spec, basePath, useCaseSensitiveFileNames, currentDirectory) {
+  function isExcludedFile(pathToCheck, spec, basePath, useCaseSensitiveFileNames2, currentDirectory) {
     const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = spec;
     if (!length(validatedIncludeSpecs) || !length(validatedExcludeSpecs))
       return false;
     basePath = normalizePath(basePath);
-    const keyMapper = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const keyMapper = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     if (validatedFilesSpec) {
       for (const fileName of validatedFilesSpec) {
         if (keyMapper(getNormalizedAbsolutePath(fileName, basePath)) === pathToCheck)
           return false;
       }
     }
-    return matchesExcludeWorker(pathToCheck, validatedExcludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath);
+    return matchesExcludeWorker(pathToCheck, validatedExcludeSpecs, useCaseSensitiveFileNames2, currentDirectory, basePath);
   }
   function invalidDotDotAfterRecursiveWildcard(s) {
     const wildcardIndex = startsWith(s, "**/") ? 0 : s.indexOf("/**/");
@@ -37291,17 +37291,17 @@ ${lanes.join("\n")}
     const lastDotIndex = endsWith(s, "/..") ? s.length : s.lastIndexOf("/../");
     return lastDotIndex > wildcardIndex;
   }
-  function matchesExclude(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory) {
+  function matchesExclude(pathToCheck, excludeSpecs, useCaseSensitiveFileNames2, currentDirectory) {
     return matchesExcludeWorker(
       pathToCheck,
       filter(excludeSpecs, (spec) => !invalidDotDotAfterRecursiveWildcard(spec)),
-      useCaseSensitiveFileNames,
+      useCaseSensitiveFileNames2,
       currentDirectory
     );
   }
-  function matchesExcludeWorker(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath) {
+  function matchesExcludeWorker(pathToCheck, excludeSpecs, useCaseSensitiveFileNames2, currentDirectory, basePath) {
     const excludePattern = getRegularExpressionForWildcard(excludeSpecs, combinePaths(normalizePath(currentDirectory), basePath), "exclude");
-    const excludeRegex = excludePattern && getRegexFromPattern(excludePattern, useCaseSensitiveFileNames);
+    const excludeRegex = excludePattern && getRegexFromPattern(excludePattern, useCaseSensitiveFileNames2);
     if (!excludeRegex)
       return false;
     if (excludeRegex.test(pathToCheck))
@@ -37331,9 +37331,9 @@ ${lanes.join("\n")}
       return [Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
     }
   }
-  function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExcludeSpecs: exclude }, path, useCaseSensitiveFileNames) {
+  function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExcludeSpecs: exclude }, path, useCaseSensitiveFileNames2) {
     const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
-    const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
+    const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames2 ? "" : "i");
     const wildcardDirectories = {};
     if (include !== void 0) {
       const recursiveKeys = [];
@@ -37342,7 +37342,7 @@ ${lanes.join("\n")}
         if (excludeRegex && excludeRegex.test(spec)) {
           continue;
         }
-        const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames);
+        const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2);
         if (match) {
           const { key, flags } = match;
           const existingFlags = wildcardDirectories[key];
@@ -37357,7 +37357,7 @@ ${lanes.join("\n")}
       for (const key in wildcardDirectories) {
         if (hasProperty(wildcardDirectories, key)) {
           for (const recursiveKey of recursiveKeys) {
-            if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
+            if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames2)) {
               delete wildcardDirectories[key];
             }
           }
@@ -37366,20 +37366,20 @@ ${lanes.join("\n")}
     }
     return wildcardDirectories;
   }
-  function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames) {
+  function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
     const match = wildcardDirectoryPattern.exec(spec);
     if (match) {
       const questionWildcardIndex = spec.indexOf("?");
       const starWildcardIndex = spec.indexOf("*");
       const lastDirectorySeperatorIndex = spec.lastIndexOf(directorySeparator);
       return {
-        key: useCaseSensitiveFileNames ? match[0] : toFileNameLowerCase(match[0]),
+        key: useCaseSensitiveFileNames2 ? match[0] : toFileNameLowerCase(match[0]),
         flags: questionWildcardIndex !== -1 && questionWildcardIndex < lastDirectorySeperatorIndex || starWildcardIndex !== -1 && starWildcardIndex < lastDirectorySeperatorIndex ? 1 /* Recursive */ : 0 /* None */
       };
     }
     if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
       return {
-        key: removeTrailingDirectorySeparator(useCaseSensitiveFileNames ? spec : toFileNameLowerCase(spec)),
+        key: removeTrailingDirectorySeparator(useCaseSensitiveFileNames2 ? spec : toFileNameLowerCase(spec)),
         flags: 1 /* Recursive */
       };
     }
@@ -39065,6 +39065,18 @@ ${lanes.join("\n")}
       result.push("JSON");
     return result.join(", ");
   }
+  function extensionsToExtensionsArray(extensions) {
+    const result = [];
+    if (extensions & 1 /* TypeScript */)
+      result.push(...supportedTSImplementationExtensions);
+    if (extensions & 2 /* JavaScript */)
+      result.push(...supportedJSExtensionsFlat);
+    if (extensions & 4 /* Declaration */)
+      result.push(...supportedDeclarationExtensions);
+    if (extensions & 8 /* Json */)
+      result.push(".json" /* Json */);
+    return result;
+  }
   function resolvedTypeScriptOnly(resolved) {
     if (!resolved) {
       return void 0;
@@ -39237,8 +39249,8 @@ ${lanes.join("\n")}
     return typeRoots;
   }
   function arePathsEqual(path1, path2, host) {
-    const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
-    return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 0 /* EqualTo */;
+    const useCaseSensitiveFileNames2 = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
+    return comparePaths(path1, path2, !useCaseSensitiveFileNames2) === 0 /* EqualTo */;
   }
   function getOriginalAndResolvedFileName(fileName, host, traceEnabled) {
     const resolvedFileName = realPath(fileName, host, traceEnabled);
@@ -40501,7 +40513,7 @@ ${lanes.join("\n")}
         arrayIsEqualTo
       );
       for (const conditions of conditionSets) {
-        const loadPackageJsonExportsState = { ...loadPackageJsonMainState, failedLookupLocations: [], conditions };
+        const loadPackageJsonExportsState = { ...loadPackageJsonMainState, failedLookupLocations: [], conditions, host };
         const exportResolutions = loadEntrypointsFromExportMap(
           packageJsonInfo,
           packageJsonInfo.contents.packageJsonContent.exports,
@@ -40533,23 +40545,42 @@ ${lanes.join("\n")}
     return entrypoints;
     function loadEntrypointsFromTargetExports(target) {
       var _a, _b;
-      if (typeof target === "string" && startsWith(target, "./") && target.indexOf("*") === -1) {
-        const partsAfterFirst = getPathComponents(target).slice(2);
-        if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
-          return false;
-        }
-        const resolvedTarget = combinePaths(scope.packageDirectory, target);
-        const finalPath = getNormalizedAbsolutePath(resolvedTarget, (_b = (_a = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a));
-        const result = loadFileNameFromPackageJsonField(
-          extensions,
-          finalPath,
-          /*onlyRecordFailures*/
-          false,
-          state
-        );
-        if (result) {
-          entrypoints = appendIfUnique(entrypoints, result, (a, b) => a.path === b.path);
-          return true;
+      if (typeof target === "string" && startsWith(target, "./")) {
+        if (target.indexOf("*") >= 0 && state.host.readDirectory) {
+          if (target.indexOf("*") !== target.lastIndexOf("*")) {
+            return false;
+          }
+          state.host.readDirectory(
+            scope.packageDirectory,
+            extensionsToExtensionsArray(extensions),
+            /*excludes*/
+            void 0,
+            [changeAnyExtension(target.replace("*", "**/*"), getDeclarationEmitExtensionForPath(target))]
+          ).forEach((entry) => {
+            entrypoints = appendIfUnique(entrypoints, {
+              path: entry,
+              ext: getAnyExtensionFromPath(entry),
+              resolvedUsingTsExtension: void 0
+            });
+          });
+        } else {
+          const partsAfterFirst = getPathComponents(target).slice(2);
+          if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
+            return false;
+          }
+          const resolvedTarget = combinePaths(scope.packageDirectory, target);
+          const finalPath = getNormalizedAbsolutePath(resolvedTarget, (_b = (_a = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a));
+          const result = loadFileNameFromPackageJsonField(
+            extensions,
+            finalPath,
+            /*onlyRecordFailures*/
+            false,
+            state
+          );
+          if (result) {
+            entrypoints = appendIfUnique(entrypoints, result, (a, b) => a.path === b.path);
+            return true;
+          }
         }
       } else if (Array.isArray(target)) {
         for (const t of target) {
@@ -41108,13 +41139,10 @@ ${lanes.join("\n")}
       function combineDirectoryPath(root, dir) {
         return ensureTrailingDirectorySeparator(combinePaths(root, dir));
       }
-      function useCaseSensitiveFileNames() {
-        return !state.host.useCaseSensitiveFileNames ? true : typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames : state.host.useCaseSensitiveFileNames();
-      }
       function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports2) {
         var _a, _b, _c, _d;
-        if (!state.isConfigLookup && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) && finalPath.indexOf("/node_modules/") === -1 && (state.compilerOptions.configFile ? containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames()) : true)) {
-          const getCanonicalFileName = hostGetCanonicalFileName({ useCaseSensitiveFileNames });
+        if (!state.isConfigLookup && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) && finalPath.indexOf("/node_modules/") === -1 && (state.compilerOptions.configFile ? containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames(state)) : true)) {
+          const getCanonicalFileName = hostGetCanonicalFileName({ useCaseSensitiveFileNames: () => useCaseSensitiveFileNames(state) });
           const commonSourceDirGuesses = [];
           if (state.compilerOptions.rootDir || state.compilerOptions.composite && state.compilerOptions.configFilePath) {
             const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [], ((_b = (_a = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a)) || "", getCanonicalFileName));
@@ -41143,7 +41171,7 @@ ${lanes.join("\n")}
           for (const commonSourceDirGuess of commonSourceDirGuesses) {
             const candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
             for (const candidateDir of candidateDirectories) {
-              if (containsPath(candidateDir, finalPath, !useCaseSensitiveFileNames())) {
+              if (containsPath(candidateDir, finalPath, !useCaseSensitiveFileNames(state))) {
                 const pathFragment = finalPath.slice(candidateDir.length + 1);
                 const possibleInputBase = combinePaths(commonSourceDirGuess, pathFragment);
                 const jsAndDtsExtensions = [".mjs" /* Mjs */, ".cjs" /* Cjs */, ".js" /* Js */, ".json" /* Json */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".d.ts" /* Dts */];
@@ -41153,7 +41181,7 @@ ${lanes.join("\n")}
                     for (const possibleExt of inputExts) {
                       if (!extensionIsOk(extensions, possibleExt))
                         continue;
-                      const possibleInputWithInputExtension = changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
+                      const possibleInputWithInputExtension = changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames(state));
                       if (state.host.fileExists(possibleInputWithInputExtension)) {
                         return toSearchResult(withPackageId(scope, loadFileNameFromPackageJsonField(
                           extensions,
@@ -41569,6 +41597,9 @@ ${lanes.join("\n")}
       trace(state.host, diagnostic, ...args);
     }
   }
+  function useCaseSensitiveFileNames(state) {
+    return !state.host.useCaseSensitiveFileNames ? true : typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames : state.host.useCaseSensitiveFileNames();
+  }
   var typeScriptVersion, nodeModulesAtTypes, NodeResolutionFeatures, nodeModulesPathPart, mangledScopedPackageSeparator;
   var init_moduleNameResolver = __esm({
     "src/compiler/moduleNameResolver.ts"() {
@@ -45148,7 +45179,7 @@ ${lanes.join("\n")}
         for (const key of getOwnKeys(exports)) {
           if (key === "default" || conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(conditions, key)) {
             const subTarget = exports[key];
-            const result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions);
+            const result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode);
             if (result) {
               return result;
             }
@@ -116968,14 +116999,14 @@ ${lanes.join("\n")}
   });
 
   // src/compiler/watchUtilities.ts
-  function createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames) {
+  function createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames2) {
     if (!host.getDirectories || !host.readDirectory) {
       return void 0;
     }
     const cachedReadDirectoryResult = /* @__PURE__ */ new Map();
-    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     return {
-      useCaseSensitiveFileNames,
+      useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
       fileExists,
       readFile: (path, encoding) => host.readFile(path, encoding),
       directoryExists: host.directoryExists && directoryExists,
@@ -117097,7 +117128,7 @@ ${lanes.join("\n")}
       const rootResult = tryReadDirectory2(rootDir, rootDirPath);
       let rootSymLinkResult;
       if (rootResult !== void 0) {
-        return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath);
+        return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath);
       }
       return host.readDirectory(rootDir, extensions, excludes, includes, depth);
       function getFileSystemEntries(dir) {
@@ -117292,7 +117323,7 @@ ${lanes.join("\n")}
     program,
     extraFileExtensions,
     currentDirectory,
-    useCaseSensitiveFileNames,
+    useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
     writeLog,
     toPath: toPath3
   }) {
@@ -117308,7 +117339,7 @@ ${lanes.join("\n")}
       writeLog(`Project: ${configFileName} Detected file add/remove of non supported extension: ${fileOrDirectory}`);
       return true;
     }
-    if (isExcludedFile(fileOrDirectory, options.configFile.configFileSpecs, getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) {
+    if (isExcludedFile(fileOrDirectory, options.configFile.configFileSpecs, getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames2, currentDirectory)) {
       writeLog(`Project: ${configFileName} Detected excluded file: ${fileOrDirectory}`);
       return true;
     }
@@ -117365,7 +117396,7 @@ ${lanes.join("\n")}
     function createExcludeHandlingAddWatch(key) {
       return (file, cb, flags, options, detailInfo1, detailInfo2) => {
         var _a;
-        return !matchesExclude(file, key === "watchFile" ? options == null ? void 0 : options.excludeFiles : options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames(), ((_a = host.getCurrentDirectory) == null ? void 0 : _a.call(host)) || "") ? factory2[key].call(
+        return !matchesExclude(file, key === "watchFile" ? options == null ? void 0 : options.excludeFiles : options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames2(), ((_a = host.getCurrentDirectory) == null ? void 0 : _a.call(host)) || "") ? factory2[key].call(
           /*thisArgs*/
           void 0,
           file,
@@ -117377,7 +117408,7 @@ ${lanes.join("\n")}
         ) : excludeWatcherFactory(file, flags, options, detailInfo1, detailInfo2);
       };
     }
-    function useCaseSensitiveFileNames() {
+    function useCaseSensitiveFileNames2() {
       return typeof host.useCaseSensitiveFileNames === "boolean" ? host.useCaseSensitiveFileNames : host.useCaseSensitiveFileNames();
     }
     function createExcludeWatcherWithLogging(file, flags, options, detailInfo1, detailInfo2) {
@@ -124512,12 +124543,12 @@ ${lanes.join("\n")}
       return true;
     const isJsonFile = fileExtensionIs(fileName, ".json" /* Json */);
     const basePath = getDirectoryPath(getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory()));
-    const useCaseSensitiveFileNames = program.useCaseSensitiveFileNames();
+    const useCaseSensitiveFileNames2 = program.useCaseSensitiveFileNames();
     return find((_b = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _b.validatedIncludeSpecs, (includeSpec) => {
       if (isJsonFile && !endsWith(includeSpec, ".json" /* Json */))
         return false;
       const pattern = getPatternFromSpec(includeSpec, basePath, "files");
-      return !!pattern && getRegexFromPattern(`(${pattern})$`, useCaseSensitiveFileNames).test(fileName);
+      return !!pattern && getRegexFromPattern(`(${pattern})$`, useCaseSensitiveFileNames2).test(fileName);
     });
   }
   function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) {
@@ -124721,7 +124752,7 @@ ${lanes.join("\n")}
     return result;
   }
   function createCompilerHostFromProgramHost(host, getCompilerOptions, directoryStructureHost = host) {
-    const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
+    const useCaseSensitiveFileNames2 = host.useCaseSensitiveFileNames();
     const compilerHost = {
       getSourceFile: createGetSourceFile(
         (fileName, encoding) => !encoding ? compilerHost.readFile(fileName) : host.readFile(fileName, encoding),
@@ -124737,8 +124768,8 @@ ${lanes.join("\n")}
         (path) => host.directoryExists(path)
       ),
       getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
-      useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
-      getCanonicalFileName: createGetCanonicalFileName(useCaseSensitiveFileNames),
+      useCaseSensitiveFileNames: () => useCaseSensitiveFileNames2,
+      getCanonicalFileName: createGetCanonicalFileName(useCaseSensitiveFileNames2),
       getNewLine: () => getNewLineCharacter(getCompilerOptions()),
       fileExists: (f) => host.fileExists(f),
       readFile: (f) => host.readFile(f),
@@ -125019,7 +125050,7 @@ ${lanes.join("\n")}
     const sourceFilesCache = /* @__PURE__ */ new Map();
     let missingFilePathsRequestedForRelease;
     let hasChangedCompilerOptions = false;
-    const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
+    const useCaseSensitiveFileNames2 = host.useCaseSensitiveFileNames();
     const currentDirectory = host.getCurrentDirectory();
     const { configFileName, optionsToExtend: optionsToExtendForConfigFile = {}, watchOptionsToExtend, extraFileExtensions, createProgram: createProgram2 } = host;
     let { rootFiles: rootFileNames, options: compilerOptions, watchOptions, projectReferences } = host;
@@ -125027,7 +125058,7 @@ ${lanes.join("\n")}
     let configFileParsingDiagnostics;
     let canConfigFileJsonReportNoInputFiles = false;
     let hasChangedConfigFileParsingErrors = false;
-    const cachedDirectoryStructureHost = configFileName === void 0 ? void 0 : createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames);
+    const cachedDirectoryStructureHost = configFileName === void 0 ? void 0 : createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames2);
     const directoryStructureHost = cachedDirectoryStructureHost || host;
     const parseConfigFileHost = parseConfigHostFromCompilerHostLike(host, directoryStructureHost);
     let newLine = updateNewLine();
@@ -125045,8 +125076,8 @@ ${lanes.join("\n")}
     Debug.assert(compilerOptions);
     Debug.assert(rootFileNames);
     const { watchFile: watchFile2, watchDirectory, writeLog } = createWatchFactory(host, compilerOptions);
-    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
-    writeLog(`Current directory: ${currentDirectory} CaseSensitiveFileNames: ${useCaseSensitiveFileNames}`);
+    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
+    writeLog(`Current directory: ${currentDirectory} CaseSensitiveFileNames: ${useCaseSensitiveFileNames2}`);
     let configFileWatcher;
     if (configFileName) {
       configFileWatcher = watchFile2(configFileName, scheduleProgramReload, 2e3 /* High */, watchOptions, WatchType.ConfigFile);
@@ -125552,7 +125583,7 @@ ${lanes.join("\n")}
             options: compilerOptions,
             program: getCurrentBuilderProgram() || rootFileNames,
             currentDirectory,
-            useCaseSensitiveFileNames,
+            useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
             writeLog,
             toPath: toPath3
           }))
@@ -125642,7 +125673,7 @@ ${lanes.join("\n")}
                   options: config.parsedCommandLine.options,
                   program: config.parsedCommandLine.fileNames,
                   currentDirectory,
-                  useCaseSensitiveFileNames,
+                  useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
                   writeLog,
                   toPath: toPath3
                 }))
@@ -128420,6 +128451,8 @@ ${lanes.join("\n")}
         ScriptElementKind2["enumMemberElement"] = "enum member";
         ScriptElementKind2["variableElement"] = "var";
         ScriptElementKind2["localVariableElement"] = "local var";
+        ScriptElementKind2["variableUsingElement"] = "using";
+        ScriptElementKind2["variableAwaitUsingElement"] = "await using";
         ScriptElementKind2["functionElement"] = "function";
         ScriptElementKind2["localFunctionElement"] = "local function";
         ScriptElementKind2["memberFunctionElement"] = "method";
@@ -131553,10 +131586,10 @@ ${lanes.join("\n")}
   }
   function forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, cb) {
     var _a, _b;
-    const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
+    const useCaseSensitiveFileNames2 = hostUsesCaseSensitiveFileNames(host);
     const excludePatterns = preferences.autoImportFileExcludePatterns && mapDefined(preferences.autoImportFileExcludePatterns, (spec) => {
       const pattern = getPatternFromSpec(spec, "", "exclude");
-      return pattern ? getRegexFromPattern(pattern, useCaseSensitiveFileNames) : void 0;
+      return pattern ? getRegexFromPattern(pattern, useCaseSensitiveFileNames2) : void 0;
     });
     forEachExternalModule(program.getTypeChecker(), program.getSourceFiles(), excludePatterns, (module2, file) => cb(
       module2,
@@ -133052,12 +133085,12 @@ ${lanes.join("\n")}
   function isDocumentRegistryEntry(entry) {
     return !!entry.sourceFile;
   }
-  function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory) {
-    return createDocumentRegistryInternal(useCaseSensitiveFileNames, currentDirectory);
+  function createDocumentRegistry(useCaseSensitiveFileNames2, currentDirectory) {
+    return createDocumentRegistryInternal(useCaseSensitiveFileNames2, currentDirectory);
   }
-  function createDocumentRegistryInternal(useCaseSensitiveFileNames, currentDirectory = "", externalCache) {
+  function createDocumentRegistryInternal(useCaseSensitiveFileNames2, currentDirectory = "", externalCache) {
     const buckets = /* @__PURE__ */ new Map();
-    const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
+    const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames2);
     function reportStats() {
       const bucketInfoArray = arrayFrom(buckets.keys()).filter((name) => name && name.charAt(0) === "_").map((name) => {
         const entries = buckets.get(name);
@@ -133266,12 +133299,12 @@ ${lanes.join("\n")}
 
   // src/services/getEditsForFileRename.ts
   function getEditsForFileRename(program, oldFileOrDirPath, newFileOrDirPath, host, formatContext, preferences, sourceMapper) {
-    const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
-    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const useCaseSensitiveFileNames2 = hostUsesCaseSensitiveFileNames(host);
+    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     const oldToNew = getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper);
     const newToOld = getPathUpdater(newFileOrDirPath, oldFileOrDirPath, getCanonicalFileName, sourceMapper);
     return ts_textChanges_exports.ChangeTracker.with({ host, formatContext, preferences }, (changeTracker) => {
-      updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, host.getCurrentDirectory(), useCaseSensitiveFileNames);
+      updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, host.getCurrentDirectory(), useCaseSensitiveFileNames2);
       updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName);
     });
   }
@@ -133293,7 +133326,7 @@ ${lanes.join("\n")}
     const rel = getRelativePathFromFile(a0, b0, getCanonicalFileName);
     return combinePathsSafe(getDirectoryPath(a1), rel);
   }
-  function updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, currentDirectory, useCaseSensitiveFileNames) {
+  function updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, currentDirectory, useCaseSensitiveFileNames2) {
     const { configFile } = program.getCompilerOptions();
     if (!configFile)
       return;
@@ -133317,10 +133350,10 @@ ${lanes.join("\n")}
             /*excludes*/
             [],
             includes,
-            useCaseSensitiveFileNames,
+            useCaseSensitiveFileNames2,
             currentDirectory
           );
-          if (getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames).test(oldFileOrDirPath) && !getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames).test(newFileOrDirPath)) {
+          if (getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames2).test(oldFileOrDirPath) && !getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames2).test(newFileOrDirPath)) {
             changeTracker.insertNodeAfter(configFile, last(property.initializer.elements), factory.createStringLiteral(relativePath(newFileOrDirPath)));
           }
           return;
@@ -133368,7 +133401,7 @@ ${lanes.join("\n")}
         configDir,
         path,
         /*ignoreCase*/
-        !useCaseSensitiveFileNames
+        !useCaseSensitiveFileNames2
       );
     }
   }
@@ -136682,7 +136715,7 @@ ${lanes.join("\n")}
     const body = addExports(oldFile, toMove.all, usage.oldFileImportsFromTargetFile, useEsModuleSyntax);
     if (typeof targetFile !== "string") {
       if (targetFile.statements.length > 0) {
-        changes.insertNodesAfter(targetFile, targetFile.statements[targetFile.statements.length - 1], body);
+        moveStatementsToTargetFile(changes, program, body, targetFile, toMove);
       } else {
         changes.insertNodesAtEndOfFile(
           targetFile,
@@ -137475,6 +137508,67 @@ ${lanes.join("\n")}
         return false;
     }
   }
+  function moveStatementsToTargetFile(changes, program, statements, targetFile, toMove) {
+    var _a;
+    const removedExports = /* @__PURE__ */ new Set();
+    const targetExports = (_a = targetFile.symbol) == null ? void 0 : _a.exports;
+    if (targetExports) {
+      const checker = program.getTypeChecker();
+      const targetToSourceExports = /* @__PURE__ */ new Map();
+      for (const node of toMove.all) {
+        if (isTopLevelDeclarationStatement(node) && hasSyntacticModifier(node, 1 /* Export */)) {
+          forEachTopLevelDeclaration(node, (declaration) => {
+            var _a2;
+            const targetDeclarations = canHaveSymbol(declaration) ? (_a2 = targetExports.get(declaration.symbol.escapedName)) == null ? void 0 : _a2.declarations : void 0;
+            const exportDeclaration = firstDefined(targetDeclarations, (d) => isExportDeclaration(d) ? d : isExportSpecifier(d) ? tryCast(d.parent.parent, isExportDeclaration) : void 0);
+            if (exportDeclaration && exportDeclaration.moduleSpecifier) {
+              targetToSourceExports.set(
+                exportDeclaration,
+                (targetToSourceExports.get(exportDeclaration) || /* @__PURE__ */ new Set()).add(declaration)
+              );
+            }
+          });
+        }
+      }
+      for (const [exportDeclaration, topLevelDeclarations] of arrayFrom(targetToSourceExports)) {
+        if (exportDeclaration.exportClause && isNamedExports(exportDeclaration.exportClause) && length(exportDeclaration.exportClause.elements)) {
+          const elements = exportDeclaration.exportClause.elements;
+          const updatedElements = filter(elements, (elem) => find(skipAlias(elem.symbol, checker).declarations, (d) => isTopLevelDeclaration(d) && topLevelDeclarations.has(d)) === void 0);
+          if (length(updatedElements) === 0) {
+            changes.deleteNode(targetFile, exportDeclaration);
+            removedExports.add(exportDeclaration);
+            continue;
+          }
+          if (length(updatedElements) < length(elements)) {
+            changes.replaceNode(
+              targetFile,
+              exportDeclaration,
+              factory.updateExportDeclaration(
+                exportDeclaration,
+                exportDeclaration.modifiers,
+                exportDeclaration.isTypeOnly,
+                factory.updateNamedExports(exportDeclaration.exportClause, factory.createNodeArray(updatedElements, elements.hasTrailingComma)),
+                exportDeclaration.moduleSpecifier,
+                exportDeclaration.assertClause
+              )
+            );
+          }
+        }
+      }
+    }
+    const lastReExport = findLast(targetFile.statements, (n) => isExportDeclaration(n) && !!n.moduleSpecifier && !removedExports.has(n));
+    if (lastReExport) {
+      changes.insertNodesBefore(
+        targetFile,
+        lastReExport,
+        statements,
+        /*blankLineBetween*/
+        true
+      );
+    } else {
+      changes.insertNodesAfter(targetFile, targetFile.statements[targetFile.statements.length - 1], statements);
+    }
+  }
   function getOverloadRangeToMove(sourceFile, statement) {
     if (isFunctionLikeDeclaration(statement)) {
       const declarations = statement.symbol.declarations;
@@ -141510,10 +141604,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         host.log(message);
       }
     }
-    const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
-    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const useCaseSensitiveFileNames2 = hostUsesCaseSensitiveFileNames(host);
+    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
     const sourceMapper = getSourceMapper({
-      useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
+      useCaseSensitiveFileNames: () => useCaseSensitiveFileNames2,
       getCurrentDirectory: () => currentDirectory,
       getProgram,
       fileExists: maybeBind(host, host.fileExists),
@@ -141561,7 +141655,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         getSourceFileByPath: getOrCreateSourceFileByPath,
         getCancellationToken: () => cancellationToken,
         getCanonicalFileName,
-        useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
+        useCaseSensitiveFileNames: () => useCaseSensitiveFileNames2,
         getNewLine: () => getNewLineCharacter(newSettings),
         getDefaultLibFileName: (options2) => host.getDefaultLibFileName(options2),
         writeFile: noop,
@@ -141605,7 +141699,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       compilerHost.getSourceFile = getSourceFileWithCache;
       (_c = host.setCompilerHost) == null ? void 0 : _c.call(host, compilerHost);
       const parseConfigHost = {
-        useCaseSensitiveFileNames,
+        useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
         fileExists: (fileName) => compilerHost.fileExists(fileName),
         readFile: (fileName) => compilerHost.readFile(fileName),
         readDirectory: (...args) => compilerHost.readDirectory(...args),
@@ -166484,6 +166578,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return "parameter" /* parameterElement */;
       } else if (symbol.valueDeclaration && isVarConst(symbol.valueDeclaration)) {
         return "const" /* constElement */;
+      } else if (symbol.valueDeclaration && isVarUsing(symbol.valueDeclaration)) {
+        return "using" /* variableUsingElement */;
+      } else if (symbol.valueDeclaration && isVarAwaitUsing(symbol.valueDeclaration)) {
+        return "await using" /* variableAwaitUsingElement */;
       } else if (forEach(symbol.declarations, isLet)) {
         return "let" /* letElement */;
       }
@@ -166877,7 +166975,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           } else {
             addPrefixForAnyFunctionOrVar(symbol, symbolKind);
           }
-          if (symbolKind === "property" /* memberVariableElement */ || symbolKind === "accessor" /* memberAccessorVariableElement */ || symbolKind === "getter" /* memberGetAccessorElement */ || symbolKind === "setter" /* memberSetAccessorElement */ || symbolKind === "JSX attribute" /* jsxAttribute */ || symbolFlags & 3 /* Variable */ || symbolKind === "local var" /* localVariableElement */ || symbolKind === "index" /* indexSignatureElement */ || isThisExpression) {
+          if (symbolKind === "property" /* memberVariableElement */ || symbolKind === "accessor" /* memberAccessorVariableElement */ || symbolKind === "getter" /* memberGetAccessorElement */ || symbolKind === "setter" /* memberSetAccessorElement */ || symbolKind === "JSX attribute" /* jsxAttribute */ || symbolFlags & 3 /* Variable */ || symbolKind === "local var" /* localVariableElement */ || symbolKind === "index" /* indexSignatureElement */ || symbolKind === "using" /* variableUsingElement */ || symbolKind === "await using" /* variableAwaitUsingElement */ || isThisExpression) {
             displayParts.push(punctuationPart(59 /* ColonToken */));
             displayParts.push(spacePart());
             if (type.symbol && type.symbol.flags & 262144 /* TypeParameter */ && symbolKind !== "index" /* indexSignatureElement */) {
@@ -167027,6 +167125,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         case "let" /* letElement */:
         case "const" /* constElement */:
         case "constructor" /* constructorImplementationElement */:
+        case "using" /* variableUsingElement */:
+        case "await using" /* variableAwaitUsingElement */:
           displayParts.push(textOrKeywordPart(symbolKind2));
           return;
         default:
@@ -167841,6 +167941,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         insertNodeBefore(sourceFile, before, newNode, blankLineBetween = false, options = {}) {
           this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween));
         }
+        insertNodesBefore(sourceFile, before, newNodes, blankLineBetween = false, options = {}) {
+          this.insertNodesAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNodes, this.getOptionsForInsertNodeBefore(before, first(newNodes), blankLineBetween));
+        }
         insertModifierAt(sourceFile, pos, modifier, options = {}) {
           this.insertNodeAt(sourceFile, pos, factory.createToken(modifier), options);
         }