@artel/artc 0.6.25226 → 0.6.25227

package/build/api/ApiServices.js

@@ -182,7 +182,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-VRQPLLYS.js";
+} from "../chunk-NOECPQMV.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 !== 78 /* MemberAccessExpression */) {
+      if (assignmentNode.left.kind !== 79 /* MemberAccessExpression */) {
         return void 0;
       }
       const propertyReceiver = assignmentNode.left.expression;
@@ -319,7 +319,7 @@ var AddPropertyAssignmentService = class {
     const reassignmentText = `${leftValueText} = ${value}`;
     const subprogramBody = this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(assignmentNode);
     if (subprogramBody !== void 0) {
-      const lastStatement = subprogramBody.expressionOrStatementList.kind === 92 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
+      const lastStatement = subprogramBody.expressionOrStatementList.kind === 93 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
       let editRangeStart;
       let indentationText;
       if (lastStatement !== void 0) {
@@ -351,9 +351,9 @@ var AddPropertyAssignmentService = class {
   ifShouldBeAssignedAtTheEndOfSubprogramThenBody(node) {
     const parent = node.parent.parent;
     switch (parent.kind) {
-      case 93 /* StatementBlock */:
+      case 94 /* StatementBlock */:
         return this.getContainingSubprogram(parent)?.block;
-      case 94 /* FunctionBlock */:
+      case 95 /* FunctionBlock */:
         return void 0;
       default:
         Debug.never(parent);
@@ -545,7 +545,7 @@ var SyntaxFactory = class {
   static packageVariableGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const getKeyword = this.keyword(58 /* Get */);
+    const getKeyword = this.keyword(59 /* Get */);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
     return new PackageVariableGetterDeclaration(
@@ -560,7 +560,7 @@ var SyntaxFactory = class {
   static packageVariableSetterDeclaration(tags, modifiers, name, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const setKeyword = this.keyword(59 /* Set */);
+    const setKeyword = this.keyword(60 /* Set */);
     const nameIdentifier = this.createIdentifier(name);
     return new PackageVariableSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
   }
@@ -607,7 +607,7 @@ var SyntaxFactory = class {
   static fieldGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const getKeyword = this.keyword(58 /* Get */);
+    const getKeyword = this.keyword(59 /* Get */);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
     return new FieldGetterDeclaration(
@@ -622,7 +622,7 @@ var SyntaxFactory = class {
   static fieldSetterDeclaration(tags, modifiers, name, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const setKeyword = this.keyword(59 /* Set */);
+    const setKeyword = this.keyword(60 /* Set */);
     const nameIdentifier = this.createIdentifier(name);
     return new FieldSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
   }
@@ -648,21 +648,21 @@ var SyntaxFactory = class {
   static constructorDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const creationKeyword = this.keyword(30 /* Creation */);
+    const creationKeyword = this.keyword(31 /* Creation */);
     const parameterClause = this.parameterClause(parameters);
     return new ConstructorDeclaration(tagList, modifierList, creationKeyword, parameterClause, body);
   }
   static destructorDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const destructionKeyword = this.keyword(47 /* Destruction */);
+    const destructionKeyword = this.keyword(48 /* Destruction */);
     const parameterClause = this.parameterClause(parameters);
     return new DestructorDeclaration(tagList, modifierList, destructionKeyword, parameterClause, body);
   }
   static indexedElementGetterDeclaration(tags, modifiers, parameters, typeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const getKeyword = this.keyword(58 /* Get */);
+    const getKeyword = this.keyword(59 /* Get */);
     const parameterClause = this.indexParameterClause(parameters);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
     return new IndexedElementGetterDeclaration(
@@ -677,7 +677,7 @@ var SyntaxFactory = class {
   static indexedElementSetterDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const getKeyword = this.keyword(59 /* Set */);
+    const getKeyword = this.keyword(60 /* Set */);
     const parameterClause = this.indexParameterClause(parameters);
     return new IndexedElementSetterDeclaration(tagList, modifierList, getKeyword, parameterClause, body);
   }
@@ -845,7 +845,7 @@ var SyntaxFactory = class {
     return new FunctionBlock(openBraceToken, statementList, closeBraceToken);
   }
   static noneLiteral() {
-    return new KeywordExpression(this.keyword(57 /* None */));
+    return new KeywordExpression(this.keyword(58 /* None */));
   }
   static integerLiteral(value) {
     return new TokenExpression(this.token(2 /* IntegerLiteral */, value.toString()));
@@ -853,7 +853,7 @@ var SyntaxFactory = class {
   static translationsDeclaration(translations) {
     const tagList = new TagList([]);
     const modifierList = new ModifierList([]);
-    const translationsKeyword = this.keyword(55 /* Translations */);
+    const translationsKeyword = this.keyword(56 /* Translations */);
     const openBraceToken = this.token(43 /* OpenBrace */);
     const translationList = new TopLevelTranslationList(translations);
     const closeBraceToken = this.token(20 /* CloseBrace */);
@@ -970,7 +970,7 @@ var SyntaxFactory = class {
     );
   }
   static constructorTranslation(sourceParameters, translatedParameters) {
-    const creationKeyword = this.keyword(30 /* Creation */);
+    const creationKeyword = this.keyword(31 /* Creation */);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
     const minusGreaterThanToken = this.token(42 /* MinusGreaterThan */);
     const translatedParameterClause = this.translationParameterClause(translatedParameters);
@@ -1697,7 +1697,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeNodeDefault(node);
   }
   writeDeclarationBody(node, addLeadingNewLineOrWhitespace = true) {
-    if (node.expressionOrStatementList.kind !== 92 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
+    if (node.expressionOrStatementList.kind !== 93 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
       this.writeWhitespace();
       this.writeFunctionBlock(node, false);
     } else {
@@ -2038,19 +2038,19 @@ var SyntaxToCode = class _SyntaxToCode {
       [54 /* FieldDeclaration */]: this.prototype.writeFieldDeclaration,
       [55 /* FieldGetterDeclaration */]: this.prototype.writeFieldGetterDeclaration,
       [56 /* FieldSetterDeclaration */]: this.prototype.writeFieldSetterDeclaration,
-      [93 /* StatementBlock */]: this.prototype.writeStatementBlock,
-      [94 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
-      [135 /* QualifiedName */]: this.prototype.writeQualifiedName,
-      [142 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
-      [143 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
-      [144 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [145 /* Argument */]: this.prototype.writeArgument,
-      [147 /* Tag */]: this.prototype.writeTag,
-      [149 /* Modifier */]: this.prototype.writeModifier,
-      [150 /* ParameterClause */]: this.prototype.writeParameterClause,
-      [151 /* ParameterList */]: this.prototype.writeParameterList,
-      [152 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [154 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [94 /* StatementBlock */]: this.prototype.writeStatementBlock,
+      [95 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
+      [136 /* QualifiedName */]: this.prototype.writeQualifiedName,
+      [143 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
+      [144 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
+      [145 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
+      [146 /* Argument */]: this.prototype.writeArgument,
+      [148 /* Tag */]: this.prototype.writeTag,
+      [150 /* Modifier */]: this.prototype.writeModifier,
+      [151 /* ParameterClause */]: this.prototype.writeParameterClause,
+      [152 /* ParameterList */]: this.prototype.writeParameterList,
+      [153 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [155 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
       [17 /* AnonymousFunctionTypeDeclaration */]: this.prototype.writeAnonymousFunctionTypeDeclaration,
       [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
       [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
@@ -2086,73 +2086,74 @@ var SyntaxToCode = class _SyntaxToCode {
       [74 /* FunctionLiteral */]: this.prototype.writeNodeDefault,
       [75 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
       [76 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
-      [77 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
-      [78 /* MemberAccessExpression */]: 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,
-      [95 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
-      [96 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
-      [97 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [98 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [99 /* TryStatement */]: this.prototype.writeNodeDefault,
-      [100 /* CatchClause */]: this.prototype.writeNodeDefault,
-      [101 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [102 /* FinallyClause */]: this.prototype.writeNodeDefault,
-      [103 /* EmptyStatement */]: this.prototype.writeNodeDefault,
-      [104 /* ErrorStatement */]: this.prototype.writeNodeDefault,
-      [105 /* ImportantStatement */]: this.prototype.writeNodeDefault,
-      [106 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
-      [107 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
-      [108 /* ForStatement */]: this.prototype.writeNodeDefault,
-      [109 /* IfStatement */]: this.prototype.writeNodeDefault,
-      [110 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
-      [111 /* ElseIfClause */]: this.prototype.writeNodeDefault,
-      [112 /* ElseClause */]: this.prototype.writeNodeDefault,
-      [113 /* InvalidStatement */]: this.prototype.writeNodeDefault,
-      [114 /* NestedFunctionDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [115 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [116 /* LoopStatement */]: this.prototype.writeNodeDefault,
-      [117 /* ReturnStatement */]: this.prototype.writeNodeDefault,
-      [118 /* CaseClauseList */]: this.prototype.writeNodeDefault,
-      [119 /* SwitchStatement */]: this.prototype.writeNodeDefault,
-      [120 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
-      [121 /* CaseClause */]: this.prototype.writeNodeDefault,
-      [122 /* WhileStatement */]: this.prototype.writeNodeDefault,
-      [123 /* YieldStatement */]: this.prototype.writeNodeDefault,
-      [124 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
-      [125 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
-      [126 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
-      [127 /* IndexParameterTranslationClause */]: this.prototype.writeIndexParameterTranslationClause,
-      [128 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
-      [129 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
-      [130 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
-      [131 /* PackageFunctionTranslation */]: this.prototype.writePackageFunctionTranslation,
-      [132 /* MethodTranslation */]: this.prototype.writeMethodTranslation,
-      [133 /* FunctionTypeTranslation */]: this.prototype.writeFunctionTypeTranslation,
-      [134 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
-      [136 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
-      [137 /* FieldOrVariantTranslation */]: this.prototype.writeFieldOrVariantTranslation,
-      [138 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
-      [139 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
-      [140 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [141 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [146 /* TagList */]: this.prototype.writeNodeDefault,
-      [148 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [153 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [155 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [156 /* TypeAnnotation */]: this.prototype.writeNodeDefault
+      [77 /* ConditionalExpression */]: this.prototype.writeNodeDefault,
+      [78 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [79 /* MemberAccessExpression */]: 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,
+      [96 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
+      [97 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
+      [98 /* DisposeStatement */]: this.prototype.writeNodeDefault,
+      [99 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [100 /* TryStatement */]: this.prototype.writeNodeDefault,
+      [101 /* CatchClause */]: this.prototype.writeNodeDefault,
+      [102 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [103 /* FinallyClause */]: this.prototype.writeNodeDefault,
+      [104 /* EmptyStatement */]: this.prototype.writeNodeDefault,
+      [105 /* ErrorStatement */]: this.prototype.writeNodeDefault,
+      [106 /* ImportantStatement */]: this.prototype.writeNodeDefault,
+      [107 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
+      [108 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
+      [109 /* ForStatement */]: this.prototype.writeNodeDefault,
+      [110 /* IfStatement */]: this.prototype.writeNodeDefault,
+      [111 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
+      [112 /* ElseIfClause */]: this.prototype.writeNodeDefault,
+      [113 /* ElseClause */]: this.prototype.writeNodeDefault,
+      [114 /* InvalidStatement */]: this.prototype.writeNodeDefault,
+      [115 /* NestedFunctionDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [116 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [117 /* LoopStatement */]: this.prototype.writeNodeDefault,
+      [118 /* ReturnStatement */]: this.prototype.writeNodeDefault,
+      [119 /* CaseClauseList */]: this.prototype.writeNodeDefault,
+      [120 /* SwitchStatement */]: this.prototype.writeNodeDefault,
+      [121 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
+      [122 /* CaseClause */]: this.prototype.writeNodeDefault,
+      [123 /* WhileStatement */]: this.prototype.writeNodeDefault,
+      [124 /* YieldStatement */]: this.prototype.writeNodeDefault,
+      [125 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
+      [126 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
+      [127 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
+      [128 /* IndexParameterTranslationClause */]: this.prototype.writeIndexParameterTranslationClause,
+      [129 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
+      [130 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
+      [131 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
+      [132 /* PackageFunctionTranslation */]: this.prototype.writePackageFunctionTranslation,
+      [133 /* MethodTranslation */]: this.prototype.writeMethodTranslation,
+      [134 /* FunctionTypeTranslation */]: this.prototype.writeFunctionTypeTranslation,
+      [135 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
+      [137 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
+      [138 /* FieldOrVariantTranslation */]: this.prototype.writeFieldOrVariantTranslation,
+      [139 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
+      [140 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
+      [141 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [142 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [147 /* TagList */]: this.prototype.writeNodeDefault,
+      [149 /* ModifierList */]: this.prototype.writeNodeDefault,
+      [154 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [156 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [157 /* TypeAnnotation */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2162,14 +2163,14 @@ var SyntaxToCode = class _SyntaxToCode {
   }
 };
 var modifierSortOrder = {
-  [36 /* Hidden */]: 0,
-  [41 /* Static */]: 1,
+  [37 /* Hidden */]: 0,
+  [42 /* Static */]: 1,
   [17 /* Basic */]: 2,
-  [38 /* Redefinable */]: 3,
-  [37 /* Abstract */]: 4,
-  [39 /* Redefined */]: 5,
-  [40 /* Async */]: 6,
-  [35 /* Const */]: 7
+  [39 /* Redefinable */]: 3,
+  [38 /* Abstract */]: 4,
+  [40 /* Redefined */]: 5,
+  [41 /* Async */]: 6,
+  [36 /* Const */]: 7
 };
 
 // source/services/TreeUtils.ts
@@ -2337,7 +2338,7 @@ var TranslationsGenerationService = class {
       return void 0;
     }
     let result;
-    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
+    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 140 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2349,7 +2350,7 @@ var TranslationsGenerationService = class {
         result = generator.generateMissingTypeMemberTranslations(tokenOrKeyword.parent);
       }
     }
-    if (result === void 0 && tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */) {
+    if (result === void 0 && tokenOrKeyword.isKeyword(56 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2375,7 +2376,7 @@ var TranslationsGenerationService = class {
     if (tokenOrKeyword === void 0) {
       return false;
     }
-    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */)) {
+    if (!(tokenOrKeyword.isKeyword(56 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */)) {
       return false;
     }
     const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
@@ -2383,7 +2384,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 === 139 /* 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 === 140 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
 var TranslationsGenerator = class _TranslationsGenerator {
@@ -2410,7 +2411,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 === 139 /* TypeTranslation */) {
+        if (n.kind === 140 /* TypeTranslation */) {
           const startOffset = Math.max(code.indexOf(newLine), 0);
           return this.addNewLineBeforeArrowsInTranslation(
             code,
@@ -2442,7 +2443,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
   generateMissingTranslationsForPartiallyTranslatedTypes(translationsDeclaration) {
     const result = new Array();
     for (const translation of translationsDeclaration.translationList.translationDeclarations) {
-      if (translation.kind === 139 /* TypeTranslation */) {
+      if (translation.kind === 140 /* TypeTranslation */) {
         const edits = this.generateMissingTypeMemberTranslations(translation);
         if (edits !== void 0) {
           result.push(...edits);
@@ -2539,13 +2540,13 @@ var TranslationsGenerator = class _TranslationsGenerator {
   }
   detectIndentationStepForTypeMemberTranslations(node) {
     let indentationStepSize;
-    if (node.kind === 139 /* TypeTranslation */) {
+    if (node.kind === 140 /* 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 === 139 /* TypeTranslation */) {
+        if (member.kind === 140 /* TypeTranslation */) {
           indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(member, this._sourceFile);
           if (indentationStepSize !== void 0) {
             break;
@@ -2832,7 +2833,7 @@ var SignatureForNode = class _SignatureForNode {
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
       case 71 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
-      case 147 /* Tag */:
+      case 148 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
       default:
         Debug.never(node);
@@ -3226,7 +3227,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 === 78 /* MemberAccessExpression */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 79 /* MemberAccessExpression */) {
       const propertyAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(propertyAccess.expression);
@@ -3258,16 +3259,15 @@ var CompletionService = class {
       const localizationContext = semanticContext.getLocalizationContext();
       const isStaticAccess = this._analyzer.checkExpressionDenotesType(propertyAccess.expression) !== void 0;
       const hidingMatcher = semanticContext.getHidingMatcher();
-      const typeExtensionLookup = semanticContext.getScopeLookup();
       return new TypeMemberCompletionContext(
         type,
         localizationContext,
         isStaticAccess,
         hidingMatcher,
-        typeExtensionLookup
+        semanticContext
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 136 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
       const namedTypeSpecifier = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveNamedTypeSpecifier(namedTypeSpecifier);
       const segmentIndex = Math.floor(
@@ -3309,7 +3309,7 @@ var CompletionService = class {
       }
       return { kind: "none" };
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 147 /* Tag */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 136 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 148 /* Tag */) {
       const tag = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveTag(tag);
       const segmentIndex = Math.floor(
@@ -3352,20 +3352,22 @@ var CompletionService = class {
           expressionType: this._analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
       }
-      const lookup = semanticContext.getScopeLookup();
-      const typeSearchLocation = new ScopeTypeSearchLocation(lookup);
+      const typeSearchLocation = new ScopeTypeSearchLocation(semanticContext);
       return new TypeCompletionContext(typeSearchLocation, completionInIsOrAsExpressionInfo);
     }
     if (syntaxContext.isUnqualifiedTagNameCompletionContext) {
-      const lookup = semanticContext.getScopeLookup();
-      const typeSearchLocation = new ScopeTypeSearchLocation(lookup);
+      const typeSearchLocation = new ScopeTypeSearchLocation(semanticContext);
       return new TagCompletionContext(typeSearchLocation);
     }
     if (syntaxContext.isExpressionContext !== void 0) {
-      const lookup = semanticContext.getScopeLookup();
       const { targetTypes, targetSignaturesParameters } = this.getTargetTypesAndTargetSignaturesParameters(syntaxContext.isExpressionContext.expressionRole, semanticContext);
       const localizationContext = semanticContext.getLocalizationContext();
-      return new ExpressionCompletionContext(lookup, targetSignaturesParameters, targetTypes, localizationContext);
+      return new ExpressionCompletionContext(
+        semanticContext,
+        targetSignaturesParameters,
+        targetTypes,
+        localizationContext
+      );
     }
     const topLevelTranslationCompletionContext = this.tryGetTopLevelTranslationCompletionContext(
       syntaxContext,
@@ -3402,17 +3404,17 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 134 /* PackageImportTranslation */) {
+    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 135 /* PackageImportTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 139 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 133 /* FunctionTypeTranslation */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 140 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 134 /* FunctionTypeTranslation */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 131 /* PackageFunctionTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 132 /* PackageFunctionTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3432,9 +3434,9 @@ var CompletionService = class {
         hasPrecedingKeyword
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 136 /* QualifiedName */) {
       const qualifiedName = tokenOrKeyword.parent;
-      if (qualifiedName.parent.kind === 134 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
+      if (qualifiedName.parent.kind === 135 /* 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 });
@@ -3459,12 +3461,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 132 /* MethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 133 /* MethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 126 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 127 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3504,7 +3506,7 @@ var CompletionService = class {
             role.argumentList.parent
           );
           break;
-        case 147 /* Tag */:
+        case 148 /* Tag */:
           signatures = SignatureForNode.getSignaturesForTag(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(role.argumentList.parent);
           break;
@@ -3649,22 +3651,22 @@ var CompletionService = class {
     }
     const kinds = /* @__PURE__ */ new Set();
     if (syntaxContext.isPackageMemberDeclarationListContext) {
-      kinds.add(18 /* Import */).add(7 /* Run */).add(30 /* Creation */).add(12 /* Function */).add(17 /* Basic */).add(16 /* Type */).add(58 /* Get */).add(59 /* Set */).add(55 /* Translations */);
+      kinds.add(18 /* Import */).add(7 /* Run */).add(31 /* Creation */).add(12 /* Function */).add(17 /* Basic */).add(16 /* Type */).add(59 /* Get */).add(60 /* Set */).add(56 /* Translations */);
     }
     if (syntaxContext.isPackageMemberDeclarationListContext || syntaxContext.isTypeMemberDeclarationListContext) {
-      kinds.add(36 /* Hidden */).add(41 /* Static */).add(38 /* Redefinable */).add(37 /* Abstract */).add(39 /* Redefined */).add(40 /* Async */).add(35 /* Const */);
+      kinds.add(37 /* Hidden */).add(42 /* Static */).add(39 /* Redefinable */).add(38 /* Abstract */).add(40 /* Redefined */).add(41 /* Async */).add(36 /* Const */);
     }
     if (syntaxContext.isTypeMemberDeclarationListContext) {
-      kinds.add(30 /* Creation */).add(12 /* Function */).add(47 /* Destruction */).add(58 /* Get */).add(59 /* Set */);
+      kinds.add(31 /* Creation */).add(12 /* Function */).add(48 /* Destruction */).add(59 /* Get */).add(60 /* Set */);
     }
     if (syntaxContext.isStatementContext) {
-      kinds.add(7 /* Run */).add(34 /* For */).add(25 /* While */).add(26 /* Loop */).add(15 /* Return */).add(20 /* Error */).add(19 /* Important */).add(28 /* Yield */).add(32 /* BreakLoop */).add(33 /* ContinueLoop */).add(13 /* If */).add(44 /* Switch */).add(1 /* Let */).add(35 /* Const */).add(46 /* Dispose */).add(8 /* Try */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(7 /* Run */).add(35 /* For */).add(25 /* While */).add(26 /* Loop */).add(15 /* Return */).add(20 /* Error */).add(19 /* Important */).add(28 /* Yield */).add(33 /* BreakLoop */).add(34 /* ContinueLoop */).add(13 /* If */).add(45 /* Switch */).add(1 /* Let */).add(36 /* Const */).add(47 /* Dispose */).add(8 /* Try */).add(12 /* Function */).add(41 /* Async */);
     }
     if (this.isFromKeywordContext(positionDescription)) {
       kinds.add(9 /* From */);
     }
     if (syntaxContext.isExpressionContext !== void 0) {
-      kinds.add(43 /* Not */).add(52 /* Yes */).add(53 /* No */).add(57 /* None */).add(40 /* Async */).add(12 /* Function */).add(54 /* Reference */).add(2 /* Autotype */);
+      kinds.add(44 /* Not */).add(53 /* Yes */).add(54 /* No */).add(58 /* None */).add(41 /* Async */).add(12 /* Function */).add(55 /* Reference */).add(2 /* Autotype */).add(30 /* Cond */);
       if (positionDescription.kind === "after-token-or-keyword") {
         const container = semanticContext.getContainingTypeOrTypeExtension();
         if (container !== void 0) {
@@ -3672,20 +3674,20 @@ var CompletionService = class {
           if (container.kind === "type") {
             const typeEntity = container.value;
             if (typeEntity?.typeEntityKind === 1 /* Structured */ && typeEntity.getBaseObjectType() !== void 0 || typeEntity?.typeEntityKind === 3 /* Variant */ || typeEntity?.typeEntityKind === 4 /* Alias */) {
-              kinds.add(56 /* Base */);
+              kinds.add(57 /* Base */);
             }
           }
         }
       }
     }
     if (this.isTypeKindCompletionContext(positionDescription)) {
-      kinds.add(4 /* Object */).add(5 /* PlainObject */).add(3 /* Aspect */).add(6 /* Variant */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(4 /* Object */).add(5 /* PlainObject */).add(3 /* Aspect */).add(6 /* Variant */).add(12 /* Function */).add(41 /* Async */);
     }
     if (this.isCaseKeywordContext(positionDescription, syntaxContext)) {
-      kinds.add(45 /* Case */);
+      kinds.add(46 /* Case */);
     }
     if (this.isCatchKeywordContext(positionDescription)) {
-      kinds.add(31 /* Catch */);
+      kinds.add(32 /* Catch */);
     }
     if (this.isFinallyKeywordContext(positionDescription)) {
       kinds.add(21 /* Finally */);
@@ -3694,18 +3696,18 @@ var CompletionService = class {
       kinds.add(10 /* Else */).add(11 /* ElseIf */);
     }
     if (syntaxContext.precedingExpression !== void 0) {
-      kinds.add(42 /* As */).add(14 /* Is */).add(22 /* And */).add(23 /* Or */).add(24 /* Xor */).add(29 /* When */);
+      kinds.add(43 /* As */).add(14 /* Is */).add(22 /* And */).add(23 /* Or */).add(24 /* Xor */).add(29 /* When */);
     }
     if (this.isModifierLevelContext(positionDescription)) {
-      kinds.add(51 /* InType */).add(48 /* InHierarchy */).add(49 /* InFile */).add(50 /* InPackage */);
+      kinds.add(52 /* InType */).add(49 /* InHierarchy */).add(50 /* InFile */).add(51 /* InPackage */);
     }
     if (this.isRepeatWhileKeywordContext(positionDescription)) {
       kinds.add(27 /* RepeatWhile */);
     }
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
-      kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(12 /* Function */).add(41 /* Async */);
     }
-    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(40 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedFunctionDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 74 /* FunctionLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* FunctionTypeDeclarationBody */)) {
+    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(41 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedFunctionDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 74 /* FunctionLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* FunctionTypeDeclarationBody */)) {
       kinds.add(12 /* Function */);
     }
     return Query.from(kinds.values()).map(
@@ -3717,35 +3719,35 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 116 /* LoopStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 117 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 149 /* Modifier */;
+    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 150 /* Modifier */;
   }
   isElseOrElseIfKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 109 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 111 /* ElseIfClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 110 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 112 /* ElseIfClause */);
   }
   isCatchKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 100 /* TryStatement */;
   }
   isFinallyKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* CatchClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 100 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 101 /* CatchClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(57 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3762,16 +3764,16 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 121 /* CaseClause */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 122 /* CaseClause */) {
       return true;
     }
-    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 119 /* SwitchStatement */) {
+    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 120 /* SwitchStatement */) {
       return true;
     }
     return false;
   }
   getExpressionCompletionItemInfos(ctx) {
-    let query = this.getScopeCompletionItemInfos(ctx.lookup);
+    let query = this.getScopeCompletionItemInfos(ctx.semanticContext);
     if (ctx.targetSignaturesValueParameters !== void 0) {
       query = query.chain(this.getCompletionItemInfosForTargetSignaturesValueParameters(ctx.targetSignaturesValueParameters));
     }
@@ -3796,8 +3798,8 @@ var CompletionService = class {
   getCompletionItemInfosForTargetSignaturesValueParameters(valueParameters) {
     return valueParameters.map((p) => new TargetSignatureValueParameterCompletionItemInfo(this.completionItemInfoContext, p));
   }
-  getScopeCompletionItemInfos(lookup) {
-    return Query.from(lookup.getNamedDeclarations()).map((d) => {
+  getScopeCompletionItemInfos(semanticContext) {
+    return Query.from(semanticContext.getNamedDeclarations()).map((d) => {
       switch (d.value.kind) {
         case "variable": {
           if (d.value.value.kind === "entity") {
@@ -3844,7 +3846,7 @@ var CompletionService = class {
           Debug.never(d.value);
       }
     }).chain(
-      Query.from(lookup.getOperators()).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization))
+      Query.from(semanticContext.getOperators()).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization))
     );
   }
   getTypeCompletionItemInfos(ctx) {
@@ -3902,7 +3904,7 @@ var CompletionService = class {
     return query.toArray();
   }
   getTypeCompletionItemInfosFromScope(searchLocation) {
-    return searchLocation.lookup.getTypesOrContainersWithTypes().map((d) => {
+    return searchLocation.semanticContext.getTypesOrContainersWithTypes().map((d) => {
       switch (d.value.kind) {
         case "type": {
           return new NamedTypeCompletionItemInfo(
@@ -3984,7 +3986,7 @@ var CompletionService = class {
     return query.toArray();
   }
   getTagCompletionItemInfosFromScope(searchLocation) {
-    return searchLocation.lookup.getNamedDeclarations().map((d) => {
+    return searchLocation.semanticContext.getNamedDeclarations().map((d) => {
       switch (d.value.kind) {
         case "type":
           return new NamedTypeCompletionItemInfo(
@@ -4059,8 +4061,8 @@ var CompletionService = class {
   getTypeMemberCompletionItemInfos(ctx) {
     const type = this._analyzer.excludeNoneFromType(ctx.type);
     const memberLookup = TypeMemberLookup.ofType(this._analyzer, type, ctx.localizationContext);
-    const options6 = ctx.isStaticAccess ? 2 /* OnlyStaticMembers */ : 0 /* None */;
-    return memberLookup.getNamedMembers(options6, ctx.hidingMatcher, ctx.typeExtensionsLookup).map((m) => {
+    const options6 = ctx.isStaticAccess ? 2 /* OnlyStaticMembers */ : 1 /* OnlyInstanceMembers */;
+    return memberLookup.getNamedMembers(options6, ctx.hidingMatcher, ctx.typeExtensionLookup).map((m) => {
       switch (m.value.kind) {
         case "method":
           return new MethodCompletionItemInfo(
@@ -4079,7 +4081,7 @@ var CompletionService = class {
         default:
           Debug.never(m.value);
       }
-    }).concat(memberLookup.getOperators(options6, ctx.hidingMatcher, ctx.typeExtensionsLookup).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization)));
+    }).concat(memberLookup.getOperators(options6, ctx.hidingMatcher, ctx.typeExtensionLookup).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization)));
   }
   getPackageImportCompletionItemInfos(ctx) {
     const result = this._analyzer.packageImports.getPackagesAvailableForImport(this._sourceFile.package).map((p) => p.getImportName()).filter((n) => {
@@ -4252,7 +4254,7 @@ var CompletionService = class {
     if (!ctx.hasPrecedingKeyword) {
       const keywords = [
         12 /* Function */,
-        30 /* Creation */
+        31 /* Creation */
       ];
       result = result.chain(
         Query.from(keywords).map(
@@ -4415,7 +4417,7 @@ function isInvalidNode(node) {
   switch (node.kind) {
     case 72 /* InvalidExpression */:
     case 43 /* InvalidPackageMemberDeclaration */:
-    case 113 /* InvalidStatement */:
+    case 114 /* InvalidStatement */:
     case 57 /* InvalidTypeMemberDeclaration */:
     case 16 /* InvalidTypeSpecifier */:
       return true;
@@ -4435,12 +4437,12 @@ var PackageImportCompletionContext = class {
   }
 };
 var TypeMemberCompletionContext = class {
-  constructor(type, localizationContext, isStaticAccess, hidingMatcher, typeExtensionsLookup) {
+  constructor(type, localizationContext, isStaticAccess, hidingMatcher, typeExtensionLookup) {
     this.type = type;
     this.localizationContext = localizationContext;
     this.isStaticAccess = isStaticAccess;
     this.hidingMatcher = hidingMatcher;
-    this.typeExtensionsLookup = typeExtensionsLookup;
+    this.typeExtensionLookup = typeExtensionLookup;
     this.kind = "type-member";
   }
 };
@@ -4479,8 +4481,8 @@ var OperatorNameCompletionContext = class {
   }
 };
 var ScopeTypeSearchLocation = class {
-  constructor(lookup) {
-    this.lookup = lookup;
+  constructor(semanticContext) {
+    this.semanticContext = semanticContext;
     this.kind = "scope";
   }
 };
@@ -4500,8 +4502,8 @@ var PackageNameSegmentTypeSearchLocation = class {
   }
 };
 var ExpressionCompletionContext = class {
-  constructor(lookup, targetSignaturesValueParameters, targetTypes, localizationContext) {
-    this.lookup = lookup;
+  constructor(semanticContext, targetSignaturesValueParameters, targetTypes, localizationContext) {
+    this.semanticContext = semanticContext;
     this.targetSignaturesValueParameters = targetSignaturesValueParameters;
     this.targetTypes = targetTypes;
     this.localizationContext = localizationContext;
@@ -5107,7 +5109,7 @@ var AliasesSourceConstructorCompletionItemInfo = class {
         Localization.Original.ofEntity(this.constructor_)
       );
       const displayParts = this.displayService.getConstructorDeclarationDisplayParts(constructorDeclaration);
-      const creationKeyword = this.displayService.displayKeyword(30 /* Creation */);
+      const creationKeyword = this.displayService.displayKeyword(31 /* Creation */);
       return creationKeyword + displayParts.valueParametersStart + displayParts.valueParameters.map((p) => p.toString()).join(displayParts.valueParameterSeparator) + displayParts.valueParametersEnd;
     });
   }
@@ -5121,7 +5123,7 @@ var AliasesSourceConstructorCompletionItemInfo = class {
     return this.label;
   }
   getInsertText() {
-    const creationKeyword = this.includeOnCreateKeyword ? this.displayService.displayKeyword(30 /* Creation */) : "";
+    const creationKeyword = this.includeOnCreateKeyword ? this.displayService.displayKeyword(31 /* Creation */) : "";
     const parameters = this.constructor_.getValueParameters().map((p) => this.ctx.getInsertTextForName(p.getName(), true)).join(", ");
     return `${creationKeyword}(${parameters})`;
   }
@@ -5247,7 +5249,7 @@ var SyntaxContextFactory = class {
     if (positionDescription.kind === "after-token-or-keyword") {
       isUnqualifiedTypeContext = this.isUnqualifiedTypeContext(positionDescription.tokenOrKeyword);
     }
-    const isUnqualifiedTagNameCompletionContext = positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(35 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 147 /* Tag */;
+    const isUnqualifiedTagNameCompletionContext = positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(35 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 148 /* Tag */;
     let isTopLevelTranslationListContext;
     if (positionDescription.kind === "after-token-or-keyword") {
       isTopLevelTranslationListContext = this.isTopLevelTranslationListContext(positionDescription.tokenOrKeyword);
@@ -5273,7 +5275,7 @@ var SyntaxContextFactory = class {
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(57 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5289,24 +5291,24 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 144 /* ParameterDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 145 /* ParameterDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 145 /* Argument */) {
+      if (tokenOrKeyword.parent.kind === 146 /* Argument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 142 /* VariantDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 143 /* VariantDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 78 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5314,11 +5316,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 === 81 /* TextTemplateLiteral */) {
+    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 82 /* 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 === 83 /* TextTemplateSpan */) {
+    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 84 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5330,12 +5332,12 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* FunctionBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 95 /* FunctionBlock */) {
       const block = tokenOrKeyword.parent;
-      if (block.expressionOrStatementList.kind !== 92 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
+      if (block.expressionOrStatementList.kind !== 93 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
         return {
           isExpressionContext: { expressionRole: new ExpressionRole_functionBlockExpression(block) },
           isStatementContext: true
@@ -5347,7 +5349,7 @@ var SyntaxContextFactory = class {
         };
       }
     }
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 92 /* StatementList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 93 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(44 /* OpenParenthesis */)) {
@@ -5355,7 +5357,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 79 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 80 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5367,7 +5369,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 147 /* Tag */) {
+      if (tokenOrKeyword.parent.kind === 148 /* Tag */) {
         const argumentList = tokenOrKeyword.parent.argumentList;
         if (argumentList !== void 0) {
           const expressionRole = new ExpressionRole_argument(argumentList, 0);
@@ -5398,7 +5400,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_argument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 120 /* MatchExpressionList */) {
+      if (tokenOrKeyword.parent.kind === 121 /* MatchExpressionList */) {
         const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5407,47 +5409,47 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 121 /* CaseClause */) {
+    if (tokenOrKeyword.isKeyword(46 /* Case */) && tokenOrKeyword.parent.kind === 122 /* CaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 117 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 118 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(20 /* Error */) && tokenOrKeyword.parent.kind === 104 /* ErrorStatement */) {
+    if (tokenOrKeyword.isKeyword(20 /* Error */) && tokenOrKeyword.parent.kind === 105 /* ErrorStatement */) {
       const expressionRole = new ExpressionRole_errorValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(19 /* Important */) && tokenOrKeyword.parent.kind === 105 /* ImportantStatement */) {
+    if (tokenOrKeyword.isKeyword(19 /* Important */) && tokenOrKeyword.parent.kind === 106 /* ImportantStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(44 /* Switch */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(45 /* Switch */) && tokenOrKeyword.parent.kind === 120 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 109 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 110 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 111 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 112 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 108 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 109 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* While */) && tokenOrKeyword.parent.kind === 122 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(25 /* While */) && tokenOrKeyword.parent.kind === 123 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 116 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(27 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 117 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(28 /* Yield */) && tokenOrKeyword.parent.kind === 123 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(28 /* Yield */) && tokenOrKeyword.parent.kind === 124 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5459,6 +5461,10 @@ var SyntaxContextFactory = class {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.secondExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
+    if (tokenOrKeyword.isKeyword(30 /* Cond */) && tokenOrKeyword.parent.kind === 77 /* ConditionalExpression */) {
+      const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
+      return { isExpressionContext: { expressionRole }, isStatementContext: false };
+    }
     {
       const checkResult = SyntaxContextUtils.tokenOrKeywordIsValidEndOfStatement(tokenOrKeyword);
       if (checkResult !== void 0) {
@@ -5477,7 +5483,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 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageFunctionDeclaration */))) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 95 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageFunctionDeclaration */))) {
       return true;
     }
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
@@ -5489,10 +5495,10 @@ var SyntaxContextFactory = class {
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 149 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 150 /* 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 === 149 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 150 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5519,13 +5525,13 @@ var SyntaxContextFactory = class {
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
       51 /* DereferencedVariableSetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* MethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* ConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* DestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 142 /* VariantDeclaration */)) {
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* MethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* ConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* DestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 143 /* VariantDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 149 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 150 /* 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 === 149 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 150 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5562,7 +5568,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 === 157 /* TypeAnnotation */) {
       return { allowsAnonymousTypes: true };
     }
     if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
@@ -5571,16 +5577,16 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isKeyword(16 /* 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 === 153 /* 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 === 154 /* TypeArgumentList */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 154 /* TypeArgumentList */ };
     }
-    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 147 /* Tag */) {
+    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 148 /* Tag */) {
       return { allowsAnonymousTypes: false };
     }
-    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 143 /* TypeParameterDeclaration */) {
+    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 144 /* TypeParameterDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
     if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 22 /* PackageAliasTypeDeclaration */) {
@@ -5589,7 +5595,7 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+    if (tokenOrKeyword.isKeyword(43 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
       return { allowsAnonymousTypes: true };
     }
     if (tokenOrKeyword.isToken(17 /* Bar */) && tokenOrKeyword.parent.kind === 11 /* UnionTypeSpecifier */) {
@@ -5612,32 +5618,32 @@ var SyntaxContextFactory = class {
     }
     const packageImport = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      134 /* PackageImportTranslation */
+      135 /* PackageImportTranslation */
     );
     if (packageImport !== void 0) {
       return { translationsDeclaration: packageImport.parent.parent };
     }
-    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 139 /* TypeTranslation */);
+    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 140 /* TypeTranslation */);
     if (type !== void 0) {
       return { translationsDeclaration: type.parent.parent };
     }
     const functionType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      133 /* FunctionTypeTranslation */
+      134 /* FunctionTypeTranslation */
     );
     if (functionType !== void 0) {
       return { translationsDeclaration: functionType.parent.parent };
     }
     const variable = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      136 /* PackageVariableTranslation */
+      137 /* PackageVariableTranslation */
     );
     if (variable !== void 0) {
       return { translationsDeclaration: variable.parent.parent };
     }
     const func = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      131 /* PackageFunctionTranslation */
+      132 /* PackageFunctionTranslation */
     );
     if (func !== void 0) {
       return { translationsDeclaration: func.parent.parent };
@@ -5645,33 +5651,33 @@ var SyntaxContextFactory = class {
     return void 0;
   }
   static isTypeMemberTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 138 /* TypeMemberTranslationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 139 /* TypeMemberTranslationList */) {
       return { typeTranslation: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslation */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 140 /* TypeTranslation */) {
       return { typeTranslation: tokenOrKeyword.parent };
     }
-    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 128 /* IndexerTranslation */);
+    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 129 /* IndexerTranslation */);
     if (indexer !== void 0) {
       return { typeTranslation: indexer.parent.parent };
     }
     const constructor = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      126 /* ConstructorTranslation */
+      127 /* ConstructorTranslation */
     );
     if (constructor !== void 0) {
       return { typeTranslation: constructor.parent.parent };
     }
     const variableOrVariant = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      137 /* FieldOrVariantTranslation */
+      138 /* FieldOrVariantTranslation */
     );
     if (variableOrVariant !== void 0) {
       return { typeTranslation: variableOrVariant.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      132 /* MethodTranslation */
+      133 /* MethodTranslation */
     );
     if (method !== void 0) {
       return { typeTranslation: method.parent.parent };
@@ -5786,23 +5792,23 @@ 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 === 77 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 78 /* 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 /* DereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* DereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 81 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+    } else if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* ConstructorDeclaration */) {
+    } else if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* ConstructorDeclaration */) {
       return this.ofConstructorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 90 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 91 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 86 /* ObjectExpression */) {
+    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 87 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 87 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(57 /* Base */) && tokenOrKeyword.parent.kind === 88 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options6);
     } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* IndexParameterClause */) {
       return this.ofIndexedElementAccessorDeclaration(analyzer, tokenOrKeyword.parent.parent);
@@ -5819,11 +5825,11 @@ var NodeSemanticInfoService = class {
     let result;
     const parent = node.parent;
     switch (parent.kind) {
-      case 129 /* TranslationTypeParameterList */:
+      case 130 /* TranslationTypeParameterList */:
         break;
-      case 124 /* TranslationParameterList */:
+      case 125 /* TranslationParameterList */:
         break;
-      case 145 /* Argument */: {
+      case 146 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new SimpleWithLocalization(
@@ -5840,7 +5846,7 @@ var NodeSemanticInfoService = class {
       case 60 /* EnumerationVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofEnumerationVariableDeclaration(parent));
         break;
-      case 101 /* ErrorVariableDeclaration */:
+      case 102 /* ErrorVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofErrorVariableDeclaration(parent));
         break;
       case 22 /* PackageAliasTypeDeclaration */:
@@ -5861,7 +5867,7 @@ var NodeSemanticInfoService = class {
       case 38 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 88 /* IdentifierExpression */:
+      case 89 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
       case 58 /* NestedFunctionDeclaration */:
@@ -5870,10 +5876,10 @@ var NodeSemanticInfoService = class {
       case 59 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
         break;
-      case 135 /* QualifiedName */:
+      case 136 /* QualifiedName */:
         result = this.ofQualifiedNameQualifier(analyzer, parent, node, options6);
         break;
-      case 136 /* PackageVariableTranslation */: {
+      case 137 /* PackageVariableTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getPackageVariableTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5893,7 +5899,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 137 /* FieldOrVariantTranslation */: {
+      case 138 /* FieldOrVariantTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getFieldOrVariantTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5917,7 +5923,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 131 /* PackageFunctionTranslation */: {
+      case 132 /* PackageFunctionTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getPackageFunctionTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5941,7 +5947,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 132 /* MethodTranslation */: {
+      case 133 /* MethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5965,7 +5971,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 139 /* TypeTranslation */: {
+      case 140 /* TypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5985,7 +5991,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 133 /* FunctionTypeTranslation */: {
+      case 134 /* FunctionTypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getFunctionTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -6005,7 +6011,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 144 /* ParameterDeclaration */:
+      case 145 /* ParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofParameterDeclaration(parent));
         break;
       case 8 /* PackageImport */:
@@ -6014,7 +6020,7 @@ var NodeSemanticInfoService = class {
       case 9 /* PackageName */:
         result = void 0;
         break;
-      case 78 /* MemberAccessExpression */:
+      case 79 /* MemberAccessExpression */:
         result = this.ofProperty(analyzer, parent, options6);
         break;
       case 52 /* MethodDeclaration */:
@@ -6026,10 +6032,10 @@ var NodeSemanticInfoService = class {
       case 54 /* FieldDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofFieldDeclaration(parent));
         break;
-      case 143 /* TypeParameterDeclaration */:
+      case 144 /* TypeParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeParameterDeclaration(parent));
         break;
-      case 142 /* VariantDeclaration */:
+      case 143 /* VariantDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofVariantDeclaration(parent));
         break;
       case 36 /* PackageVariableGetterDeclaration */:
@@ -6052,7 +6058,7 @@ var NodeSemanticInfoService = class {
     let result;
     const meaning = analyzer.resolveMemberAccessExpression(node).meaning;
     switch (meaning.kind) {
-      case "instance-variable-access": {
+      case "instance-field-access": {
         let narrowedType;
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
@@ -6065,7 +6071,7 @@ var NodeSemanticInfoService = class {
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
-      case "static-variable-access": {
+      case "static-field-access": {
         let narrowedType;
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
@@ -6165,10 +6171,10 @@ var NodeSemanticInfoService = class {
     switch (node.parent.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.ofNamedTypeSpecifierNameQualifier(analyzer, node.parent, qualifier, options6);
-      case 147 /* Tag */:
+      case 148 /* Tag */:
         return this.ofTagNameQualifier(analyzer, node.parent, qualifier, options6);
       case 42 /* ExtendedTypeClause */:
-      case 134 /* PackageImportTranslation */:
+      case 135 /* PackageImportTranslation */:
         return void 0;
       default:
         Debug.never(node.parent);
@@ -6631,7 +6637,7 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 78 /* MemberAccessExpression */) {
+    while (parent.kind === 79 /* MemberAccessExpression */) {
       const meaning = analyzer.resolveMemberAccessExpression(parent).meaning;
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
@@ -6672,7 +6678,7 @@ var NodeSemanticInfoService = class {
     let parentCallExpression;
     if (parent.kind === 69 /* CallExpression */) {
       parentCallExpression = parent;
-    } else if (parent.kind === 89 /* GenericSpecializationExpression */) {
+    } else if (parent.kind === 90 /* GenericSpecializationExpression */) {
       const grandParent = getParentSkippingParenthesizedExpressions(parent);
       if (grandParent.kind === 69 /* CallExpression */) {
         parentCallExpression = grandParent;
@@ -6928,8 +6934,6 @@ function getEntitySourceLocations(analyzer, entity) {
         case 17 /* AnonymousFunctionTypeDeclaration */:
         case 18 /* AnonymousStructuredTypeDeclaration */:
         case 19 /* AnonymousVariantTypeDeclaration */:
-        case 67 /* FunctionBlockLiteral */:
-        case 74 /* FunctionLiteral */:
           range = node.rangeWithoutTrivia;
           break;
         case 22 /* PackageAliasTypeDeclaration */:
@@ -6939,7 +6943,7 @@ function getEntitySourceLocations(analyzer, entity) {
         case 38 /* PackageVariantTypeDeclaration */:
         case 58 /* NestedFunctionDeclaration */:
         case 52 /* MethodDeclaration */:
-        case 143 /* TypeParameterDeclaration */:
+        case 144 /* TypeParameterDeclaration */:
         case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
@@ -7084,9 +7088,12 @@ var DefinitionService = class {
   getReferenceTargetSourceLocation(analyzer, target, tokenOrKeyword, sourceFile) {
     switch (target.kind) {
       case "entity":
+        if (target.entity.kind === 0 /* Variable */) {
+          return this.getSourceLocationsOfVariableEntity(analyzer, target.entity);
+        }
         return getEntitySourceLocations(analyzer, target.entity);
       case "type-variable":
-        return getEntitySourceLocations(analyzer, target.variable.getEntity());
+        return this.getSourceLocationsOfVariableEntity(analyzer, target.variable.getEntity());
       case "type-constructor":
         return getEntitySourceLocations(analyzer, target.constructor_.getEntity());
       case "accessed-function":
@@ -7096,9 +7103,9 @@ var DefinitionService = class {
       case "type-dereference-operator":
         return getEntitySourceLocations(analyzer, target.operator.getEntity());
       case "match-result-value-parameter":
-        return getEntitySourceLocations(analyzer, target.parameter.entity);
+        return this.getSourceLocationsOfVariableEntity(analyzer, target.parameter.entity);
       case "type-value-parameter":
-        return getEntitySourceLocations(analyzer, target.parameter.getEntity());
+        return this.getSourceLocationsOfVariableEntity(analyzer, target.parameter.getEntity());
       case "package":
         return [new SourceLocation(sourceFile, tokenOrKeyword.value.rangeWithoutTrivia)];
       case "package-name-tree-node":
@@ -7158,6 +7165,80 @@ var DefinitionService = class {
     }
     return new LocalizationContext(translationPackages, referenceContext.originalLocale);
   }
+  getSourceLocationsOfVariableEntity(analyzer, entity) {
+    let result = getEntitySourceLocations(analyzer, entity);
+    if (result === void 0 && entity.kind === 0 /* Variable */) {
+      const specialVariableInfo = entity.isSpecial();
+      if (specialVariableInfo !== void 0) {
+        result = this.getSourceLocationsOfSpecialVariable(analyzer, specialVariableInfo);
+      }
+    }
+    return result;
+  }
+  getSourceLocationsOfSpecialVariable(analyzer, info) {
+    switch (info.kind) {
+      case "result":
+        return [this.getSourceLocationOfSubprogramNode(analyzer, info.subprogramNode)];
+      case "value":
+        return [this.getSourceLocationOfSubprogramNode(analyzer, info.setterDeclaration)];
+      case "implicit-function-block-parameter":
+        return [this.getSourceLocationOfSubprogramNode(analyzer, info.functionBlockLiteral)];
+      case "backing":
+        return void 0;
+      default:
+        Debug.never(info);
+    }
+  }
+  getSourceLocationOfSubprogramNode(analyzer, node) {
+    let range;
+    switch (node.kind) {
+      case 27 /* PackageFunctionDeclaration */:
+      case 36 /* PackageVariableGetterDeclaration */:
+      case 37 /* PackageVariableSetterDeclaration */:
+      case 52 /* MethodDeclaration */:
+      case 55 /* FieldGetterDeclaration */:
+      case 56 /* FieldSetterDeclaration */:
+      case 58 /* NestedFunctionDeclaration */:
+        range = node.name.rangeWithoutTrivia;
+        break;
+      case 25 /* PackageConstructorDeclaration */:
+        range = node.creationKeyword.rangeWithoutTrivia;
+        break;
+      case 26 /* PackageEntryPointDeclaration */:
+        range = node.runKeyword.rangeWithoutTrivia;
+        break;
+      case 45 /* ConstructorDeclaration */:
+        range = node.creationKeyword.rangeWithoutTrivia;
+        break;
+      case 46 /* DestructorDeclaration */:
+        range = node.destructionKeyword.rangeWithoutTrivia;
+        break;
+      case 47 /* IndexedElementGetterDeclaration */:
+      case 48 /* IndexedElementSetterDeclaration */:
+        range = node.parameterClause.rangeWithoutTrivia;
+        break;
+      case 50 /* DereferencedVariableGetterDeclaration */:
+      case 51 /* DereferencedVariableSetterDeclaration */:
+        range = node.caretToken.rangeWithoutTrivia;
+        break;
+      case 53 /* OperatorDeclaration */:
+        range = node.name.rangeWithoutTrivia;
+        break;
+      case 67 /* FunctionBlockLiteral */:
+        range = node.block.openBraceToken.rangeWithoutTrivia;
+        break;
+      case 74 /* FunctionLiteral */: {
+        const rangeStart = node.functionKeyword.rangeWithoutTrivia.start;
+        const rangeEnd = node.parameterClause.rangeWithoutTrivia.end;
+        range = new Range(rangeStart, rangeEnd);
+        break;
+      }
+      default:
+        Debug.never(node);
+    }
+    const sourceFile = TreeQuery.fromNode(node).projectSourceFile(analyzer);
+    return new SourceLocation(sourceFile, range);
+  }
 };
 var DefinitionsAndReferenceInfo = class {
   constructor(definitionLocations, referenceRange) {
@@ -7234,7 +7315,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 77 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 78 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -7278,7 +7359,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 80 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 81 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -7294,7 +7375,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 91 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 92 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -7322,7 +7403,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 86 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 87 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7334,7 +7415,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 87 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 88 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7740,9 +7821,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 88 /* IdentifierExpression */:
+      case 89 /* IdentifierExpression */:
         return parent;
-      case 78 /* MemberAccessExpression */:
+      case 79 /* MemberAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7763,9 +7844,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 88 /* IdentifierExpression */:
+      case 89 /* IdentifierExpression */:
         return true;
-      case 78 /* MemberAccessExpression */:
+      case 79 /* MemberAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7791,17 +7872,17 @@ var EvaluatableExpressionService = class {
         return { nameIdentifier: node.name };
       case 59 /* LocalVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 144 /* ParameterDeclaration */:
+      case 145 /* ParameterDeclaration */:
         return { nameIdentifier: node.name };
       case 52 /* MethodDeclaration */:
         return { nameIdentifier: node.name };
       case 54 /* FieldDeclaration */:
         return { nameIdentifier: node.name };
-      case 143 /* TypeParameterDeclaration */:
+      case 144 /* TypeParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 142 /* VariantDeclaration */:
+      case 143 /* VariantDeclaration */:
         return { nameIdentifier: node.name };
-      case 101 /* ErrorVariableDeclaration */:
+      case 102 /* ErrorVariableDeclaration */:
         return { nameIdentifier: node.name };
       default:
         return void 0;
@@ -7981,7 +8062,7 @@ var HoverService = class {
           const typeText = this._displayService.displayType(firstTarget.value.type);
           return new Hover(`${keywordText}: ${typeText}`, range);
         } else if (firstTarget.value.typeContextKind === "base") {
-          const keywordText = this._displayService.displayKeyword(56 /* Base */);
+          const keywordText = this._displayService.displayKeyword(57 /* Base */);
           const typeText = this._displayService.displayType(firstTarget.value.type);
           return new Hover(`${keywordText}: ${typeText}`, range);
         } else {
@@ -8238,7 +8319,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 142 /* VariantDeclaration */: {
+        case 143 /* VariantDeclaration */: {
           result.push(
             this.createItem(
               9 /* Variant */,
@@ -8250,7 +8331,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 143 /* TypeParameterDeclaration */: {
+        case 144 /* TypeParameterDeclaration */: {
           result.push(
             this.createItem(
               18 /* TypeParameter */,
@@ -8306,23 +8387,23 @@ var SourceFileItemsService = class {
       case 8 /* InvalidType */:
         return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(16 /* Type */, this.locale, this.dialect)}>`;
       case 10 /* Constructor */:
-        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(30 /* Creation */, this.locale, this.dialect);
+        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(31 /* Creation */, this.locale, this.dialect);
       case 11 /* Destructor */:
-        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(47 /* Destruction */, this.locale, this.dialect);
+        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(48 /* Destruction */, this.locale, this.dialect);
       case 9 /* Variant */:
         return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(6 /* Variant */, this.locale, this.dialect)}>`;
       case 18 /* TypeParameter */:
         return name ?? `<${LocalizationHelper.localizeHelperPhrase(2 /* TypeParameter */, this.locale)}>`;
       case 2 /* PackageVariableGetter */:
       case 13 /* FieldGetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(58 /* Get */, this.locale, this.dialect)} ${name ?? ""}`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Get */, this.locale, this.dialect)} ${name ?? ""}`;
       case 3 /* PackageVariableSetter */:
       case 14 /* FieldSetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Set */, this.locale, this.dialect)} ${name ?? ""}`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(60 /* Set */, this.locale, this.dialect)} ${name ?? ""}`;
       case 16 /* IndexedElementGetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(58 /* Get */, this.locale, this.dialect)} []`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Get */, this.locale, this.dialect)} []`;
       case 17 /* IndexedElementSetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Set */, this.locale, this.dialect)} []`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(60 /* Set */, this.locale, this.dialect)} []`;
       default:
         Debug.never(kind);
     }
@@ -8487,7 +8568,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 === 81 /* 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 === 82 /* TextTemplateLiteral */) {
         const textContentStart = child.rangeWithoutTrivia.start + 1;
         const textContentEnd = child.rangeWithoutTrivia.end - 1;
         if (offset >= textContentStart && offset < textContentEnd) {
@@ -8518,13 +8599,13 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 156 /* TypeAnnotation */:
+      case 157 /* TypeAnnotation */:
       case 34 /* StructuredTypeDeclarationBody */:
       case 39 /* VariantTypeDeclarationBody */:
       case 23 /* AliasTypeDeclarationBody */:
       case 29 /* FunctionTypeDeclarationBody */:
-      case 83 /* TextTemplateSpan */:
-      case 82 /* TextTemplateSpanList */:
+      case 84 /* TextTemplateSpan */:
+      case 83 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8562,7 +8643,7 @@ var SemanticTokensService = class {
             controller.stopChildrenTraverse();
             return;
           }
-          if (node.kind === 88 /* IdentifierExpression */) {
+          if (node.kind === 89 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.value.getEntity();
@@ -8618,9 +8699,9 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 78 /* MemberAccessExpression */) {
+          if (node.kind === 79 /* MemberAccessExpression */) {
             const meaning = analyzer.resolveMemberAccessExpression(node).meaning;
-            if (meaning.kind === "static-variable-access") {
+            if (meaning.kind === "static-field-access") {
               const entity = meaning.variable.value.getEntity();
               if (entity.subkind === "field" && entity.isVariant()) {
                 result.push(
@@ -8662,7 +8743,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 142 /* VariantDeclaration */) {
+          if (node.kind === 143 /* VariantDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8850,7 +8931,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 === 153 /* 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);
@@ -8895,9 +8976,9 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 89 /* GenericSpecializationExpression */:
+      case 90 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
-      case 147 /* Tag */:
+      case 148 /* Tag */:
         return this.getSignaturesForTag(node);
       default:
         Debug.never(node);
@@ -8936,7 +9017,7 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
-    if (expression.kind === 88 /* IdentifierExpression */) {
+    if (expression.kind === 89 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "function-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
@@ -8951,7 +9032,7 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 78 /* MemberAccessExpression */) {
+    if (expression.kind === 79 /* MemberAccessExpression */) {
       const meaning = this._analyzer.resolveMemberAccessExpression(expression).meaning;
       let accessedFunctions;
       if (meaning.kind === "instance-method-access") {
@@ -9228,7 +9309,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 147 /* Tag */: {
+        case 148 /* Tag */: {
           if (node.openParenthesisToken !== void 0 && this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && node.argumentList !== void 0 && (node.closeParenthesisToken === void 0 || node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(node);
@@ -11765,7 +11846,7 @@ var EntityToSyntax = class {
   convertPackageVariable(entity) {
     const commonModifiers = new Array();
     if (entity.isConstant()) {
-      commonModifiers.push(SyntaxFactory.modifier(35 /* Const */));
+      commonModifiers.push(SyntaxFactory.modifier(36 /* Const */));
     }
     const name = this.getEntityName(entity);
     const type = this.convertType(entity.getType());
@@ -11807,7 +11888,7 @@ var EntityToSyntax = class {
     const tags = this.convertTags(entity.getTags());
     const modifiers = new Array();
     if (entity.isAsync()) {
-      modifiers.push(SyntaxFactory.modifier(40 /* Async */));
+      modifiers.push(SyntaxFactory.modifier(41 /* Async */));
     }
     const isHidden = entity.isHidden();
     if (isHidden !== void 0) {
@@ -11889,19 +11970,19 @@ var EntityToSyntax = class {
     }
     const commonModifiers = new Array();
     if (entity.isConstant()) {
-      commonModifiers.push(SyntaxFactory.modifier(35 /* Const */));
+      commonModifiers.push(SyntaxFactory.modifier(36 /* Const */));
     }
     if (entity.isStatic()) {
-      commonModifiers.push(SyntaxFactory.modifier(41 /* Static */));
+      commonModifiers.push(SyntaxFactory.modifier(42 /* Static */));
     }
     if (entity.isAbstract()) {
-      commonModifiers.push(SyntaxFactory.modifier(37 /* Abstract */));
+      commonModifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
     }
     if (entity.isRedefinable()) {
-      commonModifiers.push(SyntaxFactory.modifier(38 /* Redefinable */));
+      commonModifiers.push(SyntaxFactory.modifier(39 /* Redefinable */));
     }
     if (entity.isRedefined()) {
-      commonModifiers.push(SyntaxFactory.modifier(39 /* Redefined */));
+      commonModifiers.push(SyntaxFactory.modifier(40 /* Redefined */));
     }
     const name = this.getEntityName(entity);
     const type = this.convertType(entity.getType());
@@ -11947,16 +12028,16 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isStatic()) {
-      modifiers.push(SyntaxFactory.modifier(41 /* Static */));
+      modifiers.push(SyntaxFactory.modifier(42 /* Static */));
     }
     if (entity.isAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(37 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
     }
     if (entity.isRedefinable()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Redefinable */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Redefinable */));
     }
     if (entity.isRedefined()) {
-      modifiers.push(SyntaxFactory.modifier(39 /* Redefined */));
+      modifiers.push(SyntaxFactory.modifier(40 /* Redefined */));
     }
     const name = this.getEntityName(entity);
     const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
@@ -11972,7 +12053,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(37 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
     return SyntaxFactory.constructorDeclaration(tags, modifiers, parameters, void 0);
@@ -11985,7 +12066,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(37 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
     return SyntaxFactory.destructorDeclaration(tags, modifiers, parameters, void 0);
@@ -11993,10 +12074,10 @@ var EntityToSyntax = class {
   convertIndexer(entity) {
     const commonModifiers = new Array();
     if (entity.isStatic()) {
-      commonModifiers.push(SyntaxFactory.modifier(41 /* Static */));
+      commonModifiers.push(SyntaxFactory.modifier(42 /* Static */));
     }
     if (entity.isAbstract()) {
-      commonModifiers.push(SyntaxFactory.modifier(37 /* Abstract */));
+      commonModifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
     const result = new Array();
@@ -12110,21 +12191,21 @@ var EntityToSyntax = class {
     let levelKeyword;
     switch (hiding.kind) {
       case "type":
-        levelKeyword = 51 /* InType */;
+        levelKeyword = 52 /* InType */;
         break;
       case "type-hierarchy":
-        levelKeyword = 48 /* InHierarchy */;
+        levelKeyword = 49 /* InHierarchy */;
         break;
       case "file":
-        levelKeyword = 49 /* InFile */;
+        levelKeyword = 50 /* InFile */;
         break;
       case "package":
-        levelKeyword = 50 /* InPackage */;
+        levelKeyword = 51 /* InPackage */;
         break;
       default:
         Debug.never(hiding);
     }
-    return SyntaxFactory.modifier(36 /* Hidden */, levelKeyword);
+    return SyntaxFactory.modifier(37 /* Hidden */, levelKeyword);
   }
   convertTags(_entityTags) {
     return [];
@@ -13392,7 +13473,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 === 91 /* AssignmentStatement */) {
+        if (node?.kind === 92 /* AssignmentStatement */) {
           const sourceFileEdit = this._addPropertyAssignmentService.createEditWithAssignment(
             sourceFileContext.sourceFile,
             node,
@@ -13429,7 +13510,7 @@ var LanguageServer = class {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
         if (node !== void 0) {
           let nodeForRange = node;
-          if (node.kind === 91 /* AssignmentStatement */) {
+          if (node.kind === 92 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);