typescript 5.7.0-dev.20240923 → 5.7.0-dev.20240925

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-dev.20240923`;
+var version = `${versionMajorMinor}.0-dev.20240925`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6182,6 +6182,8 @@ var Diagnostics = {
   ),
   Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute: diag(1541, 1 /* Error */, "Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribut_1541", "Type-only import of an ECMAScript module from a CommonJS module must have a 'resolution-mode' attribute."),
   Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute: diag(1542, 1 /* Error */, "Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute_1542", "Type import of an ECMAScript module from a CommonJS module must have a 'resolution-mode' attribute."),
+  Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0: diag(1543, 1 /* Error */, "Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_mod_1543", `Importing a JSON file into an ECMAScript module requires a 'type: "json"' import attribute when 'module' is set to '{0}'.`),
+  Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0: diag(1544, 1 /* Error */, "Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0_1544", "Named imports from a JSON file into an ECMAScript module are not allowed when 'module' is set to '{0}'."),
   The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
   The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
   Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -6753,6 +6755,8 @@ var Diagnostics = {
   This_expression_is_always_nullish: diag(2871, 1 /* Error */, "This_expression_is_always_nullish_2871", "This expression is always nullish."),
   This_kind_of_expression_is_always_truthy: diag(2872, 1 /* Error */, "This_kind_of_expression_is_always_truthy_2872", "This kind of expression is always truthy."),
   This_kind_of_expression_is_always_falsy: diag(2873, 1 /* Error */, "This_kind_of_expression_is_always_falsy_2873", "This kind of expression is always falsy."),
+  This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found: diag(2874, 1 /* Error */, "This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found_2874", "This JSX tag requires '{0}' to be in scope, but it could not be found."),
+  This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed: diag(2875, 1 /* Error */, "This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_fo_2875", "This JSX tag requires the module path '{0}' to exist, but none could be found. Make sure you have types for the appropriate package installed."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -35596,9 +35600,10 @@ function getDeclarationFileExtension(fileName) {
     return standardExtension;
   }
   if (fileExtensionIs(fileName, ".ts" /* Ts */)) {
-    const index = getBaseFileName(fileName).lastIndexOf(".d.");
+    const baseName = getBaseFileName(fileName);
+    const index = baseName.lastIndexOf(".d.");
     if (index >= 0) {
-      return fileName.substring(index);
+      return baseName.substring(index);
     }
   }
   return void 0;
@@ -47820,10 +47825,19 @@ function createTypeChecker(host) {
   function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
     return usageMode === 99 /* ESNext */ && targetMode === 1 /* CommonJS */;
   }
-  function isOnlyImportableAsDefault(usage) {
+  function isOnlyImportableAsDefault(usage, resolvedModule) {
     if (100 /* Node16 */ <= moduleKind && moduleKind <= 199 /* NodeNext */) {
       const usageMode = getEmitSyntaxForModuleSpecifierExpression(usage);
-      return usageMode === 99 /* ESNext */ && endsWith(usage.text, ".json" /* Json */);
+      if (usageMode === 99 /* ESNext */) {
+        resolvedModule ?? (resolvedModule = resolveExternalModuleName(
+          usage,
+          usage,
+          /*ignoreErrors*/
+          true
+        ));
+        const targetFile = resolvedModule && getSourceFileOfModule(resolvedModule);
+        return targetFile && (isJsonSourceFile(targetFile) || getDeclarationFileExtension(targetFile.fileName) === ".d.json.ts");
+      }
     }
     return false;
   }
@@ -47894,7 +47908,7 @@ function createTypeChecker(host) {
     if (!specifier) {
       return exportDefaultSymbol;
     }
-    const hasDefaultOnly = isOnlyImportableAsDefault(specifier);
+    const hasDefaultOnly = isOnlyImportableAsDefault(specifier, moduleSymbol);
     const hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, specifier);
     if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) {
       if (hasExportAssignmentSymbol(moduleSymbol) && !allowSyntheticDefaultImports) {
@@ -48096,12 +48110,14 @@ function createTypeChecker(host) {
         let symbolFromModule = getExportOfModule(targetSymbol, nameText, specifier, dontResolveAlias);
         if (symbolFromModule === void 0 && nameText === "default" /* Default */) {
           const file = (_a = moduleSymbol.declarations) == null ? void 0 : _a.find(isSourceFile);
-          if (isOnlyImportableAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
+          if (isOnlyImportableAsDefault(moduleSpecifier, moduleSymbol) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
             symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
           }
         }
         const symbol = symbolFromModule && symbolFromVariable && symbolFromModule !== symbolFromVariable ? combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) : symbolFromModule || symbolFromVariable;
-        if (!symbol) {
+        if (isImportOrExportSpecifier(specifier) && isOnlyImportableAsDefault(moduleSpecifier, moduleSymbol) && nameText !== "default" /* Default */) {
+          error(name, Diagnostics.Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0, ModuleKind[moduleKind]);
+        } else if (!symbol) {
           errorNoModuleMemberSymbol(moduleSymbol, targetSymbol, node, name);
         }
         return symbol;
@@ -56412,11 +56428,20 @@ function createTypeChecker(host) {
     return type;
   }
   function isLateBindableName(node) {
+    return isLateBindableAST(node) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(node.argumentExpression));
+  }
+  function isLateBindableIndexSignature(node) {
+    return isLateBindableAST(node) && isTypeUsableAsIndexSignature(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(node.argumentExpression));
+  }
+  function isLateBindableAST(node) {
     if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
       return false;
     }
     const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
-    return isEntityNameExpression(expr) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
+    return isEntityNameExpression(expr);
+  }
+  function isTypeUsableAsIndexSignature(type) {
+    return isTypeAssignableTo(type, stringNumberSymbolType);
   }
   function isLateBoundName(name) {
     return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) === 64 /* at */;
@@ -56425,6 +56450,10 @@ function createTypeChecker(host) {
     const name = getNameOfDeclaration(node);
     return !!name && isLateBindableName(name);
   }
+  function hasLateBindableIndexSignature(node) {
+    const name = getNameOfDeclaration(node);
+    return !!name && isLateBindableIndexSignature(name);
+  }
   function hasBindableName(node) {
     return !hasDynamicName(node) || hasLateBindableName(node);
   }
@@ -56478,6 +56507,24 @@ function createTypeChecker(host) {
     }
     return links.resolvedSymbol;
   }
+  function lateBindIndexSignature(parent, earlySymbols, lateSymbols, decl) {
+    let indexSymbol = lateSymbols.get("__index" /* Index */);
+    if (!indexSymbol) {
+      const early = earlySymbols == null ? void 0 : earlySymbols.get("__index" /* Index */);
+      if (!early) {
+        indexSymbol = createSymbol(0 /* None */, "__index" /* Index */, 4096 /* Late */);
+      } else {
+        indexSymbol = cloneSymbol(early);
+        indexSymbol.links.checkFlags |= 4096 /* Late */;
+      }
+      lateSymbols.set("__index" /* Index */, indexSymbol);
+    }
+    if (!indexSymbol.declarations) {
+      indexSymbol.declarations = [decl];
+    } else if (!decl.symbol.isReplaceableByMethod) {
+      indexSymbol.declarations.push(decl);
+    }
+  }
   function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
     const links = getSymbolLinks(symbol);
     if (!links[resolutionKind]) {
@@ -56492,6 +56539,8 @@ function createTypeChecker(host) {
             if (isStatic2 === hasStaticModifier(member)) {
               if (hasLateBindableName(member)) {
                 lateBindMember(symbol, earlySymbols, lateSymbols, member);
+              } else if (hasLateBindableIndexSignature(member)) {
+                lateBindIndexSignature(symbol, earlySymbols, lateSymbols, member);
               }
             }
           }
@@ -57136,7 +57185,7 @@ function createTypeChecker(host) {
     }
     const indexSymbol = getIndexSymbolFromSymbolTable(members);
     if (indexSymbol) {
-      indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
+      indexInfos = getIndexInfosOfIndexSymbol(indexSymbol, arrayFrom(members.values()));
     } else {
       if (baseConstructorIndexInfo) {
         indexInfos = append(indexInfos, baseConstructorIndexInfo);
@@ -58755,7 +58804,7 @@ function createTypeChecker(host) {
     return signature.isolatedSignatureType;
   }
   function getIndexSymbol(symbol) {
-    return symbol.members ? getIndexSymbolFromSymbolTable(symbol.members) : void 0;
+    return symbol.members ? getIndexSymbolFromSymbolTable(getMembersOfSymbol(symbol)) : void 0;
   }
   function getIndexSymbolFromSymbolTable(symbolTable) {
     return symbolTable.get("__index" /* Index */);
@@ -58765,23 +58814,61 @@ function createTypeChecker(host) {
   }
   function getIndexInfosOfSymbol(symbol) {
     const indexSymbol = getIndexSymbol(symbol);
-    return indexSymbol ? getIndexInfosOfIndexSymbol(indexSymbol) : emptyArray;
+    return indexSymbol ? getIndexInfosOfIndexSymbol(indexSymbol, arrayFrom(getMembersOfSymbol(symbol).values())) : emptyArray;
   }
-  function getIndexInfosOfIndexSymbol(indexSymbol) {
+  function getIndexInfosOfIndexSymbol(indexSymbol, siblingSymbols = indexSymbol.parent ? arrayFrom(getMembersOfSymbol(indexSymbol.parent).values()) : void 0) {
     if (indexSymbol.declarations) {
       const indexInfos = [];
+      let hasComputedNumberProperty = false;
+      let readonlyComputedNumberProperty = true;
+      let hasComputedSymbolProperty = false;
+      let readonlyComputedSymbolProperty = true;
+      let hasComputedStringProperty = false;
+      let readonlyComputedStringProperty = true;
+      const computedPropertySymbols = [];
       for (const declaration of indexSymbol.declarations) {
-        if (declaration.parameters.length === 1) {
-          const parameter = declaration.parameters[0];
-          if (parameter.type) {
-            forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
-              if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
-                indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration));
+        if (isIndexSignatureDeclaration(declaration)) {
+          if (declaration.parameters.length === 1) {
+            const parameter = declaration.parameters[0];
+            if (parameter.type) {
+              forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
+                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
+                  indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration));
+                }
+              });
+            }
+          }
+        } else if (hasLateBindableIndexSignature(declaration)) {
+          const declName = isBinaryExpression(declaration) ? declaration.left : declaration.name;
+          const keyType = isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
+          if (findIndexInfo(indexInfos, keyType)) {
+            continue;
+          }
+          if (isTypeAssignableTo(keyType, stringNumberSymbolType)) {
+            if (isTypeAssignableTo(keyType, numberType)) {
+              hasComputedNumberProperty = true;
+              if (!hasEffectiveReadonlyModifier(declaration)) {
+                readonlyComputedNumberProperty = false;
               }
-            });
+            } else if (isTypeAssignableTo(keyType, esSymbolType)) {
+              hasComputedSymbolProperty = true;
+              if (!hasEffectiveReadonlyModifier(declaration)) {
+                readonlyComputedSymbolProperty = false;
+              }
+            } else {
+              hasComputedStringProperty = true;
+              if (!hasEffectiveReadonlyModifier(declaration)) {
+                readonlyComputedStringProperty = false;
+              }
+            }
+            computedPropertySymbols.push(declaration.symbol);
           }
         }
       }
+      const allPropertySymbols = concatenate(computedPropertySymbols, filter(siblingSymbols, (s) => s !== indexSymbol));
+      if (hasComputedStringProperty && !findIndexInfo(indexInfos, stringType)) indexInfos.push(getObjectLiteralIndexInfo(readonlyComputedStringProperty, 0, allPropertySymbols, stringType));
+      if (hasComputedNumberProperty && !findIndexInfo(indexInfos, numberType)) indexInfos.push(getObjectLiteralIndexInfo(readonlyComputedNumberProperty, 0, allPropertySymbols, numberType));
+      if (hasComputedSymbolProperty && !findIndexInfo(indexInfos, esSymbolType)) indexInfos.push(getObjectLiteralIndexInfo(readonlyComputedSymbolProperty, 0, allPropertySymbols, esSymbolType));
       return indexInfos;
     }
     return emptyArray;
@@ -70411,7 +70498,7 @@ function createTypeChecker(host) {
   }
   function markJsxAliasReferenced(node) {
     if (!getJsxNamespaceContainerForImplicitImport(node)) {
-      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
+      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found : void 0;
       const jsxFactoryNamespace = getJsxNamespace(node);
       const jsxFactoryLocation = isJsxOpeningLikeElement(node) ? node.tagName : node;
       let jsxFactorySym;
@@ -72665,7 +72752,7 @@ function createTypeChecker(host) {
     const firstDecl = (_a = symbol.declarations) == null ? void 0 : _a[0];
     return isKnownSymbol(symbol) || firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name) && isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), 4096 /* ESSymbol */);
   }
-  function getObjectLiteralIndexInfo(node, offset, properties, keyType) {
+  function getObjectLiteralIndexInfo(isReadonly, offset, properties, keyType) {
     const propTypes = [];
     for (let i = offset; i < properties.length; i++) {
       const prop = properties[i];
@@ -72674,7 +72761,7 @@ function createTypeChecker(host) {
       }
     }
     const unionType = propTypes.length ? getUnionType(propTypes, 2 /* Subtype */) : undefinedType;
-    return createIndexInfo(keyType, unionType, isConstContext(node));
+    return createIndexInfo(keyType, unionType, isReadonly);
   }
   function getImmediateAliasedSymbol(symbol) {
     Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here.");
@@ -72837,9 +72924,10 @@ function createTypeChecker(host) {
     return createObjectLiteralType();
     function createObjectLiteralType() {
       const indexInfos = [];
-      if (hasComputedStringProperty) indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, stringType));
-      if (hasComputedNumberProperty) indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, numberType));
-      if (hasComputedSymbolProperty) indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, esSymbolType));
+      const isReadonly = isConstContext(node);
+      if (hasComputedStringProperty) indexInfos.push(getObjectLiteralIndexInfo(isReadonly, offset, propertiesArray, stringType));
+      if (hasComputedNumberProperty) indexInfos.push(getObjectLiteralIndexInfo(isReadonly, offset, propertiesArray, numberType));
+      if (hasComputedSymbolProperty) indexInfos.push(getObjectLiteralIndexInfo(isReadonly, offset, propertiesArray, esSymbolType));
       const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, indexInfos);
       result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
       if (isJSObjectLiteral) {
@@ -73120,7 +73208,7 @@ function createTypeChecker(host) {
       return void 0;
     }
     const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1 /* Classic */;
-    const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
+    const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_nodenext_or_to_add_aliases_to_the_paths_option : Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed;
     const specifier = getJSXRuntimeImportSpecifier(file, runtimeImportSpecifier);
     const mod = resolveExternalModule(specifier || location, runtimeImportSpecifier, errorMessage, location);
     const result = mod && mod !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod)) : void 0;
@@ -76484,9 +76572,17 @@ function createTypeChecker(host) {
     if (exprType === silentNeverType || isErrorType(exprType) || !some(typeArguments)) {
       return exprType;
     }
+    const links = getNodeLinks(node);
+    if (!links.instantiationExpressionTypes) {
+      links.instantiationExpressionTypes = /* @__PURE__ */ new Map();
+    }
+    if (links.instantiationExpressionTypes.has(exprType.id)) {
+      return links.instantiationExpressionTypes.get(exprType.id);
+    }
     let hasSomeApplicableSignature = false;
     let nonApplicableType;
     const result = getInstantiatedType(exprType);
+    links.instantiationExpressionTypes.set(exprType.id, result);
     const errorType2 = hasSomeApplicableSignature ? nonApplicableType : exprType;
     if (errorType2) {
       diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType2)));
@@ -79955,15 +80051,17 @@ function createTypeChecker(host) {
     if (indexSymbol == null ? void 0 : indexSymbol.declarations) {
       const indexSignatureMap = /* @__PURE__ */ new Map();
       for (const declaration of indexSymbol.declarations) {
-        if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
-          forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => {
-            const entry = indexSignatureMap.get(getTypeId(type));
-            if (entry) {
-              entry.declarations.push(declaration);
-            } else {
-              indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] });
-            }
-          });
+        if (isIndexSignatureDeclaration(declaration)) {
+          if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
+            forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => {
+              const entry = indexSignatureMap.get(getTypeId(type));
+              if (entry) {
+                entry.declarations.push(declaration);
+              } else {
+                indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] });
+              }
+            });
+          }
         }
       }
       indexSignatureMap.forEach((entry) => {
@@ -84537,6 +84635,7 @@ function createTypeChecker(host) {
       grammarErrorOnFirstToken(node, Diagnostics.An_import_declaration_cannot_have_modifiers);
     }
     if (checkExternalImportOrExportDeclaration(node)) {
+      let resolvedModule;
       const importClause = node.importClause;
       if (importClause && !checkGrammarImportClause(importClause)) {
         if (importClause.name) {
@@ -84549,18 +84648,27 @@ function createTypeChecker(host) {
               checkExternalEmitHelpers(node, 65536 /* ImportStar */);
             }
           } else {
-            const moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier);
-            if (moduleExisted) {
+            resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
+            if (resolvedModule) {
               forEach(importClause.namedBindings.elements, checkImportBinding);
             }
           }
         }
+        if (isOnlyImportableAsDefault(node.moduleSpecifier, resolvedModule) && !hasTypeJsonImportAttribute(node)) {
+          error(node.moduleSpecifier, Diagnostics.Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0, ModuleKind[moduleKind]);
+        }
       } else if (noUncheckedSideEffectImports && !importClause) {
         void resolveExternalModuleName(node, node.moduleSpecifier);
       }
     }
     checkImportAttributes(node);
   }
+  function hasTypeJsonImportAttribute(node) {
+    return !!node.attributes && node.attributes.elements.some((attr) => {
+      var _a;
+      return getTextOfIdentifierOrLiteral(attr.name) === "type" && ((_a = tryCast(attr.value, isStringLiteralLike)) == null ? void 0 : _a.text) === "json";
+    });
+  }
   function checkImportEqualsDeclaration(node) {
     if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
       return;
@@ -85677,7 +85785,7 @@ function createTypeChecker(host) {
       } else if (isJSDocMemberName(name)) {
         return resolveJSDocMemberName(name);
       }
-    } else if (isTypeReferenceIdentifier(name)) {
+    } else if (isEntityName(name) && isTypeReferenceIdentifier(name)) {
       const meaning = name.parent.kind === 183 /* TypeReference */ ? 788968 /* Type */ : 1920 /* Namespace */;
       const symbol = resolveEntityName(
         name,
@@ -86871,7 +86979,29 @@ function createTypeChecker(host) {
         return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, internalFlags, tracker);
       },
       isImportRequiredByAugmentation,
-      isDefinitelyReferenceToGlobalSymbolObject
+      isDefinitelyReferenceToGlobalSymbolObject,
+      createLateBoundIndexSignatures: (cls, enclosing, flags, internalFlags, tracker) => {
+        const sym = cls.symbol;
+        const staticInfos = getIndexInfosOfType(getTypeOfSymbol(sym));
+        const instanceIndexSymbol = getIndexSymbol(sym);
+        const instanceInfos = instanceIndexSymbol && getIndexInfosOfIndexSymbol(instanceIndexSymbol, arrayFrom(getMembersOfSymbol(sym).values()));
+        let result;
+        for (const infoList of [staticInfos, instanceInfos]) {
+          if (!length(infoList)) continue;
+          result || (result = []);
+          for (const info of infoList) {
+            if (info.declaration) continue;
+            const node = nodeBuilder.indexInfoToIndexSignatureDeclaration(info, enclosing, flags, internalFlags, tracker);
+            if (node && infoList === staticInfos) {
+              (node.modifiers || (node.modifiers = factory.createNodeArray())).unshift(factory.createModifier(126 /* StaticKeyword */));
+            }
+            if (node) {
+              result.push(node);
+            }
+          }
+        }
+        return result;
+      }
     };
     function isImportRequiredByAugmentation(node) {
       const file = getSourceFileOfNode(node);
@@ -113356,7 +113486,8 @@ function transformDeclarations(context) {
             void 0
           )
         ] : void 0;
-        const memberNodes = concatenate(concatenate(privateIdentifier, parameterProperties), visitNodes2(input.members, visitDeclarationSubtree, isClassElement));
+        const lateIndexes = resolver.createLateBoundIndexSignatures(input, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+        const memberNodes = concatenate(concatenate(concatenate(privateIdentifier, lateIndexes), parameterProperties), visitNodes2(input.members, visitDeclarationSubtree, isClassElement));
         const members = factory2.createNodeArray(memberNodes);
         const extendsClause = getEffectiveBaseTypeNode(input);
         if (extendsClause && !isEntityNameExpression(extendsClause.expression) && extendsClause.expression.kind !== 106 /* NullKeyword */) {
@@ -114661,7 +114792,8 @@ var notImplementedResolver = {
   isBindingCapturedByNode: notImplemented,
   getDeclarationStatementsForSourceFile: notImplemented,
   isImportRequiredByAugmentation: notImplemented,
-  isDefinitelyReferenceToGlobalSymbolObject: notImplemented
+  isDefinitelyReferenceToGlobalSymbolObject: notImplemented,
+  createLateBoundIndexSignatures: notImplemented
 };
 var createPrinterWithDefaults = /* @__PURE__ */ memoize(() => createPrinter({}));
 var createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true }));
@@ -120815,7 +120947,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     return (_a2 = resolvedTypeReferenceDirectiveNames == null ? void 0 : resolvedTypeReferenceDirectiveNames.get(file.path)) == null ? void 0 : _a2.get(typeDirectiveName, mode);
   }
   function getResolvedTypeReferenceDirectiveFromTypeReferenceDirective(typeRef, sourceFile) {
-    return getResolvedTypeReferenceDirective(sourceFile, typeRef.fileName, typeRef.resolutionMode || sourceFile.impliedNodeFormat);
+    return getResolvedTypeReferenceDirective(
+      sourceFile,
+      typeRef.fileName,
+      getModeForTypeReferenceDirectiveInFile(typeRef, sourceFile)
+    );
   }
   function forEachResolvedModule(callback, file) {
     forEachResolution(resolvedModules, callback, file);
@@ -121202,10 +121338,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       const moduleNames = getModuleNames(newSourceFile);
       const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
       (resolvedModulesProcessing ?? (resolvedModulesProcessing = /* @__PURE__ */ new Map())).set(newSourceFile.path, resolutions);
+      const optionsForFile = getCompilerOptionsForFile(newSourceFile);
       const resolutionsChanged = hasChangesInResolutions(
         moduleNames,
         resolutions,
-        (name) => oldProgram.getResolvedModule(newSourceFile, name.text, getModeForUsageLocation2(newSourceFile, name)),
+        (name) => oldProgram.getResolvedModule(newSourceFile, name.text, getModeForUsageLocationWorker(newSourceFile, name, optionsForFile)),
         moduleResolutionIsEqualTo
       );
       if (resolutionsChanged) structureIsReused = 1 /* SafeModules */;
@@ -121215,7 +121352,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       const typeReferenceResolutionsChanged = hasChangesInResolutions(
         typesReferenceDirectives,
         typeReferenceResolutions,
-        (name) => oldProgram.getResolvedTypeReferenceDirective(newSourceFile, getTypeReferenceResolutionName(name), getModeForFileReference(name, newSourceFile.impliedNodeFormat)),
+        (name) => oldProgram.getResolvedTypeReferenceDirective(
+          newSourceFile,
+          getTypeReferenceResolutionName(name),
+          getModeForTypeReferenceDirectiveInFile(name, newSourceFile)
+        ),
         typeDirectiveIsEqualTo
       );
       if (typeReferenceResolutionsChanged) structureIsReused = 1 /* SafeModules */;
@@ -122376,8 +122517,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       const ref = file.typeReferenceDirectives[index];
       const resolvedTypeReferenceDirective = resolutions[index];
       const fileName = ref.fileName;
-      resolutionsInFile.set(fileName, getModeForFileReference(ref, file.impliedNodeFormat), resolvedTypeReferenceDirective);
-      const mode = ref.resolutionMode || getDefaultResolutionModeForFile2(file);
+      const mode = getModeForTypeReferenceDirectiveInFile(ref, file);
+      resolutionsInFile.set(fileName, mode, resolvedTypeReferenceDirective);
       processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });
     }
   }
@@ -123421,6 +123562,9 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   function shouldTransformImportCall(sourceFile) {
     return shouldTransformImportCallWorker(sourceFile, getCompilerOptionsForFile(sourceFile));
   }
+  function getModeForTypeReferenceDirectiveInFile(ref, sourceFile) {
+    return ref.resolutionMode || getDefaultResolutionModeForFile2(sourceFile);
+  }
 }
 function shouldTransformImportCallWorker(sourceFile, options) {
   const moduleKind = getEmitModuleKind(options);

package/lib/typescript.d.ts

@@ -6140,7 +6140,7 @@ declare namespace ts {
         getPrivateIdentifierPropertyOfType(leftType: Type, name: string, location: Node): Symbol | undefined;
         getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined;
         getIndexInfosOfType(type: Type): readonly IndexInfo[];
-        getIndexInfosOfIndexSymbol: (indexSymbol: Symbol) => IndexInfo[];
+        getIndexInfosOfIndexSymbol: (indexSymbol: Symbol, siblingSymbols?: Symbol[] | undefined) => IndexInfo[];
         getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[];
         getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined;
         getBaseTypes(type: InterfaceType): BaseType[];