@typescript-deploys/pr-build 5.4.0-pr-56794-34 → 5.4.0-pr-56877-6

package/lib/lib.es5.d.ts

@@ -1666,11 +1666,6 @@ type Capitalize<S extends string> = intrinsic;
  */
 type Uncapitalize<S extends string> = intrinsic;
 
-/**
- * Marker for non-inference type position
- */
-type NoInfer<T> = intrinsic;
-
 /**
  * Marker for contextual 'this' type
  */

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20231220`;
+var version = `${versionMajorMinor}.0-insiders.20231226`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1049,9 +1049,9 @@ function levenshteinWithMax(s1, s2, max) {
   const res = previous[s2.length];
   return res > max ? void 0 : res;
 }
-function endsWith(str, suffix) {
+function endsWith(str, suffix, ignoreCase) {
   const expectedPos = str.length - suffix.length;
-  return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
+  return expectedPos >= 0 && (ignoreCase ? equateStringsCaseInsensitive(str.slice(expectedPos), suffix) : str.indexOf(suffix, expectedPos) === expectedPos);
 }
 function removeSuffix(str, suffix) {
   return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str;
@@ -1109,8 +1109,8 @@ function findBestPatternMatch(values, getPattern, candidate) {
   }
   return matchedValue;
 }
-function startsWith(str, prefix) {
-  return str.lastIndexOf(prefix, 0) === 0;
+function startsWith(str, prefix, ignoreCase) {
+  return ignoreCase ? equateStringsCaseInsensitive(str.slice(0, prefix.length), prefix) : str.lastIndexOf(prefix, 0) === 0;
 }
 function removePrefix(str, prefix) {
   return startsWith(str, prefix) ? str.substr(prefix.length) : str;
@@ -3483,6 +3483,7 @@ var ModifierFlags = /* @__PURE__ */ ((ModifierFlags3) => {
   return ModifierFlags3;
 })(ModifierFlags || {});
 var RelationComparisonResult = /* @__PURE__ */ ((RelationComparisonResult3) => {
+  RelationComparisonResult3[RelationComparisonResult3["None"] = 0] = "None";
   RelationComparisonResult3[RelationComparisonResult3["Succeeded"] = 1] = "Succeeded";
   RelationComparisonResult3[RelationComparisonResult3["Failed"] = 2] = "Failed";
   RelationComparisonResult3[RelationComparisonResult3["Reported"] = 4] = "Reported";
@@ -6783,6 +6784,8 @@ var Diagnostics = {
   This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0: diag(4122, 1 /* Error */, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4122", "This member cannot have a JSDoc comment with an '@override' tag because it is not declared in the base class '{0}'."),
   This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: diag(4123, 1 /* Error */, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4123", "This member cannot have a JSDoc comment with an 'override' tag because it is not declared in the base class '{0}'. Did you mean '{1}'?"),
   Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4124, 1 /* Error */, "Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_w_4124", "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
+  Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given: diag(4125, 1 /* Error */, "Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given_4125", "Each declaration of '{0}.{1}' differs in its value, where '{2}' was expected but '{3}' was given."),
+  One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value: diag(4126, 1 /* Error */, "One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value_4126", "One value of '{0}.{1}' is the string '{2}', and the other is assumed to be an unknown numeric value."),
   The_current_host_does_not_support_the_0_option: diag(5001, 1 /* Error */, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."),
   Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, 1 /* Error */, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."),
   File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, 1 /* Error */, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."),
@@ -15728,6 +15731,13 @@ function readJsonOrUndefined(path, hostOrText) {
 function readJson(path, host) {
   return readJsonOrUndefined(path, host) || {};
 }
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
 function directoryProbablyExists(directoryName, host) {
   return !host.directoryExists || host.directoryExists(directoryName);
 }
@@ -37603,6 +37613,9 @@ function getAutomaticTypeDirectiveNames(options, host) {
 function isPackageJsonInfo(entry) {
   return !!(entry == null ? void 0 : entry.contents);
 }
+function isMissingPackageJsonInfo(entry) {
+  return !!entry && !entry.contents;
+}
 function compilerOptionValueToString(value) {
   var _a;
   if (value === null || typeof value !== "object") {
@@ -42746,7 +42759,7 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
   const { sourceDirectory, canonicalSourceDirectory, getCanonicalFileName } = info;
   const allowedEndings = getAllowedEndingsInPrefererredOrder(importMode);
   const relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, allowedEndings, compilerOptions) || processEnding(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), allowedEndings, compilerOptions);
-  if (!baseUrl && !paths || relativePreference === 0 /* Relative */) {
+  if (!baseUrl && !paths && !getResolvePackageJsonImports(compilerOptions) || relativePreference === 0 /* Relative */) {
     return pathsOnly ? void 0 : relativePath;
   }
   const baseDirectory = getNormalizedAbsolutePath(getPathsBasePath(compilerOptions, host) || baseUrl, host.getCurrentDirectory());
@@ -42754,11 +42767,12 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
   if (!relativeToBaseUrl) {
     return pathsOnly ? void 0 : relativePath;
   }
-  const fromPaths = paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions);
+  const fromPackageJsonImports = pathsOnly ? void 0 : tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, compilerOptions, host, importMode);
+  const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) : void 0;
   if (pathsOnly) {
     return fromPaths;
   }
-  const maybeNonRelative = fromPaths === void 0 && baseUrl !== void 0 ? processEnding(relativeToBaseUrl, allowedEndings, compilerOptions) : fromPaths;
+  const maybeNonRelative = fromPackageJsonImports ?? (fromPaths === void 0 && baseUrl !== void 0 ? processEnding(relativeToBaseUrl, allowedEndings, compilerOptions) : fromPaths);
   if (!maybeNonRelative) {
     return relativePath;
   }
@@ -42797,8 +42811,8 @@ function getNearestAncestorDirectoryWithPackageJson(host, fileName) {
   if (host.getNearestAncestorDirectoryWithPackageJson) {
     return host.getNearestAncestorDirectoryWithPackageJson(fileName);
   }
-  return !!forEachAncestorDirectory(fileName, (directory) => {
-    return host.fileExists(combinePaths(directory, "package.json")) ? true : void 0;
+  return forEachAncestorDirectory(fileName, (directory) => {
+    return host.fileExists(combinePaths(directory, "package.json")) ? directory : void 0;
   });
 }
 function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb) {
@@ -42972,8 +42986,12 @@ function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, hos
     return ending !== 0 /* Minimal */ || value === processEnding(relativeToBaseUrl, [ending], compilerOptions, host);
   }
 }
-function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, exports2, conditions, mode = 0 /* Exact */) {
+function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, exports2, conditions, mode, isImports) {
   if (typeof exports2 === "string") {
+    const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
+    const getCommonSourceDirectory2 = () => host.getCommonSourceDirectory();
+    const outputFile = isImports && getOutputJSFileNameWorker(targetFilePath, options, ignoreCase, getCommonSourceDirectory2);
+    const declarationFile = isImports && getOutputDeclarationFileNameWorker(targetFilePath, options, ignoreCase, getCommonSourceDirectory2);
     const pathOrPattern = getNormalizedAbsolutePath(
       combinePaths(packageDirectory, exports2),
       /*currentDirectory*/
@@ -42982,12 +43000,25 @@ function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory,
     const extensionSwappedTarget = hasTSFileExtension(targetFilePath) ? removeFileExtension(targetFilePath) + tryGetJSExtensionForFile(targetFilePath, options) : void 0;
     switch (mode) {
       case 0 /* Exact */:
-        if (comparePaths(targetFilePath, pathOrPattern) === 0 /* EqualTo */ || extensionSwappedTarget && comparePaths(extensionSwappedTarget, pathOrPattern) === 0 /* EqualTo */) {
+        if (extensionSwappedTarget && comparePaths(extensionSwappedTarget, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || comparePaths(targetFilePath, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || outputFile && comparePaths(outputFile, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || declarationFile && comparePaths(declarationFile, pathOrPattern, ignoreCase) === 0 /* EqualTo */) {
           return { moduleFileToTry: packageName };
         }
         break;
       case 1 /* Directory */:
-        if (containsPath(pathOrPattern, targetFilePath)) {
+        if (extensionSwappedTarget && containsPath(pathOrPattern, extensionSwappedTarget, ignoreCase)) {
+          const fragment = getRelativePathFromDirectory(
+            pathOrPattern,
+            extensionSwappedTarget,
+            /*ignoreCase*/
+            false
+          );
+          return { moduleFileToTry: getNormalizedAbsolutePath(
+            combinePaths(combinePaths(packageName, exports2), fragment),
+            /*currentDirectory*/
+            void 0
+          ) };
+        }
+        if (containsPath(pathOrPattern, targetFilePath, ignoreCase)) {
           const fragment = getRelativePathFromDirectory(
             pathOrPattern,
             targetFilePath,
@@ -43000,48 +43031,136 @@ function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory,
             void 0
           ) };
         }
+        if (outputFile && containsPath(pathOrPattern, outputFile, ignoreCase)) {
+          const fragment = getRelativePathFromDirectory(
+            pathOrPattern,
+            outputFile,
+            /*ignoreCase*/
+            false
+          );
+          return { moduleFileToTry: combinePaths(packageName, fragment) };
+        }
+        if (declarationFile && containsPath(pathOrPattern, declarationFile, ignoreCase)) {
+          const fragment = getRelativePathFromDirectory(
+            pathOrPattern,
+            declarationFile,
+            /*ignoreCase*/
+            false
+          );
+          return { moduleFileToTry: combinePaths(packageName, fragment) };
+        }
         break;
       case 2 /* Pattern */:
         const starPos = pathOrPattern.indexOf("*");
         const leadingSlice = pathOrPattern.slice(0, starPos);
         const trailingSlice = pathOrPattern.slice(starPos + 1);
-        if (startsWith(targetFilePath, leadingSlice) && endsWith(targetFilePath, trailingSlice)) {
+        if (extensionSwappedTarget && startsWith(extensionSwappedTarget, leadingSlice, ignoreCase) && endsWith(extensionSwappedTarget, trailingSlice, ignoreCase)) {
+          const starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length);
+          return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
+        }
+        if (startsWith(targetFilePath, leadingSlice, ignoreCase) && endsWith(targetFilePath, trailingSlice, ignoreCase)) {
           const starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
           return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
         }
-        if (extensionSwappedTarget && startsWith(extensionSwappedTarget, leadingSlice) && endsWith(extensionSwappedTarget, trailingSlice)) {
-          const starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length);
+        if (outputFile && startsWith(outputFile, leadingSlice, ignoreCase) && endsWith(outputFile, trailingSlice, ignoreCase)) {
+          const starReplacement = outputFile.slice(leadingSlice.length, outputFile.length - trailingSlice.length);
+          return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
+        }
+        if (declarationFile && startsWith(declarationFile, leadingSlice, ignoreCase) && endsWith(declarationFile, trailingSlice, ignoreCase)) {
+          const starReplacement = declarationFile.slice(leadingSlice.length, declarationFile.length - trailingSlice.length);
           return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
         }
         break;
     }
   } else if (Array.isArray(exports2)) {
-    return forEach(exports2, (e) => tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, e, conditions));
+    return forEach(exports2, (e) => tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, e, conditions, mode, isImports));
   } else if (typeof exports2 === "object" && exports2 !== null) {
-    if (allKeysStartWithDot(exports2)) {
-      return forEach(getOwnKeys(exports2), (k) => {
-        const subPackageName = getNormalizedAbsolutePath(
-          combinePaths(packageName, k),
-          /*currentDirectory*/
-          void 0
-        );
-        const mode2 = endsWith(k, "/") ? 1 /* Directory */ : k.includes("*") ? 2 /* Pattern */ : 0 /* Exact */;
-        return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, subPackageName, exports2[k], conditions, mode2);
-      });
-    } else {
-      for (const key of getOwnKeys(exports2)) {
-        if (key === "default" || conditions.includes(key) || isApplicableVersionedTypesKey(conditions, key)) {
-          const subTarget = exports2[key];
-          const result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode);
-          if (result) {
-            return result;
-          }
+    for (const key of getOwnKeys(exports2)) {
+      if (key === "default" || conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(conditions, key)) {
+        const subTarget = exports2[key];
+        const result = tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode, isImports);
+        if (result) {
+          return result;
         }
       }
     }
   }
   return void 0;
 }
+function tryGetModuleNameFromExports(options, host, targetFilePath, packageDirectory, packageName, exports2, conditions) {
+  if (typeof exports2 === "object" && exports2 !== null && !Array.isArray(exports2) && allKeysStartWithDot(exports2)) {
+    return forEach(getOwnKeys(exports2), (k) => {
+      const subPackageName = getNormalizedAbsolutePath(
+        combinePaths(packageName, k),
+        /*currentDirectory*/
+        void 0
+      );
+      const mode = endsWith(k, "/") ? 1 /* Directory */ : k.includes("*") ? 2 /* Pattern */ : 0 /* Exact */;
+      return tryGetModuleNameFromExportsOrImports(
+        options,
+        host,
+        targetFilePath,
+        packageDirectory,
+        subPackageName,
+        exports2[k],
+        conditions,
+        mode,
+        /*isImports*/
+        false
+      );
+    });
+  }
+  return tryGetModuleNameFromExportsOrImports(
+    options,
+    host,
+    targetFilePath,
+    packageDirectory,
+    packageName,
+    exports2,
+    conditions,
+    0 /* Exact */,
+    /*isImports*/
+    false
+  );
+}
+function tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, options, host, importMode) {
+  var _a, _b, _c;
+  if (!host.readFile || !getResolvePackageJsonImports(options)) {
+    return void 0;
+  }
+  const ancestorDirectoryWithPackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
+  if (!ancestorDirectoryWithPackageJson) {
+    return void 0;
+  }
+  const packageJsonPath = combinePaths(ancestorDirectoryWithPackageJson, "package.json");
+  const cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
+  if (isMissingPackageJsonInfo(cachedPackageJson) || !host.fileExists(packageJsonPath)) {
+    return void 0;
+  }
+  const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || tryParseJson(host.readFile(packageJsonPath));
+  const imports = packageJsonContent == null ? void 0 : packageJsonContent.imports;
+  if (!imports) {
+    return void 0;
+  }
+  const conditions = getConditions(options, importMode);
+  return (_c = forEach(getOwnKeys(imports), (k) => {
+    if (!startsWith(k, "#") || k === "#" || startsWith(k, "#/"))
+      return void 0;
+    const mode = endsWith(k, "/") ? 1 /* Directory */ : k.includes("*") ? 2 /* Pattern */ : 0 /* Exact */;
+    return tryGetModuleNameFromExportsOrImports(
+      options,
+      host,
+      moduleFileName,
+      ancestorDirectoryWithPackageJson,
+      k,
+      imports[k],
+      conditions,
+      mode,
+      /*isImports*/
+      true
+    );
+  })) == null ? void 0 : _c.moduleFileToTry;
+}
 function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, allowedEndings, compilerOptions) {
   const normalizedTargetPaths = getPathsRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
   if (normalizedTargetPaths === void 0) {
@@ -43115,22 +43234,21 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
     let maybeBlockedByTypesVersions = false;
     const cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
     if (isPackageJsonInfo(cachedPackageJson) || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
-      const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
+      const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || tryParseJson(host.readFile(packageJsonPath));
       const importMode = overrideMode || importingSourceFile.impliedNodeFormat;
       if (getResolvePackageJsonExports(options)) {
         const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1);
         const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2);
         const conditions = getConditions(options, importMode);
-        const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0;
+        const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(options, host, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0;
         if (fromExports) {
-          const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
-          return { ...withJsExtension, verbatimFromExports: true };
+          return { ...fromExports, verbatimFromExports: true };
         }
-        if (packageJsonContent.exports) {
+        if (packageJsonContent == null ? void 0 : packageJsonContent.exports) {
           return { moduleFileToTry: path, blockedByExports: true };
         }
       }
-      const versionPaths = packageJsonContent.typesVersions ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
+      const versionPaths = (packageJsonContent == null ? void 0 : packageJsonContent.typesVersions) ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
       if (versionPaths) {
         const subModuleName = path.slice(packageRootPath.length + 1);
         const fromPaths = tryGetModuleNameFromPaths(
@@ -43146,13 +43264,13 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
           moduleFileToTry = combinePaths(packageRootPath, fromPaths);
         }
       }
-      const mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main || "index.js";
+      const mainFileRelative = (packageJsonContent == null ? void 0 : packageJsonContent.typings) || (packageJsonContent == null ? void 0 : packageJsonContent.types) || (packageJsonContent == null ? void 0 : packageJsonContent.main) || "index.js";
       if (isString(mainFileRelative) && !(maybeBlockedByTypesVersions && matchPatternOrExact(tryParsePatterns(versionPaths.paths), mainFileRelative))) {
         const mainExportFile = toPath(mainFileRelative, packageRootPath, getCanonicalFileName);
         const canonicalModuleFileToTry = getCanonicalFileName(moduleFileToTry);
         if (removeFileExtension(mainExportFile) === removeFileExtension(canonicalModuleFileToTry)) {
           return { packageRootPath, moduleFileToTry };
-        } else if (packageJsonContent.type !== "module" && !fileExtensionIsOneOf(canonicalModuleFileToTry, extensionsNotSupportingExtensionlessResolution) && startsWith(canonicalModuleFileToTry, mainExportFile) && getDirectoryPath(canonicalModuleFileToTry) === removeTrailingDirectorySeparator(mainExportFile) && removeFileExtension(getBaseFileName(canonicalModuleFileToTry)) === "index") {
+        } else if ((packageJsonContent == null ? void 0 : packageJsonContent.type) !== "module" && !fileExtensionIsOneOf(canonicalModuleFileToTry, extensionsNotSupportingExtensionlessResolution) && startsWith(canonicalModuleFileToTry, mainExportFile) && getDirectoryPath(canonicalModuleFileToTry) === removeTrailingDirectorySeparator(mainExportFile) && removeFileExtension(getBaseFileName(canonicalModuleFileToTry)) === "index") {
           return { packageRootPath, moduleFileToTry };
         }
       }
@@ -43392,8 +43510,7 @@ var intrinsicTypeKinds = new Map(Object.entries({
   Uppercase: 0 /* Uppercase */,
   Lowercase: 1 /* Lowercase */,
   Capitalize: 2 /* Capitalize */,
-  Uncapitalize: 3 /* Uncapitalize */,
-  NoInfer: 4 /* NoInfer */
+  Uncapitalize: 3 /* Uncapitalize */
 }));
 var SymbolLinks = class {
 };
@@ -48247,13 +48364,7 @@ function createTypeChecker(host) {
         return visitAndTransformType(type, (type2) => conditionalTypeToTypeNode(type2));
       }
       if (type.flags & 33554432 /* Substitution */) {
-        const typeNode = typeToTypeNodeHelper(type.baseType, context);
-        const noInferSymbol = isNoInferType(type) && getGlobalTypeSymbol(
-          "NoInfer",
-          /*reportErrors*/
-          false
-        );
-        return noInferSymbol ? symbolToTypeNode(noInferSymbol, context, 788968 /* Type */, [typeNode]) : typeNode;
+        return typeToTypeNodeHelper(type.baseType, context);
       }
       return Debug.fail("Should be unreachable.");
       function conditionalTypeToTypeNode(type2) {
@@ -56157,11 +56268,8 @@ function createTypeChecker(host) {
   }
   function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
     const type = getDeclaredTypeOfSymbol(symbol);
-    if (type === intrinsicMarkerType) {
-      const typeKind = intrinsicTypeKinds.get(symbol.escapedName);
-      if (typeKind !== void 0 && typeArguments && typeArguments.length === 1) {
-        return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]);
-      }
+    if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
+      return getStringMappingType(symbol, typeArguments[0]);
     }
     const links = getSymbolLinks(symbol);
     const typeParameters = links.typeParameters;
@@ -56315,19 +56423,10 @@ function createTypeChecker(host) {
     }
     return links.resolvedJSDocType;
   }
-  function getNoInferType(type) {
-    return isNoInferTargetType(type) ? getOrCreateSubstitutionType(type, unknownType) : type;
-  }
-  function isNoInferTargetType(type) {
-    return !!(type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, isNoInferTargetType) || type.flags & 33554432 /* Substitution */ && !isNoInferType(type) && isNoInferTargetType(type.baseType) || type.flags & 524288 /* Object */ && !isEmptyAnonymousObjectType(type) || type.flags & (465829888 /* Instantiable */ & ~33554432 /* Substitution */) && !isPatternLiteralType(type));
-  }
-  function isNoInferType(type) {
-    return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
-  }
   function getSubstitutionType(baseType, constraint) {
-    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
-  }
-  function getOrCreateSubstitutionType(baseType, constraint) {
+    if (constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */) {
+      return baseType;
+    }
     const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
@@ -56340,7 +56439,7 @@ function createTypeChecker(host) {
     return result;
   }
   function getSubstitutionIntersection(substitutionType) {
-    return isNoInferType(substitutionType) ? substitutionType.baseType : getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
+    return getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
   }
   function isUnaryTupleTypeNode(node) {
     return node.kind === 189 /* TupleType */ && node.elements.length === 1;
@@ -57861,7 +57960,7 @@ function createTypeChecker(host) {
   }
   function getIndexType(type, indexFlags = defaultIndexFlags) {
     type = getReducedType(type);
-    return isNoInferType(type) ? getNoInferType(getIndexType(type.baseType, indexFlags)) : shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
+    return shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
   }
   function getExtractStringType(type) {
     if (keyofStringsOnly) {
@@ -59598,9 +59697,6 @@ function createTypeChecker(host) {
     }
     if (flags & 33554432 /* Substitution */) {
       const newBaseType = instantiateType(type.baseType, mapper);
-      if (isNoInferType(type)) {
-        return getNoInferType(newBaseType);
-      }
       const newConstraint = instantiateType(type.constraint, mapper);
       if (newBaseType.flags & 8650752 /* TypeVariable */ && isGenericType(newConstraint)) {
         return getSubstitutionType(newBaseType, newConstraint);
@@ -60510,12 +60606,12 @@ function createTypeChecker(host) {
       return !!(entry & 1 /* Succeeded */);
     }
     const targetEnumType = getTypeOfSymbol(targetSymbol);
-    for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
-      if (property.flags & 8 /* EnumMember */) {
-        const targetProperty = getPropertyOfType(targetEnumType, property.escapedName);
+    for (const sourceProperty of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
+      if (sourceProperty.flags & 8 /* EnumMember */) {
+        const targetProperty = getPropertyOfType(targetEnumType, sourceProperty.escapedName);
         if (!targetProperty || !(targetProperty.flags & 8 /* EnumMember */)) {
           if (errorReporter) {
-            errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(property), typeToString(
+            errorReporter(Diagnostics.Property_0_is_missing_in_type_1, symbolName(sourceProperty), typeToString(
               getDeclaredTypeOfSymbol(targetSymbol),
               /*enclosingDeclaration*/
               void 0,
@@ -60527,6 +60623,35 @@ function createTypeChecker(host) {
           }
           return false;
         }
+        const sourceValue = getEnumMemberValue(getDeclarationOfKind(sourceProperty, 306 /* EnumMember */));
+        const targetValue = getEnumMemberValue(getDeclarationOfKind(targetProperty, 306 /* EnumMember */));
+        if (sourceValue !== targetValue) {
+          const sourceIsString = typeof sourceValue === "string";
+          const targetIsString = typeof targetValue === "string";
+          if (sourceValue !== void 0 && targetValue !== void 0) {
+            if (!errorReporter) {
+              enumRelation.set(id, 2 /* Failed */);
+            } else {
+              const escapedSource = sourceIsString ? `"${escapeString(sourceValue)}"` : sourceValue;
+              const escapedTarget = targetIsString ? `"${escapeString(targetValue)}"` : targetValue;
+              errorReporter(Diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given, symbolName(targetSymbol), symbolName(targetProperty), escapedTarget, escapedSource);
+              enumRelation.set(id, 2 /* Failed */ | 4 /* Reported */);
+            }
+            return false;
+          }
+          if (sourceIsString || targetIsString) {
+            if (!errorReporter) {
+              enumRelation.set(id, 2 /* Failed */);
+            } else {
+              const knownStringValue = sourceValue ?? targetValue;
+              Debug.assert(typeof knownStringValue === "string");
+              const escapedValue = `"${escapeString(knownStringValue)}"`;
+              errorReporter(Diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value, symbolName(targetSymbol), symbolName(targetProperty), escapedValue);
+              enumRelation.set(id, 2 /* Failed */ | 4 /* Reported */);
+            }
+            return false;
+          }
+        }
       }
     }
     enumRelation.set(id, 1 /* Succeeded */);
@@ -64351,7 +64476,7 @@ function createTypeChecker(host) {
     let expandingFlags = 0 /* None */;
     inferFromTypes(originalSource, originalTarget);
     function inferFromTypes(source, target) {
-      if (!couldContainTypeVariables(target) || isNoInferType(target)) {
+      if (!couldContainTypeVariables(target)) {
         return;
       }
       if (source === wildcardType || source === blockedStringType) {
@@ -64400,9 +64525,6 @@ function createTypeChecker(host) {
         }
       }
       if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
-        if (isNoInferType(target)) {
-          return;
-        }
         target = getActualTypeVariable(target);
       }
       if (target.flags & 8650752 /* TypeVariable */) {
@@ -73920,7 +74042,7 @@ function createTypeChecker(host) {
       if (!witnesses) {
         return false;
       }
-      const operandConstraint = getBaseConstraintOrType(checkExpressionCached(node.expression.expression));
+      const operandConstraint = getBaseConstraintOfType(checkExpressionCached(node.expression.expression)) || unknownType;
       const notEqualFacts = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses);
       if (operandConstraint.flags & 3 /* AnyOrUnknown */) {
         return (556800 /* AllTypeofNE */ & notEqualFacts) === 556800 /* AllTypeofNE */;
@@ -110440,28 +110562,34 @@ function getSourceMapFilePath(jsFilePath, options) {
 function getOutputExtension(fileName, options) {
   return fileExtensionIs(fileName, ".json" /* Json */) ? ".json" /* Json */ : options.jsx === 1 /* Preserve */ && fileExtensionIsOneOf(fileName, [".jsx" /* Jsx */, ".tsx" /* Tsx */]) ? ".jsx" /* Jsx */ : fileExtensionIsOneOf(fileName, [".mts" /* Mts */, ".mjs" /* Mjs */]) ? ".mjs" /* Mjs */ : fileExtensionIsOneOf(fileName, [".cts" /* Cts */, ".cjs" /* Cjs */]) ? ".cjs" /* Cjs */ : ".js" /* Js */;
 }
-function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir, getCommonSourceDirectory2) {
+function getOutputPathWithoutChangingExt(inputFileName, ignoreCase, outputDir, getCommonSourceDirectory2) {
   return outputDir ? resolvePath(
     outputDir,
-    getRelativePathFromDirectory(getCommonSourceDirectory2 ? getCommonSourceDirectory2() : getCommonSourceDirectoryOfConfig(configFile, ignoreCase), inputFileName, ignoreCase)
+    getRelativePathFromDirectory(getCommonSourceDirectory2(), inputFileName, ignoreCase)
   ) : inputFileName;
 }
-function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2) {
+function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2 = () => getCommonSourceDirectoryOfConfig(configFile, ignoreCase)) {
+  return getOutputDeclarationFileNameWorker(inputFileName, configFile.options, ignoreCase, getCommonSourceDirectory2);
+}
+function getOutputDeclarationFileNameWorker(inputFileName, options, ignoreCase, getCommonSourceDirectory2) {
   return changeExtension(
-    getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir, getCommonSourceDirectory2),
+    getOutputPathWithoutChangingExt(inputFileName, ignoreCase, options.declarationDir || options.outDir, getCommonSourceDirectory2),
     getDeclarationEmitExtensionForPath(inputFileName)
   );
 }
-function getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2) {
+function getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2 = () => getCommonSourceDirectoryOfConfig(configFile, ignoreCase)) {
   if (configFile.options.emitDeclarationOnly)
     return void 0;
   const isJsonFile = fileExtensionIs(inputFileName, ".json" /* Json */);
-  const outputFileName = changeExtension(
-    getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir, getCommonSourceDirectory2),
-    getOutputExtension(inputFileName, configFile.options)
-  );
+  const outputFileName = getOutputJSFileNameWorker(inputFileName, configFile.options, ignoreCase, getCommonSourceDirectory2);
   return !isJsonFile || comparePaths(inputFileName, outputFileName, Debug.checkDefined(configFile.options.configFilePath), ignoreCase) !== 0 /* EqualTo */ ? outputFileName : void 0;
 }
+function getOutputJSFileNameWorker(inputFileName, options, ignoreCase, getCommonSourceDirectory2) {
+  return changeExtension(
+    getOutputPathWithoutChangingExt(inputFileName, ignoreCase, options.outDir, getCommonSourceDirectory2),
+    getOutputExtension(inputFileName, options)
+  );
+}
 function createAddOutput() {
   let outputs;
   return { addOutput, getOutputs };