@artel/artc 0.6.25215 → 0.6.25217

package/build/api/ApiServices.js

@@ -182,7 +182,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-DZ66PBHU.js";
+} from "../chunk-TXAEJ2GI.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -302,7 +302,7 @@ var AddPropertyAssignmentService = class {
     let result;
     let leftValueText;
     if (propertyName !== void 0) {
-      if (assignmentNode.left.kind !== 79 /* PropertyAccessExpression */) {
+      if (assignmentNode.left.kind !== 78 /* PropertyAccessExpression */) {
         return void 0;
       }
       const propertyReceiver = assignmentNode.left.expression;
@@ -367,19 +367,19 @@ var AddPropertyAssignmentService = class {
       case 56 /* TypeVariableSetterDeclaration */:
       case 58 /* NestedMethodDeclaration */:
       case 67 /* MethodBlockLiteral */:
-      case 75 /* MethodLiteral */:
+      case 74 /* MethodLiteral */:
       case 53 /* OperatorDeclaration */:
         return void 0;
-      case 99 /* RunStatement */:
+      case 98 /* RunStatement */:
         return this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(parent);
-      case 100 /* OnErrorClause */:
-      case 102 /* FinallyClause */:
-      case 107 /* ForStatement */:
-      case 108 /* IfStatement */:
-      case 110 /* ElseIfClause */:
-      case 114 /* LoopStatement */:
-      case 119 /* SwitchStatementCaseClause */:
-      case 120 /* WhileStatement */:
+      case 99 /* OnErrorClause */:
+      case 101 /* FinallyClause */:
+      case 106 /* ForStatement */:
+      case 107 /* IfStatement */:
+      case 109 /* ElseIfClause */:
+      case 113 /* LoopStatement */:
+      case 118 /* SwitchStatementCaseClause */:
+      case 119 /* WhileStatement */:
         return this.getContainingSubprogram(parent)?.body;
       default:
         Debug.never(parent);
@@ -414,7 +414,7 @@ function isSubprogramDeclaration(node) {
     case 56 /* TypeVariableSetterDeclaration */:
     case 58 /* NestedMethodDeclaration */:
     case 67 /* MethodBlockLiteral */:
-    case 75 /* MethodLiteral */:
+    case 74 /* MethodLiteral */:
       return true;
     default:
       Debug.typeIsAssignableTo();
@@ -2032,19 +2032,19 @@ var SyntaxToCode = class _SyntaxToCode {
       [54 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
       [55 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
       [56 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
-      [94 /* StatementBlock */]: this.prototype.writeStatementBlock,
-      [133 /* QualifiedName */]: this.prototype.writeQualifiedName,
-      [140 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
-      [141 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
-      [142 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [143 /* CallArgument */]: this.prototype.writeCallArgument,
-      [145 /* Tag */]: this.prototype.writeTag,
-      [147 /* Modifier */]: this.prototype.writeModifier,
-      [148 /* ParameterClause */]: this.prototype.writeParameterClause,
-      [149 /* ParameterList */]: this.prototype.writeParameterList,
-      [150 /* SetterParameterClause */]: this.prototype.writeSetterParameterClause,
-      [152 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [154 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [93 /* StatementBlock */]: this.prototype.writeStatementBlock,
+      [132 /* QualifiedName */]: this.prototype.writeQualifiedName,
+      [139 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
+      [140 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
+      [141 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
+      [142 /* CallArgument */]: this.prototype.writeCallArgument,
+      [144 /* Tag */]: this.prototype.writeTag,
+      [146 /* Modifier */]: this.prototype.writeModifier,
+      [147 /* ParameterClause */]: this.prototype.writeParameterClause,
+      [148 /* ParameterList */]: this.prototype.writeParameterList,
+      [149 /* SetterParameterClause */]: this.prototype.writeSetterParameterClause,
+      [151 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [153 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
       [17 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
       [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
       [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
@@ -2075,79 +2075,78 @@ var SyntaxToCode = class _SyntaxToCode {
       [68 /* CallArgumentList */]: this.prototype.writeNodeDefault,
       [69 /* CallExpression */]: this.prototype.writeNodeDefault,
       [70 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
-      [71 /* IndexedAccessArgumentList */]: this.prototype.writeNodeDefault,
-      [72 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
-      [73 /* InvalidExpression */]: this.prototype.writeNodeDefault,
-      [74 /* IsExpression */]: this.prototype.writeNodeDefault,
-      [75 /* MethodLiteral */]: this.prototype.writeNodeDefault,
-      [76 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
-      [77 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
-      [78 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
-      [79 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
-      [80 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
-      [81 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
-      [82 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
-      [83 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
-      [84 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
-      [85 /* TokenExpression */]: this.prototype.writeNodeDefault,
-      [86 /* KeywordExpression */]: this.prototype.writeNodeDefault,
-      [87 /* ObjectExpression */]: this.prototype.writeNodeDefault,
-      [88 /* BaseExpression */]: this.prototype.writeNodeDefault,
-      [89 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
-      [90 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
-      [91 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
-      [92 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
-      [93 /* StatementList */]: this.prototype.writeNodeDefault,
-      [95 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
-      [96 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
-      [97 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [98 /* RunStatementClauseList */]: this.prototype.writeNodeDefault,
-      [99 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [100 /* OnErrorClause */]: this.prototype.writeNodeDefault,
-      [101 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [102 /* FinallyClause */]: this.prototype.writeNodeDefault,
-      [103 /* EmptyStatement */]: this.prototype.writeNodeDefault,
-      [104 /* ErrorStatement */]: this.prototype.writeNodeDefault,
-      [105 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
-      [106 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
-      [107 /* ForStatement */]: this.prototype.writeNodeDefault,
-      [108 /* IfStatement */]: this.prototype.writeNodeDefault,
-      [109 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
-      [110 /* ElseIfClause */]: this.prototype.writeNodeDefault,
-      [111 /* InvalidStatement */]: this.prototype.writeNodeDefault,
-      [112 /* NestedMethodDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [113 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [114 /* LoopStatement */]: this.prototype.writeNodeDefault,
-      [115 /* ReturnStatement */]: this.prototype.writeNodeDefault,
-      [116 /* CaseClauseList */]: this.prototype.writeNodeDefault,
-      [117 /* SwitchStatement */]: this.prototype.writeNodeDefault,
-      [118 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
-      [119 /* SwitchStatementCaseClause */]: this.prototype.writeNodeDefault,
-      [120 /* WhileStatement */]: this.prototype.writeNodeDefault,
-      [121 /* YieldStatement */]: this.prototype.writeNodeDefault,
-      [122 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
-      [123 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
-      [124 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
-      [125 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
-      [126 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
-      [127 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
-      [128 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
-      [129 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
-      [130 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
-      [131 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
-      [132 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
-      [134 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
-      [135 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
-      [136 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
-      [137 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
-      [138 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [139 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [144 /* TagList */]: this.prototype.writeNodeDefault,
-      [146 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [151 /* SetterParameterDeclaration */]: this.prototype.writeNodeDefault,
-      [153 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [155 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [156 /* TypeAnnotation */]: this.prototype.writeNodeDefault
+      [71 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
+      [72 /* InvalidExpression */]: this.prototype.writeNodeDefault,
+      [73 /* IsExpression */]: this.prototype.writeNodeDefault,
+      [74 /* MethodLiteral */]: this.prototype.writeNodeDefault,
+      [75 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
+      [76 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
+      [77 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [78 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
+      [79 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
+      [80 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
+      [81 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [82 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [83 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [84 /* TokenExpression */]: this.prototype.writeNodeDefault,
+      [85 /* KeywordExpression */]: this.prototype.writeNodeDefault,
+      [86 /* ObjectExpression */]: this.prototype.writeNodeDefault,
+      [87 /* BaseExpression */]: this.prototype.writeNodeDefault,
+      [88 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
+      [89 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
+      [90 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
+      [91 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
+      [92 /* StatementList */]: this.prototype.writeNodeDefault,
+      [94 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
+      [95 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
+      [96 /* DisposeStatement */]: this.prototype.writeNodeDefault,
+      [97 /* RunStatementClauseList */]: this.prototype.writeNodeDefault,
+      [98 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [99 /* OnErrorClause */]: this.prototype.writeNodeDefault,
+      [100 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [101 /* FinallyClause */]: this.prototype.writeNodeDefault,
+      [102 /* EmptyStatement */]: this.prototype.writeNodeDefault,
+      [103 /* ErrorStatement */]: this.prototype.writeNodeDefault,
+      [104 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
+      [105 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
+      [106 /* ForStatement */]: this.prototype.writeNodeDefault,
+      [107 /* IfStatement */]: this.prototype.writeNodeDefault,
+      [108 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
+      [109 /* ElseIfClause */]: this.prototype.writeNodeDefault,
+      [110 /* InvalidStatement */]: this.prototype.writeNodeDefault,
+      [111 /* NestedMethodDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [112 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [113 /* LoopStatement */]: this.prototype.writeNodeDefault,
+      [114 /* ReturnStatement */]: this.prototype.writeNodeDefault,
+      [115 /* CaseClauseList */]: this.prototype.writeNodeDefault,
+      [116 /* SwitchStatement */]: this.prototype.writeNodeDefault,
+      [117 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
+      [118 /* SwitchStatementCaseClause */]: this.prototype.writeNodeDefault,
+      [119 /* WhileStatement */]: this.prototype.writeNodeDefault,
+      [120 /* YieldStatement */]: this.prototype.writeNodeDefault,
+      [121 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
+      [122 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
+      [123 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
+      [124 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
+      [125 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
+      [126 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
+      [127 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
+      [128 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
+      [129 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
+      [130 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
+      [131 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
+      [133 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
+      [134 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
+      [135 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
+      [136 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
+      [137 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [138 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [143 /* TagList */]: this.prototype.writeNodeDefault,
+      [145 /* ModifierList */]: this.prototype.writeNodeDefault,
+      [150 /* SetterParameterDeclaration */]: this.prototype.writeNodeDefault,
+      [152 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [154 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [155 /* TypeAnnotation */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2333,7 +2332,7 @@ var TranslationsGenerationService = class {
       return void 0;
     }
     let result;
-    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 137 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
+    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 136 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2379,7 +2378,7 @@ var TranslationsGenerationService = class {
       return false;
     }
     const generator = new TranslationsGenerator(analyzer, sourceFile, translationPackage, sourceFile.package.dialect);
-    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 137 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
+    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 136 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
 var TranslationsGenerator = class _TranslationsGenerator {
@@ -2406,7 +2405,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
       };
       const memberTranslationsCode = Query.from(memberEntities).mapAndFilter((m) => this.createPackageMemberTranslationNode(m)).uniqueWithComparator(compareNodes).map((n) => {
         const code = new SyntaxToCode(n, syntaxToCodeOptions).convert();
-        if (n.kind === 137 /* TypeTranslation */) {
+        if (n.kind === 136 /* TypeTranslation */) {
           const startOffset = Math.max(code.indexOf(newLine), 0);
           return this.addNewLineBeforeArrowsInTranslation(
             code,
@@ -2438,7 +2437,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
   generateMissingTranslationsForPartiallyTranslatedTypes(translationsDeclaration) {
     const result = new Array();
     for (const translation of translationsDeclaration.translationList.translationDeclarations) {
-      if (translation.kind === 137 /* TypeTranslation */) {
+      if (translation.kind === 136 /* TypeTranslation */) {
         const edits = this.generateMissingTypeMemberTranslations(translation);
         if (edits !== void 0) {
           result.push(...edits);
@@ -2546,13 +2545,13 @@ var TranslationsGenerator = class _TranslationsGenerator {
   }
   detectIndentationStepForTypeMemberTranslations(node) {
     let indentationStepSize;
-    if (node.kind === 137 /* TypeTranslation */) {
+    if (node.kind === 136 /* TypeTranslation */) {
       indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(node, this._sourceFile);
     }
     if (indentationStepSize === void 0) {
       const translationsDeclarations = node.kind === 21 /* TranslationsDeclaration */ ? node : node.parent.parent;
       for (const member of translationsDeclarations.translationList.translationDeclarations) {
-        if (member.kind === 137 /* TypeTranslation */) {
+        if (member.kind === 136 /* TypeTranslation */) {
           indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(member, this._sourceFile);
           if (indentationStepSize !== void 0) {
             break;
@@ -2740,7 +2739,7 @@ var CodeActionsService = class {
     }
     const result = new Array();
     const diagnosticCodeSet = new Set(diagnosticCodes);
-    if (diagnosticCodeSet.has(103 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(104 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
+    if (diagnosticCodeSet.has(104 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(105 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
       const data = { onlyTypeMembers: false };
       result.push(CodeAction.unresolved(
         "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u044B.",
@@ -2799,56 +2798,38 @@ function isGenerateMissingTranslationsCodeActionData(value) {
 
 // source/services/signature-help/SignatureWithValueParameters.ts
 var ValueArgumentFactory = class _ValueArgumentFactory {
-  static {
-    this.createValueArgumentFromCallArgument = (argument) => new ValueArgument(argument.name?.value, argument.value);
-  }
-  static {
-    this.createValueArgumentFromIndexerArgument = (argument) => new ValueArgument(void 0, argument);
-  }
   static createValueArgumentsOfCallExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromListElement(
-      node.callArgumentList.elements,
-      _ValueArgumentFactory.createValueArgumentFromCallArgument
-    );
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.callArgumentList);
   }
   static createValueArgumentsOfAutotypeCallExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromListElement(
-      node.callArgumentList.elements,
-      _ValueArgumentFactory.createValueArgumentFromCallArgument
-    );
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.callArgumentList);
   }
   static createValueArgumentsOfIndexedAccessExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromListElement(
-      node.argumentsList.elements,
-      _ValueArgumentFactory.createValueArgumentFromIndexerArgument
-    );
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentsList);
   }
   static createValueArgumentsOfTag(node) {
     if (node.callArgumentList !== void 0) {
-      return _ValueArgumentFactory.createValueArgumentsFromListElement(
-        node.callArgumentList.elements,
-        _ValueArgumentFactory.createValueArgumentFromCallArgument
-      );
+      return _ValueArgumentFactory.createValueArgumentsFromList(node.callArgumentList);
     }
     return [];
   }
-  static createValueArgumentsFromListElement(elements, createValueArgument) {
+  static createValueArgumentsFromList(list) {
     const result = new Array();
     let previousElementIsArgument = false;
-    for (const element of elements) {
+    for (const element of list.elements) {
       if (element.kind === 0 /* Token */) {
         if (!previousElementIsArgument) {
           result.push(new ValueArgument(void 0, void 0));
         }
         previousElementIsArgument = false;
       } else {
-        result.push(createValueArgument(element));
+        result.push(new ValueArgument(element.name?.value, element.value));
         previousElementIsArgument = true;
       }
     }
-    if (elements.length > 0 && elements[elements.length - 1].kind === 0 /* Token */) {
+    if (list.elements.length > 0 && list.elements[list.elements.length - 1].kind === 0 /* Token */) {
       result.push(new ValueArgument(void 0, void 0));
-    } else if (elements.length === 0) {
+    } else if (list.elements.length === 0) {
       result.push(new ValueArgument(void 0, void 0));
     }
     return result;
@@ -2861,9 +2842,9 @@ var SignatureForNode = class _SignatureForNode {
         return _SignatureForNode.getSignaturesForCallExpression(analyzer, node);
       case 70 /* AutotypeCallExpression */:
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
-      case 72 /* IndexedAccessExpression */:
+      case 71 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
-      case 145 /* Tag */:
+      case 144 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
       default:
         Debug.never(node);
@@ -2916,22 +2897,21 @@ var SignatureForNode = class _SignatureForNode {
     return void 0;
   }
   static getSignaturesForIndexedAccessExpression(analyzer, node) {
-    const meaning = analyzer.getIndexedAccessExpressionMeaning(node);
-    let indexer;
+    const meaning = analyzer.resolveIndexedAccessExpression(node).meaning;
     switch (meaning.kind) {
-      case "resolved":
-        indexer = meaning.indexer;
-        break;
+      case "resolved": {
+        let suitableSignatureIndex;
+        if (meaning.singleSuitableIndexer !== void 0) {
+          suitableSignatureIndex = meaning.candidates.indexOf(meaning.singleSuitableIndexer);
+        }
+        const signatures = meaning.candidates.map((i) => new IndexerSignature(i));
+        return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
+      }
       case "unresolved":
-        break;
+        return void 0;
       default:
         Debug.never(meaning);
     }
-    if (indexer !== void 0) {
-      const signature = new IndexerSignature(indexer);
-      return new SignaturesWithSingleSuitable([signature], 0);
-    }
-    return void 0;
   }
   static getSignaturesForTag(analyzer, node) {
     const meaning = analyzer.getTagMeaning(node);
@@ -3003,7 +2983,7 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         result = false;
         break;
       }
-      if (argument.expression === void 0 || argument.expression.kind === 73 /* InvalidExpression */) {
+      if (argument.expression === void 0 || argument.expression.kind === 72 /* InvalidExpression */) {
         continue;
       }
       const targetParameterType = targetParameter.getType();
@@ -3297,7 +3277,7 @@ var CompletionService = class {
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || this.tokenOrKeywordIsPackageImportListChild(tokenOrKeyword)) {
       return new PackageImportCompletionContext([], void 0);
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 79 /* PropertyAccessExpression */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 78 /* PropertyAccessExpression */) {
       const propertyAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(propertyAccess.expression);
@@ -3338,7 +3318,7 @@ var CompletionService = class {
         typeExtensionLookup
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 133 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 132 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
       const namedTypeSpecifier = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveNamedTypeSpecifier(namedTypeSpecifier);
       const segmentIndex = Math.floor(
@@ -3346,7 +3326,7 @@ var CompletionService = class {
       );
       if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
         let completionInIsOrAsExpressionInfo;
-        if (namedTypeSpecifier.parent.kind === 74 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
+        if (namedTypeSpecifier.parent.kind === 73 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
           completionInIsOrAsExpressionInfo = {
             expressionType: this._analyzer.type.ofExpression(namedTypeSpecifier.parent.expression)
           };
@@ -3382,7 +3362,7 @@ var CompletionService = class {
     }
     if (syntaxContext.isUnqualifiedTypeContext !== void 0) {
       let completionInIsOrAsExpressionInfo;
-      if (tokenOrKeyword.parent.kind === 74 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+      if (tokenOrKeyword.parent.kind === 73 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
         completionInIsOrAsExpressionInfo = {
           expressionType: this._analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
@@ -3432,17 +3412,17 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 132 /* PackageImportTranslation */) {
+    if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 131 /* PackageImportTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(15 /* Type */) && (tokenOrKeyword.parent.kind === 137 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 131 /* MethodTypeTranslation */)) {
+    if (tokenOrKeyword.isKeyword(15 /* Type */) && (tokenOrKeyword.parent.kind === 136 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 130 /* MethodTypeTranslation */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 129 /* PackageMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 128 /* PackageMethodTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3462,9 +3442,9 @@ var CompletionService = class {
         hasPrecedingKeyword
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 133 /* QualifiedName */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 132 /* QualifiedName */) {
       const qualifiedName = tokenOrKeyword.parent;
-      if (qualifiedName.parent.kind === 132 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
+      if (qualifiedName.parent.kind === 131 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
         const precedingSegmentNames = qualifiedName.qualifiers.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
         const sourceLocale = translationPackage.getTranslatedPackage().getLocale();
         return new PackageImportCompletionContext(precedingSegmentNames, { sourceLocale });
@@ -3489,12 +3469,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 130 /* TypeMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 129 /* TypeMethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 124 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 123 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3534,10 +3514,19 @@ var CompletionService = class {
             role.argumentList.parent
           );
           break;
-        case 145 /* Tag */:
+        case 144 /* Tag */:
           signatures = SignatureForNode.getSignaturesForTag(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(role.argumentList.parent);
           break;
+        case 71 /* IndexedAccessExpression */:
+          signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
+            this._analyzer,
+            role.argumentList.parent
+          );
+          valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(role.argumentList.parent);
+          break;
+        default:
+          Debug.never(role.argumentList.parent);
       }
       if (signatures !== void 0) {
         return this.getTargetTypesAndTargetSignaturesParametersFromSignatures(
@@ -3549,22 +3538,6 @@ var CompletionService = class {
         return { targetTypes: void 0, targetSignaturesParameters: void 0 };
       }
     }
-    if (role.kind === "indexed-access-argument") {
-      const signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
-        this._analyzer,
-        role.argumentList.parent
-      );
-      const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(role.argumentList.parent);
-      if (signatures !== void 0) {
-        return this.getTargetTypesAndTargetSignaturesParametersFromSignatures(
-          signatures.values,
-          valueArguments,
-          role.index
-        );
-      } else {
-        return { targetTypes: void 0, targetSignaturesParameters: void 0 };
-      }
-    }
     if (role.kind === "array-element") {
       let type = this._analyzer.type.ofExpression(role.array);
       type = this._analyzer.excludeNoneFromType(type);
@@ -3671,10 +3644,10 @@ var CompletionService = class {
     }
     const kinds = /* @__PURE__ */ new Set();
     if (syntaxContext.isPackageMemberDeclarationListContext) {
-      kinds.add(17 /* Import */).add(7 /* Run */).add(28 /* Creation */).add(11 /* Function */).add(15 /* Type */).add(57 /* Get */).add(58 /* Set */).add(54 /* Translations */);
+      kinds.add(17 /* Import */).add(7 /* Run */).add(28 /* Creation */).add(11 /* Function */).add(16 /* Basic */).add(15 /* Type */).add(57 /* Get */).add(58 /* Set */).add(54 /* Translations */);
     }
     if (syntaxContext.isPackageMemberDeclarationListContext || syntaxContext.isTypeMemberDeclarationListContext) {
-      kinds.add(34 /* Hidden */).add(39 /* Static */).add(16 /* Basic */).add(36 /* Redefinable */).add(35 /* Abstract */).add(37 /* Redefined */).add(38 /* Async */).add(33 /* Const */);
+      kinds.add(34 /* Hidden */).add(39 /* Static */).add(36 /* Redefinable */).add(35 /* Abstract */).add(37 /* Redefined */).add(38 /* Async */).add(33 /* Const */);
     }
     if (syntaxContext.isTypeMemberDeclarationListContext) {
       kinds.add(28 /* Creation */).add(11 /* Function */).add(46 /* Destruction */).add(57 /* Get */).add(58 /* Set */);
@@ -3724,7 +3697,7 @@ var CompletionService = class {
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
       kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(11 /* Function */).add(38 /* Async */);
     }
-    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(38 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 75 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* MethodTypeDeclarationBody */)) {
+    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(38 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 74 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* MethodTypeDeclarationBody */)) {
       kinds.add(11 /* Function */);
     }
     return Query.from(kinds.values()).map(
@@ -3736,28 +3709,28 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 114 /* LoopStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 113 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 147 /* Modifier */;
+    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 146 /* Modifier */;
   }
   isElseOrElseIfKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 108 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.thenBlock || tokenOrKeyword.parent.parent.kind === 110 /* ElseIfClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 107 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.thenBlock || tokenOrKeyword.parent.parent.kind === 109 /* ElseIfClause */);
   }
   isRunStatementAccessorListContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 99 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* OnErrorClause */ || tokenOrKeyword.parent.parent.kind === 102 /* FinallyClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 98 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 99 /* OnErrorClause */ || tokenOrKeyword.parent.parent.kind === 101 /* FinallyClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(57 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3774,10 +3747,10 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 119 /* SwitchStatementCaseClause */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 118 /* SwitchStatementCaseClause */) {
       return true;
     }
-    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 117 /* SwitchStatement */) {
+    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 116 /* SwitchStatement */) {
       return true;
     }
     return false;
@@ -4088,11 +4061,7 @@ var CompletionService = class {
   }
   getTopLevelAliasListCompletionItemInfos(ctx) {
     let result;
-    const displayService_ = new DisplayService(
-      this._analyzer,
-      new LocalizationContext([], ctx.sourceLocale),
-      this._dialect
-    );
+    const displayService_ = new DisplayService(this._analyzer, ctx.sourceLocale, this._dialect);
     if (ctx.translationKind === 1 /* PackageImport */) {
       let items;
       if (this._sourceFile.package.kind === "translation") {
@@ -4188,11 +4157,7 @@ var CompletionService = class {
   getTypeAliasMemberListItemInfos(ctx) {
     let result = Query.empty();
     if (ctx.typeEntity !== void 0) {
-      const displayService_ = new DisplayService(
-        this._analyzer,
-        new LocalizationContext([], ctx.sourceLocale),
-        this._dialect
-      );
+      const displayService_ = new DisplayService(this._analyzer, ctx.sourceLocale, this._dialect);
       if (ctx.translationKind === 1 /* Method */) {
         result = Query.from(ctx.typeEntity.getMembers().getNamedMembers()).mapAndFilter((m) => {
           if (m.kind === 5 /* Method */) {
@@ -4411,9 +4376,9 @@ function getRightmostChildExcludingValidEmptyNodes(node) {
 }
 function isInvalidNode(node) {
   switch (node.kind) {
-    case 73 /* InvalidExpression */:
+    case 72 /* InvalidExpression */:
     case 43 /* InvalidPackageMemberDeclaration */:
-    case 111 /* InvalidStatement */:
+    case 110 /* InvalidStatement */:
     case 57 /* InvalidTypeMemberDeclaration */:
     case 16 /* InvalidTypeSpecifier */:
       return true;
@@ -5199,13 +5164,6 @@ var ExpressionRole_callArgument = class {
     this.kind = "call-argument";
   }
 };
-var ExpressionRole_indexedAccessArgument = class {
-  constructor(argumentList, index) {
-    this.argumentList = argumentList;
-    this.index = index;
-    this.kind = "indexed-access-argument";
-  }
-};
 var ExpressionRole_arrayElement = class {
   constructor(array) {
     this.array = array;
@@ -5284,7 +5242,7 @@ var SyntaxContextFactory = class {
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(57 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5300,24 +5258,24 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 142 /* ParameterDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 141 /* ParameterDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 143 /* CallArgument */) {
+      if (tokenOrKeyword.parent.kind === 142 /* CallArgument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 140 /* VariantDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 139 /* VariantDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 78 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5325,11 +5283,11 @@ var SyntaxContextFactory = class {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 82 /* TextTemplateLiteral */) {
+    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 81 /* TextTemplateLiteral */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.spanList.spans.at(0)?.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 84 /* TextTemplateSpan */) {
+    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 83 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5341,18 +5299,18 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 93 /* StatementList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 92 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(44 /* OpenParenthesis */)) {
-      if (tokenOrKeyword.parent.kind === 76 /* ParenthesizedExpression */) {
+      if (tokenOrKeyword.parent.kind === 75 /* ParenthesizedExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 80 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 79 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5364,7 +5322,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_callArgument(tokenOrKeyword.parent.callArgumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 145 /* Tag */) {
+      if (tokenOrKeyword.parent.kind === 144 /* Tag */) {
         const callArgumentList = tokenOrKeyword.parent.callArgumentList;
         if (callArgumentList !== void 0) {
           const expressionRole = new ExpressionRole_callArgument(callArgumentList, 0);
@@ -5372,8 +5330,8 @@ var SyntaxContextFactory = class {
         }
       }
     }
-    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 72 /* IndexedAccessExpression */) {
-      const expressionRole = new ExpressionRole_indexedAccessArgument(tokenOrKeyword.parent.argumentsList, 0);
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+      const expressionRole = new ExpressionRole_callArgument(tokenOrKeyword.parent.argumentsList, 0);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 61 /* ArrayLiteral */) {
@@ -5395,21 +5353,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_callArgument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 71 /* IndexedAccessArgumentList */) {
-        const argumentList = tokenOrKeyword.parent;
-        let index = 0;
-        for (const element of argumentList.elements) {
-          if (element.kind === 0 /* Token */) {
-            index++;
-            if (element === tokenOrKeyword.value) {
-              break;
-            }
-          }
-        }
-        const expressionRole = new ExpressionRole_indexedAccessArgument(argumentList, index);
-        return { isExpressionContext: { expressionRole }, isStatementContext: false };
-      }
-      if (tokenOrKeyword.parent.kind === 118 /* MatchExpressionList */) {
+      if (tokenOrKeyword.parent.kind === 117 /* MatchExpressionList */) {
         const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5418,47 +5362,47 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(43 /* Case */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatementCaseClause */) {
+    if (tokenOrKeyword.isKeyword(43 /* Case */) && tokenOrKeyword.parent.kind === 118 /* SwitchStatementCaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Return */) && tokenOrKeyword.parent.kind === 115 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(14 /* Return */) && tokenOrKeyword.parent.kind === 114 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(42 /* Switch */) && tokenOrKeyword.parent.kind === 117 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(42 /* Switch */) && tokenOrKeyword.parent.kind === 116 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(12 /* If */) && tokenOrKeyword.parent.kind === 108 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(12 /* If */) && tokenOrKeyword.parent.kind === 107 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(10 /* ElseIf */) && tokenOrKeyword.parent.kind === 110 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(10 /* ElseIf */) && tokenOrKeyword.parent.kind === 109 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(8 /* From */) && tokenOrKeyword.parent.kind === 107 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(8 /* From */) && tokenOrKeyword.parent.kind === 106 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(23 /* While */) && tokenOrKeyword.parent.kind === 120 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(23 /* While */) && tokenOrKeyword.parent.kind === 119 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 114 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(25 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 113 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(26 /* Yield */) && tokenOrKeyword.parent.kind === 121 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(26 /* Yield */) && tokenOrKeyword.parent.kind === 120 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* When */) && tokenOrKeyword.parent.kind === 77 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isKeyword(27 /* When */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 77 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.secondExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5480,7 +5424,7 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 40 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 33 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 38 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 22 /* PackageAliasTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageMethodDeclaration */))) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageMethodDeclaration */))) {
       return true;
     }
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
@@ -5492,10 +5436,10 @@ var SyntaxContextFactory = class {
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 147 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 146 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 147 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 146 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5516,13 +5460,13 @@ var SyntaxContextFactory = class {
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
       51 /* TypeDereferencedVariableSetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 140 /* VariantDeclaration */)) {
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 139 /* VariantDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 147 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 146 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 147 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 146 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5559,7 +5503,7 @@ var SyntaxContextFactory = class {
     return result;
   }
   static isUnqualifiedTypeContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 156 /* TypeAnnotation */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 155 /* TypeAnnotation */) {
       return { allowsAnonymousTypes: true };
     }
     if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
@@ -5568,22 +5512,22 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isKeyword(15 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 152 /* TypeArgumentClause */) {
+    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 151 /* TypeArgumentClause */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */)) {
-      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */ };
+    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 152 /* TypeArgumentList */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 152 /* TypeArgumentList */ };
     }
-    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 145 /* Tag */) {
+    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 144 /* Tag */) {
       return { allowsAnonymousTypes: false };
     }
-    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 141 /* TypeParameterDeclaration */) {
+    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 140 /* TypeParameterDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
     if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 22 /* PackageAliasTypeDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(13 /* Is */) && tokenOrKeyword.parent.kind === 74 /* IsExpression */) {
+    if (tokenOrKeyword.isKeyword(13 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
     if (tokenOrKeyword.isKeyword(40 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
@@ -5603,32 +5547,32 @@ var SyntaxContextFactory = class {
     }
     const packageImport = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      132 /* PackageImportTranslation */
+      131 /* PackageImportTranslation */
     );
     if (packageImport !== void 0) {
       return { translationsDeclaration: packageImport.parent.parent };
     }
-    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 137 /* TypeTranslation */);
+    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 136 /* TypeTranslation */);
     if (type !== void 0) {
       return { translationsDeclaration: type.parent.parent };
     }
     const methodType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      131 /* MethodTypeTranslation */
+      130 /* MethodTypeTranslation */
     );
     if (methodType !== void 0) {
       return { translationsDeclaration: methodType.parent.parent };
     }
     const variable = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      134 /* PackageVariableTranslation */
+      133 /* PackageVariableTranslation */
     );
     if (variable !== void 0) {
       return { translationsDeclaration: variable.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      129 /* PackageMethodTranslation */
+      128 /* PackageMethodTranslation */
     );
     if (method !== void 0) {
       return { translationsDeclaration: method.parent.parent };
@@ -5636,33 +5580,33 @@ var SyntaxContextFactory = class {
     return void 0;
   }
   static isTypeMemberTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 136 /* TypeMemberTranslationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 135 /* TypeMemberTranslationList */) {
       return { typeTranslation: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 137 /* TypeTranslation */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 136 /* TypeTranslation */) {
       return { typeTranslation: tokenOrKeyword.parent };
     }
-    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 126 /* IndexerTranslation */);
+    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 125 /* IndexerTranslation */);
     if (indexer !== void 0) {
       return { typeTranslation: indexer.parent.parent };
     }
     const constructor = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      124 /* ConstructorTranslation */
+      123 /* ConstructorTranslation */
     );
     if (constructor !== void 0) {
       return { typeTranslation: constructor.parent.parent };
     }
     const variableOrVariant = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      135 /* TypeVariableOrVariantTranslation */
+      134 /* TypeVariableOrVariantTranslation */
     );
     if (variableOrVariant !== void 0) {
       return { typeTranslation: variableOrVariant.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      130 /* TypeMethodTranslation */
+      129 /* TypeMethodTranslation */
     );
     if (method !== void 0) {
       return { typeTranslation: method.parent.parent };
@@ -5777,27 +5721,27 @@ var NodeSemanticInfoService = class {
       return this.ofNonKeywordIdentifier(analyzer, tokenOrKeyword.value, options6);
     } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
       return this.ofAutotypeCallExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 78 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* TypeDereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* TypeDereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 81 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    } else if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* TypeConstructorDeclaration */) {
       return this.ofTypeConstructorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 91 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 90 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 87 /* ObjectExpression */) {
+    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 86 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(55 /* Base */) && tokenOrKeyword.parent.kind === 88 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(55 /* Base */) && tokenOrKeyword.parent.kind === 87 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options6);
     } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* TypeIndexerParameterClause */) {
       return this.ofTypeIndexerDeclaration(analyzer, tokenOrKeyword.parent.parent);
-    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 72 /* IndexedAccessExpression */) {
+    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     }
     return void 0;
@@ -5810,11 +5754,11 @@ var NodeSemanticInfoService = class {
     let result;
     const parent = node.parent;
     switch (parent.kind) {
-      case 127 /* TranslationTypeParameterList */:
+      case 126 /* TranslationTypeParameterList */:
         break;
-      case 122 /* TranslationParameterList */:
+      case 121 /* TranslationParameterList */:
         break;
-      case 143 /* CallArgument */: {
+      case 142 /* CallArgument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new SimpleWithLocalization(
@@ -5831,7 +5775,7 @@ var NodeSemanticInfoService = class {
       case 60 /* EnumerationVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofEnumerationVariableDeclaration(parent));
         break;
-      case 101 /* ErrorVariableDeclaration */:
+      case 100 /* ErrorVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofErrorVariableDeclaration(parent));
         break;
       case 22 /* PackageAliasTypeDeclaration */:
@@ -5852,7 +5796,7 @@ var NodeSemanticInfoService = class {
       case 38 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 89 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
       case 58 /* NestedMethodDeclaration */:
@@ -5861,10 +5805,10 @@ var NodeSemanticInfoService = class {
       case 59 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
         break;
-      case 133 /* QualifiedName */:
+      case 132 /* QualifiedName */:
         result = this.ofQualifiedNameQualifier(analyzer, parent, node, options6);
         break;
-      case 134 /* PackageVariableTranslation */: {
+      case 133 /* PackageVariableTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getPackageVariableTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5884,7 +5828,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 135 /* TypeVariableOrVariantTranslation */: {
+      case 134 /* TypeVariableOrVariantTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getTypeVariableOrVariantTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5908,7 +5852,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 129 /* PackageMethodTranslation */: {
+      case 128 /* PackageMethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getPackageMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5932,7 +5876,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 130 /* TypeMethodTranslation */: {
+      case 129 /* TypeMethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getTypeMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5956,7 +5900,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 137 /* TypeTranslation */: {
+      case 136 /* TypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5976,7 +5920,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 131 /* MethodTypeTranslation */: {
+      case 130 /* MethodTypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getMethodTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5996,7 +5940,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 142 /* ParameterDeclaration */:
+      case 141 /* ParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofParameterDeclaration(parent));
         break;
       case 8 /* PackageImport */:
@@ -6005,7 +5949,7 @@ var NodeSemanticInfoService = class {
       case 9 /* PackagePath */:
         result = void 0;
         break;
-      case 79 /* PropertyAccessExpression */:
+      case 78 /* PropertyAccessExpression */:
         result = this.ofProperty(analyzer, parent, options6);
         break;
       case 52 /* TypeMethodDeclaration */:
@@ -6017,10 +5961,10 @@ var NodeSemanticInfoService = class {
       case 54 /* TypeVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeVariableDeclaration(parent));
         break;
-      case 141 /* TypeParameterDeclaration */:
+      case 140 /* TypeParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeParameterDeclaration(parent));
         break;
-      case 140 /* VariantDeclaration */:
+      case 139 /* VariantDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofVariantDeclaration(parent));
         break;
       case 36 /* PackageVariableGetterDeclaration */:
@@ -6031,7 +5975,7 @@ var NodeSemanticInfoService = class {
       case 56 /* TypeVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedTypeVariableDeclaration(parent));
         break;
-      case 151 /* SetterParameterDeclaration */:
+      case 150 /* SetterParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofSetterParameterDeclaration(parent));
         break;
       case 3 /* Keyword */:
@@ -6185,7 +6129,7 @@ var NodeSemanticInfoService = class {
         return result;
       }
       case 42 /* ExtendedTypeClause */:
-      case 132 /* PackageImportTranslation */:
+      case 131 /* PackageImportTranslation */:
         return void 0;
       default:
         Debug.never(node.parent);
@@ -6312,19 +6256,28 @@ var NodeSemanticInfoService = class {
     return new DefinitionNodeSemanticInfo(entity);
   }
   static ofIndexedAccessExpressionOperator(analyzer, node, options6) {
-    const meaning = analyzer.getIndexedAccessExpressionMeaning(node);
+    const meaning = analyzer.resolveIndexedAccessExpression(node).meaning;
     if (meaning.kind === "resolved") {
-      const target = new SimpleWithLocalization(
-        new TypeIndexerReferenceTarget(meaning.indexer.value, meaning.access.kind),
-        meaning.indexer.localization
-      );
-      let result = new ReferenceNodeSemanticInfo([target], false);
-      if (options6.includeBetterReferenceTargets) {
+      let result;
+      if (isNonEmptyArray(meaning.suitableIndexers)) {
+        result = createIndexersReference(
+          meaning.suitableIndexers,
+          meaning.accessKind,
+          meaning.suitableIndexers.length > 1
+        );
+      } else if (isNonEmptyArray(meaning.candidates)) {
+        result = createIndexersReference(meaning.candidates, meaning.accessKind, true);
+      }
+      if (result !== void 0 && options6.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
       }
       return result;
     }
     return void 0;
+    function createIndexersReference(indexers, accessKind, isAmbiguous) {
+      const targets = indexers.map((i) => new SimpleWithLocalization(new TypeIndexerReferenceTarget(i.value, accessKind), i.localization));
+      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
+    }
   }
   static ofAssignmentStatementOperator(analyzer, node, options6) {
     const operatorKind = analyzer.getBinaryOperatorKindIfCompoundAssignmentOperator(node.operator);
@@ -6499,7 +6452,7 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 79 /* PropertyAccessExpression */) {
+    while (parent.kind === 78 /* PropertyAccessExpression */) {
       const meaning = analyzer.resolvePropertyAccessExpression(parent).meaning;
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
@@ -6540,7 +6493,7 @@ var NodeSemanticInfoService = class {
     let parentCallExpression;
     if (parent.kind === 69 /* CallExpression */) {
       parentCallExpression = parent;
-    } else if (parent.kind === 90 /* GenericSpecializationExpression */) {
+    } else if (parent.kind === 89 /* GenericSpecializationExpression */) {
       const grandParent = getParentSkippingParenthesizedExpressions(parent);
       if (grandParent.kind === 69 /* CallExpression */) {
         parentCallExpression = grandParent;
@@ -6792,7 +6745,7 @@ function getEntitySourceLocations(analyzer, entity) {
         case 18 /* AnonymousStructuredTypeDeclaration */:
         case 19 /* AnonymousVariantTypeDeclaration */:
         case 67 /* MethodBlockLiteral */:
-        case 75 /* MethodLiteral */:
+        case 74 /* MethodLiteral */:
           range = node.rangeWithoutTrivia;
           break;
         case 22 /* PackageAliasTypeDeclaration */:
@@ -6802,8 +6755,8 @@ function getEntitySourceLocations(analyzer, entity) {
         case 38 /* PackageVariantTypeDeclaration */:
         case 58 /* NestedMethodDeclaration */:
         case 52 /* TypeMethodDeclaration */:
-        case 141 /* TypeParameterDeclaration */:
-        case 140 /* VariantDeclaration */:
+        case 140 /* TypeParameterDeclaration */:
+        case 139 /* VariantDeclaration */:
         case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
@@ -7092,7 +7045,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 78 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 77 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -7136,7 +7089,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 81 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 80 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -7152,7 +7105,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 92 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 91 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -7180,7 +7133,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 87 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 86 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7192,7 +7145,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 88 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 87 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7216,7 +7169,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 72 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
+              if (node.kind === 71 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedAccessExpressionOperator(
                   analyzer,
                   node,
@@ -7589,9 +7542,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 89 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         return parent;
-      case 79 /* PropertyAccessExpression */:
+      case 78 /* PropertyAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7612,9 +7565,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 89 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         return true;
-      case 79 /* PropertyAccessExpression */:
+      case 78 /* PropertyAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7640,17 +7593,17 @@ var EvaluatableExpressionService = class {
         return { nameIdentifier: node.name };
       case 59 /* LocalVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 142 /* ParameterDeclaration */:
+      case 141 /* ParameterDeclaration */:
         return { nameIdentifier: node.name };
       case 52 /* TypeMethodDeclaration */:
         return { nameIdentifier: node.name };
       case 54 /* TypeVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 141 /* TypeParameterDeclaration */:
+      case 140 /* TypeParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 140 /* VariantDeclaration */:
+      case 139 /* VariantDeclaration */:
         return { nameIdentifier: node.name };
-      case 101 /* ErrorVariableDeclaration */:
+      case 100 /* ErrorVariableDeclaration */:
         return { nameIdentifier: node.name };
       default:
         return void 0;
@@ -8063,7 +8016,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 140 /* VariantDeclaration */: {
+        case 139 /* VariantDeclaration */: {
           result.push(
             this.createItem(
               9 /* Variant */,
@@ -8075,7 +8028,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 141 /* TypeParameterDeclaration */: {
+        case 140 /* TypeParameterDeclaration */: {
           result.push(
             this.createItem(
               18 /* TypeParameter */,
@@ -8307,7 +8260,7 @@ var SelectionRangeService = class {
       if (!this.nodeShouldBeSkipped(child) && !child.rangeWithoutTrivia.equals(result.range)) {
         result = new SelectionRange(child.rangeWithoutTrivia, result);
       }
-      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 82 /* TextTemplateLiteral */) {
+      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 81 /* TextTemplateLiteral */) {
         const textContentStart = child.rangeWithoutTrivia.start + 1;
         const textContentEnd = child.rangeWithoutTrivia.end - 1;
         if (offset >= textContentStart && offset < textContentEnd) {
@@ -8338,13 +8291,13 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 156 /* TypeAnnotation */:
+      case 155 /* TypeAnnotation */:
       case 34 /* StructuredTypeDeclarationBody */:
       case 39 /* VariantTypeDeclarationBody */:
       case 23 /* AliasTypeDeclarationBody */:
       case 29 /* MethodTypeDeclarationBody */:
-      case 84 /* TextTemplateSpan */:
-      case 83 /* TextTemplateSpanList */:
+      case 83 /* TextTemplateSpan */:
+      case 82 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8382,7 +8335,7 @@ var SemanticTokensService = class {
             controller.stopChildrenTraverse();
             return;
           }
-          if (node.kind === 89 /* IdentifierExpression */) {
+          if (node.kind === 88 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.value.getEntity();
@@ -8439,7 +8392,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 79 /* PropertyAccessExpression */) {
+          if (node.kind === 78 /* PropertyAccessExpression */) {
             const meaning = analyzer.resolvePropertyAccessExpression(node).meaning;
             if (meaning.kind === "variant-access") {
               result.push(
@@ -8480,7 +8433,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 140 /* VariantDeclaration */) {
+          if (node.kind === 139 /* VariantDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8664,7 +8617,7 @@ var TypeParameterSignatureHelpProvider = class {
     }
     let node = token.parent;
     while (node !== void 0) {
-      if (node.kind === 152 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
+      if (node.kind === 151 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
         const argumentIndex = this.getArgumentIndex(node.typeArgumentList, this._offset);
         const argumentCount = this.countArguments(node.typeArgumentList);
         return new NodeWithTypeArgumentsInfo(node.parent, argumentIndex, argumentCount);
@@ -8709,7 +8662,7 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 90 /* GenericSpecializationExpression */:
+      case 89 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
       default:
         Debug.never(node);
@@ -8727,7 +8680,7 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
-    if (expression.kind === 89 /* IdentifierExpression */) {
+    if (expression.kind === 88 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "method-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
@@ -8742,7 +8695,7 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 79 /* PropertyAccessExpression */) {
+    if (expression.kind === 78 /* PropertyAccessExpression */) {
       const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
       let accessedMethods;
       if (meaning.kind === "instance-method-access") {
@@ -9011,7 +8964,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 72 /* IndexedAccessExpression */: {
+        case 71 /* IndexedAccessExpression */: {
           if (this._offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentsList.elements, this._offset);
@@ -9019,7 +8972,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 145 /* Tag */: {
+        case 144 /* Tag */: {
           if (node.openParenthesisToken !== void 0 && this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && node.callArgumentList !== void 0 && (node.closeParenthesisToken === void 0 || node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const argumentIndex = this.getArgumentIndexInList(node.callArgumentList.elements, this._offset);
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(node);
@@ -9478,7 +9431,38 @@ var CompilationController = class extends ObservableObject2 {
     );
     const changeKind = checkTsInteropInputsChanged(newTsProgramLoaderInputs, this._tsProgramLoaderInputs);
     if (changeKind === 1 /* DependenciesOrRootUri */) {
-      this._tsInteropInputs = createNewTsInteropInputs(newTsProgramLoaderInputs, this.config.tsLibrariesProvider);
+      let tsInteropInputs;
+      let tsInteropInputsKey;
+      if (this.config.tsInteropInputsCache !== void 0) {
+        const cachedInputsInfo = this.config.tsInteropInputsCache.getTsInteropInputs(
+          newTsProgramLoaderInputs,
+          this.config.tsLibrariesProvider
+        );
+        if (cachedInputsInfo !== void 0) {
+          tsInteropInputs = cachedInputsInfo.inputs;
+          tsInteropInputsKey = cachedInputsInfo.key;
+        }
+      }
+      if (tsInteropInputs === void 0) {
+        tsInteropInputs = createNewTsInteropInputs(newTsProgramLoaderInputs, this.config.tsLibrariesProvider);
+        if (this.config.tsInteropInputsCache !== void 0) {
+          const cachedInputsInfo = this.config.tsInteropInputsCache.getOrAddTsInteropInputs(
+            newTsProgramLoaderInputs,
+            this.config.tsLibrariesProvider,
+            tsInteropInputs
+          );
+          tsInteropInputs = cachedInputsInfo.inputs;
+          tsInteropInputsKey = cachedInputsInfo.key;
+        }
+      }
+      this._tsInteropInputs = tsInteropInputs;
+      if (this.config.tsInteropInputsCache !== void 0) {
+        const previousTsInteropInputsKey = this._tsInteropInputsKey;
+        this._tsInteropInputsKey = tsInteropInputsKey;
+        if (previousTsInteropInputsKey !== void 0 && previousTsInteropInputsKey !== tsInteropInputsKey) {
+          this.config.tsInteropInputsCache.removeTsInteropInputs(previousTsInteropInputsKey);
+        }
+      }
     }
     this._tsProgramLoaderInputs = newTsProgramLoaderInputs;
     function checkTsInteropInputsChanged(newInputs, oldInputs) {
@@ -9759,6 +9743,9 @@ __decorateClass([
 __decorateClass([
   unobservable2
 ], CompilationController.prototype, "_tsInteropInputs", 2);
+__decorateClass([
+  unobservable2
+], CompilationController.prototype, "_tsInteropInputsKey", 2);
 __decorateClass([
   unobservable2
 ], CompilationController.prototype, "_tsProgramLoaderInputs", 2);
@@ -10125,6 +10112,56 @@ var ConfigurationDirectory = class {
     this.packageUri = packageUri;
   }
 };
+var TsInteropInputsCache = class {
+  constructor() {
+    this._inputsByKey = /* @__PURE__ */ new Map();
+  }
+  getTsInteropInputs(tsProgramLoaderInputs, librariesProvider) {
+    const key = this.createKey(tsProgramLoaderInputs, librariesProvider);
+    const inputsInfo = this._inputsByKey.get(key);
+    if (inputsInfo === void 0) {
+      return void 0;
+    }
+    inputsInfo.referenceCount++;
+    return { inputs: inputsInfo.inputs, key };
+  }
+  getOrAddTsInteropInputs(tsProgramLoaderInputs, librariesProvider, inputs) {
+    const key = this.createKey(tsProgramLoaderInputs, librariesProvider);
+    let resultInputs;
+    const resultInputsInfo = this._inputsByKey.get(key);
+    if (resultInputsInfo === void 0) {
+      this._inputsByKey.set(key, { inputs, referenceCount: 1 });
+      resultInputs = inputs;
+    } else {
+      resultInputsInfo.referenceCount++;
+      resultInputs = resultInputsInfo.inputs;
+    }
+    return { inputs: resultInputs, key };
+  }
+  removeTsInteropInputs(key) {
+    const inputsInfo = this._inputsByKey.get(key);
+    if (inputsInfo !== void 0) {
+      inputsInfo.referenceCount--;
+      if (inputsInfo.referenceCount <= 0) {
+        this._inputsByKey.delete(key);
+      }
+    }
+  }
+  // Ключ состоит из имён файлов стандартных библиотек, npm пакетов, модулей, а также путей ко всем доступным
+  // папкам node_modules.
+  createKey(tsProgramLoaderInputs, librariesProvider) {
+    const nodeModulesUris = new Array();
+    let currentDirectoryUri = tsProgramLoaderInputs.tsProjectUri;
+    while (currentDirectoryUri !== void 0) {
+      const nodeModulesUri = currentDirectoryUri.append("node_modules");
+      if (librariesProvider.directoryExistsSync(nodeModulesUri)) {
+        nodeModulesUris.push(nodeModulesUri);
+      }
+      currentDirectoryUri = currentDirectoryUri.parentUri();
+    }
+    return tsProgramLoaderInputs.orderedStandardLibraryNames.join(",") + ";" + tsProgramLoaderInputs.orderedPackageNames.join(",") + ";" + tsProgramLoaderInputs.orderedModuleNames.join(",") + ";" + nodeModulesUris.map((u) => u.toString()).join(",");
+  }
+};
 
 // source/services/workspace/FileSystemTreeProviderBasedOnWatchedFileSystem.ts
 import {
@@ -11141,6 +11178,7 @@ var _Workspace = class _Workspace extends ObservableObject6 {
     this._controllersWithOpenedFiles = new ObservableMap5();
     this._atLeastOneFileOfCompilationHasBeenOpened = false;
     this._standardPackageContents = new Cached();
+    this._tsInteropInputsCache = new TsInteropInputsCache();
     this._config = config;
     this._files = new WorkspaceFiles(config.fileSystemTreeProvider);
   }
@@ -11359,7 +11397,8 @@ var _Workspace = class _Workspace extends ObservableObject6 {
       standardPackagesUri: this._config.standardPackagesUri,
       showErrorMessage: this._config.showErrorMessage,
       builtInStandardPackagesUri: this._config.builtInStandardPackagesUri,
-      additionalPackageContents: this._config.additionalPackageContents
+      additionalPackageContents: this._config.additionalPackageContents,
+      tsInteropInputsCache: this._tsInteropInputsCache
     };
     return new CompilationController(config);
   }
@@ -11417,6 +11456,9 @@ __decorateClass([
 __decorateClass([
   unobservable6
 ], _Workspace.prototype, "_standardPackageContents", 2);
+__decorateClass([
+  unobservable6
+], _Workspace.prototype, "_tsInteropInputsCache", 2);
 __decorateClass([
   cached
 ], _Workspace.prototype, "compilationControllerByUri", 1);
@@ -12544,7 +12586,7 @@ var LanguageServer = class {
       Logger.info("\u041D\u0430\u0447\u0430\u0442\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044F \u0441\u0435\u0440\u0432\u0438\u0441\u043E\u0432.");
       const initializeStartTime = performance.now();
       this._clientCapabilities = params.capabilities;
-      setUserLocale(params.initializationOptions?.localeOverride ?? params.locale ?? "en");
+      setUserLocale("ru");
       let workspaceFolderUris;
       if (params.initializationOptions?.workspaceFoldersOverride !== void 0) {
         workspaceFolderUris = params.initializationOptions.workspaceFoldersOverride.map((f) => this.convertVscodeUriToUri(URI2.parse(f.uri)));
@@ -13101,7 +13143,7 @@ var LanguageServer = class {
       const sourceFileContext = yield this.getSourceFileContext(uri, token);
       if (sourceFileContext !== void 0) {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
-        if (node?.kind === 92 /* AssignmentStatement */) {
+        if (node?.kind === 91 /* AssignmentStatement */) {
           const sourceFileEdit = this._addPropertyAssignmentService.createEditWithAssignment(
             sourceFileContext.sourceFile,
             node,
@@ -13138,7 +13180,7 @@ var LanguageServer = class {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
         if (node !== void 0) {
           let nodeForRange = node;
-          if (node.kind === 92 /* AssignmentStatement */) {
+          if (node.kind === 91 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);