@artel/artc 0.6.25235 → 0.6.25237

package/build/api/ApiServices.js

@@ -182,7 +182,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-PGJQFLPG.js";
+} from "../chunk-PDVQZURU.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 !== 76 /* 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 === 90 /* 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 91 /* StatementBlock */:
         return this.getContainingSubprogram(parent)?.block;
-      case 94 /* FunctionBlock */:
+      case 92 /* FunctionBlock */:
         return void 0;
       default:
         Debug.never(parent);
@@ -372,23 +372,23 @@ var AddPropertyAssignmentService = class {
 };
 function isSubprogramDeclaration(node) {
   switch (node.kind) {
-    case 25 /* PackageConstructorDeclaration */:
-    case 26 /* PackageEntryPointDeclaration */:
-    case 27 /* PackageFunctionDeclaration */:
-    case 36 /* PackageVariableGetterDeclaration */:
-    case 37 /* PackageVariableSetterDeclaration */:
-    case 45 /* ConstructorDeclaration */:
-    case 46 /* DestructorDeclaration */:
-    case 47 /* IndexedElementGetterDeclaration */:
-    case 48 /* IndexedElementSetterDeclaration */:
-    case 50 /* DereferencedVariableGetterDeclaration */:
-    case 51 /* DereferencedVariableSetterDeclaration */:
-    case 52 /* MethodDeclaration */:
-    case 55 /* FieldGetterDeclaration */:
-    case 56 /* FieldSetterDeclaration */:
-    case 58 /* NestedFunctionDeclaration */:
-    case 67 /* FunctionBlockLiteral */:
-    case 74 /* FunctionLiteral */:
+    case 23 /* PackageConstructorDeclaration */:
+    case 24 /* PackageEntryPointDeclaration */:
+    case 25 /* PackageFunctionDeclaration */:
+    case 34 /* PackageVariableGetterDeclaration */:
+    case 35 /* PackageVariableSetterDeclaration */:
+    case 43 /* ConstructorDeclaration */:
+    case 44 /* DestructorDeclaration */:
+    case 45 /* IndexedElementGetterDeclaration */:
+    case 46 /* IndexedElementSetterDeclaration */:
+    case 48 /* DereferencedVariableGetterDeclaration */:
+    case 49 /* DereferencedVariableSetterDeclaration */:
+    case 50 /* MethodDeclaration */:
+    case 53 /* FieldGetterDeclaration */:
+    case 54 /* FieldSetterDeclaration */:
+    case 56 /* NestedFunctionDeclaration */:
+    case 65 /* FunctionBlockLiteral */:
+    case 72 /* FunctionLiteral */:
       return true;
     default:
       Debug.typeIsAssignableTo();
@@ -1619,10 +1619,10 @@ var SyntaxToCode = class _SyntaxToCode {
         return true;
       case 15 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 29 /* FunctionTypeDeclarationBody */:
+          case 27 /* FunctionTypeDeclarationBody */:
             return true;
-          case 34 /* StructuredTypeDeclarationBody */:
-          case 39 /* VariantTypeDeclarationBody */:
+          case 32 /* StructuredTypeDeclarationBody */:
+          case 37 /* VariantTypeDeclarationBody */:
             return false;
           default:
             Debug.never(node.typeDeclaration.body);
@@ -1645,10 +1645,10 @@ var SyntaxToCode = class _SyntaxToCode {
         return true;
       case 15 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 29 /* FunctionTypeDeclarationBody */:
+          case 27 /* FunctionTypeDeclarationBody */:
             return true;
-          case 34 /* StructuredTypeDeclarationBody */:
-          case 39 /* VariantTypeDeclarationBody */:
+          case 32 /* StructuredTypeDeclarationBody */:
+          case 37 /* VariantTypeDeclarationBody */:
             return false;
           default:
             Debug.never(node.typeDeclaration.body);
@@ -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 !== 90 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
       this.writeWhitespace();
       this.writeFunctionBlock(node, false);
     } else {
@@ -2010,36 +2010,36 @@ var SyntaxToCode = class _SyntaxToCode {
       [13 /* ParenthesizedTypeSpecifier */]: this.prototype.writeParenthesizedTypeSpecifier,
       [14 /* NullableTypeSpecifier */]: this.prototype.writeNullableTypeSpecifier,
       [15 /* AnonymousTypeSpecifier */]: this.prototype.writeAnonymousTypeSpecifier,
-      [22 /* PackageAliasTypeDeclaration */]: this.prototype.writePackageAliasTypeDeclaration,
-      [24 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
-      [25 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
-      [26 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
-      [27 /* PackageFunctionDeclaration */]: this.prototype.writePackageFunctionDeclaration,
-      [28 /* PackageFunctionTypeDeclaration */]: this.prototype.writePackageFunctionTypeDeclaration,
-      [29 /* FunctionTypeDeclarationBody */]: this.prototype.writeFunctionTypeDeclarationBody,
-      [30 /* BaseTypeList */]: this.prototype.writeBaseTypeList,
-      [32 /* TypeMemberDeclarationBlock */]: this.prototype.writeTypeMemberDeclarationBlock,
-      [33 /* PackageStructuredTypeDeclaration */]: this.prototype.writePackageStructuredTypeDeclaration,
-      [34 /* StructuredTypeDeclarationBody */]: this.prototype.writeStructuredTypeDeclarationBody,
-      [35 /* PackageVariableDeclaration */]: this.prototype.writePackageVariableDeclaration,
-      [36 /* PackageVariableGetterDeclaration */]: this.prototype.writePackageVariableGetterDeclaration,
-      [37 /* PackageVariableSetterDeclaration */]: this.prototype.writePackageVariableSetterDeclaration,
-      [38 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
-      [39 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
-      [44 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
-      [45 /* ConstructorDeclaration */]: this.prototype.writeConstructorDeclaration,
-      [46 /* DestructorDeclaration */]: this.prototype.writeDestructorDeclaration,
-      [47 /* IndexedElementGetterDeclaration */]: this.prototype.writeIndexedElementGetterDeclaration,
-      [48 /* IndexedElementSetterDeclaration */]: this.prototype.writeIndexedElementSetterDeclaration,
-      [50 /* DereferencedVariableGetterDeclaration */]: this.prototype.writeDereferencedVariableGetterDeclaration,
-      [51 /* DereferencedVariableSetterDeclaration */]: this.prototype.writeDereferencedVariableSetterDeclaration,
-      [52 /* MethodDeclaration */]: this.prototype.writeMethodDeclaration,
-      [53 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
-      [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,
+      [20 /* PackageAliasTypeDeclaration */]: this.prototype.writePackageAliasTypeDeclaration,
+      [22 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
+      [23 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
+      [24 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
+      [25 /* PackageFunctionDeclaration */]: this.prototype.writePackageFunctionDeclaration,
+      [26 /* PackageFunctionTypeDeclaration */]: this.prototype.writePackageFunctionTypeDeclaration,
+      [27 /* FunctionTypeDeclarationBody */]: this.prototype.writeFunctionTypeDeclarationBody,
+      [28 /* BaseTypeList */]: this.prototype.writeBaseTypeList,
+      [30 /* TypeMemberDeclarationBlock */]: this.prototype.writeTypeMemberDeclarationBlock,
+      [31 /* PackageStructuredTypeDeclaration */]: this.prototype.writePackageStructuredTypeDeclaration,
+      [32 /* StructuredTypeDeclarationBody */]: this.prototype.writeStructuredTypeDeclarationBody,
+      [33 /* PackageVariableDeclaration */]: this.prototype.writePackageVariableDeclaration,
+      [34 /* PackageVariableGetterDeclaration */]: this.prototype.writePackageVariableGetterDeclaration,
+      [35 /* PackageVariableSetterDeclaration */]: this.prototype.writePackageVariableSetterDeclaration,
+      [36 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
+      [37 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
+      [42 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
+      [43 /* ConstructorDeclaration */]: this.prototype.writeConstructorDeclaration,
+      [44 /* DestructorDeclaration */]: this.prototype.writeDestructorDeclaration,
+      [45 /* IndexedElementGetterDeclaration */]: this.prototype.writeIndexedElementGetterDeclaration,
+      [46 /* IndexedElementSetterDeclaration */]: this.prototype.writeIndexedElementSetterDeclaration,
+      [48 /* DereferencedVariableGetterDeclaration */]: this.prototype.writeDereferencedVariableGetterDeclaration,
+      [49 /* DereferencedVariableSetterDeclaration */]: this.prototype.writeDereferencedVariableSetterDeclaration,
+      [50 /* MethodDeclaration */]: this.prototype.writeMethodDeclaration,
+      [51 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
+      [52 /* FieldDeclaration */]: this.prototype.writeFieldDeclaration,
+      [53 /* FieldGetterDeclaration */]: this.prototype.writeFieldGetterDeclaration,
+      [54 /* FieldSetterDeclaration */]: this.prototype.writeFieldSetterDeclaration,
+      [91 /* StatementBlock */]: this.prototype.writeStatementBlock,
+      [92 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
       [135 /* QualifiedName */]: this.prototype.writeQualifiedName,
       [142 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
       [143 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
@@ -2057,80 +2057,80 @@ var SyntaxToCode = class _SyntaxToCode {
       [6 /* PackageGroupImportDirective */]: this.prototype.writeNodeDefault,
       [7 /* PackageImportList */]: this.prototype.writeNodeDefault,
       [16 /* InvalidTypeSpecifier */]: this.prototype.writeNodeDefault,
-      [20 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
-      [21 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
-      [23 /* AliasTypeDeclarationBody */]: this.prototype.writeNodeDefault,
-      [31 /* TypeMemberDeclarationList */]: this.prototype.writeNodeDefault,
-      [40 /* TypeExtensionDeclaration */]: this.prototype.writeNodeDefault,
-      [41 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
-      [42 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
-      [43 /* InvalidPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [49 /* IndexParameterClause */]: this.prototype.writeNodeDefault,
-      [57 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [58 /* NestedFunctionDeclaration */]: this.prototype.writeNodeDefault,
-      [59 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [60 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [61 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
-      [62 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
-      [63 /* AssertionExpression */]: this.prototype.writeNodeDefault,
-      [64 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
-      [65 /* AsExpression */]: this.prototype.writeNodeDefault,
-      [66 /* BinaryExpression */]: this.prototype.writeNodeDefault,
-      [67 /* FunctionBlockLiteral */]: this.prototype.writeNodeDefault,
-      [68 /* ArgumentList */]: this.prototype.writeNodeDefault,
-      [69 /* CallExpression */]: this.prototype.writeNodeDefault,
-      [70 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
-      [71 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
-      [72 /* InvalidExpression */]: this.prototype.writeNodeDefault,
-      [73 /* IsExpression */]: this.prototype.writeNodeDefault,
-      [74 /* FunctionLiteral */]: this.prototype.writeNodeDefault,
-      [75 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
-      [76 /* ConditionalExpression */]: 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,
+      [123 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
+      [122 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
+      [21 /* AliasTypeDeclarationBody */]: this.prototype.writeNodeDefault,
+      [29 /* TypeMemberDeclarationList */]: this.prototype.writeNodeDefault,
+      [38 /* TypeExtensionDeclaration */]: this.prototype.writeNodeDefault,
+      [39 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
+      [40 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
+      [41 /* InvalidPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
+      [47 /* IndexParameterClause */]: this.prototype.writeNodeDefault,
+      [55 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
+      [56 /* NestedFunctionDeclaration */]: this.prototype.writeNodeDefault,
+      [57 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [58 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [59 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
+      [60 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
+      [61 /* AssertionExpression */]: this.prototype.writeNodeDefault,
+      [62 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
+      [63 /* AsExpression */]: this.prototype.writeNodeDefault,
+      [64 /* BinaryExpression */]: this.prototype.writeNodeDefault,
+      [65 /* FunctionBlockLiteral */]: this.prototype.writeNodeDefault,
+      [66 /* ArgumentList */]: this.prototype.writeNodeDefault,
+      [67 /* CallExpression */]: this.prototype.writeNodeDefault,
+      [68 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
+      [69 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
+      [70 /* InvalidExpression */]: this.prototype.writeNodeDefault,
+      [71 /* IsExpression */]: this.prototype.writeNodeDefault,
+      [72 /* FunctionLiteral */]: this.prototype.writeNodeDefault,
+      [73 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
+      [74 /* ConditionalExpression */]: this.prototype.writeNodeDefault,
+      [75 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [76 /* MemberAccessExpression */]: this.prototype.writeNodeDefault,
+      [77 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
+      [78 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
+      [79 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [80 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [81 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [82 /* TokenExpression */]: this.prototype.writeNodeDefault,
+      [83 /* KeywordExpression */]: this.prototype.writeNodeDefault,
+      [84 /* ObjectExpression */]: this.prototype.writeNodeDefault,
+      [85 /* BaseExpression */]: this.prototype.writeNodeDefault,
+      [86 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
+      [87 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
+      [88 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
+      [89 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
+      [90 /* StatementList */]: this.prototype.writeNodeDefault,
+      [93 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
+      [94 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
+      [95 /* DisposeStatement */]: this.prototype.writeNodeDefault,
+      [96 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [97 /* TryStatement */]: this.prototype.writeNodeDefault,
+      [98 /* CatchClause */]: this.prototype.writeNodeDefault,
+      [99 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [100 /* FinallyClause */]: this.prototype.writeNodeDefault,
+      [101 /* EmptyStatement */]: this.prototype.writeNodeDefault,
+      [102 /* ErrorStatement */]: this.prototype.writeNodeDefault,
+      [103 /* ImportantStatement */]: this.prototype.writeNodeDefault,
+      [104 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
+      [105 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
+      [106 /* ForStatement */]: this.prototype.writeNodeDefault,
+      [107 /* IfStatement */]: this.prototype.writeNodeDefault,
+      [108 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
+      [109 /* ElseIfClause */]: this.prototype.writeNodeDefault,
+      [110 /* ElseClause */]: this.prototype.writeNodeDefault,
+      [111 /* InvalidStatement */]: this.prototype.writeNodeDefault,
+      [112 /* NestedFunctionDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [113 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [114 /* LoopStatement */]: this.prototype.writeNodeDefault,
+      [115 /* ReturnStatement */]: this.prototype.writeNodeDefault,
+      [116 /* CaseClauseList */]: this.prototype.writeNodeDefault,
+      [117 /* SwitchStatement */]: this.prototype.writeNodeDefault,
+      [118 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
+      [119 /* CaseClause */]: this.prototype.writeNodeDefault,
+      [120 /* WhileStatement */]: this.prototype.writeNodeDefault,
+      [121 /* YieldStatement */]: this.prototype.writeNodeDefault,
       [124 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
       [125 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
       [126 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
@@ -2348,7 +2348,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(55 /* Translations */) && tokenOrKeyword.parent.kind === 122 /* TranslationsDeclaration */) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2374,7 +2374,7 @@ var TranslationsGenerationService = class {
     if (tokenOrKeyword === void 0) {
       return false;
     }
-    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */)) {
+    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 122 /* TranslationsDeclaration */)) {
       return false;
     }
     const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
@@ -2542,7 +2542,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
       indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(node, this._sourceFile);
     }
     if (indentationStepSize === void 0) {
-      const translationsDeclarations = node.kind === 21 /* TranslationsDeclaration */ ? node : node.parent.parent;
+      const translationsDeclarations = node.kind === 122 /* TranslationsDeclaration */ ? node : node.parent.parent;
       for (const member of translationsDeclarations.translationList.translationDeclarations) {
         if (member.kind === 139 /* TypeTranslation */) {
           indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(member, this._sourceFile);
@@ -2825,11 +2825,11 @@ var ValueArgumentFactory = class _ValueArgumentFactory {
 var SignatureForNode = class _SignatureForNode {
   static getSignaturesForNode(analyzer, node) {
     switch (node.kind) {
-      case 69 /* CallExpression */:
+      case 67 /* CallExpression */:
         return _SignatureForNode.getSignaturesForCallExpression(analyzer, node);
-      case 70 /* AutotypeCallExpression */:
+      case 68 /* AutotypeCallExpression */:
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
-      case 71 /* IndexedAccessExpression */:
+      case 69 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
       case 147 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
@@ -2969,7 +2969,7 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         result = false;
         break;
       }
-      if (argument.expression === void 0 || argument.expression.kind === 72 /* InvalidExpression */) {
+      if (argument.expression === void 0 || argument.expression.kind === 70 /* InvalidExpression */) {
         continue;
       }
       const targetParameterType = targetParameter.getType();
@@ -3207,7 +3207,7 @@ var CompletionService = class {
     if (syntaxContext.isInComment || syntaxContext.isInStringOrChar) {
       return { kind: "none" };
     }
-    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 53 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 52 /* MethodDeclaration */)) {
+    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 51 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 50 /* MethodDeclaration */)) {
       return new OperatorNameCompletionContext(syntaxContext.isInQuotedIdentifier);
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
@@ -3225,7 +3225,7 @@ var CompletionService = class {
     if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || this.tokenOrKeywordIsPackageImportListChild(tokenOrKeyword)) {
       return new PackageImportCompletionContext([], void 0);
     }
-    if (tokenOrKeyword.isToken(27 /* Dot */) && tokenOrKeyword.parent.kind === 78 /* MemberAccessExpression */) {
+    if (tokenOrKeyword.isToken(27 /* Dot */) && tokenOrKeyword.parent.kind === 76 /* MemberAccessExpression */) {
       const memberAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(memberAccess.expression);
@@ -3273,7 +3273,7 @@ var CompletionService = class {
       );
       if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
         let completionInIsOrAsExpressionInfo;
-        if (namedTypeSpecifier.parent.kind === 73 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
+        if (namedTypeSpecifier.parent.kind === 71 /* IsExpression */ || namedTypeSpecifier.parent.kind === 63 /* AsExpression */) {
           completionInIsOrAsExpressionInfo = {
             expressionType: this._analyzer.type.ofExpression(namedTypeSpecifier.parent.expression)
           };
@@ -3345,7 +3345,7 @@ var CompletionService = class {
     }
     if (syntaxContext.isUnqualifiedTypeContext !== void 0) {
       let completionInIsOrAsExpressionInfo;
-      if (tokenOrKeyword.parent.kind === 73 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+      if (tokenOrKeyword.parent.kind === 71 /* IsExpression */ || tokenOrKeyword.parent.kind === 63 /* AsExpression */) {
         completionInIsOrAsExpressionInfo = {
           expressionType: this._analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
@@ -3494,11 +3494,11 @@ var CompletionService = class {
       let signatures;
       let valueArguments;
       switch (role.argumentList.parent.kind) {
-        case 69 /* CallExpression */:
+        case 67 /* CallExpression */:
           signatures = SignatureForNode.getSignaturesForCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(role.argumentList.parent);
           break;
-        case 70 /* AutotypeCallExpression */:
+        case 68 /* AutotypeCallExpression */:
           signatures = SignatureForNode.getSignaturesForAutotypeCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(
             role.argumentList.parent
@@ -3508,7 +3508,7 @@ var CompletionService = class {
           signatures = SignatureForNode.getSignaturesForTag(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(role.argumentList.parent);
           break;
-        case 71 /* IndexedAccessExpression */:
+        case 69 /* IndexedAccessExpression */:
           signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
             this._analyzer,
             role.argumentList.parent
@@ -3705,7 +3705,7 @@ var CompletionService = class {
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
       kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(12 /* Function */).add(40 /* 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(40 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 56 /* NestedFunctionDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 72 /* FunctionLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 27 /* FunctionTypeDeclarationBody */)) {
       kinds.add(12 /* Function */);
     }
     return Query.from(kinds.values()).map(
@@ -3717,7 +3717,7 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 116 /* LoopStatement */;
+    return tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 91 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 114 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
@@ -3731,21 +3731,21 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(21 /* 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(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 91 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 107 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 109 /* ElseIfClause */);
   }
   isCatchKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */;
+    return tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 91 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 97 /* TryStatement */;
   }
   isFinallyKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* CatchClause */);
+    return tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 91 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 97 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 98 /* CatchClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(58 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3755,17 +3755,17 @@ var CompletionService = class {
       return false;
     }
     const token = positionDescription.tokenOrKeyword.value;
-    return token.parent.kind === 60 /* EnumerationVariableDeclaration */ && (token.parent.parent.elements.length > 0 && token.parent.parent.elements[token.parent.parent.elements.length - 1] === token.parent || token.parent.parent.elements.length > 1 && token.parent.parent.elements[token.parent.parent.elements.length - 2] === token.parent);
+    return token.parent.kind === 58 /* EnumerationVariableDeclaration */ && (token.parent.parent.elements.length > 0 && token.parent.parent.elements[token.parent.parent.elements.length - 1] === token.parent || token.parent.parent.elements.length > 1 && token.parent.parent.elements[token.parent.parent.elements.length - 2] === token.parent);
   }
   isCaseKeywordContext(positionDescription, syntaxContext) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 121 /* CaseClause */) {
+    if (tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 91 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 119 /* CaseClause */) {
       return true;
     }
-    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 119 /* SwitchStatement */) {
+    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 117 /* SwitchStatement */) {
       return true;
     }
     return false;
@@ -4413,10 +4413,10 @@ function getRightmostChildExcludingValidEmptyNodes(node) {
 }
 function isInvalidNode(node) {
   switch (node.kind) {
-    case 72 /* InvalidExpression */:
-    case 43 /* InvalidPackageMemberDeclaration */:
-    case 113 /* InvalidStatement */:
-    case 57 /* InvalidTypeMemberDeclaration */:
+    case 70 /* InvalidExpression */:
+    case 41 /* InvalidPackageMemberDeclaration */:
+    case 111 /* InvalidStatement */:
+    case 55 /* InvalidTypeMemberDeclaration */:
     case 16 /* InvalidTypeSpecifier */:
       return true;
     case 0 /* Token */:
@@ -5273,19 +5273,19 @@ var SyntaxContextFactory = class {
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(58 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 89 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 59 /* LocalVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 57 /* LocalVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 35 /* PackageVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 33 /* PackageVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 54 /* FieldDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 52 /* FieldDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5302,23 +5302,23 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 89 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 75 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 64 /* BinaryExpression */) {
       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 === 79 /* 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 === 81 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5330,12 +5330,12 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 91 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* FunctionBlock */) {
+    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 92 /* FunctionBlock */) {
       const block = tokenOrKeyword.parent;
-      if (block.expressionOrStatementList.kind !== 92 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
+      if (block.expressionOrStatementList.kind !== 90 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
         return {
           isExpressionContext: { expressionRole: new ExpressionRole_functionBlockExpression(block) },
           isStatementContext: true
@@ -5347,23 +5347,23 @@ var SyntaxContextFactory = class {
         };
       }
     }
-    if (tokenOrKeyword.isToken(52 /* Semicolon */) && tokenOrKeyword.parent.kind === 92 /* StatementList */) {
+    if (tokenOrKeyword.isToken(52 /* Semicolon */) && tokenOrKeyword.parent.kind === 90 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(45 /* OpenParenthesis */)) {
-      if (tokenOrKeyword.parent.kind === 75 /* ParenthesizedExpression */) {
+      if (tokenOrKeyword.parent.kind === 73 /* ParenthesizedExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 79 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 77 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 69 /* CallExpression */) {
+      if (tokenOrKeyword.parent.kind === 67 /* CallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
+      if (tokenOrKeyword.parent.kind === 68 /* AutotypeCallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5374,21 +5374,21 @@ var SyntaxContextFactory = class {
           return { isExpressionContext: { expressionRole }, isStatementContext: false };
         }
       }
-      if (tokenOrKeyword.parent.kind === 76 /* ConditionalExpression */) {
+      if (tokenOrKeyword.parent.kind === 74 /* ConditionalExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isToken(46 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+    if (tokenOrKeyword.isToken(46 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 69 /* IndexedAccessExpression */) {
       const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(46 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 61 /* ArrayLiteral */) {
+    if (tokenOrKeyword.isToken(46 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 59 /* ArrayLiteral */) {
       const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(25 /* Comma */)) {
-      if (tokenOrKeyword.parent.kind === 68 /* ArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 66 /* ArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5402,15 +5402,15 @@ 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 === 118 /* MatchExpressionList */) {
         const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 62 /* ArrayLiteralElementList */) {
+      if (tokenOrKeyword.parent.kind === 60 /* ArrayLiteralElementList */) {
         const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 76 /* ConditionalExpression */) {
+      if (tokenOrKeyword.parent.kind === 74 /* ConditionalExpression */) {
         if (tokenOrKeyword.value === tokenOrKeyword.parent.firstComma) {
           const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.firstExpression);
           return { isExpressionContext: { expressionRole }, isStatementContext: false };
@@ -5422,51 +5422,51 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: void 0, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 121 /* CaseClause */) {
+    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 119 /* 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 === 115 /* 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 === 102 /* 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 === 103 /* 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(44 /* Switch */) && tokenOrKeyword.parent.kind === 117 /* 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 === 107 /* 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 === 109 /* 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 === 106 /* 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 === 120 /* 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 === 114 /* 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 === 121 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(30 /* Cond */) && tokenOrKeyword.parent.kind === 76 /* ConditionalExpression */) {
+    if (tokenOrKeyword.isKeyword(30 /* Cond */) && tokenOrKeyword.parent.kind === 74 /* ConditionalExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5485,19 +5485,19 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(52 /* Semicolon */) && (tokenOrKeyword.parent.kind === 2 /* PackageMemberDeclarationList */ || tokenOrKeyword.parent.kind === 4 /* PackageImportDirectiveList */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* 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 */)) {
+    if (tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 30 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 38 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 31 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 36 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 20 /* PackageAliasTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* 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(21 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 122 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 22 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 92 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 23 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 24 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 25 /* PackageFunctionDeclaration */))) {
       return true;
     }
-    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 22 /* PackageMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 27 /* PackageFunctionDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 28 /* PackageFunctionTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 22 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 35 /* PackageVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 25 /* PackageFunctionDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 26 /* PackageFunctionTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 20 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 33 /* PackageVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      36 /* PackageVariableGetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
+      34 /* PackageVariableGetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 35 /* 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)) {
@@ -5513,28 +5513,28 @@ var SyntaxContextFactory = class {
     return false;
   }
   static isTypeMemberDeclarationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(52 /* Semicolon */) && tokenOrKeyword.parent.kind === 31 /* TypeMemberDeclarationList */) {
+    if (tokenOrKeyword.isToken(52 /* Semicolon */) && tokenOrKeyword.parent.kind === 29 /* TypeMemberDeclarationList */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */) {
+    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 30 /* TypeMemberDeclarationBlock */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && tokenOrKeyword.parent.parent.kind === 44 /* TypeMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(21 /* CloseBrace */) && tokenOrKeyword.parent.kind === 30 /* TypeMemberDeclarationBlock */ && tokenOrKeyword.parent.parent.kind === 42 /* TypeMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* FieldDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* FieldGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* FieldSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* FieldDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* FieldGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* FieldSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      47 /* IndexedElementGetterDeclaration */
+      45 /* IndexedElementGetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      48 /* IndexedElementSetterDeclaration */
+      46 /* IndexedElementSetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      50 /* DereferencedVariableGetterDeclaration */
+      48 /* DereferencedVariableGetterDeclaration */
     ) || 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 */)) {
+      49 /* DereferencedVariableSetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 50 /* MethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 51 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 43 /* ConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 44 /* DestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 142 /* 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)) {
@@ -5584,16 +5584,16 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(24 /* Colon */) && tokenOrKeyword.parent.kind === 156 /* TypeAnnotation */) {
       return { allowsAnonymousTypes: true };
     }
-    if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
+    if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 32 /* StructuredTypeDeclarationBody */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 38 /* TypeExtensionDeclaration */)) {
       return { allowsAnonymousTypes: false };
     }
     if (tokenOrKeyword.isToken(37 /* LessThan */) && tokenOrKeyword.parent.kind === 152 /* TypeArgumentClause */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(25 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */)) {
+    if (tokenOrKeyword.isToken(25 /* Comma */) && (tokenOrKeyword.parent.kind === 28 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */)) {
       return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */ };
     }
     if (tokenOrKeyword.isToken(36 /* HashSign */) && tokenOrKeyword.parent.kind === 147 /* Tag */) {
@@ -5602,13 +5602,13 @@ var SyntaxContextFactory = class {
     if ((tokenOrKeyword.isToken(24 /* Colon */) || tokenOrKeyword.isToken(58 /* Equals */)) && tokenOrKeyword.parent.kind === 143 /* TypeParameterDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(58 /* Equals */) && tokenOrKeyword.parent.kind === 22 /* PackageAliasTypeDeclaration */) {
+    if (tokenOrKeyword.isToken(58 /* Equals */) && tokenOrKeyword.parent.kind === 20 /* PackageAliasTypeDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
+    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 71 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 63 /* AsExpression */) {
       return { allowsAnonymousTypes: true };
     }
     if (tokenOrKeyword.isToken(18 /* Bar */) && tokenOrKeyword.parent.kind === 11 /* UnionTypeSpecifier */) {
@@ -5623,10 +5623,10 @@ var SyntaxContextFactory = class {
     return void 0;
   }
   static isTopLevelTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(52 /* Semicolon */) && tokenOrKeyword.parent.kind === 20 /* TopLevelTranslationList */) {
+    if (tokenOrKeyword.isToken(52 /* Semicolon */) && tokenOrKeyword.parent.kind === 123 /* TopLevelTranslationList */) {
       return { translationsDeclaration: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */) {
+    if (tokenOrKeyword.isToken(44 /* OpenBrace */) && tokenOrKeyword.parent.kind === 122 /* TranslationsDeclaration */) {
       return { translationsDeclaration: tokenOrKeyword.parent };
     }
     const packageImport = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
@@ -5803,29 +5803,29 @@ var NodeSemanticInfoService = class {
   static ofTokenOrKeyword(analyzer, tokenOrKeyword, options6) {
     if (isIdentifier(tokenOrKeyword.value)) {
       return this.ofNonKeywordIdentifier(analyzer, tokenOrKeyword.value, options6);
-    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
+    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 68 /* AutotypeCallExpression */) {
       return this.ofAutotypeCallExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 75 /* PrefixUnaryExpression */) {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 64 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isToken(20 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* DereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* DereferencedVariableSetterDeclaration */)) {
+    } else if (tokenOrKeyword.isToken(20 /* Caret */) && (tokenOrKeyword.parent.kind === 48 /* DereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 49 /* DereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(20 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(20 /* Caret */) && tokenOrKeyword.parent.kind === 78 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+    } else if (tokenOrKeyword.parent.kind === 89 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* ConstructorDeclaration */) {
+    } else if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 43 /* ConstructorDeclaration */) {
       return this.ofConstructorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(14 /* Asterisk */) && tokenOrKeyword.parent.kind === 90 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isToken(14 /* Asterisk */) && tokenOrKeyword.parent.kind === 88 /* 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 === 84 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 87 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 85 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if ((tokenOrKeyword.isToken(46 /* OpenSquareBracket */) || tokenOrKeyword.isToken(23 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* IndexParameterClause */) {
+    } else if ((tokenOrKeyword.isToken(46 /* OpenSquareBracket */) || tokenOrKeyword.isToken(23 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 47 /* IndexParameterClause */) {
       return this.ofIndexedElementAccessorDeclaration(analyzer, tokenOrKeyword.parent.parent);
-    } else if ((tokenOrKeyword.isToken(46 /* OpenSquareBracket */) || tokenOrKeyword.isToken(23 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+    } else if ((tokenOrKeyword.isToken(46 /* OpenSquareBracket */) || tokenOrKeyword.isToken(23 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 69 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     }
     return void 0;
@@ -5856,37 +5856,37 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 60 /* EnumerationVariableDeclaration */:
+      case 58 /* EnumerationVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofEnumerationVariableDeclaration(parent));
         break;
-      case 101 /* ErrorVariableDeclaration */:
+      case 99 /* ErrorVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofErrorVariableDeclaration(parent));
         break;
-      case 22 /* PackageAliasTypeDeclaration */:
+      case 20 /* PackageAliasTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageAliasTypeDeclaration(parent));
         break;
-      case 27 /* PackageFunctionDeclaration */:
+      case 25 /* PackageFunctionDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionDeclaration(parent));
         break;
-      case 28 /* PackageFunctionTypeDeclaration */:
+      case 26 /* PackageFunctionTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionTypeDeclaration(parent));
         break;
-      case 33 /* PackageStructuredTypeDeclaration */:
+      case 31 /* PackageStructuredTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageStructuredTypeDeclaration(parent));
         break;
-      case 35 /* PackageVariableDeclaration */:
+      case 33 /* PackageVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariableDeclaration(parent));
         break;
-      case 38 /* PackageVariantTypeDeclaration */:
+      case 36 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 88 /* IdentifierExpression */:
+      case 86 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
-      case 58 /* NestedFunctionDeclaration */:
+      case 56 /* NestedFunctionDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedFunctionDeclaration(parent));
         break;
-      case 59 /* LocalVariableDeclaration */:
+      case 57 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
         break;
       case 135 /* QualifiedName */:
@@ -6033,16 +6033,16 @@ var NodeSemanticInfoService = class {
       case 9 /* PackageName */:
         result = void 0;
         break;
-      case 78 /* MemberAccessExpression */:
+      case 76 /* MemberAccessExpression */:
         result = this.ofMember(analyzer, parent, options6);
         break;
-      case 52 /* MethodDeclaration */:
+      case 50 /* MethodDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofMethodDeclaration(parent));
         break;
-      case 53 /* OperatorDeclaration */:
+      case 51 /* OperatorDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofOperatorDeclaration(parent));
         break;
-      case 54 /* FieldDeclaration */:
+      case 52 /* FieldDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofFieldDeclaration(parent));
         break;
       case 143 /* TypeParameterDeclaration */:
@@ -6051,12 +6051,12 @@ var NodeSemanticInfoService = class {
       case 142 /* VariantDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofVariantDeclaration(parent));
         break;
-      case 36 /* PackageVariableGetterDeclaration */:
-      case 37 /* PackageVariableSetterDeclaration */:
+      case 34 /* PackageVariableGetterDeclaration */:
+      case 35 /* PackageVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedPackageVariableDeclaration(parent));
         break;
-      case 55 /* FieldGetterDeclaration */:
-      case 56 /* FieldSetterDeclaration */:
+      case 53 /* FieldGetterDeclaration */:
+      case 54 /* FieldSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedFieldDeclaration(parent));
         break;
       case 3 /* Keyword */:
@@ -6186,7 +6186,7 @@ var NodeSemanticInfoService = class {
         return this.ofNamedTypeSpecifierNameQualifier(analyzer, node.parent, qualifier, options6);
       case 147 /* Tag */:
         return this.ofTagNameQualifier(analyzer, node.parent, qualifier, options6);
-      case 42 /* ExtendedTypeClause */:
+      case 40 /* ExtendedTypeClause */:
       case 134 /* PackageImportTranslation */:
         return void 0;
       default:
@@ -6650,7 +6650,7 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 78 /* MemberAccessExpression */) {
+    while (parent.kind === 76 /* MemberAccessExpression */) {
       const meaning = analyzer.resolveMemberAccessExpression(parent).meaning;
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
@@ -6689,11 +6689,11 @@ var NodeSemanticInfoService = class {
     }
     const parent = getParentSkippingParenthesizedExpressions(typeAccessExpression);
     let parentCallExpression;
-    if (parent.kind === 69 /* CallExpression */) {
+    if (parent.kind === 67 /* CallExpression */) {
       parentCallExpression = parent;
-    } else if (parent.kind === 89 /* GenericSpecializationExpression */) {
+    } else if (parent.kind === 87 /* GenericSpecializationExpression */) {
       const grandParent = getParentSkippingParenthesizedExpressions(parent);
-      if (grandParent.kind === 69 /* CallExpression */) {
+      if (grandParent.kind === 67 /* CallExpression */) {
         parentCallExpression = grandParent;
       }
     }
@@ -6949,52 +6949,52 @@ function getEntitySourceLocations(analyzer, entity) {
         case 19 /* AnonymousVariantTypeDeclaration */:
           range = node.rangeWithoutTrivia;
           break;
-        case 22 /* PackageAliasTypeDeclaration */:
-        case 27 /* PackageFunctionDeclaration */:
-        case 28 /* PackageFunctionTypeDeclaration */:
-        case 33 /* PackageStructuredTypeDeclaration */:
-        case 38 /* PackageVariantTypeDeclaration */:
-        case 58 /* NestedFunctionDeclaration */:
-        case 52 /* MethodDeclaration */:
+        case 20 /* PackageAliasTypeDeclaration */:
+        case 25 /* PackageFunctionDeclaration */:
+        case 26 /* PackageFunctionTypeDeclaration */:
+        case 31 /* PackageStructuredTypeDeclaration */:
+        case 36 /* PackageVariantTypeDeclaration */:
+        case 56 /* NestedFunctionDeclaration */:
+        case 50 /* MethodDeclaration */:
         case 143 /* TypeParameterDeclaration */:
-        case 53 /* OperatorDeclaration */:
+        case 51 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
-        case 45 /* ConstructorDeclaration */:
+        case 43 /* ConstructorDeclaration */:
           range = node.creationKeyword.rangeWithoutTrivia;
           break;
-        case 46 /* DestructorDeclaration */:
+        case 44 /* DestructorDeclaration */:
           range = node.destructionKeyword.rangeWithoutTrivia;
           break;
         case 8 /* PackageImport */:
           Debug.assertNotNull(node.alias);
           range = node.alias.rangeWithoutTrivia;
           break;
-        case 40 /* TypeExtensionDeclaration */:
+        case 38 /* TypeExtensionDeclaration */:
           range = node.plusEqualsToken.rangeWithoutTrivia;
           break;
-        case 36 /* PackageVariableGetterDeclaration */:
+        case 34 /* PackageVariableGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 37 /* PackageVariableSetterDeclaration */:
+        case 35 /* PackageVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 55 /* FieldGetterDeclaration */:
+        case 53 /* FieldGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 56 /* FieldSetterDeclaration */:
+        case 54 /* FieldSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 47 /* IndexedElementGetterDeclaration */:
+        case 45 /* IndexedElementGetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 48 /* IndexedElementSetterDeclaration */:
+        case 46 /* IndexedElementSetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 50 /* DereferencedVariableGetterDeclaration */:
+        case 48 /* DereferencedVariableGetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
-        case 51 /* DereferencedVariableSetterDeclaration */:
+        case 49 /* DereferencedVariableSetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
         default:
@@ -7205,42 +7205,42 @@ var DefinitionService = class {
   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 */:
+      case 25 /* PackageFunctionDeclaration */:
+      case 34 /* PackageVariableGetterDeclaration */:
+      case 35 /* PackageVariableSetterDeclaration */:
+      case 50 /* MethodDeclaration */:
+      case 53 /* FieldGetterDeclaration */:
+      case 54 /* FieldSetterDeclaration */:
+      case 56 /* NestedFunctionDeclaration */:
         range = node.name.rangeWithoutTrivia;
         break;
-      case 25 /* PackageConstructorDeclaration */:
+      case 23 /* PackageConstructorDeclaration */:
         range = node.creationKeyword.rangeWithoutTrivia;
         break;
-      case 26 /* PackageEntryPointDeclaration */:
+      case 24 /* PackageEntryPointDeclaration */:
         range = node.runKeyword.rangeWithoutTrivia;
         break;
-      case 45 /* ConstructorDeclaration */:
+      case 43 /* ConstructorDeclaration */:
         range = node.creationKeyword.rangeWithoutTrivia;
         break;
-      case 46 /* DestructorDeclaration */:
+      case 44 /* DestructorDeclaration */:
         range = node.destructionKeyword.rangeWithoutTrivia;
         break;
-      case 47 /* IndexedElementGetterDeclaration */:
-      case 48 /* IndexedElementSetterDeclaration */:
+      case 45 /* IndexedElementGetterDeclaration */:
+      case 46 /* IndexedElementSetterDeclaration */:
         range = node.parameterClause.rangeWithoutTrivia;
         break;
-      case 50 /* DereferencedVariableGetterDeclaration */:
-      case 51 /* DereferencedVariableSetterDeclaration */:
+      case 48 /* DereferencedVariableGetterDeclaration */:
+      case 49 /* DereferencedVariableSetterDeclaration */:
         range = node.caretToken.rangeWithoutTrivia;
         break;
-      case 53 /* OperatorDeclaration */:
+      case 51 /* OperatorDeclaration */:
         range = node.name.rangeWithoutTrivia;
         break;
-      case 67 /* FunctionBlockLiteral */:
+      case 65 /* FunctionBlockLiteral */:
         range = node.block.openBraceToken.rangeWithoutTrivia;
         break;
-      case 74 /* FunctionLiteral */: {
+      case 72 /* FunctionLiteral */: {
         const rangeStart = node.functionKeyword.rangeWithoutTrivia.start;
         const rangeEnd = node.parameterClause.rangeWithoutTrivia.end;
         range = new Range(rangeStart, rangeEnd);
@@ -7316,7 +7316,7 @@ var ReferencesService = class {
               }
             }
             if (!options6.onlyNamed) {
-              if (node.kind === 70 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
+              if (node.kind === 68 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
                 const semanticInfo = NodeSemanticInfoService.ofAutotypeCallExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7328,7 +7328,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 77 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 75 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -7344,7 +7344,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 66 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
+              if (node.kind === 64 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofBinaryExpressionOperator(
                   analyzer,
                   node,
@@ -7360,7 +7360,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 50 /* DereferencedVariableGetterDeclaration */ || node.kind === 51 /* DereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
+              if ((node.kind === 48 /* DereferencedVariableGetterDeclaration */ || node.kind === 49 /* DereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceOperatorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7372,7 +7372,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 80 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 78 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -7388,7 +7388,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 91 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 89 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -7404,7 +7404,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 45 /* ConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
+              if (node.kind === 43 /* ConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
                 const semanticInfo = NodeSemanticInfoService.ofConstructorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7416,7 +7416,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 86 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 84 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7428,7 +7428,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 87 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 85 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7440,7 +7440,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 47 /* IndexedElementGetterDeclaration */ || node.kind === 48 /* IndexedElementSetterDeclaration */) && restrictions.canBeIndexer) {
+              if ((node.kind === 45 /* IndexedElementGetterDeclaration */ || node.kind === 46 /* IndexedElementSetterDeclaration */) && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedElementAccessorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7452,7 +7452,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 71 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
+              if (node.kind === 69 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedAccessExpressionOperator(
                   analyzer,
                   node,
@@ -7834,9 +7834,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 88 /* IdentifierExpression */:
+      case 86 /* IdentifierExpression */:
         return parent;
-      case 78 /* MemberAccessExpression */:
+      case 76 /* MemberAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7857,9 +7857,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 88 /* IdentifierExpression */:
+      case 86 /* IdentifierExpression */:
         return true;
-      case 78 /* MemberAccessExpression */:
+      case 76 /* MemberAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7867,35 +7867,35 @@ var EvaluatableExpressionService = class {
   }
   isNamedDeclaration(node) {
     switch (node.kind) {
-      case 60 /* EnumerationVariableDeclaration */:
+      case 58 /* EnumerationVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 22 /* PackageAliasTypeDeclaration */:
+      case 20 /* PackageAliasTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 27 /* PackageFunctionDeclaration */:
+      case 25 /* PackageFunctionDeclaration */:
         return { nameIdentifier: node.name };
-      case 28 /* PackageFunctionTypeDeclaration */:
+      case 26 /* PackageFunctionTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 33 /* PackageStructuredTypeDeclaration */:
+      case 31 /* PackageStructuredTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 35 /* PackageVariableDeclaration */:
+      case 33 /* PackageVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 38 /* PackageVariantTypeDeclaration */:
+      case 36 /* PackageVariantTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 58 /* NestedFunctionDeclaration */:
+      case 56 /* NestedFunctionDeclaration */:
         return { nameIdentifier: node.name };
-      case 59 /* LocalVariableDeclaration */:
+      case 57 /* LocalVariableDeclaration */:
         return { nameIdentifier: node.name };
       case 144 /* ParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 52 /* MethodDeclaration */:
+      case 50 /* MethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 54 /* FieldDeclaration */:
+      case 52 /* FieldDeclaration */:
         return { nameIdentifier: node.name };
       case 143 /* TypeParameterDeclaration */:
         return { nameIdentifier: node.name };
       case 142 /* VariantDeclaration */:
         return { nameIdentifier: node.name };
-      case 101 /* ErrorVariableDeclaration */:
+      case 99 /* ErrorVariableDeclaration */:
         return { nameIdentifier: node.name };
       default:
         return void 0;
@@ -8154,7 +8154,7 @@ var SourceFileItemsService = class {
           }
           break;
         }
-        case 35 /* PackageVariableDeclaration */: {
+        case 33 /* PackageVariableDeclaration */: {
           result.push(
             this.createItem(
               1 /* PackageVariable */,
@@ -8166,7 +8166,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 36 /* PackageVariableGetterDeclaration */: {
+        case 34 /* PackageVariableGetterDeclaration */: {
           result.push(
             this.createItem(
               2 /* PackageVariableGetter */,
@@ -8178,7 +8178,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 37 /* PackageVariableSetterDeclaration */: {
+        case 35 /* PackageVariableSetterDeclaration */: {
           result.push(
             this.createItem(
               3 /* PackageVariableSetter */,
@@ -8190,7 +8190,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 27 /* PackageFunctionDeclaration */: {
+        case 25 /* PackageFunctionDeclaration */: {
           result.push(
             this.createItem(
               4 /* PackageFunction */,
@@ -8202,7 +8202,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 33 /* PackageStructuredTypeDeclaration */: {
+        case 31 /* PackageStructuredTypeDeclaration */: {
           result.push(
             this.createItem(
               5 /* StructuredType */,
@@ -8214,7 +8214,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 54 /* FieldDeclaration */: {
+        case 52 /* FieldDeclaration */: {
           result.push(
             this.createItem(
               12 /* Field */,
@@ -8226,7 +8226,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 55 /* FieldGetterDeclaration */: {
+        case 53 /* FieldGetterDeclaration */: {
           result.push(
             this.createItem(
               13 /* FieldGetter */,
@@ -8238,7 +8238,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 56 /* FieldSetterDeclaration */: {
+        case 54 /* FieldSetterDeclaration */: {
           result.push(
             this.createItem(
               14 /* FieldSetter */,
@@ -8250,7 +8250,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 52 /* MethodDeclaration */: {
+        case 50 /* MethodDeclaration */: {
           result.push(
             this.createItem(
               15 /* Method */,
@@ -8262,7 +8262,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 45 /* ConstructorDeclaration */: {
+        case 43 /* ConstructorDeclaration */: {
           result.push(
             this.createItem(
               10 /* Constructor */,
@@ -8274,7 +8274,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 46 /* DestructorDeclaration */: {
+        case 44 /* DestructorDeclaration */: {
           result.push(this.createItem(
             11 /* Destructor */,
             void 0,
@@ -8284,7 +8284,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 47 /* IndexedElementGetterDeclaration */: {
+        case 45 /* IndexedElementGetterDeclaration */: {
           result.push(
             this.createItem(
               16 /* IndexedElementGetter */,
@@ -8296,7 +8296,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 48 /* IndexedElementSetterDeclaration */: {
+        case 46 /* IndexedElementSetterDeclaration */: {
           result.push(
             this.createItem(
               17 /* IndexedElementSetter */,
@@ -8308,7 +8308,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 28 /* PackageFunctionTypeDeclaration */: {
+        case 26 /* PackageFunctionTypeDeclaration */: {
           result.push(
             this.createItem(
               6 /* FunctionType */,
@@ -8320,7 +8320,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 38 /* PackageVariantTypeDeclaration */: {
+        case 36 /* PackageVariantTypeDeclaration */: {
           result.push(
             this.createItem(
               7 /* VariantType */,
@@ -8356,7 +8356,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 58 /* NestedFunctionDeclaration */: {
+        case 56 /* NestedFunctionDeclaration */: {
           result.push(
             this.createItem(
               19 /* NestedFunction */,
@@ -8581,7 +8581,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 === 79 /* TextTemplateLiteral */) {
         const textContentStart = child.rangeWithoutTrivia.start + 1;
         const textContentEnd = child.rangeWithoutTrivia.end - 1;
         if (offset >= textContentStart && offset < textContentEnd) {
@@ -8613,12 +8613,12 @@ var SelectionRangeService = class {
     }
     switch (node.kind) {
       case 156 /* TypeAnnotation */:
-      case 34 /* StructuredTypeDeclarationBody */:
-      case 39 /* VariantTypeDeclarationBody */:
-      case 23 /* AliasTypeDeclarationBody */:
-      case 29 /* FunctionTypeDeclarationBody */:
-      case 83 /* TextTemplateSpan */:
-      case 82 /* TextTemplateSpanList */:
+      case 32 /* StructuredTypeDeclarationBody */:
+      case 37 /* VariantTypeDeclarationBody */:
+      case 21 /* AliasTypeDeclarationBody */:
+      case 27 /* FunctionTypeDeclarationBody */:
+      case 81 /* TextTemplateSpan */:
+      case 80 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8656,7 +8656,7 @@ var SemanticTokensService = class {
             controller.stopChildrenTraverse();
             return;
           }
-          if (node.kind === 88 /* IdentifierExpression */) {
+          if (node.kind === 86 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.value.getEntity();
@@ -8712,7 +8712,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 78 /* MemberAccessExpression */) {
+          if (node.kind === 76 /* MemberAccessExpression */) {
             const meaning = analyzer.resolveMemberAccessExpression(node).meaning;
             if (meaning.kind === "static-field-access") {
               const entity = meaning.field.value.getEntity();
@@ -8765,7 +8765,7 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 27 /* PackageFunctionDeclaration */) {
+          if (node.kind === 25 /* PackageFunctionDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8774,7 +8774,7 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 58 /* NestedFunctionDeclaration */) {
+          if (node.kind === 56 /* NestedFunctionDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8783,12 +8783,12 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 52 /* MethodDeclaration */) {
+          if (node.kind === 50 /* MethodDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 6 /* Method */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
             );
           }
-          if (node.kind === 53 /* OperatorDeclaration */) {
+          if (node.kind === 51 /* OperatorDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 7 /* Operator */, new SemanticTokenModifiers().makeDeclaration())
             );
@@ -8989,7 +8989,7 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 89 /* GenericSpecializationExpression */:
+      case 87 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
       case 147 /* Tag */:
         return this.getSignaturesForTag(node);
@@ -9030,7 +9030,7 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
-    if (expression.kind === 88 /* IdentifierExpression */) {
+    if (expression.kind === 86 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "function-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
@@ -9045,7 +9045,7 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 78 /* MemberAccessExpression */) {
+    if (expression.kind === 76 /* MemberAccessExpression */) {
       const meaning = this._analyzer.resolveMemberAccessExpression(expression).meaning;
       let accessedFunctions;
       if (meaning.kind === "instance-method-access") {
@@ -9298,7 +9298,7 @@ var ValueParametersSignatureHelpProvider = class {
     let node = token.parent;
     while (node !== void 0) {
       switch (node.kind) {
-        case 69 /* CallExpression */: {
+        case 67 /* CallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
@@ -9306,7 +9306,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 70 /* AutotypeCallExpression */: {
+        case 68 /* AutotypeCallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
@@ -9314,7 +9314,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 71 /* IndexedAccessExpression */: {
+        case 69 /* IndexedAccessExpression */: {
           if (this._offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
@@ -13486,7 +13486,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 === 89 /* AssignmentStatement */) {
           const sourceFileEdit = this._addPropertyAssignmentService.createEditWithAssignment(
             sourceFileContext.sourceFile,
             node,
@@ -13523,7 +13523,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 === 89 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);