@artel/artc 0.6.25224 → 0.6.25225

package/build/api/ApiServices.js

@@ -1,8 +1,8 @@
 import {
-  AccessedMethod_typeMember,
+  AccessedFunction_typeMember,
   AliasTypeDeclarationBody,
   Analyzer,
-  AnonymousMethodTypeDeclaration,
+  AnonymousFunctionTypeDeclaration,
   AnonymousStructuredTypeDeclaration,
   AnonymousTypeSpecifier,
   AnonymousVariantTypeDeclaration,
@@ -14,6 +14,7 @@ import {
   ConfigurationConverter,
   ConfigurationDirectoryNameSet,
   ConfigurationFileParser,
+  ConstructorDeclaration,
   ConstructorDeclaration_entity,
   ConstructorDeclaration_typeMember,
   ConstructorTranslation,
@@ -22,21 +23,34 @@ import {
   DefaultLocale,
   DefaultNamesOfDirectoriesToIgnore,
   DereferenceOperatorDeclaration_typeMember,
+  DestructorDeclaration,
   DiagnosticCollector,
   DisplayService,
   Emitter,
   EntityLocalizationHelper,
+  FieldDeclaration,
+  FieldGetterDeclaration,
+  FieldOrVariantTranslation,
+  FieldSetterDeclaration,
   FileSystemTree,
   FunctionBlock,
+  FunctionDeclaration_accessedFunction,
+  FunctionDeclaration_entity,
+  FunctionDeclaration_substitutedFunction,
+  FunctionDeclaration_typeMember,
+  FunctionTypeDeclarationBody,
+  FunctionTypeTranslation,
   GeneratedSourceFileScheme,
   GenericCancellationToken,
   InMemoryPackageScheme,
+  IndexParameterClause,
+  IndexParameterTranslationClause,
+  IndexedElementGetterDeclaration,
+  IndexedElementSetterDeclaration,
   IndexerDeclaration_entity,
   IndexerDeclaration_typeMember,
   IndexerTranslation,
-  IndexerTranslationParameterClause,
   IntersectionTypeSpecifier,
-  IntersectionTypeSpecifierTypeList,
   JavaScriptInterfacePackageImplementationConfig,
   JsonConfigurationFileNameSet,
   Keyword,
@@ -47,18 +61,14 @@ import {
   LocalizationContext,
   LocalizationHelper,
   Logger,
-  MethodDeclaration_accessedMethod,
-  MethodDeclaration_entity,
-  MethodDeclaration_substitutedMethod,
-  MethodDeclaration_typeMember,
-  MethodTypeDeclarationBody,
-  MethodTypeTranslation,
+  MethodDeclaration,
+  MethodTranslation,
   Modifier,
   ModifierList,
   Name,
   NamedTypeSpecifier,
   NamedType_alias,
-  NamedType_method,
+  NamedType_function,
   NamedType_structured,
   NamedType_variant,
   NodeModulesDirectoryName,
@@ -67,15 +77,15 @@ import {
   NullableTypeSpecifier,
   OperatorDeclaration_typeMember,
   PackageAliasTypeDeclaration,
+  PackageFunctionDeclaration,
+  PackageFunctionTranslation,
+  PackageFunctionTypeDeclaration,
   PackageImport,
   PackageImportDirectiveList,
   PackageMemberDeclarationList,
   PackageMemberGroupDeclaration,
   PackageMemberLookup,
-  PackageMethodDeclaration,
-  PackageMethodTranslation,
-  PackageMethodTypeDeclaration,
-  PackagePath,
+  PackageName,
   PackageStructuredTypeDeclaration,
   PackageVariableDeclaration,
   PackageVariableGetterDeclaration,
@@ -118,36 +128,24 @@ import {
   TypeAnnotation,
   TypeArgumentClause,
   TypeArgumentList,
-  TypeConstructorDeclaration,
   TypeDeclarationAlias_entity,
-  TypeDeclarationMethod_entity,
+  TypeDeclarationFunction_entity,
   TypeDeclarationStructured_entity,
   TypeDeclarationVariant_entity,
   TypeDeclaration_alias,
-  TypeDeclaration_method,
+  TypeDeclaration_function,
   TypeDeclaration_structured,
   TypeDeclaration_variant,
-  TypeDestructorDeclaration,
-  TypeIndexedGetterDeclaration,
-  TypeIndexedSetterDeclaration,
-  TypeIndexerParameterClause,
   TypeMemberDeclarationBlock,
   TypeMemberDeclarationList,
   TypeMemberGroupDeclaration,
   TypeMemberLookup,
   TypeMemberTranslationList,
-  TypeMethodDeclaration,
-  TypeMethodTranslation,
   TypeParameterClause,
   TypeParameterDeclaration,
   TypeParameterList,
   TypeTranslation,
-  TypeVariableDeclaration,
-  TypeVariableGetterDeclaration,
-  TypeVariableOrVariantTranslation,
-  TypeVariableSetterDeclaration,
   UnionTypeSpecifier,
-  UnionTypeSpecifierTypeList,
   Uri,
   ValueParameterDeclaration_matchResultValueParameter,
   ValueParameterDeclaration_typeMember,
@@ -184,7 +182,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-24QZJOMF.js";
+} from "../chunk-TFTCV5R5.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -304,7 +302,7 @@ var AddPropertyAssignmentService = class {
     let result;
     let leftValueText;
     if (propertyName !== void 0) {
-      if (assignmentNode.left.kind !== 80 /* PropertyAccessExpression */) {
+      if (assignmentNode.left.kind !== 78 /* MemberAccessExpression */) {
         return void 0;
       }
       const propertyReceiver = assignmentNode.left.expression;
@@ -321,7 +319,7 @@ var AddPropertyAssignmentService = class {
     const reassignmentText = `${leftValueText} = ${value}`;
     const subprogramBody = this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(assignmentNode);
     if (subprogramBody !== void 0) {
-      const lastStatement = subprogramBody.expressionOrStatementList.kind === 94 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
+      const lastStatement = subprogramBody.expressionOrStatementList.kind === 92 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
       let editRangeStart;
       let indentationText;
       if (lastStatement !== void 0) {
@@ -353,9 +351,9 @@ var AddPropertyAssignmentService = class {
   ifShouldBeAssignedAtTheEndOfSubprogramThenBody(node) {
     const parent = node.parent.parent;
     switch (parent.kind) {
-      case 95 /* StatementBlock */:
+      case 93 /* StatementBlock */:
         return this.getContainingSubprogram(parent)?.block;
-      case 96 /* FunctionBlock */:
+      case 94 /* FunctionBlock */:
         return void 0;
       default:
         Debug.never(parent);
@@ -374,23 +372,23 @@ var AddPropertyAssignmentService = class {
 };
 function isSubprogramDeclaration(node) {
   switch (node.kind) {
-    case 27 /* PackageConstructorDeclaration */:
-    case 28 /* PackageEntryPointDeclaration */:
-    case 29 /* PackageMethodDeclaration */:
-    case 38 /* PackageVariableGetterDeclaration */:
-    case 39 /* PackageVariableSetterDeclaration */:
-    case 47 /* TypeConstructorDeclaration */:
-    case 48 /* TypeDestructorDeclaration */:
-    case 49 /* TypeIndexedGetterDeclaration */:
-    case 50 /* TypeIndexedSetterDeclaration */:
-    case 52 /* TypeDereferencedVariableGetterDeclaration */:
-    case 53 /* TypeDereferencedVariableSetterDeclaration */:
-    case 54 /* TypeMethodDeclaration */:
-    case 57 /* TypeVariableGetterDeclaration */:
-    case 58 /* TypeVariableSetterDeclaration */:
-    case 60 /* NestedMethodDeclaration */:
-    case 69 /* MethodBlockLiteral */:
-    case 76 /* MethodLiteral */:
+    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 */:
       return true;
     default:
       Debug.typeIsAssignableTo();
@@ -414,15 +412,15 @@ var SyntaxFactory = class {
       aliasIdentifier = this.createIdentifier(alias);
       equalsToken = this.token(57 /* Equals */);
     }
-    const packagePath = this.packagePath(pathSegments);
-    const packageImport = new PackageImport(aliasIdentifier, equalsToken, packagePath);
+    const packageName = this.packageName(pathSegments);
+    const packageImport = new PackageImport(aliasIdentifier, equalsToken, packageName);
     const importKeyword = this.keyword(18 /* Import */);
     return new SinglePackageImportDirective(importKeyword, packageImport);
   }
-  static packagePath(segments) {
+  static packageName(segments) {
     const segmentIdentifiers = segments.map((s) => this.createIdentifier(s));
-    const packagePathParts = this.createTokenSeparatedElements(segmentIdentifiers, 26 /* Dot */);
-    return new PackagePath(packagePathParts);
+    const packageNameParts = this.createTokenSeparatedElements(segmentIdentifiers, 26 /* Dot */);
+    return new PackageName(packageNameParts);
   }
   static packageAliasTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags);
@@ -457,7 +455,7 @@ var SyntaxFactory = class {
       this.token(20 /* CloseBrace */)
     );
   }
-  static packageMethodDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
+  static packageFunctionDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const functionKeyword = this.keyword(12 /* Function */);
@@ -465,7 +463,7 @@ var SyntaxFactory = class {
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const parameterClause = this.parameterClause(parameters);
     const returnTypeAnnotation = this.createTypeAnnotation(returnTypeSpecifier);
-    return new PackageMethodDeclaration(
+    return new PackageFunctionDeclaration(
       tagList,
       modifierList,
       functionKeyword,
@@ -476,14 +474,14 @@ var SyntaxFactory = class {
       body
     );
   }
-  static packageMethodTypeDeclaration(tags, modifiers, name, typeParameters, body) {
+  static packageFunctionTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(57 /* Equals */);
-    return new PackageMethodTypeDeclaration(
+    return new PackageFunctionTypeDeclaration(
       tagList,
       modifierList,
       typeKeyword,
@@ -493,11 +491,11 @@ var SyntaxFactory = class {
       body
     );
   }
-  static methodTypeDeclarationBody(parameters, returnTypeSpecifier) {
+  static functionTypeDeclarationBody(parameters, returnTypeSpecifier) {
     const functionKeyword = this.keyword(12 /* Function */);
     const parameterClause = this.parameterClause(parameters);
     const returnTypeAnnotation = this.createTypeAnnotation(returnTypeSpecifier);
-    return new MethodTypeDeclarationBody(void 0, functionKeyword, parameterClause, returnTypeAnnotation);
+    return new FunctionTypeDeclarationBody(void 0, functionKeyword, parameterClause, returnTypeAnnotation);
   }
   static packageStructuredTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags);
@@ -588,7 +586,7 @@ var SyntaxFactory = class {
     const memberBlock = this.typeMemberDeclarationBlock(members);
     return new VariantTypeDeclarationBody(variantKeyword, void 0, memberBlock);
   }
-  static typeVariableDeclaration(tags, modifiers, name, typeSpecifier, initializer) {
+  static fieldDeclaration(tags, modifiers, name, typeSpecifier, initializer) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const nameIdentifier = this.createIdentifier(name);
@@ -597,7 +595,7 @@ var SyntaxFactory = class {
     if (initializer !== void 0) {
       equalsToken = this.token(57 /* Equals */);
     }
-    return new TypeVariableDeclaration(
+    return new FieldDeclaration(
       tagList,
       modifierList,
       nameIdentifier,
@@ -606,13 +604,13 @@ var SyntaxFactory = class {
       initializer
     );
   }
-  static typeVariableGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
+  static fieldGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const getKeyword = this.keyword(58 /* Get */);
     const nameIdentifier = this.createIdentifier(name);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
-    return new TypeVariableGetterDeclaration(
+    return new FieldGetterDeclaration(
       tagList,
       modifierList,
       getKeyword,
@@ -621,14 +619,14 @@ var SyntaxFactory = class {
       body
     );
   }
-  static typeVariableSetterDeclaration(tags, modifiers, name, body) {
+  static fieldSetterDeclaration(tags, modifiers, name, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const setKeyword = this.keyword(59 /* Set */);
     const nameIdentifier = this.createIdentifier(name);
-    return new TypeVariableSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
+    return new FieldSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
   }
-  static typeMethodDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
+  static methodDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const functionKeyword = this.keyword(12 /* Function */);
@@ -636,7 +634,7 @@ var SyntaxFactory = class {
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const parameterClause = this.parameterClause(parameters);
     const returnTypeAnnotation = this.createTypeAnnotation(returnTypeSpecifier);
-    return new TypeMethodDeclaration(
+    return new MethodDeclaration(
       tagList,
       modifierList,
       functionKeyword,
@@ -647,27 +645,27 @@ var SyntaxFactory = class {
       body
     );
   }
-  static typeConstructorDeclaration(tags, modifiers, parameters, body) {
+  static constructorDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const creationKeyword = this.keyword(30 /* Creation */);
     const parameterClause = this.parameterClause(parameters);
-    return new TypeConstructorDeclaration(tagList, modifierList, creationKeyword, parameterClause, body);
+    return new ConstructorDeclaration(tagList, modifierList, creationKeyword, parameterClause, body);
   }
-  static typeDestructorDeclaration(tags, modifiers, parameters, body) {
+  static destructorDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const destructionKeyword = this.keyword(47 /* Destruction */);
     const parameterClause = this.parameterClause(parameters);
-    return new TypeDestructorDeclaration(tagList, modifierList, destructionKeyword, parameterClause, body);
+    return new DestructorDeclaration(tagList, modifierList, destructionKeyword, parameterClause, body);
   }
-  static typeIndexedGetterDeclaration(tags, modifiers, parameters, typeSpecifier, body) {
+  static indexedElementGetterDeclaration(tags, modifiers, parameters, typeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const getKeyword = this.keyword(58 /* Get */);
-    const parameterClause = this.indexerParameterClause(parameters);
+    const parameterClause = this.indexParameterClause(parameters);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
-    return new TypeIndexedGetterDeclaration(
+    return new IndexedElementGetterDeclaration(
       tagList,
       modifierList,
       getKeyword,
@@ -676,12 +674,12 @@ var SyntaxFactory = class {
       body
     );
   }
-  static typeIndexedSetterDeclaration(tags, modifiers, parameters, body) {
+  static indexedElementSetterDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const getKeyword = this.keyword(59 /* Set */);
-    const parameterClause = this.indexerParameterClause(parameters);
-    return new TypeIndexedSetterDeclaration(tagList, modifierList, getKeyword, parameterClause, body);
+    const parameterClause = this.indexParameterClause(parameters);
+    return new IndexedElementSetterDeclaration(tagList, modifierList, getKeyword, parameterClause, body);
   }
   static typeMemberGroupDeclaration(tags, modifiers, members) {
     const tagList = new TagList(tags);
@@ -713,10 +711,10 @@ var SyntaxFactory = class {
       this.token(21 /* CloseParenthesis */)
     );
   }
-  static indexerParameterClause(indexerParameters) {
-    return new TypeIndexerParameterClause(
+  static indexParameterClause(indexParameters) {
+    return new IndexParameterClause(
       this.token(45 /* OpenSquareBracket */),
-      new ParameterList(this.createTokenSeparatedElements(indexerParameters, 24 /* Comma */)),
+      new ParameterList(this.createTokenSeparatedElements(indexParameters, 24 /* Comma */)),
       this.token(22 /* CloseSquareBracket */)
     );
   }
@@ -732,17 +730,13 @@ var SyntaxFactory = class {
     return new NamedTypeSpecifier(qualifiedName, typeArgumentClause);
   }
   static unionTypeSpecifier(typeSpecifiers) {
-    return new UnionTypeSpecifier(
-      new UnionTypeSpecifierTypeList(this.createTokenSeparatedElements(typeSpecifiers, 17 /* Bar */))
-    );
+    return new UnionTypeSpecifier(this.createTokenSeparatedElements(typeSpecifiers, 17 /* Bar */));
   }
   static intersectionTypeSpecifier(typeSpecifiers) {
-    return new IntersectionTypeSpecifier(
-      new IntersectionTypeSpecifierTypeList(this.createTokenSeparatedElements(
-        typeSpecifiers,
-        10 /* Ampersand */
-      ))
-    );
+    return new IntersectionTypeSpecifier(this.createTokenSeparatedElements(
+      typeSpecifiers,
+      10 /* Ampersand */
+    ));
   }
   static nullableTypeSpecifier(typeSpecifier) {
     const questionToken = this.token(49 /* Question */);
@@ -756,8 +750,8 @@ var SyntaxFactory = class {
   static anonymousStructuredTypeSpecifier(body) {
     return new AnonymousTypeSpecifier(new AnonymousStructuredTypeDeclaration(body));
   }
-  static anonymousMethodTypeSpecifier(body) {
-    return new AnonymousTypeSpecifier(new AnonymousMethodTypeDeclaration(body));
+  static anonymousFunctionTypeSpecifier(body) {
+    return new AnonymousTypeSpecifier(new AnonymousFunctionTypeDeclaration(body));
   }
   static anonymousVariantTypeSpecifier(body) {
     return new AnonymousTypeSpecifier(new AnonymousVariantTypeDeclaration(body));
@@ -878,7 +872,7 @@ var SyntaxFactory = class {
     const translatedNameIdentifier = this.createIdentifier(translatedName);
     return new PackageVariableTranslation(sourceNameIdentifier, minusGreaterThanToken, translatedNameIdentifier);
   }
-  static packageMethodTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
+  static packageFunctionTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
     const functionKeyword = this.keyword(12 /* Function */);
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
@@ -887,7 +881,7 @@ var SyntaxFactory = class {
     const translatedNameIdentifier = this.createIdentifier(translatedName);
     const translatedTypeParameterClause = this.createTranslationTypeParameterClause(translatedTypeParameters);
     const translatedParameterClause = this.translationParameterClause(translatedParameters);
-    return new PackageMethodTranslation(
+    return new PackageFunctionTranslation(
       functionKeyword,
       sourceNameIdentifier,
       sourceTypeParameterClause,
@@ -925,7 +919,7 @@ var SyntaxFactory = class {
       closeBraceToken
     );
   }
-  static methodTypeTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
+  static functionTypeTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
     const typeKeyword = this.keyword(16 /* Type */);
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
@@ -934,7 +928,7 @@ var SyntaxFactory = class {
     const translatedNameIdentifier = this.createIdentifier(translatedName);
     const translatedTypeParameterClause = this.createTranslationTypeParameterClause(translatedTypeParameters);
     const translatedParameterClause = this.translationParameterClause(translatedParameters);
-    return new MethodTypeTranslation(
+    return new FunctionTypeTranslation(
       typeKeyword,
       sourceNameIdentifier,
       sourceTypeParameterClause,
@@ -945,17 +939,17 @@ var SyntaxFactory = class {
       translatedParameterClause
     );
   }
-  static typeVariableOrVariantTranslation(sourceName, translatedName) {
+  static fieldOrVariantTranslation(sourceName, translatedName) {
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const minusGreaterThanToken = this.token(42 /* MinusGreaterThan */);
     const translatedNameIdentifier = this.createIdentifier(translatedName);
-    return new TypeVariableOrVariantTranslation(
+    return new FieldOrVariantTranslation(
       sourceNameIdentifier,
       minusGreaterThanToken,
       translatedNameIdentifier
     );
   }
-  static typeMethodTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
+  static methodTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
     const functionKeyword = this.keyword(12 /* Function */);
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
@@ -964,7 +958,7 @@ var SyntaxFactory = class {
     const translatedNameIdentifier = this.createIdentifier(translatedName);
     const translatedTypeParameterClause = this.createTranslationTypeParameterClause(translatedTypeParameters);
     const translatedParameterClause = this.translationParameterClause(translatedParameters);
-    return new TypeMethodTranslation(
+    return new MethodTranslation(
       functionKeyword,
       sourceNameIdentifier,
       sourceTypeParameterClause,
@@ -988,9 +982,9 @@ var SyntaxFactory = class {
     );
   }
   static indexerTranslation(sourceParameters, translatedParameters) {
-    const sourceParameterClause = this.indexerTranslationParameterClause(sourceParameters);
+    const sourceParameterClause = this.indexParameterTranslationClause(sourceParameters);
     const minusGreaterThanToken = this.token(42 /* MinusGreaterThan */);
-    const translatedParameterClause = this.indexerTranslationParameterClause(translatedParameters);
+    const translatedParameterClause = this.indexParameterTranslationClause(translatedParameters);
     return new IndexerTranslation(sourceParameterClause, minusGreaterThanToken, translatedParameterClause);
   }
   static translationParameterClause(parameters) {
@@ -1001,13 +995,13 @@ var SyntaxFactory = class {
     const closeParenthesisToken = this.token(21 /* CloseParenthesis */);
     return new TranslationParameterClause(openParenthesisToken, parameterList, closeParenthesisToken);
   }
-  static indexerTranslationParameterClause(parameters) {
+  static indexParameterTranslationClause(parameters) {
     const openSquareBracketToken = this.token(45 /* OpenSquareBracket */);
     const parameterList = new TranslationParameterList(
       this.createTokenSeparatedElements(parameters.map((p) => this.createIdentifier(p)), 24 /* Comma */)
     );
     const closeSquareBracketToken = this.token(22 /* CloseSquareBracket */);
-    return new IndexerTranslationParameterClause(openSquareBracketToken, parameterList, closeSquareBracketToken);
+    return new IndexParameterTranslationClause(openSquareBracketToken, parameterList, closeSquareBracketToken);
   }
   static token(kind, value) {
     const flags = value === void 0 ? 1 /* Missing */ : 0 /* None */;
@@ -1115,9 +1109,9 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeToken(node.equalsToken);
       this.writeWhitespace();
     }
-    this.writePackagePath(node.packagePath);
+    this.writePackageName(node.packageName);
   }
-  writePackagePath(node) {
+  writePackageName(node) {
     for (const part of node.parts) {
       this.writeToken(part);
     }
@@ -1161,7 +1155,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writePackageMethodDeclaration(node) {
+  writePackageFunctionDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.functionKeyword);
@@ -1223,7 +1217,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeWhitespace();
     this.writeVariantTypeDeclarationBody(node.body);
   }
-  writePackageMethodTypeDeclaration(node) {
+  writePackageFunctionTypeDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.typeKeyword);
@@ -1235,7 +1229,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeWhitespace();
     this.writeToken(node.equalsToken);
     this.writeWhitespace();
-    this.writeMethodTypeDeclarationBody(node.body);
+    this.writeFunctionTypeDeclarationBody(node.body);
   }
   writePackageMemberGroupDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
@@ -1278,7 +1272,7 @@ var SyntaxToCode = class _SyntaxToCode {
     }
     this.writeTypeMemberDeclarationBlock(node.memberBlock);
   }
-  writeMethodTypeDeclarationBody(node) {
+  writeFunctionTypeDeclarationBody(node) {
     this.writeKeyword(node.functionKeyword);
     this.writeParameterClause(node.parameterClause);
     if (node.returnTypeAnnotation !== void 0) {
@@ -1303,7 +1297,7 @@ var SyntaxToCode = class _SyntaxToCode {
     }
     this.writeToken(node.closeBraceToken);
   }
-  writeTypeVariableDeclaration(node) {
+  writeFieldDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeToken(node.name);
@@ -1317,7 +1311,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeExpression(node.initializer);
     }
   }
-  writeTypeVariableGetterDeclaration(node) {
+  writeFieldGetterDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.getKeyword);
@@ -1328,7 +1322,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeVariableSetterDeclaration(node) {
+  writeFieldSetterDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.setKeyword);
@@ -1338,7 +1332,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeMethodDeclaration(node) {
+  writeMethodDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.functionKeyword);
@@ -1369,7 +1363,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeConstructorDeclaration(node) {
+  writeConstructorDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.creationKeyword);
@@ -1378,7 +1372,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeDestructorDeclaration(node) {
+  writeDestructorDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.destructionKeyword);
@@ -1387,7 +1381,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeIndexedGetterDeclaration(node) {
+  writeIndexedElementGetterDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.getKeyword);
@@ -1400,7 +1394,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeIndexedSetterDeclaration(node) {
+  writeIndexedElementSetterDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.setKeyword);
@@ -1412,7 +1406,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeDereferencedVariableGetterDeclaration(node) {
+  writeDereferencedVariableGetterDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.getKeyword);
@@ -1423,7 +1417,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.block);
     }
   }
-  writeTypeDereferencedVariableSetterDeclaration(node) {
+  writeDereferencedVariableSetterDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
     this.writeKeyword(node.setKeyword);
@@ -1552,8 +1546,8 @@ var SyntaxToCode = class _SyntaxToCode {
   writeAnonymousTypeSpecifier(node) {
     this.writeNode(node.typeDeclaration);
   }
-  writeAnonymousMethodTypeDeclaration(node) {
-    this.writeMethodTypeDeclarationBody(node.body);
+  writeAnonymousFunctionTypeDeclaration(node) {
+    this.writeFunctionTypeDeclarationBody(node.body);
   }
   writeAnonymousStructuredTypeDeclaration(node) {
     this.writeStructuredTypeDeclarationBody(node.body);
@@ -1562,11 +1556,8 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeVariantTypeDeclarationBody(node.body);
   }
   writeUnionTypeSpecifier(node) {
-    this.writeUnionTypeSpecifierTypeList(node.typeList);
-  }
-  writeUnionTypeSpecifierTypeList(node) {
-    for (let i = 0; i < node.elements.length; i++) {
-      const element = node.elements[i];
+    for (let i = 0; i < node.typeListElements.length; i++) {
+      const element = node.typeListElements[i];
       if (element.kind === 0 /* Token */) {
         this.writeWhitespace();
         this.writeToken(element);
@@ -1586,11 +1577,8 @@ var SyntaxToCode = class _SyntaxToCode {
     }
   }
   writeIntersectionTypeSpecifier(node) {
-    this.writeIntersectionTypeSpecifierTypeList(node.typeList);
-  }
-  writeIntersectionTypeSpecifierTypeList(node) {
-    for (let i = 0; i < node.elements.length; i++) {
-      const element = node.elements[i];
+    for (let i = 0; i < node.typeListElements.length; i++) {
+      const element = node.typeListElements[i];
       if (element.kind === 0 /* Token */) {
         this.writeWhitespace();
         this.writeToken(element);
@@ -1629,22 +1617,22 @@ var SyntaxToCode = class _SyntaxToCode {
     switch (node.kind) {
       case 11 /* UnionTypeSpecifier */:
         return true;
-      case 17 /* AnonymousTypeSpecifier */: {
+      case 15 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 31 /* MethodTypeDeclarationBody */:
+          case 29 /* FunctionTypeDeclarationBody */:
             return true;
-          case 36 /* StructuredTypeDeclarationBody */:
-          case 41 /* VariantTypeDeclarationBody */:
+          case 34 /* StructuredTypeDeclarationBody */:
+          case 39 /* VariantTypeDeclarationBody */:
             return false;
           default:
             Debug.never(node.typeDeclaration.body);
         }
       }
       case 10 /* NamedTypeSpecifier */:
-      case 15 /* ParenthesizedTypeSpecifier */:
-      case 16 /* NullableTypeSpecifier */:
-      case 18 /* InvalidTypeSpecifier */:
-      case 13 /* IntersectionTypeSpecifier */:
+      case 13 /* ParenthesizedTypeSpecifier */:
+      case 14 /* NullableTypeSpecifier */:
+      case 16 /* InvalidTypeSpecifier */:
+      case 12 /* IntersectionTypeSpecifier */:
         return false;
       default:
         Debug.never(node);
@@ -1653,23 +1641,23 @@ var SyntaxToCode = class _SyntaxToCode {
   doesIntersectionTypeElementRequireParenthesis(node) {
     switch (node.kind) {
       case 11 /* UnionTypeSpecifier */:
-      case 13 /* IntersectionTypeSpecifier */:
+      case 12 /* IntersectionTypeSpecifier */:
         return true;
-      case 17 /* AnonymousTypeSpecifier */: {
+      case 15 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 31 /* MethodTypeDeclarationBody */:
+          case 29 /* FunctionTypeDeclarationBody */:
             return true;
-          case 36 /* StructuredTypeDeclarationBody */:
-          case 41 /* VariantTypeDeclarationBody */:
+          case 34 /* StructuredTypeDeclarationBody */:
+          case 39 /* VariantTypeDeclarationBody */:
             return false;
           default:
             Debug.never(node.typeDeclaration.body);
         }
       }
       case 10 /* NamedTypeSpecifier */:
-      case 15 /* ParenthesizedTypeSpecifier */:
-      case 16 /* NullableTypeSpecifier */:
-      case 18 /* InvalidTypeSpecifier */:
+      case 13 /* ParenthesizedTypeSpecifier */:
+      case 14 /* NullableTypeSpecifier */:
+      case 16 /* InvalidTypeSpecifier */:
         return false;
       default:
         Debug.never(node);
@@ -1678,13 +1666,13 @@ var SyntaxToCode = class _SyntaxToCode {
   doesTypeMadeNullableRequireParenthesis(node) {
     switch (node.kind) {
       case 11 /* UnionTypeSpecifier */:
-      case 13 /* IntersectionTypeSpecifier */:
-      case 17 /* AnonymousTypeSpecifier */:
+      case 12 /* IntersectionTypeSpecifier */:
+      case 15 /* AnonymousTypeSpecifier */:
         return true;
       case 10 /* NamedTypeSpecifier */:
-      case 15 /* ParenthesizedTypeSpecifier */:
-      case 16 /* NullableTypeSpecifier */:
-      case 18 /* InvalidTypeSpecifier */:
+      case 13 /* ParenthesizedTypeSpecifier */:
+      case 14 /* NullableTypeSpecifier */:
+      case 16 /* InvalidTypeSpecifier */:
         return false;
       default:
         Debug.never(node);
@@ -1709,7 +1697,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeNodeDefault(node);
   }
   writeDeclarationBody(node, addLeadingNewLineOrWhitespace = true) {
-    if (node.expressionOrStatementList.kind !== 94 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
+    if (node.expressionOrStatementList.kind !== 92 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
       this.writeWhitespace();
       this.writeFunctionBlock(node, false);
     } else {
@@ -1758,7 +1746,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeWhitespace();
     this.writeToken(node.translatedName);
   }
-  writePackageMethodTranslation(node) {
+  writePackageFunctionTranslation(node) {
     this.writeKeyword(node.functionKeyword);
     this.writeWhitespace();
     this.writeToken(node.sourceName);
@@ -1803,7 +1791,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeToken(node.closeBraceToken);
     }
   }
-  writeMethodTypeTranslation(node) {
+  writeFunctionTypeTranslation(node) {
     this.writeKeyword(node.typeKeyword);
     this.writeWhitespace();
     this.writeToken(node.sourceName);
@@ -1820,14 +1808,14 @@ var SyntaxToCode = class _SyntaxToCode {
     }
     this.writeTranslationParameterClause(node.translatedParameterClause);
   }
-  writeTypeVariableOrVariantTranslation(node) {
+  writeFieldOrVariantTranslation(node) {
     this.writeToken(node.sourceName);
     this.writeWhitespace();
     this.writeToken(node.minusGreaterThanToken);
     this.writeWhitespace();
     this.writeToken(node.translatedName);
   }
-  writeTypeMethodTranslation(node) {
+  writeMethodTranslation(node) {
     this.writeKeyword(node.functionKeyword);
     this.writeWhitespace();
     this.writeToken(node.sourceName);
@@ -1845,11 +1833,11 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeTranslationParameterClause(node.translatedParameterClause);
   }
   writeIndexerTranslation(node) {
-    this.writeIndexerTranslationParameterClause(node.sourceParameterClause);
+    this.writeIndexParameterTranslationClause(node.sourceParameterClause);
     this.writeWhitespace();
     this.writeToken(node.minusGreaterThanToken);
     this.writeWhitespace();
-    this.writeIndexerTranslationParameterClause(node.translatedParameterClause);
+    this.writeIndexParameterTranslationClause(node.translatedParameterClause);
   }
   writeConstructorTranslation(node) {
     this.writeKeyword(node.creationKeyword);
@@ -1871,7 +1859,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeCommaSeparatedList(node.parameterList.elements, (p) => this.writeToken(p));
     this.writeToken(node.closeParenthesisToken);
   }
-  writeIndexerTranslationParameterClause(node) {
+  writeIndexParameterTranslationClause(node) {
     this.writeToken(node.openSquareBracketToken);
     this.writeCommaSeparatedList(node.parameterList.elements, (p) => this.writeToken(p));
     this.writeToken(node.closeSquareBracketToken);
@@ -2006,7 +1994,6 @@ var SyntaxToCode = class _SyntaxToCode {
   decreaseIndentation() {
     this._indentation = this._indentation.substring(0, this._indentation.length - this._indentationStep.length);
   }
-  /* eslint-disable @stylistic/max-len */
   static createWriteFunctions() {
     const writeFunctions = {
       [0 /* Token */]: this.prototype.writeToken,
@@ -2016,162 +2003,159 @@ var SyntaxToCode = class _SyntaxToCode {
       [4 /* PackageImportDirectiveList */]: this.prototype.writePackageImportDirectiveList,
       [5 /* SinglePackageImportDirective */]: this.prototype.writeSinglePackageImportDirective,
       [8 /* PackageImport */]: this.prototype.writePackageImport,
-      [9 /* PackagePath */]: this.prototype.writePackagePath,
+      [9 /* PackageName */]: this.prototype.writePackageName,
       [10 /* NamedTypeSpecifier */]: this.prototype.writeNamedTypeSpecifier,
       [11 /* UnionTypeSpecifier */]: this.prototype.writeUnionTypeSpecifier,
-      [13 /* IntersectionTypeSpecifier */]: this.prototype.writeIntersectionTypeSpecifier,
-      [15 /* ParenthesizedTypeSpecifier */]: this.prototype.writeParenthesizedTypeSpecifier,
-      [16 /* NullableTypeSpecifier */]: this.prototype.writeNullableTypeSpecifier,
-      [17 /* AnonymousTypeSpecifier */]: this.prototype.writeAnonymousTypeSpecifier,
-      [24 /* PackageAliasTypeDeclaration */]: this.prototype.writePackageAliasTypeDeclaration,
-      [26 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
-      [27 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
-      [28 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
-      [29 /* PackageMethodDeclaration */]: this.prototype.writePackageMethodDeclaration,
-      [30 /* PackageMethodTypeDeclaration */]: this.prototype.writePackageMethodTypeDeclaration,
-      [31 /* MethodTypeDeclarationBody */]: this.prototype.writeMethodTypeDeclarationBody,
-      [32 /* BaseTypeList */]: this.prototype.writeBaseTypeList,
-      [34 /* TypeMemberDeclarationBlock */]: this.prototype.writeTypeMemberDeclarationBlock,
-      [35 /* PackageStructuredTypeDeclaration */]: this.prototype.writePackageStructuredTypeDeclaration,
-      [36 /* StructuredTypeDeclarationBody */]: this.prototype.writeStructuredTypeDeclarationBody,
-      [37 /* PackageVariableDeclaration */]: this.prototype.writePackageVariableDeclaration,
-      [38 /* PackageVariableGetterDeclaration */]: this.prototype.writePackageVariableGetterDeclaration,
-      [39 /* PackageVariableSetterDeclaration */]: this.prototype.writePackageVariableSetterDeclaration,
-      [40 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
-      [41 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
-      [46 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
-      [47 /* TypeConstructorDeclaration */]: this.prototype.writeTypeConstructorDeclaration,
-      [48 /* TypeDestructorDeclaration */]: this.prototype.writeTypeDestructorDeclaration,
-      [49 /* TypeIndexedGetterDeclaration */]: this.prototype.writeTypeIndexedGetterDeclaration,
-      [50 /* TypeIndexedSetterDeclaration */]: this.prototype.writeTypeIndexedSetterDeclaration,
-      [52 /* TypeDereferencedVariableGetterDeclaration */]: this.prototype.writeTypeDereferencedVariableGetterDeclaration,
-      [53 /* TypeDereferencedVariableSetterDeclaration */]: this.prototype.writeTypeDereferencedVariableSetterDeclaration,
-      [54 /* TypeMethodDeclaration */]: this.prototype.writeTypeMethodDeclaration,
-      [55 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
-      [56 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
-      [57 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
-      [58 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
-      [95 /* StatementBlock */]: this.prototype.writeStatementBlock,
-      [96 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
-      [137 /* QualifiedName */]: this.prototype.writeQualifiedName,
-      [144 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
-      [145 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
-      [146 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [147 /* Argument */]: this.prototype.writeArgument,
-      [149 /* Tag */]: this.prototype.writeTag,
-      [151 /* Modifier */]: this.prototype.writeModifier,
-      [152 /* ParameterClause */]: this.prototype.writeParameterClause,
-      [153 /* ParameterList */]: this.prototype.writeParameterList,
-      [154 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [156 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
-      [19 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
-      [20 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
-      [21 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
+      [12 /* IntersectionTypeSpecifier */]: this.prototype.writeIntersectionTypeSpecifier,
+      [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,
+      [135 /* QualifiedName */]: this.prototype.writeQualifiedName,
+      [142 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
+      [143 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
+      [144 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
+      [145 /* Argument */]: this.prototype.writeArgument,
+      [147 /* Tag */]: this.prototype.writeTag,
+      [149 /* Modifier */]: this.prototype.writeModifier,
+      [150 /* ParameterClause */]: this.prototype.writeParameterClause,
+      [151 /* ParameterList */]: this.prototype.writeParameterList,
+      [152 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [154 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [17 /* AnonymousFunctionTypeDeclaration */]: this.prototype.writeAnonymousFunctionTypeDeclaration,
+      [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
+      [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
       [6 /* PackageGroupImportDirective */]: this.prototype.writeNodeDefault,
       [7 /* PackageImportList */]: this.prototype.writeNodeDefault,
-      [12 /* UnionTypeSpecifierTypeList */]: this.prototype.writeUnionTypeSpecifierTypeList,
-      [14 /* IntersectionTypeSpecifierTypeList */]: this.prototype.writeIntersectionTypeSpecifierTypeList,
-      [18 /* InvalidTypeSpecifier */]: this.prototype.writeNodeDefault,
-      [22 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
-      [23 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
-      [25 /* AliasTypeDeclarationBody */]: this.prototype.writeNodeDefault,
-      [33 /* TypeMemberDeclarationList */]: this.prototype.writeNodeDefault,
-      [42 /* TypeExtensionDeclaration */]: this.prototype.writeNodeDefault,
-      [43 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
-      [44 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
-      [45 /* InvalidPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [51 /* TypeIndexerParameterClause */]: this.prototype.writeNodeDefault,
-      [59 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [60 /* NestedMethodDeclaration */]: this.prototype.writeNodeDefault,
-      [61 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [62 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [63 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
-      [64 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
-      [65 /* AssertionExpression */]: this.prototype.writeNodeDefault,
-      [66 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
-      [67 /* AsExpression */]: this.prototype.writeNodeDefault,
-      [68 /* BinaryExpression */]: this.prototype.writeNodeDefault,
-      [69 /* MethodBlockLiteral */]: this.prototype.writeNodeDefault,
-      [70 /* ArgumentList */]: this.prototype.writeNodeDefault,
-      [71 /* CallExpression */]: this.prototype.writeNodeDefault,
-      [72 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
-      [73 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
-      [74 /* InvalidExpression */]: this.prototype.writeNodeDefault,
-      [75 /* IsExpression */]: this.prototype.writeNodeDefault,
-      [76 /* MethodLiteral */]: this.prototype.writeNodeDefault,
-      [77 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
-      [78 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
-      [79 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
-      [80 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
-      [81 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
-      [82 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
-      [83 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
-      [84 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
-      [85 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
-      [86 /* TokenExpression */]: this.prototype.writeNodeDefault,
-      [87 /* KeywordExpression */]: this.prototype.writeNodeDefault,
-      [88 /* ObjectExpression */]: this.prototype.writeNodeDefault,
-      [89 /* BaseExpression */]: this.prototype.writeNodeDefault,
-      [90 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
-      [91 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
-      [92 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
-      [93 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
-      [94 /* StatementList */]: this.prototype.writeNodeDefault,
-      [97 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
-      [98 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
-      [99 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [100 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [101 /* TryStatement */]: this.prototype.writeNodeDefault,
-      [102 /* CatchClause */]: this.prototype.writeNodeDefault,
-      [103 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [104 /* FinallyClause */]: this.prototype.writeNodeDefault,
-      [105 /* EmptyStatement */]: this.prototype.writeNodeDefault,
-      [106 /* ErrorStatement */]: this.prototype.writeNodeDefault,
-      [107 /* ImportantStatement */]: this.prototype.writeNodeDefault,
-      [108 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
-      [109 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
-      [110 /* ForStatement */]: this.prototype.writeNodeDefault,
-      [111 /* IfStatement */]: this.prototype.writeNodeDefault,
-      [112 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
-      [113 /* ElseIfClause */]: this.prototype.writeNodeDefault,
-      [114 /* ElseClause */]: this.prototype.writeNodeDefault,
-      [115 /* InvalidStatement */]: this.prototype.writeNodeDefault,
-      [116 /* NestedMethodDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [117 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [118 /* LoopStatement */]: this.prototype.writeNodeDefault,
-      [119 /* ReturnStatement */]: this.prototype.writeNodeDefault,
-      [120 /* CaseClauseList */]: this.prototype.writeNodeDefault,
-      [121 /* SwitchStatement */]: this.prototype.writeNodeDefault,
-      [122 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
-      [123 /* CaseClause */]: this.prototype.writeNodeDefault,
-      [124 /* WhileStatement */]: this.prototype.writeNodeDefault,
-      [125 /* YieldStatement */]: this.prototype.writeNodeDefault,
-      [126 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
-      [127 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
-      [128 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
-      [129 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
-      [130 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
-      [131 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
-      [132 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
-      [133 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
-      [134 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
-      [135 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
-      [136 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
-      [138 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
-      [139 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
-      [140 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
-      [141 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
-      [142 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [143 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [148 /* TagList */]: this.prototype.writeNodeDefault,
-      [150 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [155 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [157 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [158 /* TypeAnnotation */]: 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 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
+      [77 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [78 /* MemberAccessExpression */]: this.prototype.writeNodeDefault,
+      [79 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
+      [80 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
+      [81 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [82 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [83 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [84 /* TokenExpression */]: this.prototype.writeNodeDefault,
+      [85 /* KeywordExpression */]: this.prototype.writeNodeDefault,
+      [86 /* ObjectExpression */]: this.prototype.writeNodeDefault,
+      [87 /* BaseExpression */]: this.prototype.writeNodeDefault,
+      [88 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
+      [89 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
+      [90 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
+      [91 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
+      [92 /* StatementList */]: this.prototype.writeNodeDefault,
+      [95 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
+      [96 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
+      [97 /* DisposeStatement */]: this.prototype.writeNodeDefault,
+      [98 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [99 /* TryStatement */]: this.prototype.writeNodeDefault,
+      [100 /* CatchClause */]: this.prototype.writeNodeDefault,
+      [101 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [102 /* FinallyClause */]: this.prototype.writeNodeDefault,
+      [103 /* EmptyStatement */]: this.prototype.writeNodeDefault,
+      [104 /* ErrorStatement */]: this.prototype.writeNodeDefault,
+      [105 /* ImportantStatement */]: this.prototype.writeNodeDefault,
+      [106 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
+      [107 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
+      [108 /* ForStatement */]: this.prototype.writeNodeDefault,
+      [109 /* IfStatement */]: this.prototype.writeNodeDefault,
+      [110 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
+      [111 /* ElseIfClause */]: this.prototype.writeNodeDefault,
+      [112 /* ElseClause */]: this.prototype.writeNodeDefault,
+      [113 /* InvalidStatement */]: this.prototype.writeNodeDefault,
+      [114 /* NestedFunctionDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [115 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [116 /* LoopStatement */]: this.prototype.writeNodeDefault,
+      [117 /* ReturnStatement */]: this.prototype.writeNodeDefault,
+      [118 /* CaseClauseList */]: this.prototype.writeNodeDefault,
+      [119 /* SwitchStatement */]: this.prototype.writeNodeDefault,
+      [120 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
+      [121 /* CaseClause */]: this.prototype.writeNodeDefault,
+      [122 /* WhileStatement */]: this.prototype.writeNodeDefault,
+      [123 /* YieldStatement */]: this.prototype.writeNodeDefault,
+      [124 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
+      [125 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
+      [126 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
+      [127 /* IndexParameterTranslationClause */]: this.prototype.writeIndexParameterTranslationClause,
+      [128 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
+      [129 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
+      [130 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
+      [131 /* PackageFunctionTranslation */]: this.prototype.writePackageFunctionTranslation,
+      [132 /* MethodTranslation */]: this.prototype.writeMethodTranslation,
+      [133 /* FunctionTypeTranslation */]: this.prototype.writeFunctionTypeTranslation,
+      [134 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
+      [136 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
+      [137 /* FieldOrVariantTranslation */]: this.prototype.writeFieldOrVariantTranslation,
+      [138 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
+      [139 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
+      [140 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [141 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [146 /* TagList */]: this.prototype.writeNodeDefault,
+      [148 /* ModifierList */]: this.prototype.writeNodeDefault,
+      [153 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [155 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [156 /* TypeAnnotation */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
-  /* eslint-enable @stylistic/max-len */
   // TODO: перенести метод в другое место (в Scanner)
   escapeLiteralIdentifier(value) {
     return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -2353,7 +2337,7 @@ var TranslationsGenerationService = class {
       return void 0;
     }
     let result;
-    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 141 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
+    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2365,7 +2349,7 @@ var TranslationsGenerationService = class {
         result = generator.generateMissingTypeMemberTranslations(tokenOrKeyword.parent);
       }
     }
-    if (result === void 0 && tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */) {
+    if (result === void 0 && tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2391,7 +2375,7 @@ var TranslationsGenerationService = class {
     if (tokenOrKeyword === void 0) {
       return false;
     }
-    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */)) {
+    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */)) {
       return false;
     }
     const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
@@ -2399,7 +2383,7 @@ var TranslationsGenerationService = class {
       return false;
     }
     const generator = new TranslationsGenerator(analyzer, sourceFile, translationPackage, sourceFile.package.dialect);
-    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 141 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
+    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 139 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
 var TranslationsGenerator = class _TranslationsGenerator {
@@ -2426,7 +2410,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
       };
       const memberTranslationsCode = Query.from(memberEntities).mapAndFilter((m) => this.createPackageMemberTranslationNode(m)).uniqueWithComparator(compareNodes).map((n) => {
         const code = new SyntaxToCode(n, syntaxToCodeOptions).convert();
-        if (n.kind === 141 /* TypeTranslation */) {
+        if (n.kind === 139 /* TypeTranslation */) {
           const startOffset = Math.max(code.indexOf(newLine), 0);
           return this.addNewLineBeforeArrowsInTranslation(
             code,
@@ -2458,7 +2442,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
   generateMissingTranslationsForPartiallyTranslatedTypes(translationsDeclaration) {
     const result = new Array();
     for (const translation of translationsDeclaration.translationList.translationDeclarations) {
-      if (translation.kind === 141 /* TypeTranslation */) {
+      if (translation.kind === 139 /* TypeTranslation */) {
         const edits = this.generateMissingTypeMemberTranslations(translation);
         if (edits !== void 0) {
           result.push(...edits);
@@ -2555,13 +2539,13 @@ var TranslationsGenerator = class _TranslationsGenerator {
   }
   detectIndentationStepForTypeMemberTranslations(node) {
     let indentationStepSize;
-    if (node.kind === 141 /* TypeTranslation */) {
+    if (node.kind === 139 /* TypeTranslation */) {
       indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(node, this._sourceFile);
     }
     if (indentationStepSize === void 0) {
-      const translationsDeclarations = node.kind === 23 /* TranslationsDeclaration */ ? node : node.parent.parent;
+      const translationsDeclarations = node.kind === 21 /* TranslationsDeclaration */ ? node : node.parent.parent;
       for (const member of translationsDeclarations.translationList.translationDeclarations) {
-        if (member.kind === 141 /* TypeTranslation */) {
+        if (member.kind === 139 /* TypeTranslation */) {
           indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(member, this._sourceFile);
           if (indentationStepSize !== void 0) {
             break;
@@ -2612,11 +2596,11 @@ var TranslationsGenerator = class _TranslationsGenerator {
     switch (entity.kind) {
       case 0 /* Variable */:
         return this.createPackageVariableTranslation(entity);
-      case 1 /* Method */:
-        return this.createPackageMethodTranslation(entity);
+      case 1 /* Function */:
+        return this.createPackageFunctionTranslation(entity);
       case 2 /* Type */:
-        if (entity.typeEntityKind === 0 /* Method */) {
-          return this.createPackageMethodTypeTranslation(entity);
+        if (entity.typeEntityKind === 0 /* Function */) {
+          return this.createPackageFunctionTypeTranslation(entity);
         } else {
           return this.createPackageTypeWithMembersTranslation(entity);
         }
@@ -2630,11 +2614,11 @@ var TranslationsGenerator = class _TranslationsGenerator {
     const name = this.getNameText(entity.getName());
     return SyntaxFactory.packageVariableTranslation(name, name);
   }
-  createPackageMethodTranslation(entity) {
+  createPackageFunctionTranslation(entity) {
     const name = this.getNameText(entity.getName());
     const typeParameters = entity.getTypeParameters().map((p) => this.getNameText(p.getName()));
     const parameters = entity.getValueParameters().map((p) => this.getNameText(p.getName()));
-    return SyntaxFactory.packageMethodTranslation(name, typeParameters, parameters, name, typeParameters, parameters);
+    return SyntaxFactory.packageFunctionTranslation(name, typeParameters, parameters, name, typeParameters, parameters);
   }
   createPackageTypeWithMembersTranslation(entity) {
     const name = this.getNameText(entity.getName());
@@ -2642,18 +2626,18 @@ var TranslationsGenerator = class _TranslationsGenerator {
     const members = Query.from(this.collectNotTranslatedTypeMembers(entity)).mapAndFilter((e) => this.createTypeMemberTranslationNode(e)).filter((n) => n !== void 0).uniqueWithComparator(compareNodes).toArray();
     return SyntaxFactory.typeTranslation(name, typeParameters, name, typeParameters, members);
   }
-  createPackageMethodTypeTranslation(entity) {
+  createPackageFunctionTypeTranslation(entity) {
     const name = this.getNameText(entity.getName());
     const typeParameters = entity.getTypeParameters().map((p) => this.getNameText(p.getName()));
     const parameters = entity.getValueParameters().map((p) => this.getNameText(p.getName()));
-    return SyntaxFactory.methodTypeTranslation(name, typeParameters, parameters, name, typeParameters, parameters);
+    return SyntaxFactory.functionTypeTranslation(name, typeParameters, parameters, name, typeParameters, parameters);
   }
   createTypeMemberTranslationNode(entity) {
     switch (entity.kind) {
       case 0 /* Variable */:
-        return this.createTypeVariableTranslation(entity);
-      case 1 /* Method */:
-        return this.createTypeMethodTranslation(entity);
+        return this.createFieldTranslation(entity);
+      case 1 /* Function */:
+        return this.createMethodTranslation(entity);
       case 7 /* Constructor */:
         return this.createConstructorTranslation(entity);
       case 5 /* Indexer */:
@@ -2666,15 +2650,15 @@ var TranslationsGenerator = class _TranslationsGenerator {
         Debug.never(entity);
     }
   }
-  createTypeVariableTranslation(entity) {
+  createFieldTranslation(entity) {
     const name = this.getNameText(entity.getName());
-    return SyntaxFactory.typeVariableOrVariantTranslation(name, name);
+    return SyntaxFactory.fieldOrVariantTranslation(name, name);
   }
-  createTypeMethodTranslation(entity) {
+  createMethodTranslation(entity) {
     const name = this.getNameText(entity.getName());
     const typeParameters = entity.getTypeParameters().map((p) => this.getNameText(p.getName()));
     const parameters = entity.getValueParameters().map((p) => this.getNameText(p.getName()));
-    return SyntaxFactory.typeMethodTranslation(name, typeParameters, parameters, name, typeParameters, parameters);
+    return SyntaxFactory.methodTranslation(name, typeParameters, parameters, name, typeParameters, parameters);
   }
   createConstructorTranslation(entity) {
     const parameters = entity.getValueParameters().map((p) => this.getNameText(p.getName()));
@@ -2743,7 +2727,7 @@ var CodeActionsService = class {
     }
     const result = new Array();
     const diagnosticCodeSet = new Set(diagnosticCodes);
-    if (diagnosticCodeSet.has(109 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(110 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
+    if (diagnosticCodeSet.has(2073 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(2074 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
       const data = { onlyTypeMembers: false };
       result.push(CodeAction.unresolved(
         "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u044B.",
@@ -2842,13 +2826,13 @@ var ValueArgumentFactory = class _ValueArgumentFactory {
 var SignatureForNode = class _SignatureForNode {
   static getSignaturesForNode(analyzer, node) {
     switch (node.kind) {
-      case 71 /* CallExpression */:
+      case 69 /* CallExpression */:
         return _SignatureForNode.getSignaturesForCallExpression(analyzer, node);
-      case 72 /* AutotypeCallExpression */:
+      case 70 /* AutotypeCallExpression */:
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
-      case 73 /* IndexedAccessExpression */:
+      case 71 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
-      case 149 /* Tag */:
+      case 147 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
       default:
         Debug.never(node);
@@ -2864,17 +2848,17 @@ var SignatureForNode = class _SignatureForNode {
       const signatures = meaning.candidates.map((c) => new ConstructorSignature(c));
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
-    const info = analyzer.checkExpressionDenotesMethod(node.expression);
+    const info = analyzer.checkExpressionDenotesFunction(node.expression);
     if (info !== void 0) {
       let suitableSignatureIndex;
-      if (info.suitableMethods.length === 1) {
-        suitableSignatureIndex = info.candidates.indexOf(info.suitableMethods[0]);
+      if (info.suitableFunctions.length === 1) {
+        suitableSignatureIndex = info.candidates.indexOf(info.suitableFunctions[0]);
       }
-      const signatures = info.candidates.map((c) => new AccessedMethodSignature(c));
+      const signatures = info.candidates.map((c) => new AccessedFunctionSignature(c));
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
-    if (meaning.kind === "object-method-call") {
-      const signature = new MethodTypeSignature(meaning.type);
+    if (meaning.kind === "object-function-call") {
+      const signature = new FunctionTypeSignature(meaning.type);
       return new SignaturesWithSingleSuitable([signature], 0);
     }
     return void 0;
@@ -2918,12 +2902,12 @@ var SignatureForNode = class _SignatureForNode {
       const signatures = meaning.candidates.map((c) => new ConstructorSignature(c));
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
-    if (meaning.kind === "tag-method") {
+    if (meaning.kind === "tag-function") {
       let suitableSignatureIndex;
-      if (meaning.suitableMethods.length === 1) {
-        suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableMethods[0]);
+      if (meaning.suitableFunctions.length === 1) {
+        suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableFunctions[0]);
       }
-      const signatures = meaning.candidates.map((c) => new AccessedMethodSignature(c));
+      const signatures = meaning.candidates.map((c) => new AccessedFunctionSignature(c));
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
     if (meaning.kind === "unresolved") {
@@ -2986,7 +2970,7 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         result = false;
         break;
       }
-      if (argument.expression === void 0 || argument.expression.kind === 74 /* InvalidExpression */) {
+      if (argument.expression === void 0 || argument.expression.kind === 72 /* InvalidExpression */) {
         continue;
       }
       const targetParameterType = targetParameter.getType();
@@ -3034,34 +3018,34 @@ var MatchedSignature = class {
     this.matchResult = matchResult;
   }
 };
-var AccessedMethodSignature = class {
-  constructor(method) {
-    this.kind = "accessed-method";
+var AccessedFunctionSignature = class {
+  constructor(func) {
+    this.kind = "accessed-function";
     this._valueParameters = new Cached();
-    this.method = method;
+    this.func = func;
   }
   getValueParameters() {
     return this._valueParameters.getOrInsertWith(() => {
-      const localizedSignature = EntityLocalizationHelper.getLocalizedMethodSignature(
-        this.method.value.getEntity(),
-        this.method.localization
+      const localizedSignature = EntityLocalizationHelper.getLocalizedFunctionSignature(
+        this.func.value.getEntity(),
+        this.func.localization
       );
-      return Query.from(this.method.value.getValueParameters()).zip(
+      return Query.from(this.func.value.getValueParameters()).zip(
         localizedSignature.getValueParameterNames(),
         (p, n) => new UniversalValueParameter(n.value, p.type, p.entity, n.localization)
       ).toArray();
     });
   }
 };
-var MethodTypeSignature = class {
-  constructor(methodType) {
-    this.kind = "method-type";
+var FunctionTypeSignature = class {
+  constructor(functionType) {
+    this.kind = "function-type";
     this._valueParameters = new Cached();
-    this.methodType = methodType;
+    this.functionType = functionType;
   }
   getValueParameters() {
     return this._valueParameters.getOrInsertWith(
-      () => this.methodType.getValueParameters().map(
+      () => this.functionType.getValueParameters().map(
         (p) => new UniversalValueParameter(
           p.getName(),
           p.getType(),
@@ -3160,7 +3144,7 @@ var CompletionService = class {
       semanticContext,
       positionDescription
     );
-    completionItemInfos = this.mergeOverloadedMethods(completionItemInfos);
+    completionItemInfos = this.mergeOverloadedFunctions(completionItemInfos);
     completionItemInfos = this.removeCompletionItemsWithDuplicateLabels(completionItemInfos);
     const cacheId = this._cache.add(completionItemInfos, sourceFile).id;
     const result = this.convertCompletionItemInfos(completionItemInfos, cacheId);
@@ -3224,7 +3208,7 @@ var CompletionService = class {
     if (syntaxContext.isInComment || syntaxContext.isInStringOrChar) {
       return { kind: "none" };
     }
-    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 55 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 54 /* TypeMethodDeclaration */)) {
+    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 53 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 52 /* MethodDeclaration */)) {
       return new OperatorNameCompletionContext(syntaxContext.isInQuotedIdentifier);
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
@@ -3234,15 +3218,15 @@ var CompletionService = class {
     if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 8 /* PackageImport */) {
       return new PackageImportCompletionContext([], void 0);
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 9 /* PackagePath */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 9 /* PackageName */) {
       const packageImport = tokenOrKeyword.parent.parent;
-      const precedingSegmentNames = packageImport.packagePath.segments.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
+      const precedingSegmentNames = packageImport.packageName.segments.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
       return new PackageImportCompletionContext(precedingSegmentNames, void 0);
     }
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || this.tokenOrKeywordIsPackageImportListChild(tokenOrKeyword)) {
       return new PackageImportCompletionContext([], void 0);
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 80 /* PropertyAccessExpression */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 78 /* MemberAccessExpression */) {
       const propertyAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(propertyAccess.expression);
@@ -3283,7 +3267,7 @@ var CompletionService = class {
         typeExtensionLookup
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 137 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
       const namedTypeSpecifier = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveNamedTypeSpecifier(namedTypeSpecifier);
       const segmentIndex = Math.floor(
@@ -3291,7 +3275,7 @@ var CompletionService = class {
       );
       if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
         let completionInIsOrAsExpressionInfo;
-        if (namedTypeSpecifier.parent.kind === 75 /* IsExpression */ || namedTypeSpecifier.parent.kind === 67 /* AsExpression */) {
+        if (namedTypeSpecifier.parent.kind === 73 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
           completionInIsOrAsExpressionInfo = {
             expressionType: this._analyzer.type.ofExpression(namedTypeSpecifier.parent.expression)
           };
@@ -3325,7 +3309,7 @@ var CompletionService = class {
       }
       return { kind: "none" };
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 137 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 149 /* Tag */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 147 /* Tag */) {
       const tag = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveTag(tag);
       const segmentIndex = Math.floor(
@@ -3363,7 +3347,7 @@ var CompletionService = class {
     }
     if (syntaxContext.isUnqualifiedTypeContext !== void 0) {
       let completionInIsOrAsExpressionInfo;
-      if (tokenOrKeyword.parent.kind === 75 /* IsExpression */ || tokenOrKeyword.parent.kind === 67 /* AsExpression */) {
+      if (tokenOrKeyword.parent.kind === 73 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
         completionInIsOrAsExpressionInfo = {
           expressionType: this._analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
@@ -3418,17 +3402,17 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 136 /* PackageImportTranslation */) {
+    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 134 /* PackageImportTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 141 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 135 /* MethodTypeTranslation */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 139 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 133 /* FunctionTypeTranslation */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 133 /* PackageMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 131 /* PackageFunctionTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3448,9 +3432,9 @@ var CompletionService = class {
         hasPrecedingKeyword
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 137 /* QualifiedName */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */) {
       const qualifiedName = tokenOrKeyword.parent;
-      if (qualifiedName.parent.kind === 136 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
+      if (qualifiedName.parent.kind === 134 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
         const precedingSegmentNames = qualifiedName.qualifiers.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
         const sourceLocale = translationPackage.getTranslatedPackage().getLocale();
         return new PackageImportCompletionContext(precedingSegmentNames, { sourceLocale });
@@ -3475,12 +3459,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 134 /* TypeMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 132 /* MethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 128 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 126 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3510,21 +3494,21 @@ var CompletionService = class {
       let signatures;
       let valueArguments;
       switch (role.argumentList.parent.kind) {
-        case 71 /* CallExpression */:
+        case 69 /* CallExpression */:
           signatures = SignatureForNode.getSignaturesForCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(role.argumentList.parent);
           break;
-        case 72 /* AutotypeCallExpression */:
+        case 70 /* AutotypeCallExpression */:
           signatures = SignatureForNode.getSignaturesForAutotypeCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(
             role.argumentList.parent
           );
           break;
-        case 149 /* Tag */:
+        case 147 /* Tag */:
           signatures = SignatureForNode.getSignaturesForTag(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(role.argumentList.parent);
           break;
-        case 73 /* IndexedAccessExpression */:
+        case 71 /* IndexedAccessExpression */:
           signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
             this._analyzer,
             role.argumentList.parent
@@ -3607,7 +3591,7 @@ var CompletionService = class {
   }
   tokenOrKeywordIsPackageImportListChild(tokenOrKeyword) {
     let parent = tokenOrKeyword.parent;
-    while (parent.kind === 3 /* Keyword */ || parent.kind === 9 /* PackagePath */ || parent.kind === 8 /* PackageImport */) {
+    while (parent.kind === 3 /* Keyword */ || parent.kind === 9 /* PackageName */ || parent.kind === 8 /* PackageImport */) {
       parent = parent.parent;
     }
     return parent.kind === 7 /* PackageImportList */;
@@ -3721,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 === 60 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 76 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 31 /* MethodTypeDeclarationBody */)) {
+    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 */)) {
       kinds.add(12 /* Function */);
     }
     return Query.from(kinds.values()).map(
@@ -3733,35 +3717,35 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 118 /* LoopStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 116 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 151 /* Modifier */;
+    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 149 /* Modifier */;
   }
   isElseOrElseIfKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 111 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 113 /* ElseIfClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 109 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 111 /* ElseIfClause */);
   }
   isCatchKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 101 /* TryStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */;
   }
   isFinallyKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 101 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 102 /* CatchClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* CatchClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(57 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3771,17 +3755,17 @@ var CompletionService = class {
       return false;
     }
     const token = positionDescription.tokenOrKeyword.value;
-    return token.parent.kind === 62 /* 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 === 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);
   }
   isCaseKeywordContext(positionDescription, syntaxContext) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 123 /* CaseClause */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 121 /* CaseClause */) {
       return true;
     }
-    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 121 /* SwitchStatement */) {
+    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 119 /* SwitchStatement */) {
       return true;
     }
     return false;
@@ -3824,7 +3808,7 @@ var CompletionService = class {
               d.requiresExplicitOriginalName
             );
           } else {
-            return new TypeVariableCompletionItemInfo(
+            return new FieldCompletionItemInfo(
               this.completionItemInfoContext,
               d.value.value.value,
               d.name,
@@ -3832,16 +3816,16 @@ var CompletionService = class {
             );
           }
         }
-        case "method": {
+        case "function": {
           if (d.value.value.kind === "entity") {
-            return new MethodEntityCompletionItemInfo(
+            return new FunctionEntityCompletionItemInfo(
               this.completionItemInfoContext,
               d.value.value.value,
               d.name,
               d.requiresExplicitOriginalName
             );
           } else {
-            return new TypeMethodCompletionItemInfo(
+            return new MethodCompletionItemInfo(
               this.completionItemInfoContext,
               d.value.value.value,
               d.name,
@@ -3961,8 +3945,8 @@ var CompletionService = class {
           m.name,
           m.requiresExplicitOriginalName
         );
-      } else if (m.value.kind === 1 /* Method */) {
-        return new MethodEntityCompletionItemInfo(
+      } else if (m.value.kind === 1 /* Function */) {
+        return new FunctionEntityCompletionItemInfo(
           this.completionItemInfoContext,
           m.value,
           m.name,
@@ -3985,8 +3969,8 @@ var CompletionService = class {
               m.name,
               m.requiresExplicitOriginalName
             );
-          } else if (m.value.kind === 1 /* Method */) {
-            return new MethodEntityCompletionItemInfo(
+          } else if (m.value.kind === 1 /* Function */) {
+            return new FunctionEntityCompletionItemInfo(
               this.completionItemInfoContext,
               m.value,
               m.name,
@@ -4009,8 +3993,8 @@ var CompletionService = class {
             d.name,
             d.requiresExplicitOriginalName
           );
-        case "method":
-          return new MethodEntityCompletionItemInfo(
+        case "function":
+          return new FunctionEntityCompletionItemInfo(
             this.completionItemInfoContext,
             d.value.value.getEntity(),
             d.name,
@@ -4049,8 +4033,8 @@ var CompletionService = class {
           name,
           isNameExplicitlyOriginal
         );
-      case 1 /* Method */:
-        return new MethodEntityCompletionItemInfo(
+      case 1 /* Function */:
+        return new FunctionEntityCompletionItemInfo(
           this.completionItemInfoContext,
           member,
           name,
@@ -4079,14 +4063,14 @@ var CompletionService = class {
     return memberLookup.getNamedMembers(options6, ctx.hidingMatcher, ctx.typeExtensionsLookup).map((m) => {
       switch (m.value.kind) {
         case "method":
-          return new TypeMethodCompletionItemInfo(
+          return new MethodCompletionItemInfo(
             this.completionItemInfoContext,
             m.value,
             m.name,
             m.requiresExplicitOriginalName
           );
         case "variable":
-          return new TypeVariableCompletionItemInfo(
+          return new FieldCompletionItemInfo(
             this.completionItemInfoContext,
             m.value,
             m.name,
@@ -4129,8 +4113,8 @@ var CompletionService = class {
       result = items ?? Query.empty();
     } else if (ctx.translationKind === 2 /* Method */) {
       result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).mapAndFilter((d) => {
-        if (d.value.kind === 1 /* Method */) {
-          return new AliasesSourceMethodCompletionItemInfo(
+        if (d.value.kind === 1 /* Function */) {
+          return new AliasesSourceFunctionCompletionItemInfo(
             this.completionItemInfoContext,
             d.value,
             !ctx.hasPrecedingKeyword,
@@ -4171,8 +4155,8 @@ var CompletionService = class {
                 d.value,
                 displayService_
               );
-            case 1 /* Method */:
-              return new AliasesSourceMethodCompletionItemInfo(
+            case 1 /* Function */:
+              return new AliasesSourceFunctionCompletionItemInfo(
                 this.completionItemInfoContext,
                 d.value,
                 !ctx.hasPrecedingKeyword,
@@ -4213,8 +4197,8 @@ var CompletionService = class {
       const displayService_ = new DisplayService(this._analyzer, ctx.sourceLocale, this._dialect);
       if (ctx.translationKind === 1 /* Method */) {
         result = Query.from(ctx.typeEntity.getMembers().getNamedMembers()).mapAndFilter((m) => {
-          if (m.kind === 1 /* Method */) {
-            return new AliasesSourceMethodCompletionItemInfo(
+          if (m.kind === 1 /* Function */) {
+            return new AliasesSourceFunctionCompletionItemInfo(
               this.completionItemInfoContext,
               m,
               !ctx.hasPrecedingKeyword,
@@ -4225,7 +4209,7 @@ var CompletionService = class {
         });
       } else if (ctx.translationKind === 3 /* Constructor */) {
         result = Query.from(ctx.typeEntity.getMembers().getConstructors()).map(
-          (c) => new AliasesSourceTypeConstructorCompletionItemInfo(
+          (c) => new AliasesSourceConstructorCompletionItemInfo(
             this.completionItemInfoContext,
             c,
             !ctx.hasPrecedingKeyword,
@@ -4233,13 +4217,13 @@ var CompletionService = class {
           )
         );
       } else if (ctx.translationKind === 2 /* Indexer */) {
-        result = Query.from(ctx.typeEntity.getMembers().getIndexers()).map((i) => new AliasesSourceTypeIndexerCompletionItemInfo(this.completionItemInfoContext, i, displayService_));
+        result = Query.from(ctx.typeEntity.getMembers().getIndexers()).map((i) => new AliasesSourceIndexerCompletionItemInfo(this.completionItemInfoContext, i, displayService_));
       } else if (ctx.translationKind === 0 /* Any */) {
         result = Query.from(ctx.typeEntity.getMembers().getNamedMembers()).mapAndFilter((m) => {
           if (m.kind === 0 /* Variable */) {
             return new AliasesSourceVariableCompletionItemInfo(this.completionItemInfoContext, m, displayService_);
-          } else if (m.kind === 1 /* Method */) {
-            return new AliasesSourceMethodCompletionItemInfo(
+          } else if (m.kind === 1 /* Function */) {
+            return new AliasesSourceFunctionCompletionItemInfo(
               this.completionItemInfoContext,
               m,
               !ctx.hasPrecedingKeyword,
@@ -4249,7 +4233,7 @@ var CompletionService = class {
           return void 0;
         }).chain(
           ctx.typeEntity.getMembers().getConstructors().map(
-            (c) => new AliasesSourceTypeConstructorCompletionItemInfo(
+            (c) => new AliasesSourceConstructorCompletionItemInfo(
               this.completionItemInfoContext,
               c,
               !ctx.hasPrecedingKeyword,
@@ -4258,7 +4242,7 @@ var CompletionService = class {
           )
         ).chain(
           ctx.typeEntity.getMembers().getIndexers().map(
-            (i) => new AliasesSourceTypeIndexerCompletionItemInfo(this.completionItemInfoContext, i, displayService_)
+            (i) => new AliasesSourceIndexerCompletionItemInfo(this.completionItemInfoContext, i, displayService_)
           )
         );
       } else {
@@ -4289,20 +4273,20 @@ var CompletionService = class {
       return new OperatorNameCompletionItemInfo(this.completionItemInfoContext, value, editRange);
     });
   }
-  mergeOverloadedMethods(completionItemInfos) {
+  mergeOverloadedFunctions(completionItemInfos) {
     const result = new Array();
-    const methodInfoByLabel = /* @__PURE__ */ new Map();
+    const functionInfoByLabel = /* @__PURE__ */ new Map();
     for (const itemInfo of completionItemInfos) {
       switch (itemInfo.kind) {
-        case "type-method":
-        case "method-entity":
+        case "method":
+        case "function-entity":
         case "operator": {
           const label = itemInfo.getLabel();
-          const methodInfo = methodInfoByLabel.get(label);
-          if (methodInfo !== void 0) {
-            methodInfo.count++;
+          const functionInfo = functionInfoByLabel.get(label);
+          if (functionInfo !== void 0) {
+            functionInfo.count++;
           } else {
-            methodInfoByLabel.set(label, { itemInfo, count: 1 });
+            functionInfoByLabel.set(label, { itemInfo, count: 1 });
           }
           break;
         }
@@ -4310,17 +4294,17 @@ var CompletionService = class {
           result.push(itemInfo);
       }
     }
-    for (const methodInfo of methodInfoByLabel.values()) {
-      if (methodInfo.count > 1) {
+    for (const functionInfo of functionInfoByLabel.values()) {
+      if (functionInfo.count > 1) {
         result.push(
-          new MergedOverloadedMethodCompletionItemInfo(
+          new MergedOverloadedFunctionCompletionItemInfo(
             this.completionItemInfoContext,
-            methodInfo.itemInfo,
-            methodInfo.count
+            functionInfo.itemInfo,
+            functionInfo.count
           )
         );
       } else {
-        result.push(methodInfo.itemInfo);
+        result.push(functionInfo.itemInfo);
       }
     }
     return result;
@@ -4329,7 +4313,7 @@ var CompletionService = class {
     const seenLabels = /* @__PURE__ */ new Set();
     const result = new Array();
     for (const completionItemInfo of completionItemInfos) {
-      if (completionItemInfo.kind === "aliases-source-method" || completionItemInfo.kind === "aliases-source-package-type") {
+      if (completionItemInfo.kind === "aliases-source-function" || completionItemInfo.kind === "aliases-source-package-type") {
         result.push(completionItemInfo);
         continue;
       }
@@ -4429,11 +4413,11 @@ function getRightmostChildExcludingValidEmptyNodes(node) {
 }
 function isInvalidNode(node) {
   switch (node.kind) {
-    case 74 /* InvalidExpression */:
-    case 45 /* InvalidPackageMemberDeclaration */:
-    case 115 /* InvalidStatement */:
-    case 59 /* InvalidTypeMemberDeclaration */:
-    case 18 /* InvalidTypeSpecifier */:
+    case 72 /* InvalidExpression */:
+    case 43 /* InvalidPackageMemberDeclaration */:
+    case 113 /* InvalidStatement */:
+    case 57 /* InvalidTypeMemberDeclaration */:
+    case 16 /* InvalidTypeSpecifier */:
       return true;
     case 0 /* Token */:
       return node.isMissing;
@@ -4619,7 +4603,7 @@ var PackageAliasEntityCompletionItemInfo = class {
     return void 0;
   }
 };
-var TypeVariableCompletionItemInfo = class {
+var FieldCompletionItemInfo = class {
   constructor(ctx, variable, name, isNameExplicitlyOriginal) {
     this.ctx = ctx;
     this.variable = variable;
@@ -4631,7 +4615,7 @@ var TypeVariableCompletionItemInfo = class {
     return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
   }
   getCompletionItemKind() {
-    return this.variable.isVariant() ? 12 /* Variant */ : 2 /* TypeVariable */;
+    return this.variable.isVariant() ? 12 /* Variant */ : 2 /* Field */;
   }
   getDetails() {
     return this.ctx.displayService.displayVariableDeclaration(
@@ -4648,23 +4632,23 @@ var TypeVariableCompletionItemInfo = class {
     return void 0;
   }
 };
-var TypeMethodCompletionItemInfo = class {
+var MethodCompletionItemInfo = class {
   constructor(ctx, method, name, isNameExplicitlyOriginal) {
     this.ctx = ctx;
     this.method = method;
     this.name = name;
     this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
-    this.kind = "type-method";
+    this.kind = "method";
   }
   getLabel() {
     return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
   }
   getCompletionItemKind() {
-    return 3 /* TypeMethod */;
+    return 3 /* Method */;
   }
   getDetails() {
-    return this.ctx.displayService.displayMethodDeclaration(
-      new MethodDeclaration_typeMember(this.method, this.name.localization)
+    return this.ctx.displayService.displayFunctionDeclaration(
+      new FunctionDeclaration_typeMember(this.method, this.name.localization)
     );
   }
   getInsertText() {
@@ -4720,8 +4704,8 @@ var VariableEntityCompletionItemInfo = class {
     switch (this.entity.subkind) {
       case "package":
         return 7 /* PackageVariable */;
-      case "type":
-        return this.entity.isVariant() ? 12 /* Variant */ : 2 /* TypeVariable */;
+      case "field":
+        return this.entity.isVariant() ? 12 /* Variant */ : 2 /* Field */;
       case "parameter":
         return 10 /* ParameterVariable */;
       case "local":
@@ -4745,13 +4729,13 @@ var VariableEntityCompletionItemInfo = class {
     return void 0;
   }
 };
-var MethodEntityCompletionItemInfo = class {
+var FunctionEntityCompletionItemInfo = class {
   constructor(ctx, entity, name, isNameExplicitlyOriginal) {
     this.ctx = ctx;
     this.entity = entity;
     this.name = name;
     this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
-    this.kind = "method-entity";
+    this.kind = "function-entity";
   }
   getLabel() {
     return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
@@ -4759,18 +4743,18 @@ var MethodEntityCompletionItemInfo = class {
   getCompletionItemKind() {
     switch (this.entity.subkind) {
       case "package":
-        return 8 /* PackageMethod */;
-      case "type":
-        return 3 /* TypeMethod */;
+        return 8 /* PackageFunction */;
+      case "method":
+        return 3 /* Method */;
       case "nested":
-        return 11 /* NestedMethod */;
+        return 11 /* NestedFunction */;
       default:
         Debug.never(this.entity);
     }
   }
   getDetails() {
-    return this.ctx.displayService.displayMethodDeclaration(
-      new MethodDeclaration_entity(this.entity, this.name.localization)
+    return this.ctx.displayService.displayFunctionDeclaration(
+      new FunctionDeclaration_entity(this.entity, this.name.localization)
     );
   }
   getInsertText() {
@@ -4802,8 +4786,8 @@ var NamedTypeCompletionItemInfo = class {
         return 16 /* VariantType */;
       case 2 /* Parameter */:
         return 17 /* TypeParameter */;
-      case 0 /* Method */:
-        return 18 /* MethodType */;
+      case 0 /* Function */:
+        return 18 /* FunctionType */;
       case 1 /* Structured */:
         if (this.entity.isRefObject()) {
           return 13 /* RefObjectType */;
@@ -4859,12 +4843,12 @@ var KeywordCompletionItemInfo = class {
     return void 0;
   }
 };
-var MergedOverloadedMethodCompletionItemInfo = class {
+var MergedOverloadedFunctionCompletionItemInfo = class {
   constructor(ctx, firstOverloadInfo, overloadCount) {
     this.ctx = ctx;
     this.firstOverloadInfo = firstOverloadInfo;
     this.overloadCount = overloadCount;
-    this.kind = "merged-overloaded-method";
+    this.kind = "merged-overloaded-function";
   }
   getLabel() {
     return this.firstOverloadInfo.getLabel();
@@ -4933,8 +4917,8 @@ var AliasesSourceVariableCompletionItemInfo = class {
     switch (this.variable.subkind) {
       case "package":
         return 7 /* PackageVariable */;
-      case "type":
-        return 2 /* TypeVariable */;
+      case "field":
+        return 2 /* Field */;
       case "parameter":
         return 7 /* PackageVariable */;
       case "local":
@@ -4958,39 +4942,39 @@ var AliasesSourceVariableCompletionItemInfo = class {
     return void 0;
   }
 };
-var AliasesSourceMethodCompletionItemInfo = class {
-  constructor(ctx, method, includeMethodKeyword, displayService) {
+var AliasesSourceFunctionCompletionItemInfo = class {
+  constructor(ctx, func, includeFunctionKeyword, displayService) {
     this.ctx = ctx;
-    this.method = method;
-    this.includeMethodKeyword = includeMethodKeyword;
+    this.func = func;
+    this.includeFunctionKeyword = includeFunctionKeyword;
     this.displayService = displayService;
-    this.kind = "aliases-source-method";
+    this.kind = "aliases-source-function";
   }
   getLabel() {
-    return this.ctx.getInsertTextForName(this.method.getName());
+    return this.ctx.getInsertTextForName(this.func.getName());
   }
   getCompletionItemKind() {
-    switch (this.method.subkind) {
+    switch (this.func.subkind) {
       case "package":
-        return 8 /* PackageMethod */;
-      case "type":
-        return 3 /* TypeMethod */;
+        return 8 /* PackageFunction */;
+      case "method":
+        return 3 /* Method */;
       case "nested":
-        return 11 /* NestedMethod */;
+        return 11 /* NestedFunction */;
       default:
-        Debug.never(this.method);
+        Debug.never(this.func);
     }
   }
   getDetails() {
-    return this.displayService.displayMethodDeclaration(
-      new MethodDeclaration_entity(this.method, Localization.Original.ofEntity(this.method))
+    return this.displayService.displayFunctionDeclaration(
+      new FunctionDeclaration_entity(this.func, Localization.Original.ofEntity(this.func))
     );
   }
   getInsertText() {
-    const displayParts = this.displayService.getMethodDeclarationDisplayParts(
-      new MethodDeclaration_entity(this.method, Localization.Original.ofEntity(this.method))
+    const displayParts = this.displayService.getFunctionDeclarationDisplayParts(
+      new FunctionDeclaration_entity(this.func, Localization.Original.ofEntity(this.func))
     );
-    const keywordWithWhitespace = this.includeMethodKeyword ? displayParts.functionKeyword + displayParts.whitespaceAfterFunctionKeyword : "";
+    const keywordWithWhitespace = this.includeFunctionKeyword ? displayParts.functionKeyword + displayParts.whitespaceAfterFunctionKeyword : "";
     const valueParameters = displayParts.valueParameters.map((p) => p.name).join(displayParts.typeParameterSeparator);
     return keywordWithWhitespace + displayParts.name + displayParts.typeParametersStart + displayParts.typeParameters.join(displayParts.typeParameterSeparator) + displayParts.typeParametersEnd + displayParts.valueParametersStart + valueParameters + displayParts.valueParametersEnd;
   }
@@ -5016,8 +5000,8 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
     switch (this.typeEntity.typeEntityKind) {
       case 3 /* Variant */:
         return 16 /* VariantType */;
-      case 0 /* Method */:
-        return 18 /* MethodType */;
+      case 0 /* Function */:
+        return 18 /* FunctionType */;
       case 1 /* Structured */: {
         if (this.typeEntity.isRefObject()) {
           return 13 /* RefObjectType */;
@@ -5052,9 +5036,9 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
         return new TypeDeclaration_variant(
           new TypeDeclarationVariant_entity(this.typeEntity, localization)
         );
-      case 0 /* Method */:
-        return new TypeDeclaration_method(
-          new TypeDeclarationMethod_entity(this.typeEntity, localization)
+      case 0 /* Function */:
+        return new TypeDeclaration_function(
+          new TypeDeclarationFunction_entity(this.typeEntity, localization)
         );
       case 1 /* Structured */:
         return new TypeDeclaration_structured(
@@ -5072,7 +5056,7 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
     return void 0;
   }
 };
-var AliasesSourceTypeIndexerCompletionItemInfo = class {
+var AliasesSourceIndexerCompletionItemInfo = class {
   constructor(ctx, indexer, displayService) {
     this.ctx = ctx;
     this.indexer = indexer;
@@ -5091,7 +5075,7 @@ var AliasesSourceTypeIndexerCompletionItemInfo = class {
     return this.label;
   }
   getCompletionItemKind() {
-    return 5 /* TypeIndexer */;
+    return 5 /* Indexer */;
   }
   getDetails() {
     return this.label;
@@ -5107,7 +5091,7 @@ var AliasesSourceTypeIndexerCompletionItemInfo = class {
     return void 0;
   }
 };
-var AliasesSourceTypeConstructorCompletionItemInfo = class {
+var AliasesSourceConstructorCompletionItemInfo = class {
   constructor(ctx, constructor_, includeOnCreateKeyword, displayService) {
     this.ctx = ctx;
     this.constructor_ = constructor_;
@@ -5131,7 +5115,7 @@ var AliasesSourceTypeConstructorCompletionItemInfo = class {
     return this.label;
   }
   getCompletionItemKind() {
-    return 6 /* TypeConstructor */;
+    return 6 /* Constructor */;
   }
   getDetails() {
     return this.label;
@@ -5263,7 +5247,7 @@ var SyntaxContextFactory = class {
     if (positionDescription.kind === "after-token-or-keyword") {
       isUnqualifiedTypeContext = this.isUnqualifiedTypeContext(positionDescription.tokenOrKeyword);
     }
-    const isUnqualifiedTagNameCompletionContext = positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(35 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 149 /* Tag */;
+    const isUnqualifiedTagNameCompletionContext = positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(35 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 147 /* Tag */;
     let isTopLevelTranslationListContext;
     if (positionDescription.kind === "after-token-or-keyword") {
       isTopLevelTranslationListContext = this.isTopLevelTranslationListContext(positionDescription.tokenOrKeyword);
@@ -5289,52 +5273,52 @@ var SyntaxContextFactory = class {
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(57 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 61 /* LocalVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 59 /* LocalVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 37 /* PackageVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 35 /* PackageVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 56 /* TypeVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 54 /* FieldDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 146 /* ParameterDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 144 /* ParameterDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 147 /* Argument */) {
+      if (tokenOrKeyword.parent.kind === 145 /* Argument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 144 /* VariantDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 142 /* VariantDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 79 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 68 /* BinaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 83 /* TextTemplateLiteral */) {
+    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 81 /* TextTemplateLiteral */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.spanList.spans.at(0)?.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 85 /* TextTemplateSpan */) {
+    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 83 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5346,12 +5330,12 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 96 /* FunctionBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* FunctionBlock */) {
       const block = tokenOrKeyword.parent;
-      if (block.expressionOrStatementList.kind !== 94 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
+      if (block.expressionOrStatementList.kind !== 92 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
         return {
           isExpressionContext: { expressionRole: new ExpressionRole_functionBlockExpression(block) },
           isStatementContext: true
@@ -5363,27 +5347,27 @@ var SyntaxContextFactory = class {
         };
       }
     }
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 94 /* StatementList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 92 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(44 /* OpenParenthesis */)) {
-      if (tokenOrKeyword.parent.kind === 77 /* ParenthesizedExpression */) {
+      if (tokenOrKeyword.parent.kind === 75 /* ParenthesizedExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 81 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 79 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 71 /* CallExpression */) {
+      if (tokenOrKeyword.parent.kind === 69 /* CallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 72 /* AutotypeCallExpression */) {
+      if (tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 149 /* Tag */) {
+      if (tokenOrKeyword.parent.kind === 147 /* Tag */) {
         const argumentList = tokenOrKeyword.parent.argumentList;
         if (argumentList !== void 0) {
           const expressionRole = new ExpressionRole_argument(argumentList, 0);
@@ -5391,16 +5375,16 @@ var SyntaxContextFactory = class {
         }
       }
     }
-    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 73 /* IndexedAccessExpression */) {
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
       const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 63 /* ArrayLiteral */) {
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 61 /* ArrayLiteral */) {
       const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(24 /* Comma */)) {
-      if (tokenOrKeyword.parent.kind === 70 /* ArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 68 /* ArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5414,64 +5398,64 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_argument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 122 /* MatchExpressionList */) {
+      if (tokenOrKeyword.parent.kind === 120 /* MatchExpressionList */) {
         const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 64 /* ArrayLiteralElementList */) {
+      if (tokenOrKeyword.parent.kind === 62 /* ArrayLiteralElementList */) {
         const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 123 /* CaseClause */) {
+    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 121 /* CaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 119 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 117 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(20 /* Error */) && tokenOrKeyword.parent.kind === 106 /* ErrorStatement */) {
+    if (tokenOrKeyword.isKeyword(20 /* Error */) && tokenOrKeyword.parent.kind === 104 /* ErrorStatement */) {
       const expressionRole = new ExpressionRole_errorValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(19 /* Important */) && tokenOrKeyword.parent.kind === 107 /* ImportantStatement */) {
+    if (tokenOrKeyword.isKeyword(19 /* Important */) && tokenOrKeyword.parent.kind === 105 /* ImportantStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(44 /* Switch */) && tokenOrKeyword.parent.kind === 121 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(44 /* Switch */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 111 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 109 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 113 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 111 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 110 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 108 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* While */) && tokenOrKeyword.parent.kind === 124 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(25 /* While */) && tokenOrKeyword.parent.kind === 122 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 118 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(27 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 116 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(28 /* Yield */) && tokenOrKeyword.parent.kind === 125 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(28 /* Yield */) && tokenOrKeyword.parent.kind === 123 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(29 /* When */) && tokenOrKeyword.parent.kind === 78 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isKeyword(29 /* When */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 78 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.secondExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5490,52 +5474,58 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(51 /* Semicolon */) && (tokenOrKeyword.parent.kind === 2 /* PackageMemberDeclarationList */ || tokenOrKeyword.parent.kind === 4 /* PackageImportDirectiveList */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 34 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 42 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 35 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 40 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 24 /* PackageAliasTypeDeclaration */)) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 40 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 33 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 38 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 22 /* PackageAliasTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 26 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 96 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 27 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 28 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 29 /* PackageMethodDeclaration */))) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 94 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageFunctionDeclaration */))) {
       return true;
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 26 /* PackageMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 29 /* PackageMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 30 /* PackageMethodTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 24 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    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(
       tokenOrKeyword,
-      38 /* PackageVariableGetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 39 /* PackageVariableSetterDeclaration */)) {
+      36 /* PackageVariableGetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 151 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 149 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 151 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 149 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
   }
   static isTypeMemberDeclarationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 33 /* TypeMemberDeclarationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 31 /* TypeMemberDeclarationList */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 34 /* TypeMemberDeclarationBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 46 /* TypeMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 44 /* TypeMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* TypeVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 57 /* TypeVariableGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 58 /* TypeVariableSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 49 /* TypeIndexedGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 50 /* TypeIndexedSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* FieldDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* FieldGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* FieldSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+      tokenOrKeyword,
+      47 /* IndexedElementGetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      52 /* TypeDereferencedVariableGetterDeclaration */
+      48 /* IndexedElementSetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      53 /* TypeDereferencedVariableSetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 47 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 48 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 144 /* VariantDeclaration */)) {
+      50 /* 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 */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 151 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 149 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 151 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 149 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5572,116 +5562,116 @@ var SyntaxContextFactory = class {
     return result;
   }
   static isUnqualifiedTypeContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 158 /* TypeAnnotation */) {
+    if (tokenOrKeyword.isToken(23 /* 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 === 36 /* StructuredTypeDeclarationBody */) {
+    if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 42 /* TypeExtensionDeclaration */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 154 /* TypeArgumentClause */) {
+    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 152 /* TypeArgumentClause */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 32 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 155 /* TypeArgumentList */)) {
-      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 155 /* TypeArgumentList */ };
+    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */ };
     }
-    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 149 /* Tag */) {
+    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 147 /* Tag */) {
       return { allowsAnonymousTypes: false };
     }
-    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 145 /* TypeParameterDeclaration */) {
+    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 143 /* TypeParameterDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 24 /* PackageAliasTypeDeclaration */) {
+    if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 22 /* PackageAliasTypeDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 75 /* IsExpression */) {
+    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 67 /* AsExpression */) {
+    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(17 /* Bar */) && tokenOrKeyword.parent.kind === 12 /* UnionTypeSpecifierTypeList */) {
+    if (tokenOrKeyword.isToken(17 /* Bar */) && tokenOrKeyword.parent.kind === 11 /* UnionTypeSpecifier */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(10 /* Ampersand */) && tokenOrKeyword.parent.kind === 14 /* IntersectionTypeSpecifierTypeList */) {
+    if (tokenOrKeyword.isToken(10 /* Ampersand */) && tokenOrKeyword.parent.kind === 12 /* IntersectionTypeSpecifier */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 15 /* ParenthesizedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 13 /* ParenthesizedTypeSpecifier */) {
       return { allowsAnonymousTypes: true };
     }
     return void 0;
   }
   static isTopLevelTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 22 /* TopLevelTranslationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 20 /* TopLevelTranslationList */) {
       return { translationsDeclaration: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */) {
       return { translationsDeclaration: tokenOrKeyword.parent };
     }
     const packageImport = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      136 /* PackageImportTranslation */
+      134 /* PackageImportTranslation */
     );
     if (packageImport !== void 0) {
       return { translationsDeclaration: packageImport.parent.parent };
     }
-    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 141 /* TypeTranslation */);
+    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 139 /* TypeTranslation */);
     if (type !== void 0) {
       return { translationsDeclaration: type.parent.parent };
     }
-    const methodType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
+    const functionType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      135 /* MethodTypeTranslation */
+      133 /* FunctionTypeTranslation */
     );
-    if (methodType !== void 0) {
-      return { translationsDeclaration: methodType.parent.parent };
+    if (functionType !== void 0) {
+      return { translationsDeclaration: functionType.parent.parent };
     }
     const variable = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      138 /* PackageVariableTranslation */
+      136 /* PackageVariableTranslation */
     );
     if (variable !== void 0) {
       return { translationsDeclaration: variable.parent.parent };
     }
-    const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
+    const func = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      133 /* PackageMethodTranslation */
+      131 /* PackageFunctionTranslation */
     );
-    if (method !== void 0) {
-      return { translationsDeclaration: method.parent.parent };
+    if (func !== void 0) {
+      return { translationsDeclaration: func.parent.parent };
     }
     return void 0;
   }
   static isTypeMemberTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 140 /* TypeMemberTranslationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 138 /* TypeMemberTranslationList */) {
       return { typeTranslation: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 141 /* TypeTranslation */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslation */) {
       return { typeTranslation: tokenOrKeyword.parent };
     }
-    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 130 /* IndexerTranslation */);
+    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 128 /* IndexerTranslation */);
     if (indexer !== void 0) {
       return { typeTranslation: indexer.parent.parent };
     }
     const constructor = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      128 /* ConstructorTranslation */
+      126 /* ConstructorTranslation */
     );
     if (constructor !== void 0) {
       return { typeTranslation: constructor.parent.parent };
     }
     const variableOrVariant = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      139 /* TypeVariableOrVariantTranslation */
+      137 /* FieldOrVariantTranslation */
     );
     if (variableOrVariant !== void 0) {
       return { typeTranslation: variableOrVariant.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      134 /* TypeMethodTranslation */
+      132 /* MethodTranslation */
     );
     if (method !== void 0) {
       return { typeTranslation: method.parent.parent };
@@ -5794,29 +5784,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 === 72 /* AutotypeCallExpression */) {
+    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
       return this.ofAutotypeCallExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 79 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 68 /* BinaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 52 /* TypeDereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 53 /* TypeDereferencedVariableSetterDeclaration */)) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* DereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* DereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 82 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
+    } else if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 47 /* TypeConstructorDeclaration */) {
-      return this.ofTypeConstructorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 92 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* ConstructorDeclaration */) {
+      return this.ofConstructorDeclaration(analyzer, tokenOrKeyword.parent);
+    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 90 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 88 /* ObjectExpression */) {
+    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 86 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 89 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 87 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 51 /* TypeIndexerParameterClause */) {
-      return this.ofTypeIndexerDeclaration(analyzer, tokenOrKeyword.parent.parent);
-    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 73 /* IndexedAccessExpression */) {
+    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* IndexParameterClause */) {
+      return this.ofIndexedElementAccessorDeclaration(analyzer, tokenOrKeyword.parent.parent);
+    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     }
     return void 0;
@@ -5829,11 +5819,11 @@ var NodeSemanticInfoService = class {
     let result;
     const parent = node.parent;
     switch (parent.kind) {
-      case 131 /* TranslationTypeParameterList */:
+      case 129 /* TranslationTypeParameterList */:
         break;
-      case 126 /* TranslationParameterList */:
+      case 124 /* TranslationParameterList */:
         break;
-      case 147 /* Argument */: {
+      case 145 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new SimpleWithLocalization(
@@ -5847,43 +5837,43 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 62 /* EnumerationVariableDeclaration */:
+      case 60 /* EnumerationVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofEnumerationVariableDeclaration(parent));
         break;
-      case 103 /* ErrorVariableDeclaration */:
+      case 101 /* ErrorVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofErrorVariableDeclaration(parent));
         break;
-      case 24 /* PackageAliasTypeDeclaration */:
+      case 22 /* PackageAliasTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageAliasTypeDeclaration(parent));
         break;
-      case 29 /* PackageMethodDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageMethodDeclaration(parent));
+      case 27 /* PackageFunctionDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionDeclaration(parent));
         break;
-      case 30 /* PackageMethodTypeDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageMethodTypeDeclaration(parent));
+      case 28 /* PackageFunctionTypeDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionTypeDeclaration(parent));
         break;
-      case 35 /* PackageStructuredTypeDeclaration */:
+      case 33 /* PackageStructuredTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageStructuredTypeDeclaration(parent));
         break;
-      case 37 /* PackageVariableDeclaration */:
+      case 35 /* PackageVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariableDeclaration(parent));
         break;
-      case 40 /* PackageVariantTypeDeclaration */:
+      case 38 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 90 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
-      case 60 /* NestedMethodDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedMethodDeclaration(parent));
+      case 58 /* NestedFunctionDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedFunctionDeclaration(parent));
         break;
-      case 61 /* LocalVariableDeclaration */:
+      case 59 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
         break;
-      case 137 /* QualifiedName */:
+      case 135 /* QualifiedName */:
         result = this.ofQualifiedNameQualifier(analyzer, parent, node, options6);
         break;
-      case 138 /* PackageVariableTranslation */: {
+      case 136 /* PackageVariableTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getPackageVariableTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5903,9 +5893,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 139 /* TypeVariableOrVariantTranslation */: {
+      case 137 /* FieldOrVariantTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetsResult = translationPackage?.getTypeVariableOrVariantTranslationTargets(parent);
+        const getTargetsResult = translationPackage?.getFieldOrVariantTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
           if (node === parent.sourceName) {
             const targets = getTargetsResult.targets.map((t) => new SimpleWithLocalization(
@@ -5927,9 +5917,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 133 /* PackageMethodTranslation */: {
+      case 131 /* PackageFunctionTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetsResult = translationPackage?.getPackageMethodTranslationTargets(parent);
+        const getTargetsResult = translationPackage?.getPackageFunctionTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
           if (node === parent.sourceName) {
             const targets = getTargetsResult.targets.map((t) => new SimpleWithLocalization(
@@ -5951,9 +5941,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 134 /* TypeMethodTranslation */: {
+      case 132 /* MethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetsResult = translationPackage?.getTypeMethodTranslationTargets(parent);
+        const getTargetsResult = translationPackage?.getMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
           if (node === parent.sourceName) {
             const targets = getTargetsResult.targets.map((t) => new SimpleWithLocalization(
@@ -5975,7 +5965,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 141 /* TypeTranslation */: {
+      case 139 /* TypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5995,9 +5985,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 135 /* MethodTypeTranslation */: {
+      case 133 /* FunctionTypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
-        const getTargetResult = translationPackage?.getMethodTypeTranslationTarget(parent);
+        const getTargetResult = translationPackage?.getFunctionTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
           if (node === parent.sourceName) {
             const target = new SimpleWithLocalization(
@@ -6015,40 +6005,40 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 146 /* ParameterDeclaration */:
+      case 144 /* ParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofParameterDeclaration(parent));
         break;
       case 8 /* PackageImport */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageImport(parent));
         break;
-      case 9 /* PackagePath */:
+      case 9 /* PackageName */:
         result = void 0;
         break;
-      case 80 /* PropertyAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         result = this.ofProperty(analyzer, parent, options6);
         break;
-      case 54 /* TypeMethodDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeMethodDeclaration(parent));
+      case 52 /* MethodDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofMethodDeclaration(parent));
         break;
-      case 55 /* OperatorDeclaration */:
+      case 53 /* OperatorDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofOperatorDeclaration(parent));
         break;
-      case 56 /* TypeVariableDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeVariableDeclaration(parent));
+      case 54 /* FieldDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofFieldDeclaration(parent));
         break;
-      case 145 /* TypeParameterDeclaration */:
+      case 143 /* TypeParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeParameterDeclaration(parent));
         break;
-      case 144 /* VariantDeclaration */:
+      case 142 /* VariantDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofVariantDeclaration(parent));
         break;
-      case 38 /* PackageVariableGetterDeclaration */:
-      case 39 /* PackageVariableSetterDeclaration */:
+      case 36 /* PackageVariableGetterDeclaration */:
+      case 37 /* PackageVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedPackageVariableDeclaration(parent));
         break;
-      case 57 /* TypeVariableGetterDeclaration */:
-      case 58 /* TypeVariableSetterDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedTypeVariableDeclaration(parent));
+      case 55 /* FieldGetterDeclaration */:
+      case 56 /* FieldSetterDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedFieldDeclaration(parent));
         break;
       case 3 /* Keyword */:
         break;
@@ -6060,14 +6050,14 @@ var NodeSemanticInfoService = class {
   }
   static ofProperty(analyzer, node, options6) {
     let result;
-    const meaning = analyzer.resolvePropertyAccessExpression(node).meaning;
+    const meaning = analyzer.resolveMemberAccessExpression(node).meaning;
     switch (meaning.kind) {
       case "instance-variable-access": {
         let narrowedType;
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new SimpleWithLocalization(new TypeVariableReferenceTarget(
+        const target = new SimpleWithLocalization(new FieldReferenceTarget(
           meaning.variable.value,
           meaning.accessKind,
           narrowedType
@@ -6080,7 +6070,7 @@ var NodeSemanticInfoService = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new SimpleWithLocalization(new TypeVariableReferenceTarget(
+        const target = new SimpleWithLocalization(new FieldReferenceTarget(
           meaning.variable.value,
           meaning.accessKind,
           narrowedType
@@ -6102,17 +6092,17 @@ var NodeSemanticInfoService = class {
         break;
       }
       case "instance-method-access":
-        if (isNonEmptyArray(meaning.suitableMethods)) {
-          result = createAccessedMethodsReference(meaning.suitableMethods, meaning.suitableMethods.length > 1);
+        if (isNonEmptyArray(meaning.suitableFunctions)) {
+          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedMethodsReference(meaning.candidates, true);
+          result = createAccessedFunctionsReference(meaning.candidates, true);
         }
         break;
       case "static-method-access":
-        if (isNonEmptyArray(meaning.suitableMethods)) {
-          result = createAccessedMethodsReference(meaning.suitableMethods, meaning.suitableMethods.length > 1);
+        if (isNonEmptyArray(meaning.suitableFunctions)) {
+          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedMethodsReference(meaning.candidates, true);
+          result = createAccessedFunctionsReference(meaning.candidates, true);
         }
         break;
       case "operator-access": {
@@ -6123,11 +6113,11 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case "package-method-access":
-        if (isNonEmptyArray(meaning.suitableMethods)) {
-          result = createAccessedMethodsReference(meaning.suitableMethods, meaning.suitableMethods.length > 1);
+      case "package-function-access":
+        if (isNonEmptyArray(meaning.suitableFunctions)) {
+          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedMethodsReference(meaning.candidates, true);
+          result = createAccessedFunctionsReference(meaning.candidates, true);
         }
         break;
       case "package-type-access":
@@ -6162,8 +6152,8 @@ var NodeSemanticInfoService = class {
       result = this.getBetterReferenceTargetsOrPreserve(result);
     }
     return result;
-    function createAccessedMethodsReference(methods, isAmbiguous) {
-      const targets = methods.map((o) => new SimpleWithLocalization(new AccessedMethodReferenceTarget(o.value), o.localization));
+    function createAccessedFunctionsReference(functions, isAmbiguous) {
+      const targets = functions.map((o) => new SimpleWithLocalization(new AccessedFunctionReferenceTarget(o.value), o.localization));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
     function createOperatorsReference(operators, isAmbiguous) {
@@ -6175,10 +6165,10 @@ var NodeSemanticInfoService = class {
     switch (node.parent.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.ofNamedTypeSpecifierNameQualifier(analyzer, node.parent, qualifier, options6);
-      case 149 /* Tag */:
+      case 147 /* Tag */:
         return this.ofTagNameQualifier(analyzer, node.parent, qualifier, options6);
-      case 44 /* ExtendedTypeClause */:
-      case 136 /* PackageImportTranslation */:
+      case 42 /* ExtendedTypeClause */:
+      case 134 /* PackageImportTranslation */:
         return void 0;
       default:
         Debug.never(node.parent);
@@ -6260,18 +6250,18 @@ var NodeSemanticInfoService = class {
             }
           } else {
             if (resolutionResult.meaning.suitableConstructors.length > 0) {
-              const targets = resolutionResult.meaning.suitableConstructors.map((t) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(t.value), t.localization));
+              const targets = resolutionResult.meaning.suitableConstructors.map((t) => new SimpleWithLocalization(new ConstructorReferenceTarget(t.value), t.localization));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
             } else if (resolutionResult.meaning.candidates.length > 0) {
-              const targets = resolutionResult.meaning.candidates.map((t) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(t.value), t.localization));
+              const targets = resolutionResult.meaning.candidates.map((t) => new SimpleWithLocalization(new ConstructorReferenceTarget(t.value), t.localization));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
             }
           }
           break;
         }
-        case "method":
-          if (resolvedQualifier.suitableMethods.length > 0) {
-            const targets = resolvedQualifier.suitableMethods.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+        case "function":
+          if (resolvedQualifier.suitableFunctions.length > 0) {
+            const targets = resolvedQualifier.suitableFunctions.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
             result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
           } else if (resolvedQualifier.candidates.length > 0) {
             const targets = resolvedQualifier.candidates.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
@@ -6338,11 +6328,11 @@ var NodeSemanticInfoService = class {
           result = this.ofMaybeConstructorCallExpression(analyzer, meaning.suitableTypes, node, options6);
         }
         break;
-      case "method-access":
-        if (isNonEmptyArray(meaning.suitableMethods)) {
-          result = createAccessedMethodsReference(meaning.suitableMethods, meaning.suitableMethods.length > 1);
+      case "function-access":
+        if (isNonEmptyArray(meaning.suitableFunctions)) {
+          result = createAccessedFunctionsReference(meaning.suitableFunctions, meaning.suitableFunctions.length > 1);
         } else if (isNonEmptyArray(meaning.candidates)) {
-          result = createAccessedMethodsReference(meaning.candidates, true);
+          result = createAccessedFunctionsReference(meaning.candidates, true);
         }
         break;
       case "operator-access": {
@@ -6367,7 +6357,7 @@ var NodeSemanticInfoService = class {
           result = new ReferenceNodeSemanticInfo([target], false);
         } else if (variable.value.kind === "type-member") {
           const target = new SimpleWithLocalization(
-            new TypeVariableReferenceTarget(variable.value.value, meaning.accessKind, narrowedType),
+            new FieldReferenceTarget(variable.value.value, meaning.accessKind, narrowedType),
             variable.localization
           );
           result = new ReferenceNodeSemanticInfo([target], false);
@@ -6392,7 +6382,7 @@ var NodeSemanticInfoService = class {
         const targets = meaning.declarations.map((d) => {
           let target;
           switch (d.value.kind) {
-            case "method":
+            case "function":
               target = new EntityReferenceTarget(d.value.value.getEntity(), 0 /* Get */);
               break;
             case "variable":
@@ -6426,8 +6416,8 @@ var NodeSemanticInfoService = class {
       result = this.getBetterReferenceTargetsOrPreserve(result);
     }
     return result;
-    function createAccessedMethodsReference(methods, isAmbiguous) {
-      const targets = methods.map((o) => new SimpleWithLocalization(new AccessedMethodReferenceTarget(o.value), o.localization));
+    function createAccessedFunctionsReference(functions, isAmbiguous) {
+      const targets = functions.map((o) => new SimpleWithLocalization(new AccessedFunctionReferenceTarget(o.value), o.localization));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
     function createOperatorsReference(operators, isAmbiguous) {
@@ -6435,12 +6425,12 @@ var NodeSemanticInfoService = class {
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
   }
-  static ofTypeConstructorDeclaration(analyzer, node) {
-    const entity = analyzer.entity.ofTypeConstructorDeclaration(node);
+  static ofConstructorDeclaration(analyzer, node) {
+    const entity = analyzer.entity.ofConstructorDeclaration(node);
     return new DefinitionNodeSemanticInfo(entity);
   }
-  static ofTypeIndexerDeclaration(analyzer, node) {
-    const entity = analyzer.entity.ofTypeIndexerDeclaration(node);
+  static ofIndexedElementAccessorDeclaration(analyzer, node) {
+    const entity = analyzer.entity.ofIndexerDeclaration(node);
     return new DefinitionNodeSemanticInfo(entity);
   }
   static ofIndexedAccessExpressionOperator(analyzer, node, options6) {
@@ -6463,7 +6453,7 @@ var NodeSemanticInfoService = class {
     }
     return void 0;
     function createIndexersReference(indexers, accessKind, isAmbiguous) {
-      const targets = indexers.map((i) => new SimpleWithLocalization(new TypeIndexerReferenceTarget(i.value, accessKind), i.localization));
+      const targets = indexers.map((i) => new SimpleWithLocalization(new IndexerReferenceTarget(i.value, accessKind), i.localization));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
   }
@@ -6519,14 +6509,14 @@ var NodeSemanticInfoService = class {
     return void 0;
   }
   static ofDereferenceOperatorDeclaration(analyzer, node) {
-    const entity = analyzer.entity.ofTypeDereferenceOperatorDeclaration(node);
+    const entity = analyzer.entity.ofDereferenceOperatorDeclaration(node);
     return new DefinitionNodeSemanticInfo(entity);
   }
   static ofDereferenceExpressionOperator(analyzer, node, options6) {
     const meaning = analyzer.getDereferenceExpressionMeaning(node);
     if (meaning.kind === "resolved") {
       const target = new SimpleWithLocalization(
-        new TypeDereferenceOperatorReferenceTarget(meaning.operator.value, meaning.accessKind),
+        new DereferenceOperatorReferenceTarget(meaning.operator.value, meaning.accessKind),
         meaning.operator.localization
       );
       let result = new ReferenceNodeSemanticInfo([target], false);
@@ -6542,10 +6532,10 @@ var NodeSemanticInfoService = class {
     let result;
     if (meaning.kind === "constructor-call") {
       if (meaning.suitableConstructors.length > 0) {
-        const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+        const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
         result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
       } else if (meaning.candidates.length > 0) {
-        const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+        const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
         result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
       }
     }
@@ -6560,10 +6550,10 @@ var NodeSemanticInfoService = class {
     switch (meaning.kind) {
       case "own-constructor-access": {
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         }
         break;
@@ -6594,10 +6584,10 @@ var NodeSemanticInfoService = class {
     switch (meaning.kind) {
       case "base-constructor-access": {
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         }
         break;
@@ -6614,7 +6604,7 @@ var NodeSemanticInfoService = class {
       case "overridden-method-access": {
         const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
         const target = new SimpleWithLocalization(
-          new AccessedMethodReferenceTarget(new AccessedMethod_typeMember(meaning.method)),
+          new AccessedFunctionReferenceTarget(new AccessedFunction_typeMember(meaning.method)),
           new Localization.Original(locale)
         );
         result = new ReferenceNodeSemanticInfo([target], false);
@@ -6641,8 +6631,8 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 80 /* PropertyAccessExpression */) {
-      const meaning = analyzer.resolvePropertyAccessExpression(parent).meaning;
+    while (parent.kind === 78 /* MemberAccessExpression */) {
+      const meaning = analyzer.resolveMemberAccessExpression(parent).meaning;
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
         parent = getParentSkippingParenthesizedExpressions(parent);
@@ -6680,11 +6670,11 @@ var NodeSemanticInfoService = class {
     }
     const parent = getParentSkippingParenthesizedExpressions(typeAccessExpression);
     let parentCallExpression;
-    if (parent.kind === 71 /* CallExpression */) {
+    if (parent.kind === 69 /* CallExpression */) {
       parentCallExpression = parent;
-    } else if (parent.kind === 91 /* GenericSpecializationExpression */) {
+    } else if (parent.kind === 89 /* GenericSpecializationExpression */) {
       const grandParent = getParentSkippingParenthesizedExpressions(parent);
-      if (grandParent.kind === 71 /* CallExpression */) {
+      if (grandParent.kind === 69 /* CallExpression */) {
         parentCallExpression = grandParent;
       }
     }
@@ -6692,10 +6682,10 @@ var NodeSemanticInfoService = class {
       const meaning = analyzer.getCallExpressionMeaning(parentCallExpression);
       if (meaning.kind === "constructor-call") {
         if (meaning.suitableConstructors.length > 0) {
-          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
           return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), meaning.suitableConstructors.length > 1);
         } else if (meaning.candidates.length > 0) {
-          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
+          const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new ConstructorReferenceTarget(c.value), c.localization));
           return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         }
       }
@@ -6724,7 +6714,7 @@ var NodeSemanticInfoService = class {
         {
           if (currentTarget.value.entity.subkind === "parameter") {
             const specialVariableInfo = currentTarget.value.entity.isSpecial();
-            if (specialVariableInfo?.kind === "implicit-method-block-parameter") {
+            if (specialVariableInfo?.kind === "implicit-function-block-parameter") {
               betterTarget = new SimpleWithLocalization(
                 new TypeValueParameterReferenceTarget(
                   specialVariableInfo.targetTypeParameter,
@@ -6746,7 +6736,7 @@ var NodeSemanticInfoService = class {
             );
           }
         }
-      } else if (currentTarget.value.kind === "entity" && currentTarget.value.entity.kind === 1 /* Method */) {
+      } else if (currentTarget.value.kind === "entity" && currentTarget.value.entity.kind === 1 /* Function */) {
       }
       if (betterTarget !== void 0) {
         result = betterTarget;
@@ -6791,7 +6781,7 @@ var EntityReferenceTarget = class {
     this.kind = "entity";
   }
 };
-var TypeVariableReferenceTarget = class {
+var FieldReferenceTarget = class {
   constructor(variable, accessKind, narrowedType) {
     this.variable = variable;
     this.accessKind = accessKind;
@@ -6806,23 +6796,23 @@ var TypeValueParameterReferenceTarget = class {
     this.kind = "type-value-parameter";
   }
 };
-var TypeConstructorReferenceTarget = class {
+var ConstructorReferenceTarget = class {
   constructor(constructor_) {
     this.constructor_ = constructor_;
     this.kind = "type-constructor";
   }
 };
-var TypeDereferenceOperatorReferenceTarget = class {
+var DereferenceOperatorReferenceTarget = class {
   constructor(operator, accessKind) {
     this.operator = operator;
     this.accessKind = accessKind;
     this.kind = "type-dereference-operator";
   }
 };
-var AccessedMethodReferenceTarget = class {
-  constructor(method) {
-    this.method = method;
-    this.kind = "accessed-method";
+var AccessedFunctionReferenceTarget = class {
+  constructor(func) {
+    this.func = func;
+    this.kind = "accessed-function";
   }
 };
 var OperatorReferenceTarget = class {
@@ -6857,7 +6847,7 @@ var TypeContextReferenceTarget = class {
     this.kind = "type-context";
   }
 };
-var TypeIndexerReferenceTarget = class {
+var IndexerReferenceTarget = class {
   constructor(indexer, accessKind) {
     this.indexer = indexer;
     this.accessKind = accessKind;
@@ -6935,59 +6925,59 @@ function getEntitySourceLocations(analyzer, entity) {
       const node = definition.node;
       let range;
       switch (node.kind) {
-        case 19 /* AnonymousMethodTypeDeclaration */:
-        case 20 /* AnonymousStructuredTypeDeclaration */:
-        case 21 /* AnonymousVariantTypeDeclaration */:
-        case 69 /* MethodBlockLiteral */:
-        case 76 /* MethodLiteral */:
+        case 17 /* AnonymousFunctionTypeDeclaration */:
+        case 18 /* AnonymousStructuredTypeDeclaration */:
+        case 19 /* AnonymousVariantTypeDeclaration */:
+        case 67 /* FunctionBlockLiteral */:
+        case 74 /* FunctionLiteral */:
           range = node.rangeWithoutTrivia;
           break;
-        case 24 /* PackageAliasTypeDeclaration */:
-        case 29 /* PackageMethodDeclaration */:
-        case 30 /* PackageMethodTypeDeclaration */:
-        case 35 /* PackageStructuredTypeDeclaration */:
-        case 40 /* PackageVariantTypeDeclaration */:
-        case 60 /* NestedMethodDeclaration */:
-        case 54 /* TypeMethodDeclaration */:
-        case 145 /* TypeParameterDeclaration */:
-        case 55 /* OperatorDeclaration */:
+        case 22 /* PackageAliasTypeDeclaration */:
+        case 27 /* PackageFunctionDeclaration */:
+        case 28 /* PackageFunctionTypeDeclaration */:
+        case 33 /* PackageStructuredTypeDeclaration */:
+        case 38 /* PackageVariantTypeDeclaration */:
+        case 58 /* NestedFunctionDeclaration */:
+        case 52 /* MethodDeclaration */:
+        case 143 /* TypeParameterDeclaration */:
+        case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
-        case 47 /* TypeConstructorDeclaration */:
+        case 45 /* ConstructorDeclaration */:
           range = node.creationKeyword.rangeWithoutTrivia;
           break;
-        case 48 /* TypeDestructorDeclaration */:
+        case 46 /* DestructorDeclaration */:
           range = node.destructionKeyword.rangeWithoutTrivia;
           break;
         case 8 /* PackageImport */:
           Debug.assertNotNull(node.alias);
           range = node.alias.rangeWithoutTrivia;
           break;
-        case 42 /* TypeExtensionDeclaration */:
+        case 40 /* TypeExtensionDeclaration */:
           range = node.plusEqualsToken.rangeWithoutTrivia;
           break;
-        case 38 /* PackageVariableGetterDeclaration */:
+        case 36 /* PackageVariableGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 39 /* PackageVariableSetterDeclaration */:
+        case 37 /* PackageVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 57 /* TypeVariableGetterDeclaration */:
+        case 55 /* FieldGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 58 /* TypeVariableSetterDeclaration */:
+        case 56 /* FieldSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 49 /* TypeIndexedGetterDeclaration */:
+        case 47 /* IndexedElementGetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 50 /* TypeIndexedSetterDeclaration */:
+        case 48 /* IndexedElementSetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 52 /* TypeDereferencedVariableGetterDeclaration */:
+        case 50 /* DereferencedVariableGetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
-        case 53 /* TypeDereferencedVariableSetterDeclaration */:
+        case 51 /* DereferencedVariableSetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
         default:
@@ -7099,8 +7089,8 @@ var DefinitionService = class {
         return getEntitySourceLocations(analyzer, target.variable.getEntity());
       case "type-constructor":
         return getEntitySourceLocations(analyzer, target.constructor_.getEntity());
-      case "accessed-method":
-        return getEntitySourceLocations(analyzer, target.method.getEntity());
+      case "accessed-function":
+        return getEntitySourceLocations(analyzer, target.func.getEntity());
       case "operator":
         return getEntitySourceLocations(analyzer, target.operator.getEntity());
       case "type-dereference-operator":
@@ -7143,8 +7133,8 @@ var DefinitionService = class {
         return target.operator.getEntity();
       case "type-dereference-operator":
         return target.operator.getEntity();
-      case "accessed-method":
-        return target.method.getEntity();
+      case "accessed-function":
+        return target.func.getEntity();
       case "match-result-value-parameter":
         return target.parameter.entity;
       case "package":
@@ -7232,7 +7222,7 @@ var ReferencesService = class {
               }
             }
             if (!options6.onlyNamed) {
-              if (node.kind === 72 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
+              if (node.kind === 70 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
                 const semanticInfo = NodeSemanticInfoService.ofAutotypeCallExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7244,7 +7234,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 79 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 77 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -7260,7 +7250,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 68 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
+              if (node.kind === 66 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofBinaryExpressionOperator(
                   analyzer,
                   node,
@@ -7276,7 +7266,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 52 /* TypeDereferencedVariableGetterDeclaration */ || node.kind === 53 /* TypeDereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
+              if ((node.kind === 50 /* DereferencedVariableGetterDeclaration */ || node.kind === 51 /* DereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceOperatorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7288,7 +7278,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 82 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 80 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -7304,7 +7294,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 93 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 91 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -7320,8 +7310,8 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 47 /* TypeConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
-                const semanticInfo = NodeSemanticInfoService.ofTypeConstructorDeclaration(analyzer, node);
+              if (node.kind === 45 /* ConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
+                const semanticInfo = NodeSemanticInfoService.ofConstructorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
                   semanticInfo,
@@ -7332,7 +7322,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 88 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 86 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7344,7 +7334,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 89 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 87 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7356,8 +7346,8 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 49 /* TypeIndexedGetterDeclaration */ || node.kind === 50 /* TypeIndexedSetterDeclaration */) && restrictions.canBeIndexer) {
-                const semanticInfo = NodeSemanticInfoService.ofTypeIndexerDeclaration(analyzer, node);
+              if ((node.kind === 47 /* IndexedElementGetterDeclaration */ || node.kind === 48 /* IndexedElementSetterDeclaration */) && restrictions.canBeIndexer) {
+                const semanticInfo = NodeSemanticInfoService.ofIndexedElementAccessorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
                   semanticInfo,
@@ -7368,7 +7358,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 73 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
+              if (node.kind === 71 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedAccessExpressionOperator(
                   analyzer,
                   node,
@@ -7495,8 +7485,8 @@ var ReferencesService = class {
             target.localization,
             accessKindToReferenceKind(target.value.accessKind)
           );
-        case "accessed-method":
-          return new DefinitionInfo(target.value.method.getEntity(), target.localization, 0 /* Read */);
+        case "accessed-function":
+          return new DefinitionInfo(target.value.func.getEntity(), target.localization, 0 /* Read */);
         case "match-result-value-parameter":
           return new DefinitionInfo(target.value.parameter.entity, target.localization, 0 /* Read */);
         case "package":
@@ -7558,7 +7548,7 @@ var ReferencesService = class {
       result.canBeObjectExpression = true;
       result.canBeBaseExpression = true;
     }
-    if (definition.value.kind === 1 /* Method */) {
+    if (definition.value.kind === 1 /* Function */) {
       result.canBeBaseExpression = true;
     }
     if (definition.value.kind === 5 /* Indexer */) {
@@ -7597,7 +7587,7 @@ var ReferencesService = class {
         return { name: entity.getName() };
       case 2 /* Type */: {
         switch (entity.typeEntityKind) {
-          case 0 /* Method */: {
+          case 0 /* Function */: {
             const naming = entity.getNaming();
             if (naming.kind === "named") {
               return { name: naming.value };
@@ -7626,7 +7616,7 @@ var ReferencesService = class {
             Debug.never(entity);
         }
       }
-      case 1 /* Method */:
+      case 1 /* Function */:
         return { name: entity.getName() };
       case 10 /* PackageAlias */:
         return { name: entity.getName() };
@@ -7750,9 +7740,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 90 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         return parent;
-      case 80 /* PropertyAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7773,9 +7763,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 90 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         return true;
-      case 80 /* PropertyAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7783,35 +7773,35 @@ var EvaluatableExpressionService = class {
   }
   isNamedDeclaration(node) {
     switch (node.kind) {
-      case 62 /* EnumerationVariableDeclaration */:
+      case 60 /* EnumerationVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 24 /* PackageAliasTypeDeclaration */:
+      case 22 /* PackageAliasTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 29 /* PackageMethodDeclaration */:
+      case 27 /* PackageFunctionDeclaration */:
         return { nameIdentifier: node.name };
-      case 30 /* PackageMethodTypeDeclaration */:
+      case 28 /* PackageFunctionTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 35 /* PackageStructuredTypeDeclaration */:
+      case 33 /* PackageStructuredTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 37 /* PackageVariableDeclaration */:
+      case 35 /* PackageVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 40 /* PackageVariantTypeDeclaration */:
+      case 38 /* PackageVariantTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 60 /* NestedMethodDeclaration */:
+      case 58 /* NestedFunctionDeclaration */:
         return { nameIdentifier: node.name };
-      case 61 /* LocalVariableDeclaration */:
+      case 59 /* LocalVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 146 /* ParameterDeclaration */:
+      case 144 /* ParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 54 /* TypeMethodDeclaration */:
+      case 52 /* MethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 56 /* TypeVariableDeclaration */:
+      case 54 /* FieldDeclaration */:
         return { nameIdentifier: node.name };
-      case 145 /* TypeParameterDeclaration */:
+      case 143 /* TypeParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 144 /* VariantDeclaration */:
+      case 142 /* VariantDeclaration */:
         return { nameIdentifier: node.name };
-      case 103 /* ErrorVariableDeclaration */:
+      case 101 /* ErrorVariableDeclaration */:
         return { nameIdentifier: node.name };
       default:
         return void 0;
@@ -7965,8 +7955,8 @@ var HoverService = class {
         const operator = new DereferenceOperatorDeclaration_typeMember(firstTarget.value.operator);
         return new Hover(this._displayService.displayDereferenceOperatorDeclaration(operator), range);
       }
-      case "accessed-method":
-        return this.createHoverAtAccessedMethod(firstTarget.value.method, firstTarget.localization, range);
+      case "accessed-function":
+        return this.createHoverAtAccessedFunction(firstTarget.value.func, firstTarget.localization, range);
       case "match-result-value-parameter": {
         const declaration = new ValueParameterDeclaration_matchResultValueParameter(
           firstTarget.value.parameter,
@@ -8009,22 +7999,22 @@ var HoverService = class {
         Debug.never(firstTarget.value);
     }
   }
-  createHoverAtAccessedMethod(method, localization, range) {
-    switch (method.kind) {
+  createHoverAtAccessedFunction(func, localization, range) {
+    switch (func.kind) {
       case "entity": {
-        const declaration = new MethodDeclaration_entity(method.value, localization);
-        return new Hover(this._displayService.displayMethodDeclaration(declaration), range);
+        const declaration = new FunctionDeclaration_entity(func.value, localization);
+        return new Hover(this._displayService.displayFunctionDeclaration(declaration), range);
       }
       case "type-member": {
-        const declaration = new MethodDeclaration_typeMember(method.value, localization);
-        return new Hover(this._displayService.displayMethodDeclaration(declaration), range);
+        const declaration = new FunctionDeclaration_typeMember(func.value, localization);
+        return new Hover(this._displayService.displayFunctionDeclaration(declaration), range);
       }
-      case "substituted-method": {
-        const declaration = new MethodDeclaration_substitutedMethod(method.value, localization);
-        return new Hover(this._displayService.displayMethodDeclaration(declaration), range);
+      case "substituted-function": {
+        const declaration = new FunctionDeclaration_substitutedFunction(func.value, localization);
+        return new Hover(this._displayService.displayFunctionDeclaration(declaration), range);
       }
       default:
-        Debug.never(method);
+        Debug.never(func);
     }
   }
 };
@@ -8070,7 +8060,7 @@ var SourceFileItemsService = class {
           }
           break;
         }
-        case 37 /* PackageVariableDeclaration */: {
+        case 35 /* PackageVariableDeclaration */: {
           result.push(
             this.createItem(
               1 /* PackageVariable */,
@@ -8082,7 +8072,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 38 /* PackageVariableGetterDeclaration */: {
+        case 36 /* PackageVariableGetterDeclaration */: {
           result.push(
             this.createItem(
               2 /* PackageVariableGetter */,
@@ -8094,7 +8084,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 39 /* PackageVariableSetterDeclaration */: {
+        case 37 /* PackageVariableSetterDeclaration */: {
           result.push(
             this.createItem(
               3 /* PackageVariableSetter */,
@@ -8106,10 +8096,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 29 /* PackageMethodDeclaration */: {
+        case 27 /* PackageFunctionDeclaration */: {
           result.push(
             this.createItem(
-              4 /* PackageMethod */,
+              4 /* PackageFunction */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8118,7 +8108,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 35 /* PackageStructuredTypeDeclaration */: {
+        case 33 /* PackageStructuredTypeDeclaration */: {
           result.push(
             this.createItem(
               5 /* StructuredType */,
@@ -8130,10 +8120,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 56 /* TypeVariableDeclaration */: {
+        case 54 /* FieldDeclaration */: {
           result.push(
             this.createItem(
-              12 /* TypeVariable */,
+              12 /* Field */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8142,10 +8132,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 57 /* TypeVariableGetterDeclaration */: {
+        case 55 /* FieldGetterDeclaration */: {
           result.push(
             this.createItem(
-              13 /* TypeVariableGetter */,
+              13 /* FieldGetter */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8154,10 +8144,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 58 /* TypeVariableSetterDeclaration */: {
+        case 56 /* FieldSetterDeclaration */: {
           result.push(
             this.createItem(
-              14 /* TypeVariableSetter */,
+              14 /* FieldSetter */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8166,10 +8156,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 54 /* TypeMethodDeclaration */: {
+        case 52 /* MethodDeclaration */: {
           result.push(
             this.createItem(
-              15 /* TypeMethod */,
+              15 /* Method */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8178,10 +8168,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 47 /* TypeConstructorDeclaration */: {
+        case 45 /* ConstructorDeclaration */: {
           result.push(
             this.createItem(
-              10 /* TypeConstructor */,
+              10 /* Constructor */,
               void 0,
               node2.rangeWithoutTrivia,
               node2.rangeWithoutTrivia,
@@ -8190,9 +8180,9 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 48 /* TypeDestructorDeclaration */: {
+        case 46 /* DestructorDeclaration */: {
           result.push(this.createItem(
-            11 /* TypeDestructor */,
+            11 /* Destructor */,
             void 0,
             node2.rangeWithoutTrivia,
             node2.rangeWithoutTrivia,
@@ -8200,10 +8190,10 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 49 /* TypeIndexedGetterDeclaration */: {
+        case 47 /* IndexedElementGetterDeclaration */: {
           result.push(
             this.createItem(
-              16 /* TypeIndexedGetter */,
+              16 /* IndexedElementGetter */,
               void 0,
               node2.rangeWithoutTrivia,
               node2.rangeWithoutTrivia,
@@ -8212,10 +8202,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 50 /* TypeIndexedSetterDeclaration */: {
+        case 48 /* IndexedElementSetterDeclaration */: {
           result.push(
             this.createItem(
-              17 /* TypeIndexedSetter */,
+              17 /* IndexedElementSetter */,
               void 0,
               node2.rangeWithoutTrivia,
               node2.rangeWithoutTrivia,
@@ -8224,10 +8214,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 30 /* PackageMethodTypeDeclaration */: {
+        case 28 /* PackageFunctionTypeDeclaration */: {
           result.push(
             this.createItem(
-              6 /* MethodType */,
+              6 /* FunctionType */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8236,7 +8226,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 40 /* PackageVariantTypeDeclaration */: {
+        case 38 /* PackageVariantTypeDeclaration */: {
           result.push(
             this.createItem(
               7 /* VariantType */,
@@ -8248,7 +8238,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 144 /* VariantDeclaration */: {
+        case 142 /* VariantDeclaration */: {
           result.push(
             this.createItem(
               9 /* Variant */,
@@ -8260,7 +8250,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 145 /* TypeParameterDeclaration */: {
+        case 143 /* TypeParameterDeclaration */: {
           result.push(
             this.createItem(
               18 /* TypeParameter */,
@@ -8272,10 +8262,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 60 /* NestedMethodDeclaration */: {
+        case 58 /* NestedFunctionDeclaration */: {
           result.push(
             this.createItem(
-              19 /* NestedMethod */,
+              19 /* NestedFunction */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8304,34 +8294,34 @@ var SourceFileItemsService = class {
       case 0 /* PackageAlias */:
         return name ?? `<${LocalizationHelper.localizeHelperPhrase(4 /* PackageAlias */, this.locale)}>`;
       case 1 /* PackageVariable */:
-      case 12 /* TypeVariable */:
+      case 12 /* Field */:
         return name ?? `<${LocalizationHelper.localizeHelperPhrase(6 /* Variable */, this.locale)}>`;
-      case 4 /* PackageMethod */:
-      case 15 /* TypeMethod */:
-      case 19 /* NestedMethod */:
+      case 4 /* PackageFunction */:
+      case 15 /* Method */:
+      case 19 /* NestedFunction */:
         return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(12 /* Function */, this.locale, this.dialect)}>`;
       case 5 /* StructuredType */:
-      case 6 /* MethodType */:
+      case 6 /* FunctionType */:
       case 7 /* VariantType */:
       case 8 /* InvalidType */:
         return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(16 /* Type */, this.locale, this.dialect)}>`;
-      case 10 /* TypeConstructor */:
+      case 10 /* Constructor */:
         return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(30 /* Creation */, this.locale, this.dialect);
-      case 11 /* TypeDestructor */:
+      case 11 /* Destructor */:
         return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(47 /* Destruction */, this.locale, this.dialect);
       case 9 /* Variant */:
         return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(6 /* Variant */, this.locale, this.dialect)}>`;
       case 18 /* TypeParameter */:
         return name ?? `<${LocalizationHelper.localizeHelperPhrase(2 /* TypeParameter */, this.locale)}>`;
       case 2 /* PackageVariableGetter */:
-      case 13 /* TypeVariableGetter */:
+      case 13 /* FieldGetter */:
         return `${LocalizationHelper.localizeKeywordAndTakeFirst(58 /* Get */, this.locale, this.dialect)} ${name ?? ""}`;
       case 3 /* PackageVariableSetter */:
-      case 14 /* TypeVariableSetter */:
+      case 14 /* FieldSetter */:
         return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Set */, this.locale, this.dialect)} ${name ?? ""}`;
-      case 16 /* TypeIndexedGetter */:
+      case 16 /* IndexedElementGetter */:
         return `${LocalizationHelper.localizeKeywordAndTakeFirst(58 /* Get */, this.locale, this.dialect)} []`;
-      case 17 /* TypeIndexedSetter */:
+      case 17 /* IndexedElementSetter */:
         return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Set */, this.locale, this.dialect)} []`;
       default:
         Debug.never(kind);
@@ -8433,8 +8423,8 @@ var RenameService = class {
           case "type-value-parameter":
             canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.parameter.getEntity());
             break;
-          case "accessed-method":
-            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.method.getEntity());
+          case "accessed-function":
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.func.getEntity());
             break;
           case "match-result-value-parameter":
             canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.parameter.entity);
@@ -8497,7 +8487,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 === 83 /* TextTemplateLiteral */) {
+      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 81 /* TextTemplateLiteral */) {
         const textContentStart = child.rangeWithoutTrivia.start + 1;
         const textContentEnd = child.rangeWithoutTrivia.end - 1;
         if (offset >= textContentStart && offset < textContentEnd) {
@@ -8528,13 +8518,13 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 158 /* TypeAnnotation */:
-      case 36 /* StructuredTypeDeclarationBody */:
-      case 41 /* VariantTypeDeclarationBody */:
-      case 25 /* AliasTypeDeclarationBody */:
-      case 31 /* MethodTypeDeclarationBody */:
-      case 85 /* TextTemplateSpan */:
-      case 84 /* TextTemplateSpanList */:
+      case 156 /* TypeAnnotation */:
+      case 34 /* StructuredTypeDeclarationBody */:
+      case 39 /* VariantTypeDeclarationBody */:
+      case 23 /* AliasTypeDeclarationBody */:
+      case 29 /* FunctionTypeDeclarationBody */:
+      case 83 /* TextTemplateSpan */:
+      case 82 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8572,11 +8562,11 @@ var SemanticTokensService = class {
             controller.stopChildrenTraverse();
             return;
           }
-          if (node.kind === 90 /* IdentifierExpression */) {
+          if (node.kind === 88 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.value.getEntity();
-              if (variable.subkind === "type" && variable.isVariant()) {
+              if (variable.subkind === "field" && variable.isVariant()) {
                 result.push(
                   new SemanticToken(
                     node.rangeWithoutTrivia,
@@ -8593,8 +8583,8 @@ var SemanticTokensService = class {
                     case "value":
                       semanticTokenKind = 1 /* SpecialVariable */;
                       break;
-                    case "implicit-method-block-parameter":
-                      semanticTokenKind = 0 /* MethodBlockLiteralParameter */;
+                    case "implicit-function-block-parameter":
+                      semanticTokenKind = 0 /* FunctionBlockLiteralParameter */;
                       break;
                     case "backing":
                       semanticTokenKind = void 0;
@@ -8610,13 +8600,13 @@ var SemanticTokensService = class {
                 }
               }
             }
-            if (meaning.kind === "method-access" && meaning.suitableMethods.length > 0) {
-              const method = meaning.suitableMethods[0];
+            if (meaning.kind === "function-access" && meaning.suitableFunctions.length > 0) {
+              const func = meaning.suitableFunctions[0];
               result.push(
                 new SemanticToken(
                   node.rangeWithoutTrivia,
-                  this.getSemanticTokenKindForMethodEntity(method.value.getEntity()),
-                  new SemanticTokenModifiers().setCapitalized(this.isCapitalizedName(method.value.getName()))
+                  this.getSemanticTokenKindForFunctionEntity(func.value.getEntity()),
+                  new SemanticTokenModifiers().setCapitalized(this.isCapitalizedName(func.value.getName()))
                 )
               );
             }
@@ -8628,11 +8618,11 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 80 /* PropertyAccessExpression */) {
-            const meaning = analyzer.resolvePropertyAccessExpression(node).meaning;
+          if (node.kind === 78 /* MemberAccessExpression */) {
+            const meaning = analyzer.resolveMemberAccessExpression(node).meaning;
             if (meaning.kind === "static-variable-access") {
               const entity = meaning.variable.value.getEntity();
-              if (entity.subkind === "type" && entity.isVariant()) {
+              if (entity.subkind === "field" && entity.isVariant()) {
                 result.push(
                   new SemanticToken(
                     node.propertyName.rangeWithoutTrivia,
@@ -8642,25 +8632,25 @@ var SemanticTokensService = class {
                 );
               }
             }
-            let suitableMethods;
+            let suitableFunctions;
             switch (meaning.kind) {
-              case "package-method-access":
-                suitableMethods = meaning.suitableMethods.map((m) => m.value);
+              case "package-function-access":
+                suitableFunctions = meaning.suitableFunctions.map((m) => m.value);
                 break;
               case "static-method-access":
-                suitableMethods = meaning.suitableMethods.map((m) => m.value);
+                suitableFunctions = meaning.suitableFunctions.map((m) => m.value);
                 break;
               case "instance-method-access":
-                suitableMethods = meaning.suitableMethods.map((m) => m.value);
+                suitableFunctions = meaning.suitableFunctions.map((m) => m.value);
                 break;
             }
-            if (suitableMethods !== void 0 && suitableMethods.length > 0) {
-              const method = suitableMethods[0];
+            if (suitableFunctions !== void 0 && suitableFunctions.length > 0) {
+              const func = suitableFunctions[0];
               result.push(
                 new SemanticToken(
                   node.propertyName.rangeWithoutTrivia,
-                  this.getSemanticTokenKindForMethodEntity(method.getEntity()),
-                  new SemanticTokenModifiers().setCapitalized(this.isCapitalizedName(method.getName()))
+                  this.getSemanticTokenKindForFunctionEntity(func.getEntity()),
+                  new SemanticTokenModifiers().setCapitalized(this.isCapitalizedName(func.getName()))
                 )
               );
             }
@@ -8672,7 +8662,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 144 /* VariantDeclaration */) {
+          if (node.kind === 142 /* VariantDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8681,26 +8671,30 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 29 /* PackageMethodDeclaration */) {
+          if (node.kind === 27 /* PackageFunctionDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
-                4 /* PackageMethod */,
+                4 /* PackageFunction */,
                 new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value))
               )
             );
           }
-          if (node.kind === 60 /* NestedMethodDeclaration */) {
+          if (node.kind === 58 /* NestedFunctionDeclaration */) {
             result.push(
-              new SemanticToken(node.name.rangeWithoutTrivia, 5 /* NestedMethod */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
+              new SemanticToken(
+                node.name.rangeWithoutTrivia,
+                5 /* NestedFunction */,
+                new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value))
+              )
             );
           }
-          if (node.kind === 54 /* TypeMethodDeclaration */) {
+          if (node.kind === 52 /* MethodDeclaration */) {
             result.push(
-              new SemanticToken(node.name.rangeWithoutTrivia, 6 /* TypeMethod */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
+              new SemanticToken(node.name.rangeWithoutTrivia, 6 /* Method */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
             );
           }
-          if (node.kind === 55 /* OperatorDeclaration */) {
+          if (node.kind === 53 /* OperatorDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 7 /* Operator */, new SemanticTokenModifiers().makeDeclaration())
             );
@@ -8713,14 +8707,14 @@ var SemanticTokensService = class {
   rangesOverlap(range1, range2) {
     return range1.start < range2.end && range1.end > range2.start;
   }
-  getSemanticTokenKindForMethodEntity(entity) {
+  getSemanticTokenKindForFunctionEntity(entity) {
     switch (entity.subkind) {
       case "package":
-        return 4 /* PackageMethod */;
-      case "type":
-        return 6 /* TypeMethod */;
+        return 4 /* PackageFunction */;
+      case "method":
+        return 6 /* Method */;
       case "nested":
-        return 5 /* NestedMethod */;
+        return 5 /* NestedFunction */;
       default:
         Debug.never(entity);
     }
@@ -8775,13 +8769,13 @@ var SemanticTokenModifiers = class {
   }
 };
 var supportedSemanticTokens = [
-  0 /* MethodBlockLiteralParameter */,
+  0 /* FunctionBlockLiteralParameter */,
   1 /* SpecialVariable */,
   2 /* SpecialMethod */,
   3 /* Variant */,
-  4 /* PackageMethod */,
-  5 /* NestedMethod */,
-  6 /* TypeMethod */,
+  4 /* PackageFunction */,
+  5 /* NestedFunction */,
+  6 /* Method */,
   7 /* Operator */
 ];
 var supportedSemanticTokenModifiers = [
@@ -8856,7 +8850,7 @@ var TypeParameterSignatureHelpProvider = class {
     }
     let node = token.parent;
     while (node !== void 0) {
-      if (node.kind === 154 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
+      if (node.kind === 152 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
         const argumentIndex = this.getArgumentIndex(node.typeArgumentList, this._offset);
         const argumentCount = this.countArguments(node.typeArgumentList);
         return new NodeWithTypeArgumentsInfo(node.parent, argumentIndex, argumentCount);
@@ -8901,9 +8895,9 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 91 /* GenericSpecializationExpression */:
+      case 89 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
-      case 149 /* Tag */:
+      case 147 /* Tag */:
         return this.getSignaturesForTag(node);
       default:
         Debug.never(node);
@@ -8925,11 +8919,11 @@ var TypeParameterSignatureHelpProvider = class {
       const lastQualifier = resolutionResult.resolvedQualifiers[resolutionResult.resolvedQualifiers.length - 1];
       if (lastQualifier.kind === "type") {
         return Query.from(lastQualifier.candidates).mapAndFilter((t) => this.getSignatureForNamedType(t.value)).toArray();
-      } else if (lastQualifier.kind === "method") {
-        if (resolutionResult.meaning.kind === "tag-method") {
+      } else if (lastQualifier.kind === "function") {
+        if (resolutionResult.meaning.kind === "tag-function") {
           return Query.from(resolutionResult.meaning.candidates).mapAndFilter((d) => {
-            if (d.value.kind === "substituted-method") {
-              return this.getSignatureForSubstitutedMethod(d.value.value, d.localization);
+            if (d.value.kind === "substituted-function") {
+              return this.getSignatureForSubstitutedFunction(d.value.value, d.localization);
             }
             return void 0;
           }).toArray();
@@ -8942,12 +8936,12 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
-    if (expression.kind === 90 /* IdentifierExpression */) {
+    if (expression.kind === 88 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
-      if (meaning.kind === "method-access") {
+      if (meaning.kind === "function-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
-          if (o.value.kind === "substituted-method") {
-            return this.getSignatureForSubstitutedMethod(o.value.value, o.localization);
+          if (o.value.kind === "substituted-function") {
+            return this.getSignatureForSubstitutedFunction(o.value.value, o.localization);
           }
           return void 0;
         }).toArray();
@@ -8957,20 +8951,20 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 80 /* PropertyAccessExpression */) {
-      const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
-      let accessedMethods;
+    if (expression.kind === 78 /* MemberAccessExpression */) {
+      const meaning = this._analyzer.resolveMemberAccessExpression(expression).meaning;
+      let accessedFunctions;
       if (meaning.kind === "instance-method-access") {
-        accessedMethods = meaning.candidates;
+        accessedFunctions = meaning.candidates;
       } else if (meaning.kind === "static-method-access") {
-        accessedMethods = meaning.candidates;
-      } else if (meaning.kind === "package-method-access") {
-        accessedMethods = meaning.candidates;
-      }
-      if (accessedMethods !== void 0) {
-        return Query.from(accessedMethods).mapAndFilter((o) => {
-          if (o.value.kind === "substituted-method") {
-            return this.getSignatureForSubstitutedMethod(o.value.value, o.localization);
+        accessedFunctions = meaning.candidates;
+      } else if (meaning.kind === "package-function-access") {
+        accessedFunctions = meaning.candidates;
+      }
+      if (accessedFunctions !== void 0) {
+        return Query.from(accessedFunctions).mapAndFilter((o) => {
+          if (o.value.kind === "substituted-function") {
+            return this.getSignatureForSubstitutedFunction(o.value.value, o.localization);
           }
           return void 0;
         }).toArray();
@@ -8982,21 +8976,21 @@ var TypeParameterSignatureHelpProvider = class {
     }
     return void 0;
   }
-  getSignatureForSubstitutedMethod(method, localization) {
+  getSignatureForSubstitutedFunction(func, localization) {
     let result = void 0;
-    switch (method.kind) {
+    switch (func.kind) {
       case "entity":
-        if (method.entity.getTypeParametersArity() > 0) {
-          result = new MethodEntitySignature(this.signatureContext, method.entity, localization);
+        if (func.entity.getTypeParametersArity() > 0) {
+          result = new FunctionEntitySignature(this.signatureContext, func.entity, localization);
         }
         break;
       case "type-member":
-        if (method.method.getTypeParametersArity() > 0) {
-          result = new TypeMethodSignature(this.signatureContext, method.method, localization);
+        if (func.method.getTypeParametersArity() > 0) {
+          result = new MethodSignature(this.signatureContext, func.method, localization);
         }
         break;
       default:
-        Debug.never(method);
+        Debug.never(func);
     }
     return result;
   }
@@ -9008,9 +9002,9 @@ var TypeParameterSignatureHelpProvider = class {
           result = new StructuredTypeSignature(this.signatureContext, type);
         }
         break;
-      case 0 /* Method */:
+      case 0 /* Function */:
         if (type.getArity() > 0) {
-          result = new MethodTypeSignature2(this.signatureContext, type);
+          result = new FunctionTypeSignature2(this.signatureContext, type);
         }
         break;
       case 3 /* Variant */:
@@ -9038,36 +9032,36 @@ var NodeWithTypeArgumentsInfo = class {
     this.argumentCount = argumentCount;
   }
 };
-var MethodEntitySignature = class {
-  constructor(ctx, method, localization) {
+var FunctionEntitySignature = class {
+  constructor(ctx, func, localization) {
     this.ctx = ctx;
-    this.method = method;
+    this.func = func;
     this.localization = localization;
-    this.kind = "method-entity";
+    this.kind = "function-entity";
   }
   getArity() {
-    return this.method.getTypeParametersArity();
+    return this.func.getTypeParametersArity();
   }
   getDisplayParts() {
-    const method = new MethodDeclaration_entity(this.method, this.localization);
-    const displayParts = this.ctx.displayService.getMethodDeclarationDisplayParts(method);
-    return this.ctx.convertMethodDisplayParts(displayParts);
+    const func = new FunctionDeclaration_entity(this.func, this.localization);
+    const displayParts = this.ctx.displayService.getFunctionDeclarationDisplayParts(func);
+    return this.ctx.convertFunctionDisplayParts(displayParts);
   }
 };
-var TypeMethodSignature = class {
+var MethodSignature = class {
   constructor(ctx, method, localization) {
     this.ctx = ctx;
     this.method = method;
     this.localization = localization;
-    this.kind = "type-method";
+    this.kind = "method";
   }
   getArity() {
     return this.method.getTypeParametersArity();
   }
   getDisplayParts() {
-    const method = new MethodDeclaration_typeMember(this.method, this.localization);
-    const displayParts = this.ctx.displayService.getMethodDeclarationDisplayParts(method);
-    return this.ctx.convertMethodDisplayParts(displayParts);
+    const func = new FunctionDeclaration_typeMember(this.method, this.localization);
+    const displayParts = this.ctx.displayService.getFunctionDeclarationDisplayParts(func);
+    return this.ctx.convertFunctionDisplayParts(displayParts);
   }
 };
 var StructuredTypeSignature = class {
@@ -9100,7 +9094,7 @@ var VariantTypeSignature = class {
     return this.ctx.convertNamedTypeDisplayParts(displayParts);
   }
 };
-var MethodTypeSignature2 = class {
+var FunctionTypeSignature2 = class {
   constructor(ctx, type) {
     this.ctx = ctx;
     this.type = type;
@@ -9110,7 +9104,7 @@ var MethodTypeSignature2 = class {
     return this.type.getArity();
   }
   getDisplayParts() {
-    const type = new NamedType_method(this.type);
+    const type = new NamedType_function(this.type);
     const displayParts = this.ctx.displayService.getNamedTypeDisplayParts(type);
     return this.ctx.convertNamedTypeDisplayParts(displayParts);
   }
@@ -9134,7 +9128,7 @@ var SignatureContext = class {
   constructor(displayService) {
     this.displayService = displayService;
   }
-  convertMethodDisplayParts(parts) {
+  convertFunctionDisplayParts(parts) {
     const prefix = parts.asyncKeywordWithWhitespace + parts.functionKeyword + parts.whitespaceAfterFunctionKeyword + parts.container + parts.name + parts.typeParametersStart;
     const postfix = parts.typeParametersEnd + parts.valueParametersStart + parts.valueParameters.map((p) => p.toString()).join(parts.valueParameterSeparator) + parts.valueParametersEnd + parts.returnTypeAnnotationColon + parts.returnType;
     return new SignatureDisplayParts(prefix, parts.typeParameters, parts.typeParameterSeparator, postfix);
@@ -9210,7 +9204,7 @@ var ValueParametersSignatureHelpProvider = class {
     let node = token.parent;
     while (node !== void 0) {
       switch (node.kind) {
-        case 71 /* CallExpression */: {
+        case 69 /* 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);
@@ -9218,7 +9212,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 72 /* AutotypeCallExpression */: {
+        case 70 /* 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);
@@ -9226,7 +9220,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 73 /* IndexedAccessExpression */: {
+        case 71 /* IndexedAccessExpression */: {
           if (this._offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
@@ -9234,7 +9228,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 149 /* Tag */: {
+        case 147 /* Tag */: {
           if (node.openParenthesisToken !== void 0 && this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && node.argumentList !== void 0 && (node.closeParenthesisToken === void 0 || node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(node);
@@ -9262,17 +9256,17 @@ var ValueParametersSignatureHelpProvider = class {
   }
   getSignatureDisplayParts(signature) {
     switch (signature.kind) {
-      case "accessed-method": {
-        const method = new MethodDeclaration_accessedMethod(
-          signature.method.value,
-          signature.method.localization
+      case "accessed-function": {
+        const func = new FunctionDeclaration_accessedFunction(
+          signature.func.value,
+          signature.func.localization
         );
-        const displayParts = this.signatureContext.displayService.getMethodDeclarationDisplayParts(method);
-        return this.signatureContext.convertMethodDisplayParts(displayParts);
+        const displayParts = this.signatureContext.displayService.getFunctionDeclarationDisplayParts(func);
+        return this.signatureContext.convertFunctionDisplayParts(displayParts);
       }
-      case "method-type": {
-        const displayParts = this.signatureContext.displayService.getMethodTypeBodyDisplayParts(signature.methodType);
-        return this.signatureContext.convertMethodTypeBodyDisplayParts(displayParts);
+      case "function-type": {
+        const displayParts = this.signatureContext.displayService.getFunctionTypeBodyDisplayParts(signature.functionType);
+        return this.signatureContext.convertFunctionTypeBodyDisplayParts(displayParts);
       }
       case "constructor": {
         const constructor = new ConstructorDeclaration_typeMember(
@@ -9304,13 +9298,13 @@ var SignatureContext2 = class {
   constructor(displayService) {
     this.displayService = displayService;
   }
-  convertMethodDisplayParts(parts) {
+  convertFunctionDisplayParts(parts) {
     const prefix = parts.asyncKeywordWithWhitespace + parts.functionKeyword + parts.whitespaceAfterFunctionKeyword + parts.container + parts.name + parts.typeParametersStart + parts.typeParameters.join(parts.typeParameterSeparator) + parts.typeParametersEnd + parts.valueParametersStart;
     const valueParameters = parts.valueParameters.map((p) => p.toString());
     const postfix = parts.valueParametersEnd + parts.returnTypeAnnotationColon + parts.returnType;
     return new SignatureDisplayParts(prefix, valueParameters, parts.valueParameterSeparator, postfix);
   }
-  convertMethodTypeBodyDisplayParts(parts) {
+  convertFunctionTypeBodyDisplayParts(parts) {
     const prefix = parts.asyncKeywordWithWhitespace + parts.functionKeyword + parts.valueParametersStart;
     const valueParameters = parts.valueParameters.map((p) => p.toString());
     const postfix = parts.valueParametersEnd + parts.returnTypeAnnotationColon + parts.returnType;
@@ -11746,8 +11740,8 @@ var EntityToSyntax = class {
     switch (entity.kind) {
       case 0 /* Variable */:
         return this.convertPackageVariable(entity);
-      case 1 /* Method */:
-        return this.convertPackageMethod(entity);
+      case 1 /* Function */:
+        return this.convertPackageFunction(entity);
       case 2 /* Type */:
         return this.convertPackageType(entity);
       default:
@@ -11756,8 +11750,8 @@ var EntityToSyntax = class {
   }
   convertPackageType(entity) {
     switch (entity.typeEntityKind) {
-      case 0 /* Method */:
-        return this.convertPackageMethodType(entity);
+      case 0 /* Function */:
+        return this.convertPackageFunctionType(entity);
       case 1 /* Structured */:
         return this.convertPackageStructuredType(entity);
       case 3 /* Variant */:
@@ -11809,7 +11803,7 @@ var EntityToSyntax = class {
     }
     return result;
   }
-  convertPackageMethod(entity) {
+  convertPackageFunction(entity) {
     const tags = this.convertTags(entity.getTags());
     const modifiers = new Array();
     if (entity.isAsync()) {
@@ -11823,7 +11817,7 @@ var EntityToSyntax = class {
     const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
     const valueParameters = this.convertValueParameters(entity.getValueParameters());
     const returnType = this.convertType(entity.getReturnType());
-    return SyntaxFactory.packageMethodDeclaration(
+    return SyntaxFactory.packageFunctionDeclaration(
       tags,
       modifiers,
       name,
@@ -11869,7 +11863,7 @@ var EntityToSyntax = class {
     const body = this.createVariantTypeDeclarationBody(entity);
     return SyntaxFactory.packageVariantTypeDeclaration(tags, modifiers, name, typeParameters, body);
   }
-  convertPackageMethodType(entity) {
+  convertPackageFunctionType(entity) {
     const tags = this.convertTags(entity.getTags());
     const modifiers = new Array();
     const isHidden = entity.isHidden();
@@ -11878,18 +11872,18 @@ var EntityToSyntax = class {
     }
     const name = this.getEntityName(entity);
     const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
-    const body = this.createMethodTypeDeclarationBody(entity);
-    return SyntaxFactory.packageMethodTypeDeclaration(tags, modifiers, name, typeParameters, body);
+    const body = this.createFunctionTypeDeclarationBody(entity);
+    return SyntaxFactory.packageFunctionTypeDeclaration(tags, modifiers, name, typeParameters, body);
   }
   convertTypeEntityMembers(members) {
-    const variables = members.getNamedMembers().filter((m) => m.kind === 0 /* Variable */).flatMap((m) => this.convertTypeVariable(m));
-    const methods = members.getNamedMembers().filter((m) => m.kind !== 0 /* Variable */).map((m) => this.convertTypeMethod(m));
-    const constructors = members.getConstructors().map((c) => this.convertTypeConstructor(c));
-    const destructors = members.getDestructors().map((d) => this.convertTypeDestructor(d));
-    const indexers = members.getIndexers().flatMap((i) => this.convertTypeIndexer(i));
+    const variables = members.getNamedMembers().filter((m) => m.kind === 0 /* Variable */).flatMap((m) => this.convertField(m));
+    const methods = members.getNamedMembers().filter((m) => m.kind !== 0 /* Variable */).map((m) => this.convertMethod(m));
+    const constructors = members.getConstructors().map((c) => this.convertConstructor(c));
+    const destructors = members.getDestructors().map((d) => this.convertDestructor(d));
+    const indexers = members.getIndexers().flatMap((i) => this.convertIndexer(i));
     return variables.concat(indexers, constructors, methods, destructors);
   }
-  convertTypeVariable(entity) {
+  convertField(entity) {
     if (entity.isVariant()) {
       return this.convertVariant(entity);
     }
@@ -11922,7 +11916,7 @@ var EntityToSyntax = class {
         if (isHidden !== void 0) {
           modifiers.push(this.createHidingModifier(isHidden));
         }
-        result.push(SyntaxFactory.typeVariableGetterDeclaration(tags, modifiers, name, type, void 0));
+        result.push(SyntaxFactory.fieldGetterDeclaration(tags, modifiers, name, type, void 0));
       }
       const setterEntity = entity.getSetter();
       if (setterEntity !== void 0) {
@@ -11932,7 +11926,7 @@ var EntityToSyntax = class {
         if (isHidden !== void 0) {
           modifiers.push(this.createHidingModifier(isHidden));
         }
-        result.push(SyntaxFactory.typeVariableSetterDeclaration(tags, modifiers, name, void 0));
+        result.push(SyntaxFactory.fieldSetterDeclaration(tags, modifiers, name, void 0));
       }
     } else {
       const tags = this.convertTags(entity.getTags());
@@ -11941,11 +11935,11 @@ var EntityToSyntax = class {
       if (isHidden !== void 0) {
         modifiers.push(this.createHidingModifier(isHidden));
       }
-      result = SyntaxFactory.typeVariableDeclaration(tags, commonModifiers, name, type);
+      result = SyntaxFactory.fieldDeclaration(tags, commonModifiers, name, type);
     }
     return result;
   }
-  convertTypeMethod(entity) {
+  convertMethod(entity) {
     const tags = this.convertTags(entity.getTags());
     const modifiers = new Array();
     const isHidden = entity.isHidden();
@@ -11968,9 +11962,9 @@ var EntityToSyntax = class {
     const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
     const parameters = this.convertValueParameters(entity.getValueParameters());
     const returnType = this.convertType(entity.getReturnType());
-    return SyntaxFactory.typeMethodDeclaration(tags, modifiers, name, typeParameters, parameters, returnType, void 0);
+    return SyntaxFactory.methodDeclaration(tags, modifiers, name, typeParameters, parameters, returnType, void 0);
   }
-  convertTypeConstructor(entity) {
+  convertConstructor(entity) {
     const tags = this.convertTags(entity.getTags());
     const modifiers = new Array();
     const isHidden = entity.isHidden();
@@ -11981,9 +11975,9 @@ var EntityToSyntax = class {
       modifiers.push(SyntaxFactory.modifier(37 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
-    return SyntaxFactory.typeConstructorDeclaration(tags, modifiers, parameters, void 0);
+    return SyntaxFactory.constructorDeclaration(tags, modifiers, parameters, void 0);
   }
-  convertTypeDestructor(entity) {
+  convertDestructor(entity) {
     const tags = this.convertTags(entity.getTags());
     const modifiers = new Array();
     const isHidden = entity.isHidden();
@@ -11994,9 +11988,9 @@ var EntityToSyntax = class {
       modifiers.push(SyntaxFactory.modifier(37 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
-    return SyntaxFactory.typeDestructorDeclaration(tags, modifiers, parameters, void 0);
+    return SyntaxFactory.destructorDeclaration(tags, modifiers, parameters, void 0);
   }
-  convertTypeIndexer(entity) {
+  convertIndexer(entity) {
     const commonModifiers = new Array();
     if (entity.isStatic()) {
       commonModifiers.push(SyntaxFactory.modifier(41 /* Static */));
@@ -12015,14 +12009,14 @@ var EntityToSyntax = class {
         modifiers.push(this.createHidingModifier(isHidden));
       }
       const type = this.convertType(entity.getType());
-      const declaration = SyntaxFactory.typeIndexedGetterDeclaration(tags, modifiers, parameters, type, void 0);
+      const declaration = SyntaxFactory.indexedElementGetterDeclaration(tags, modifiers, parameters, type, void 0);
       result.push(declaration);
     }
     const setterEntity = entity.getSetter();
     if (setterEntity !== void 0) {
       const tags = this.convertTags(setterEntity.getTags());
       const modifiers = Array.from(commonModifiers);
-      const declaration = SyntaxFactory.typeIndexedSetterDeclaration(tags, modifiers, parameters, void 0);
+      const declaration = SyntaxFactory.indexedElementSetterDeclaration(tags, modifiers, parameters, void 0);
       result.push(declaration);
     }
     return result;
@@ -12074,10 +12068,10 @@ var EntityToSyntax = class {
     const members = this.convertTypeEntityMembers(entity.getMembers());
     return SyntaxFactory.variantTypeDeclarationBody(members);
   }
-  createMethodTypeDeclarationBody(entity) {
+  createFunctionTypeDeclarationBody(entity) {
     const parameters = this.convertValueParameters(entity.getValueParameters());
     const returnType = this.convertType(entity.getReturnType());
-    return SyntaxFactory.methodTypeDeclarationBody(parameters, returnType);
+    return SyntaxFactory.functionTypeDeclarationBody(parameters, returnType);
   }
   convertTypeParameters(entities) {
     if (entities.length === 0) {
@@ -12144,8 +12138,8 @@ var EntityToSyntax = class {
         return this.convertStructuredType(type);
       case "variant":
         return this.convertVariantType(type);
-      case "method":
-        return this.convertMethodType(type);
+      case "function":
+        return this.convertFunctionType(type);
       case "alias":
         return this.convertAliasType(type);
       case "parameter":
@@ -12180,14 +12174,14 @@ var EntityToSyntax = class {
       return SyntaxFactory.anonymousVariantTypeSpecifier(body);
     }
   }
-  convertMethodType(type) {
+  convertFunctionType(type) {
     const entity = type.getEntity();
     if (entity.subkind === "package") {
       const name = this.getEntityName(entity);
       return this.createNamedTypeSpecifier(name, type.getSubstitutions());
     } else {
-      const body = this.createMethodTypeDeclarationBody(entity);
-      return SyntaxFactory.anonymousMethodTypeSpecifier(body);
+      const body = this.createFunctionTypeDeclarationBody(entity);
+      return SyntaxFactory.anonymousFunctionTypeSpecifier(body);
     }
   }
   convertAliasType(type) {
@@ -12378,7 +12372,7 @@ var SourceGenerationService = class extends TriggeringObject7 {
       case 0 /* Variable */:
         if (entity.subkind === "package") {
           return true;
-        } else if (entity.subkind === "type") {
+        } else if (entity.subkind === "field") {
           return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainer().getEntity());
         } else if (entity.subkind === "parameter") {
           const container = entity.getContainer();
@@ -12386,10 +12380,10 @@ var SourceGenerationService = class extends TriggeringObject7 {
         } else {
           return false;
         }
-      case 1 /* Method */:
+      case 1 /* Function */:
         if (entity.subkind === "package") {
           return true;
-        } else if (entity.subkind === "type") {
+        } else if (entity.subkind === "method") {
           return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainer().getEntity());
         } else {
           return false;
@@ -12398,7 +12392,7 @@ var SourceGenerationService = class extends TriggeringObject7 {
         switch (entity.typeEntityKind) {
           case 1 /* Structured */:
           case 3 /* Variant */:
-          case 0 /* Method */: {
+          case 0 /* Function */: {
             if (entity.subkind === "package") {
               return true;
             }
@@ -12467,13 +12461,13 @@ var EntityFinder = class {
     switch (entity.kind) {
       case 0 /* Variable */:
         return this.findVariableEntity(entity);
-      case 1 /* Method */:
-        return this.findMethodEntity(entity);
+      case 1 /* Function */:
+        return this.findFunctionEntity(entity);
       case 2 /* Type */:
         switch (entity.typeEntityKind) {
           case 3 /* Variant */:
           case 1 /* Structured */:
-          case 0 /* Method */: {
+          case 0 /* Function */: {
             if (entity.subkind === "package") {
               return this.findPackageTypeEntityByNameAndArity(this.getEntityName(entity), entity.getArity());
             }
@@ -12509,7 +12503,7 @@ var EntityFinder = class {
   findVariableEntity(entity) {
     if (entity.subkind === "package") {
       return this._packageEntity.getMembers().getNamedMembersByName(this.getEntityName(entity)).at(0);
-    } else if (entity.subkind === "type") {
+    } else if (entity.subkind === "field") {
       const containingType = this.findEntity(entity.getContainer().getEntity());
       if (containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType)) {
         return containingType.getMembers().getNamedMembersByName(this.getEntityName(entity))[0];
@@ -12526,10 +12520,10 @@ var EntityFinder = class {
     }
     return void 0;
   }
-  findMethodEntity(entity) {
+  findFunctionEntity(entity) {
     switch (entity.subkind) {
       case "package": {
-        const members = this._packageEntity.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === 1 /* Method */);
+        const members = this._packageEntity.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === 1 /* Function */);
         if (members.length === 0) {
           return void 0;
         } else if (members.length === 1) {
@@ -12544,12 +12538,12 @@ var EntityFinder = class {
           return index >= 0 ? members[index] : void 0;
         }
       }
-      case "type": {
+      case "method": {
         const containingType = this.findEntity(entity.getContainer().getEntity());
         if (!(containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType))) {
           return void 0;
         }
-        const members = containingType.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === 1 /* Method */);
+        const members = containingType.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === 1 /* Function */);
         if (members.length === 0) {
           return void 0;
         } else if (members.length === 1) {
@@ -12666,7 +12660,7 @@ var EntityFinder = class {
   }
   ifEntityWithParametersThenParameters(entity) {
     switch (entity.kind) {
-      case 1 /* Method */:
+      case 1 /* Function */:
         return entity.getValueParameters();
       case 5 /* Indexer */:
         return entity.getValueParameters();
@@ -12675,7 +12669,7 @@ var EntityFinder = class {
       case 8 /* Destructor */:
         return entity.getValueParameters();
       case 2 /* Type */: {
-        if (entity.typeEntityKind === 0 /* Method */) {
+        if (entity.typeEntityKind === 0 /* Function */) {
           return entity.getValueParameters();
         }
         return void 0;
@@ -12696,7 +12690,7 @@ var EntityFinder = class {
   }
   ifEntityWithTypeParametersThenParameters(entity) {
     switch (entity.kind) {
-      case 1 /* Method */:
+      case 1 /* Function */:
         return entity.getTypeParameters();
       case 2 /* Type */: {
         if (entity.typeEntityKind !== 2 /* Parameter */) {
@@ -13290,7 +13284,7 @@ var LanguageServer = class {
   }
   convertSourceFileItemKind(kind) {
     switch (kind) {
-      case 4 /* PackageMethod */:
+      case 4 /* PackageFunction */:
         return ls3.SymbolKind.Function;
       case 1 /* PackageVariable */:
       case 2 /* PackageVariableGetter */:
@@ -13298,23 +13292,23 @@ var LanguageServer = class {
         return ls3.SymbolKind.Variable;
       case 5 /* StructuredType */:
         return ls3.SymbolKind.Class;
-      case 12 /* TypeVariable */:
+      case 12 /* Field */:
         return ls3.SymbolKind.Field;
-      case 13 /* TypeVariableGetter */:
-      case 14 /* TypeVariableSetter */:
+      case 13 /* FieldGetter */:
+      case 14 /* FieldSetter */:
         return ls3.SymbolKind.Property;
-      case 15 /* TypeMethod */:
+      case 15 /* Method */:
         return ls3.SymbolKind.Method;
-      case 10 /* TypeConstructor */:
+      case 10 /* Constructor */:
         return ls3.SymbolKind.Constructor;
-      case 11 /* TypeDestructor */:
+      case 11 /* Destructor */:
         return ls3.SymbolKind.Method;
-      case 16 /* TypeIndexedGetter */:
-      case 17 /* TypeIndexedSetter */:
+      case 16 /* IndexedElementGetter */:
+      case 17 /* IndexedElementSetter */:
         return ls3.SymbolKind.Property;
       case 18 /* TypeParameter */:
         return ls3.SymbolKind.TypeParameter;
-      case 19 /* NestedMethod */:
+      case 19 /* NestedFunction */:
         return ls3.SymbolKind.Function;
       case 7 /* VariantType */:
         return ls3.SymbolKind.Enum;
@@ -13322,7 +13316,7 @@ var LanguageServer = class {
         return ls3.SymbolKind.EnumMember;
       case 8 /* InvalidType */:
         return ls3.SymbolKind.Class;
-      case 6 /* MethodType */:
+      case 6 /* FunctionType */:
         return ls3.SymbolKind.Class;
       case 0 /* PackageAlias */:
         return ls3.SymbolKind.Module;
@@ -13398,7 +13392,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 === 93 /* AssignmentStatement */) {
+        if (node?.kind === 91 /* AssignmentStatement */) {
           const sourceFileEdit = this._addPropertyAssignmentService.createEditWithAssignment(
             sourceFileContext.sourceFile,
             node,
@@ -13435,7 +13429,7 @@ var LanguageServer = class {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
         if (node !== void 0) {
           let nodeForRange = node;
-          if (node.kind === 93 /* AssignmentStatement */) {
+          if (node.kind === 91 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);
@@ -13630,25 +13624,25 @@ ${e}`);
         return ls3.CompletionItemKind.Module;
       case 1 /* PackageAlias */:
         return ls3.CompletionItemKind.Module;
-      case 2 /* TypeVariable */:
+      case 2 /* Field */:
         return ls3.CompletionItemKind.Property;
-      case 3 /* TypeMethod */:
+      case 3 /* Method */:
         return ls3.CompletionItemKind.Method;
-      case 5 /* TypeIndexer */:
+      case 5 /* Indexer */:
         return ls3.CompletionItemKind.Property;
-      case 6 /* TypeConstructor */:
+      case 6 /* Constructor */:
         return ls3.CompletionItemKind.Constructor;
       case 12 /* Variant */:
         return ls3.CompletionItemKind.EnumMember;
       case 7 /* PackageVariable */:
         return ls3.CompletionItemKind.Variable;
-      case 8 /* PackageMethod */:
+      case 8 /* PackageFunction */:
         return ls3.CompletionItemKind.Function;
       case 9 /* LocalVariable */:
         return ls3.CompletionItemKind.Variable;
       case 10 /* ParameterVariable */:
         return ls3.CompletionItemKind.Variable;
-      case 11 /* NestedMethod */:
+      case 11 /* NestedFunction */:
         return ls3.CompletionItemKind.Function;
       case 13 /* RefObjectType */:
         return ls3.CompletionItemKind.Class;
@@ -13660,7 +13654,7 @@ ${e}`);
         return ls3.CompletionItemKind.Enum;
       case 17 /* TypeParameter */:
         return ls3.CompletionItemKind.TypeParameter;
-      case 18 /* MethodType */:
+      case 18 /* FunctionType */:
         return ls3.CompletionItemKind.Function;
       case 19 /* AliasType */:
         return ls3.CompletionItemKind.Class;
@@ -13746,7 +13740,7 @@ ${e}`);
   }
   convertSemanticTokenKind(kind) {
     switch (kind) {
-      case 0 /* MethodBlockLiteralParameter */:
+      case 0 /* FunctionBlockLiteralParameter */:
         return "keyword.art";
       case 1 /* SpecialVariable */:
         return "keyword.art";
@@ -13754,11 +13748,11 @@ ${e}`);
         return "keyword.art";
       case 3 /* Variant */:
         return ls3.SemanticTokenTypes.enumMember;
-      case 4 /* PackageMethod */:
+      case 4 /* PackageFunction */:
         return ls3.SemanticTokenTypes.function;
-      case 5 /* NestedMethod */:
+      case 5 /* NestedFunction */:
         return ls3.SemanticTokenTypes.function;
-      case 6 /* TypeMethod */:
+      case 6 /* Method */:
         return ls3.SemanticTokenTypes.method;
       case 7 /* Operator */:
         return ls3.SemanticTokenTypes.operator;