@artel/artc 0.6.25223 → 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,19 +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,
   JavaScriptInterfacePackageImplementationConfig,
   JsonConfigurationFileNameSet,
   Keyword,
@@ -45,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,
@@ -65,15 +77,15 @@ import {
   NullableTypeSpecifier,
   OperatorDeclaration_typeMember,
   PackageAliasTypeDeclaration,
+  PackageFunctionDeclaration,
+  PackageFunctionTranslation,
+  PackageFunctionTypeDeclaration,
   PackageImport,
   PackageImportDirectiveList,
   PackageMemberDeclarationList,
   PackageMemberGroupDeclaration,
   PackageMemberLookup,
-  PackageMethodDeclaration,
-  PackageMethodTranslation,
-  PackageMethodTypeDeclaration,
-  PackagePath,
+  PackageName,
   PackageStructuredTypeDeclaration,
   PackageVariableDeclaration,
   PackageVariableGetterDeclaration,
@@ -116,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,
@@ -182,7 +182,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-DZNNWICP.js";
+} from "../chunk-TFTCV5R5.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -302,7 +302,7 @@ var AddPropertyAssignmentService = class {
     let result;
     let leftValueText;
     if (propertyName !== void 0) {
-      if (assignmentNode.left.kind !== 78 /* PropertyAccessExpression */) {
+      if (assignmentNode.left.kind !== 78 /* MemberAccessExpression */) {
         return void 0;
       }
       const propertyReceiver = assignmentNode.left.expression;
@@ -374,21 +374,21 @@ function isSubprogramDeclaration(node) {
   switch (node.kind) {
     case 25 /* PackageConstructorDeclaration */:
     case 26 /* PackageEntryPointDeclaration */:
-    case 27 /* PackageMethodDeclaration */:
+    case 27 /* PackageFunctionDeclaration */:
     case 36 /* PackageVariableGetterDeclaration */:
     case 37 /* PackageVariableSetterDeclaration */:
-    case 45 /* TypeConstructorDeclaration */:
-    case 46 /* TypeDestructorDeclaration */:
-    case 47 /* TypeIndexedGetterDeclaration */:
-    case 48 /* TypeIndexedSetterDeclaration */:
-    case 50 /* TypeDereferencedVariableGetterDeclaration */:
-    case 51 /* TypeDereferencedVariableSetterDeclaration */:
-    case 52 /* TypeMethodDeclaration */:
-    case 55 /* TypeVariableGetterDeclaration */:
-    case 56 /* TypeVariableSetterDeclaration */:
-    case 58 /* NestedMethodDeclaration */:
-    case 67 /* MethodBlockLiteral */:
-    case 74 /* MethodLiteral */:
+    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();
@@ -412,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);
@@ -455,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 */);
@@ -463,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,
@@ -474,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,
@@ -491,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);
@@ -586,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);
@@ -595,7 +595,7 @@ var SyntaxFactory = class {
     if (initializer !== void 0) {
       equalsToken = this.token(57 /* Equals */);
     }
-    return new TypeVariableDeclaration(
+    return new FieldDeclaration(
       tagList,
       modifierList,
       nameIdentifier,
@@ -604,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,
@@ -619,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 */);
@@ -634,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,
@@ -645,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,
@@ -674,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);
@@ -711,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 */)
     );
   }
@@ -730,9 +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(this.createTokenSeparatedElements(
+      typeSpecifiers,
+      10 /* Ampersand */
+    ));
   }
   static nullableTypeSpecifier(typeSpecifier) {
     const questionToken = this.token(49 /* Question */);
@@ -746,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));
@@ -868,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);
@@ -877,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,
@@ -915,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);
@@ -924,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,
@@ -935,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);
@@ -954,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,
@@ -978,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) {
@@ -991,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 */;
@@ -1105,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);
     }
@@ -1151,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);
@@ -1213,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);
@@ -1225,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);
@@ -1268,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) {
@@ -1293,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);
@@ -1307,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);
@@ -1318,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);
@@ -1328,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);
@@ -1359,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);
@@ -1368,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);
@@ -1377,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);
@@ -1390,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);
@@ -1402,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);
@@ -1413,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);
@@ -1542,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);
@@ -1552,8 +1556,8 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeVariantTypeDeclarationBody(node.body);
   }
   writeUnionTypeSpecifier(node) {
-    for (let i = 0; i < node.typeList.elements.length; i++) {
-      const element = node.typeList.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);
@@ -1561,7 +1565,28 @@ var SyntaxToCode = class _SyntaxToCode {
         if (i > 0) {
           this.writeWhitespace();
         }
-        const areParenthesisRequired = this.doesConstituentTypeRequireParenthesis(element);
+        const areParenthesisRequired = this.doesUnionTypeElementRequireParenthesis(element);
+        if (areParenthesisRequired) {
+          this.writeCode("(");
+        }
+        this.writeTypeSpecifier(element, false);
+        if (areParenthesisRequired) {
+          this.writeCode(")");
+        }
+      }
+    }
+  }
+  writeIntersectionTypeSpecifier(node) {
+    for (let i = 0; i < node.typeListElements.length; i++) {
+      const element = node.typeListElements[i];
+      if (element.kind === 0 /* Token */) {
+        this.writeWhitespace();
+        this.writeToken(element);
+      } else {
+        if (i > 0) {
+          this.writeWhitespace();
+        }
+        const areParenthesisRequired = this.doesIntersectionTypeElementRequireParenthesis(element);
         if (areParenthesisRequired) {
           this.writeCode("(");
         }
@@ -1588,13 +1613,39 @@ var SyntaxToCode = class _SyntaxToCode {
     }
     this.writeToken(node.questionToken);
   }
-  doesConstituentTypeRequireParenthesis(node) {
+  doesUnionTypeElementRequireParenthesis(node) {
     switch (node.kind) {
       case 11 /* UnionTypeSpecifier */:
         return true;
       case 15 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 29 /* MethodTypeDeclarationBody */:
+          case 29 /* FunctionTypeDeclarationBody */:
+            return true;
+          case 34 /* StructuredTypeDeclarationBody */:
+          case 39 /* VariantTypeDeclarationBody */:
+            return false;
+          default:
+            Debug.never(node.typeDeclaration.body);
+        }
+      }
+      case 10 /* NamedTypeSpecifier */:
+      case 13 /* ParenthesizedTypeSpecifier */:
+      case 14 /* NullableTypeSpecifier */:
+      case 16 /* InvalidTypeSpecifier */:
+      case 12 /* IntersectionTypeSpecifier */:
+        return false;
+      default:
+        Debug.never(node);
+    }
+  }
+  doesIntersectionTypeElementRequireParenthesis(node) {
+    switch (node.kind) {
+      case 11 /* UnionTypeSpecifier */:
+      case 12 /* IntersectionTypeSpecifier */:
+        return true;
+      case 15 /* AnonymousTypeSpecifier */: {
+        switch (node.typeDeclaration.body.kind) {
+          case 29 /* FunctionTypeDeclarationBody */:
             return true;
           case 34 /* StructuredTypeDeclarationBody */:
           case 39 /* VariantTypeDeclarationBody */:
@@ -1615,6 +1666,7 @@ var SyntaxToCode = class _SyntaxToCode {
   doesTypeMadeNullableRequireParenthesis(node) {
     switch (node.kind) {
       case 11 /* UnionTypeSpecifier */:
+      case 12 /* IntersectionTypeSpecifier */:
       case 15 /* AnonymousTypeSpecifier */:
         return true;
       case 10 /* NamedTypeSpecifier */:
@@ -1694,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);
@@ -1739,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);
@@ -1756,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);
@@ -1781,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);
@@ -1807,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);
@@ -1942,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,
@@ -1952,9 +2003,10 @@ 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,
+      [12 /* IntersectionTypeSpecifier */]: this.prototype.writeIntersectionTypeSpecifier,
       [13 /* ParenthesizedTypeSpecifier */]: this.prototype.writeParenthesizedTypeSpecifier,
       [14 /* NullableTypeSpecifier */]: this.prototype.writeNullableTypeSpecifier,
       [15 /* AnonymousTypeSpecifier */]: this.prototype.writeAnonymousTypeSpecifier,
@@ -1962,9 +2014,9 @@ var SyntaxToCode = class _SyntaxToCode {
       [24 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
       [25 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
       [26 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
-      [27 /* PackageMethodDeclaration */]: this.prototype.writePackageMethodDeclaration,
-      [28 /* PackageMethodTypeDeclaration */]: this.prototype.writePackageMethodTypeDeclaration,
-      [29 /* MethodTypeDeclarationBody */]: this.prototype.writeMethodTypeDeclarationBody,
+      [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,
@@ -1975,17 +2027,17 @@ var SyntaxToCode = class _SyntaxToCode {
       [38 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
       [39 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
       [44 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
-      [45 /* TypeConstructorDeclaration */]: this.prototype.writeTypeConstructorDeclaration,
-      [46 /* TypeDestructorDeclaration */]: this.prototype.writeTypeDestructorDeclaration,
-      [47 /* TypeIndexedGetterDeclaration */]: this.prototype.writeTypeIndexedGetterDeclaration,
-      [48 /* TypeIndexedSetterDeclaration */]: this.prototype.writeTypeIndexedSetterDeclaration,
-      [50 /* TypeDereferencedVariableGetterDeclaration */]: this.prototype.writeTypeDereferencedVariableGetterDeclaration,
-      [51 /* TypeDereferencedVariableSetterDeclaration */]: this.prototype.writeTypeDereferencedVariableSetterDeclaration,
-      [52 /* TypeMethodDeclaration */]: this.prototype.writeTypeMethodDeclaration,
+      [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 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
-      [55 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
-      [56 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
+      [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,
@@ -1999,12 +2051,11 @@ var SyntaxToCode = class _SyntaxToCode {
       [151 /* ParameterList */]: this.prototype.writeParameterList,
       [152 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
       [154 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
-      [17 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
+      [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.writeNodeDefault,
       [16 /* InvalidTypeSpecifier */]: this.prototype.writeNodeDefault,
       [20 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
       [21 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
@@ -2014,9 +2065,9 @@ var SyntaxToCode = class _SyntaxToCode {
       [41 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
       [42 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
       [43 /* InvalidPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [49 /* TypeIndexerParameterClause */]: this.prototype.writeNodeDefault,
+      [49 /* IndexParameterClause */]: this.prototype.writeNodeDefault,
       [57 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [58 /* NestedMethodDeclaration */]: this.prototype.writeNodeDefault,
+      [58 /* NestedFunctionDeclaration */]: this.prototype.writeNodeDefault,
       [59 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
       [60 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
       [61 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
@@ -2025,18 +2076,18 @@ var SyntaxToCode = class _SyntaxToCode {
       [64 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
       [65 /* AsExpression */]: this.prototype.writeNodeDefault,
       [66 /* BinaryExpression */]: this.prototype.writeNodeDefault,
-      [67 /* MethodBlockLiteral */]: 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 /* MethodLiteral */]: this.prototype.writeNodeDefault,
+      [74 /* FunctionLiteral */]: this.prototype.writeNodeDefault,
       [75 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
       [76 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
       [77 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
-      [78 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
+      [78 /* MemberAccessExpression */]: this.prototype.writeNodeDefault,
       [79 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
       [80 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
       [81 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
@@ -2070,7 +2121,7 @@ var SyntaxToCode = class _SyntaxToCode {
       [111 /* ElseIfClause */]: this.prototype.writeNodeDefault,
       [112 /* ElseClause */]: this.prototype.writeNodeDefault,
       [113 /* InvalidStatement */]: this.prototype.writeNodeDefault,
-      [114 /* NestedMethodDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [114 /* NestedFunctionDeclarationStatement */]: this.prototype.writeNodeDefault,
       [115 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
       [116 /* LoopStatement */]: this.prototype.writeNodeDefault,
       [117 /* ReturnStatement */]: this.prototype.writeNodeDefault,
@@ -2083,16 +2134,16 @@ var SyntaxToCode = class _SyntaxToCode {
       [124 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
       [125 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
       [126 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
-      [127 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
+      [127 /* IndexParameterTranslationClause */]: this.prototype.writeIndexParameterTranslationClause,
       [128 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
       [129 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
       [130 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
-      [131 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
-      [132 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
-      [133 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
+      [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 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
+      [137 /* FieldOrVariantTranslation */]: this.prototype.writeFieldOrVariantTranslation,
       [138 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
       [139 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
       [140 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
@@ -2105,7 +2156,6 @@ var SyntaxToCode = class _SyntaxToCode {
     };
     return writeFunctions;
   }
-  /* eslint-enable @stylistic/max-len */
   // TODO: перенести метод в другое место (в Scanner)
   escapeLiteralIdentifier(value) {
     return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -2546,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);
         }
@@ -2564,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());
@@ -2576,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 */:
@@ -2600,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()));
@@ -2677,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.",
@@ -2798,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;
@@ -2852,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") {
@@ -2968,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(),
@@ -3094,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);
@@ -3158,7 +3208,7 @@ var CompletionService = class {
     if (syntaxContext.isInComment || syntaxContext.isInStringOrChar) {
       return { kind: "none" };
     }
-    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 53 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 52 /* 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;
@@ -3168,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 === 78 /* PropertyAccessExpression */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 78 /* MemberAccessExpression */) {
       const propertyAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(propertyAccess.expression);
@@ -3357,12 +3407,12 @@ var CompletionService = class {
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 139 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 133 /* 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 === 131 /* PackageMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 131 /* PackageFunctionTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3409,7 +3459,7 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 132 /* TypeMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 132 /* MethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
@@ -3498,6 +3548,11 @@ var CompletionService = class {
       }
       return { targetTypes: void 0, targetSignaturesParameters: void 0 };
     }
+    if (role.kind === "error-value") {
+      const errorType = this._analyzer.standardTypes.error;
+      const textType = this._analyzer.standardTypes.text;
+      return { targetTypes: [errorType, textType], targetSignaturesParameters: void 0 };
+    }
     if (role.kind === "function-block-expression") {
       const targetType = semanticContext.getContainingSubprogram()?.getReturnType();
       if (targetType !== void 0 && !targetType.equals(this._analyzer.standardTypes.none)) {
@@ -3536,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 */;
@@ -3603,7 +3658,7 @@ var CompletionService = class {
       kinds.add(30 /* Creation */).add(12 /* Function */).add(47 /* Destruction */).add(58 /* Get */).add(59 /* Set */);
     }
     if (syntaxContext.isStatementContext) {
-      kinds.add(7 /* Run */).add(34 /* For */).add(25 /* While */).add(26 /* Loop */).add(15 /* Return */).add(20 /* Error */).add(28 /* Yield */).add(32 /* BreakLoop */).add(33 /* ContinueLoop */).add(13 /* If */).add(44 /* Switch */).add(1 /* Let */).add(35 /* Const */).add(46 /* Dispose */).add(8 /* Try */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(7 /* Run */).add(34 /* For */).add(25 /* While */).add(26 /* Loop */).add(15 /* Return */).add(20 /* Error */).add(19 /* Important */).add(28 /* Yield */).add(32 /* BreakLoop */).add(33 /* ContinueLoop */).add(13 /* If */).add(44 /* Switch */).add(1 /* Let */).add(35 /* Const */).add(46 /* Dispose */).add(8 /* Try */).add(12 /* Function */).add(40 /* Async */);
     }
     if (this.isFromKeywordContext(positionDescription)) {
       kinds.add(9 /* From */);
@@ -3650,7 +3705,7 @@ var CompletionService = class {
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
       kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(12 /* Function */).add(40 /* Async */);
     }
-    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(40 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 74 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* 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(
@@ -3730,7 +3785,7 @@ var CompletionService = class {
     return result;
   }
   prioritizeItemsFromUnionType(items, type) {
-    const constituentTypeEntities = Query.from(type.unaliasedFlattenedTypes).mapAndFilter((t) => this.getEntityFromType(t)).uniqueToSet();
+    const constituentTypeEntities = Query.from(type.unaliasedFlattenedTypes).mapAndFilter((t) => t.getEntity()).uniqueToSet();
     for (const item of items) {
       if (item.kind === "named-type" && constituentTypeEntities.has(item.entity)) {
         item.prefix = "*";
@@ -3753,7 +3808,7 @@ var CompletionService = class {
               d.requiresExplicitOriginalName
             );
           } else {
-            return new TypeVariableCompletionItemInfo(
+            return new FieldCompletionItemInfo(
               this.completionItemInfoContext,
               d.value.value.value,
               d.name,
@@ -3761,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,
@@ -3813,25 +3868,6 @@ var CompletionService = class {
     }
     return result;
   }
-  getEntityFromType(type) {
-    switch (type.kind) {
-      case "structured":
-        return type.getEntity();
-      case "variant":
-        return type.getEntity();
-      case "method":
-        return type.getEntity();
-      case "alias":
-        return type.getEntity();
-      case "parameter":
-        return type.getEntity();
-      case "unresolved":
-      case "union":
-        return void 0;
-      default:
-        Debug.never(type);
-    }
-  }
   getTypeCompletionItemInfosFromPackage(searchLocation) {
     return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
       if (m.value.kind === 2 /* Type */) {
@@ -3909,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,
@@ -3933,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,
@@ -3957,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,
@@ -3997,8 +4033,8 @@ var CompletionService = class {
           name,
           isNameExplicitlyOriginal
         );
-      case 1 /* Method */:
-        return new MethodEntityCompletionItemInfo(
+      case 1 /* Function */:
+        return new FunctionEntityCompletionItemInfo(
           this.completionItemInfoContext,
           member,
           name,
@@ -4027,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,
@@ -4077,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,
@@ -4119,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,
@@ -4161,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,
@@ -4173,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,
@@ -4181,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,
@@ -4197,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,
@@ -4206,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 {
@@ -4237,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;
         }
@@ -4258,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;
@@ -4277,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;
       }
@@ -4567,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;
@@ -4579,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(
@@ -4596,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() {
@@ -4668,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":
@@ -4693,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)}`;
@@ -4707,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() {
@@ -4750,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 */;
@@ -4807,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();
@@ -4821,7 +4857,7 @@ var MergedOverloadedMethodCompletionItemInfo = class {
     return this.firstOverloadInfo.getCompletionItemKind();
   }
   getDetails() {
-    const overloadsWord = LocalizationHelper.localizeHelperPhrase(6 /* Overloads */, this.ctx.locale);
+    const overloadsWord = LocalizationHelper.localizeHelperPhrase(7 /* Overloads */, this.ctx.locale);
     const overloadCountText = ` (+${overloadsWord}: ${this.overloadCount - 1})`;
     const originalDetails = this.firstOverloadInfo.getDetails();
     return originalDetails + overloadCountText;
@@ -4881,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":
@@ -4906,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;
   }
@@ -4964,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 */;
@@ -5000,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(
@@ -5020,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;
@@ -5039,7 +5075,7 @@ var AliasesSourceTypeIndexerCompletionItemInfo = class {
     return this.label;
   }
   getCompletionItemKind() {
-    return 5 /* TypeIndexer */;
+    return 5 /* Indexer */;
   }
   getDetails() {
     return this.label;
@@ -5055,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_;
@@ -5079,7 +5115,7 @@ var AliasesSourceTypeConstructorCompletionItemInfo = class {
     return this.label;
   }
   getCompletionItemKind() {
-    return 6 /* TypeConstructor */;
+    return 6 /* Constructor */;
   }
   getDetails() {
     return this.label;
@@ -5163,6 +5199,12 @@ var ExpressionRole_returnedValue = class {
     this.kind = "returned-value";
   }
 };
+var ExpressionRole_errorValue = class {
+  constructor(errorStatement) {
+    this.errorStatement = errorStatement;
+    this.kind = "error-value";
+  }
+};
 var ExpressionRole_functionBlockExpression = class {
   constructor(functionBlock) {
     this.functionBlock = functionBlock;
@@ -5243,7 +5285,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 54 /* TypeVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 54 /* FieldDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5373,6 +5415,14 @@ var SyntaxContextFactory = class {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
+    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 === 105 /* ImportantStatement */) {
+      const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
+      return { isExpressionContext: { expressionRole }, isStatementContext: false };
+    }
     if (tokenOrKeyword.isKeyword(44 /* Switch */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
@@ -5427,13 +5477,13 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 40 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 33 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 38 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 22 /* PackageAliasTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 94 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* 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 === 24 /* PackageMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 27 /* PackageMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 28 /* PackageMethodTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 22 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 35 /* 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,
       36 /* PackageVariableGetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
@@ -5457,13 +5507,19 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 44 /* TypeMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* TypeVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* TypeVariableGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* TypeVariableSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 47 /* TypeIndexedGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 48 /* TypeIndexedSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* FieldDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* FieldGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* FieldSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      50 /* TypeDereferencedVariableGetterDeclaration */
+      47 /* IndexedElementGetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      51 /* TypeDereferencedVariableSetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 142 /* VariantDeclaration */)) {
+      48 /* IndexedElementSetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+      tokenOrKeyword,
+      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 === 149 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
@@ -5536,7 +5592,10 @@ var SyntaxContextFactory = class {
     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 === 12 /* IntersectionTypeSpecifier */) {
       return { allowsAnonymousTypes: false };
     }
     if (tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 13 /* ParenthesizedTypeSpecifier */) {
@@ -5562,12 +5621,12 @@ var SyntaxContextFactory = class {
     if (type !== void 0) {
       return { translationsDeclaration: type.parent.parent };
     }
-    const methodType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
+    const functionType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      133 /* 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,
@@ -5576,12 +5635,12 @@ var SyntaxContextFactory = class {
     if (variable !== void 0) {
       return { translationsDeclaration: variable.parent.parent };
     }
-    const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
+    const func = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      131 /* PackageMethodTranslation */
+      131 /* PackageFunctionTranslation */
     );
-    if (method !== void 0) {
-      return { translationsDeclaration: method.parent.parent };
+    if (func !== void 0) {
+      return { translationsDeclaration: func.parent.parent };
     }
     return void 0;
   }
@@ -5605,14 +5664,14 @@ var SyntaxContextFactory = class {
     }
     const variableOrVariant = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      137 /* TypeVariableOrVariantTranslation */
+      137 /* FieldOrVariantTranslation */
     );
     if (variableOrVariant !== void 0) {
       return { typeTranslation: variableOrVariant.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      132 /* TypeMethodTranslation */
+      132 /* MethodTranslation */
     );
     if (method !== void 0) {
       return { typeTranslation: method.parent.parent };
@@ -5731,22 +5790,22 @@ var NodeSemanticInfoService = class {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* TypeDereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* TypeDereferencedVariableSetterDeclaration */)) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* DereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* DereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
     } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* TypeConstructorDeclaration */) {
-      return this.ofTypeConstructorDeclaration(analyzer, tokenOrKeyword.parent);
+    } 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 === 86 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
     } 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 === 49 /* TypeIndexerParameterClause */) {
-      return this.ofTypeIndexerDeclaration(analyzer, tokenOrKeyword.parent.parent);
+    } 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);
     }
@@ -5787,11 +5846,11 @@ var NodeSemanticInfoService = class {
       case 22 /* PackageAliasTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageAliasTypeDeclaration(parent));
         break;
-      case 27 /* PackageMethodDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageMethodDeclaration(parent));
+      case 27 /* PackageFunctionDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionDeclaration(parent));
         break;
-      case 28 /* PackageMethodTypeDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageMethodTypeDeclaration(parent));
+      case 28 /* PackageFunctionTypeDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionTypeDeclaration(parent));
         break;
       case 33 /* PackageStructuredTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageStructuredTypeDeclaration(parent));
@@ -5805,8 +5864,8 @@ var NodeSemanticInfoService = class {
       case 88 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
-      case 58 /* NestedMethodDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedMethodDeclaration(parent));
+      case 58 /* NestedFunctionDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedFunctionDeclaration(parent));
         break;
       case 59 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
@@ -5834,9 +5893,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 137 /* 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(
@@ -5858,9 +5917,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 131 /* 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(
@@ -5882,9 +5941,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 132 /* 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(
@@ -5926,9 +5985,9 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 133 /* 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(
@@ -5952,20 +6011,20 @@ var NodeSemanticInfoService = class {
       case 8 /* PackageImport */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageImport(parent));
         break;
-      case 9 /* PackagePath */:
+      case 9 /* PackageName */:
         result = void 0;
         break;
-      case 78 /* PropertyAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         result = this.ofProperty(analyzer, parent, options6);
         break;
-      case 52 /* TypeMethodDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeMethodDeclaration(parent));
+      case 52 /* MethodDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofMethodDeclaration(parent));
         break;
       case 53 /* OperatorDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofOperatorDeclaration(parent));
         break;
-      case 54 /* TypeVariableDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeVariableDeclaration(parent));
+      case 54 /* FieldDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofFieldDeclaration(parent));
         break;
       case 143 /* TypeParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeParameterDeclaration(parent));
@@ -5977,9 +6036,9 @@ var NodeSemanticInfoService = class {
       case 37 /* PackageVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedPackageVariableDeclaration(parent));
         break;
-      case 55 /* TypeVariableGetterDeclaration */:
-      case 56 /* 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;
@@ -5991,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
@@ -6011,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
@@ -6033,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": {
@@ -6054,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":
@@ -6074,6 +6133,16 @@ var NodeSemanticInfoService = class {
       case "package-name-segment-access":
         result = this.ofPackageNameSegmentAccess(analyzer, meaning.packageTreeNode, node);
         break;
+      case "mixed-ambiguous-access": {
+        const targets = Query.from(meaning.entities).mapAndFilter((d) => {
+          const target = new EntityReferenceTarget(d.value, 0 /* Get */);
+          return new SimpleWithLocalization(target, d.localization);
+        }).toArray();
+        if (isNonEmptyArray(targets)) {
+          result = new ReferenceNodeSemanticInfo(targets, true);
+        }
+        break;
+      }
       case "unresolved":
         break;
       default:
@@ -6083,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) {
@@ -6143,6 +6212,20 @@ var NodeSemanticInfoService = class {
       } else {
         Debug.never(resolvedQualifier);
       }
+    } else if (qualifierIndex === resolutionResult.resolvedQualifiers.length && resolutionResult.ambiguousDeclarations !== void 0) {
+      const targets = resolutionResult.ambiguousDeclarations.map((d) => {
+        switch (d.value.kind) {
+          case "entity":
+            return new SimpleWithLocalization(new EntityReferenceTarget(d.value.entity, 0 /* Get */), d.localization);
+          case "node":
+            return new SimpleWithLocalization(new PackageNameTreeNodeReferenceTarget(d.value.node), d.localization);
+          default:
+            Debug.never(d.value);
+        }
+      });
+      if (isNonEmptyArray(targets)) {
+        result = new ReferenceNodeSemanticInfo(targets, true);
+      }
     }
     if (result !== void 0 && options6.includeBetterReferenceTargets) {
       result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6157,7 +6240,7 @@ var NodeSemanticInfoService = class {
       const resolvedQualifier = resolutionResult.resolvedQualifiers[qualifierIndex];
       switch (resolvedQualifier.kind) {
         case "type": {
-          if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration") {
+          if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration" || resolutionResult.meaning.kind !== "tag-type") {
             if (resolvedQualifier.suitableTypes.length > 0) {
               const targets = resolvedQualifier.suitableTypes.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
@@ -6166,21 +6249,19 @@ var NodeSemanticInfoService = class {
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
             }
           } else {
-            if (resolutionResult.meaning.kind === "tag-type") {
-              if (resolutionResult.meaning.suitableConstructors.length > 0) {
-                const targets = resolutionResult.meaning.suitableConstructors.map((t) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(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));
-                result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
-              }
+            if (resolutionResult.meaning.suitableConstructors.length > 0) {
+              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 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));
@@ -6215,6 +6296,20 @@ var NodeSemanticInfoService = class {
         default:
           Debug.never(resolvedQualifier);
       }
+    } else if (qualifierIndex === resolutionResult.resolvedQualifiers.length && resolutionResult.ambiguousDeclarations !== void 0) {
+      const targets = resolutionResult.ambiguousDeclarations.map((d) => {
+        switch (d.value.kind) {
+          case "entity":
+            return new SimpleWithLocalization(new EntityReferenceTarget(d.value.entity, 0 /* Get */), d.localization);
+          case "node":
+            return new SimpleWithLocalization(new PackageNameTreeNodeReferenceTarget(d.value.node), d.localization);
+          default:
+            Debug.never(d.value);
+        }
+      });
+      if (isNonEmptyArray(targets)) {
+        result = new ReferenceNodeSemanticInfo(targets, true);
+      }
     }
     if (result !== void 0 && options6.includeBetterReferenceTargets) {
       result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6233,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": {
@@ -6262,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);
@@ -6284,10 +6379,10 @@ var NodeSemanticInfoService = class {
         break;
       }
       case "mixed-ambiguous-access": {
-        const targets = Query.from(meaning.declarations).mapAndFilter((d) => {
+        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":
@@ -6300,15 +6395,13 @@ var NodeSemanticInfoService = class {
               target = new EntityReferenceTarget(d.value.value, 0 /* Get */);
               break;
             case "package-name-segment":
-              if (d.value.value.package !== void 0) {
-                target = new PackageReferenceTarget(d.value.value.package.value);
-              }
+              target = new PackageNameTreeNodeReferenceTarget(d.value.value);
               break;
             default:
               Debug.never(d.value);
           }
-          return target !== void 0 ? new SimpleWithLocalization(target, d.localization) : void 0;
-        }).toArray();
+          return new SimpleWithLocalization(target, d.localization);
+        });
         if (isNonEmptyArray(targets)) {
           result = new ReferenceNodeSemanticInfo(targets, true);
         }
@@ -6323,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) {
@@ -6332,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) {
@@ -6360,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);
     }
   }
@@ -6416,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);
@@ -6439,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);
       }
     }
@@ -6457,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;
@@ -6491,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;
@@ -6511,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);
@@ -6538,8 +6631,8 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 78 /* 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);
@@ -6589,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);
         }
       }
@@ -6621,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,
@@ -6643,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;
@@ -6688,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;
@@ -6703,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 {
@@ -6741,6 +6834,12 @@ var PackageReferenceTarget = class {
     this.kind = "package";
   }
 };
+var PackageNameTreeNodeReferenceTarget = class {
+  constructor(node) {
+    this.node = node;
+    this.kind = "package-name-tree-node";
+  }
+};
 var TypeContextReferenceTarget = class {
   constructor(type, typeContextKind) {
     this.type = type;
@@ -6748,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;
@@ -6826,28 +6925,28 @@ function getEntitySourceLocations(analyzer, entity) {
       const node = definition.node;
       let range;
       switch (node.kind) {
-        case 17 /* AnonymousMethodTypeDeclaration */:
+        case 17 /* AnonymousFunctionTypeDeclaration */:
         case 18 /* AnonymousStructuredTypeDeclaration */:
         case 19 /* AnonymousVariantTypeDeclaration */:
-        case 67 /* MethodBlockLiteral */:
-        case 74 /* MethodLiteral */:
+        case 67 /* FunctionBlockLiteral */:
+        case 74 /* FunctionLiteral */:
           range = node.rangeWithoutTrivia;
           break;
         case 22 /* PackageAliasTypeDeclaration */:
-        case 27 /* PackageMethodDeclaration */:
-        case 28 /* PackageMethodTypeDeclaration */:
+        case 27 /* PackageFunctionDeclaration */:
+        case 28 /* PackageFunctionTypeDeclaration */:
         case 33 /* PackageStructuredTypeDeclaration */:
         case 38 /* PackageVariantTypeDeclaration */:
-        case 58 /* NestedMethodDeclaration */:
-        case 52 /* TypeMethodDeclaration */:
+        case 58 /* NestedFunctionDeclaration */:
+        case 52 /* MethodDeclaration */:
         case 143 /* TypeParameterDeclaration */:
         case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
-        case 45 /* TypeConstructorDeclaration */:
+        case 45 /* ConstructorDeclaration */:
           range = node.creationKeyword.rangeWithoutTrivia;
           break;
-        case 46 /* TypeDestructorDeclaration */:
+        case 46 /* DestructorDeclaration */:
           range = node.destructionKeyword.rangeWithoutTrivia;
           break;
         case 8 /* PackageImport */:
@@ -6863,22 +6962,22 @@ function getEntitySourceLocations(analyzer, entity) {
         case 37 /* PackageVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 55 /* TypeVariableGetterDeclaration */:
+        case 55 /* FieldGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 56 /* TypeVariableSetterDeclaration */:
+        case 56 /* FieldSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 47 /* TypeIndexedGetterDeclaration */:
+        case 47 /* IndexedElementGetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 48 /* TypeIndexedSetterDeclaration */:
+        case 48 /* IndexedElementSetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 50 /* TypeDereferencedVariableGetterDeclaration */:
+        case 50 /* DereferencedVariableGetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
-        case 51 /* TypeDereferencedVariableSetterDeclaration */:
+        case 51 /* DereferencedVariableSetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
         default:
@@ -6990,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":
@@ -7000,9 +7099,13 @@ var DefinitionService = class {
         return getEntitySourceLocations(analyzer, target.parameter.entity);
       case "type-value-parameter":
         return getEntitySourceLocations(analyzer, target.parameter.getEntity());
-      case "package": {
+      case "package":
         return [new SourceLocation(sourceFile, tokenOrKeyword.value.rangeWithoutTrivia)];
-      }
+      case "package-name-tree-node":
+        if (target.node.package !== void 0) {
+          return [new SourceLocation(sourceFile, tokenOrKeyword.value.rangeWithoutTrivia)];
+        }
+        return void 0;
       case "type-context": {
         const entity = target.type.getEntity();
         if (entity !== void 0) {
@@ -7030,12 +7133,14 @@ 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":
         return target.package_;
+      case "package-name-tree-node":
+        return target.node.package?.value;
       case "type-context":
         return target.type.getEntity();
       case "type-indexer":
@@ -7161,7 +7266,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 50 /* TypeDereferencedVariableGetterDeclaration */ || node.kind === 51 /* 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,
@@ -7205,8 +7310,8 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 45 /* 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,
@@ -7241,8 +7346,8 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 47 /* TypeIndexedGetterDeclaration */ || node.kind === 48 /* 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,
@@ -7380,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":
@@ -7399,6 +7504,11 @@ var ReferencesService = class {
             target.localization,
             accessKindToReferenceKind(target.value.accessKind)
           );
+        case "package-name-tree-node":
+          if (target.value.node.package !== void 0) {
+            return new DefinitionInfo(target.value.node.package.value, target.localization, 0 /* Read */);
+          }
+          return void 0;
         default:
           Debug.never(target.value);
       }
@@ -7438,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 */) {
@@ -7477,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 };
@@ -7506,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() };
@@ -7632,7 +7742,7 @@ var EvaluatableExpressionService = class {
     switch (parent.kind) {
       case 88 /* IdentifierExpression */:
         return parent;
-      case 78 /* PropertyAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7655,7 +7765,7 @@ var EvaluatableExpressionService = class {
     switch (expression.kind) {
       case 88 /* IdentifierExpression */:
         return true;
-      case 78 /* PropertyAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7667,9 +7777,9 @@ var EvaluatableExpressionService = class {
         return { nameIdentifier: node.name };
       case 22 /* PackageAliasTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 27 /* PackageMethodDeclaration */:
+      case 27 /* PackageFunctionDeclaration */:
         return { nameIdentifier: node.name };
-      case 28 /* PackageMethodTypeDeclaration */:
+      case 28 /* PackageFunctionTypeDeclaration */:
         return { nameIdentifier: node.name };
       case 33 /* PackageStructuredTypeDeclaration */:
         return { nameIdentifier: node.name };
@@ -7677,15 +7787,15 @@ var EvaluatableExpressionService = class {
         return { nameIdentifier: node.name };
       case 38 /* PackageVariantTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 58 /* NestedMethodDeclaration */:
+      case 58 /* NestedFunctionDeclaration */:
         return { nameIdentifier: node.name };
       case 59 /* LocalVariableDeclaration */:
         return { nameIdentifier: node.name };
       case 144 /* ParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 52 /* TypeMethodDeclaration */:
+      case 52 /* MethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 54 /* TypeVariableDeclaration */:
+      case 54 /* FieldDeclaration */:
         return { nameIdentifier: node.name };
       case 143 /* TypeParameterDeclaration */:
         return { nameIdentifier: node.name };
@@ -7845,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,
@@ -7863,6 +7973,8 @@ var HoverService = class {
       }
       case "package":
         return new Hover(this._displayService.displayPackage(firstTarget.value.package_), range);
+      case "package-name-tree-node":
+        return new Hover(this._displayService.displayPackageNameTreeNode(firstTarget.value.node), range);
       case "type-context": {
         if (firstTarget.value.typeContextKind === "object") {
           const keywordText = this._displayService.displayKeyword(4 /* Object */);
@@ -7887,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);
     }
   }
 };
@@ -7984,10 +8096,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 27 /* PackageMethodDeclaration */: {
+        case 27 /* PackageFunctionDeclaration */: {
           result.push(
             this.createItem(
-              4 /* PackageMethod */,
+              4 /* PackageFunction */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8008,10 +8120,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 54 /* TypeVariableDeclaration */: {
+        case 54 /* FieldDeclaration */: {
           result.push(
             this.createItem(
-              12 /* TypeVariable */,
+              12 /* Field */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8020,10 +8132,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 55 /* TypeVariableGetterDeclaration */: {
+        case 55 /* FieldGetterDeclaration */: {
           result.push(
             this.createItem(
-              13 /* TypeVariableGetter */,
+              13 /* FieldGetter */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8032,10 +8144,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 56 /* TypeVariableSetterDeclaration */: {
+        case 56 /* FieldSetterDeclaration */: {
           result.push(
             this.createItem(
-              14 /* TypeVariableSetter */,
+              14 /* FieldSetter */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8044,10 +8156,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 52 /* TypeMethodDeclaration */: {
+        case 52 /* MethodDeclaration */: {
           result.push(
             this.createItem(
-              15 /* TypeMethod */,
+              15 /* Method */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8056,10 +8168,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 45 /* TypeConstructorDeclaration */: {
+        case 45 /* ConstructorDeclaration */: {
           result.push(
             this.createItem(
-              10 /* TypeConstructor */,
+              10 /* Constructor */,
               void 0,
               node2.rangeWithoutTrivia,
               node2.rangeWithoutTrivia,
@@ -8068,9 +8180,9 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 46 /* TypeDestructorDeclaration */: {
+        case 46 /* DestructorDeclaration */: {
           result.push(this.createItem(
-            11 /* TypeDestructor */,
+            11 /* Destructor */,
             void 0,
             node2.rangeWithoutTrivia,
             node2.rangeWithoutTrivia,
@@ -8078,10 +8190,10 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 47 /* TypeIndexedGetterDeclaration */: {
+        case 47 /* IndexedElementGetterDeclaration */: {
           result.push(
             this.createItem(
-              16 /* TypeIndexedGetter */,
+              16 /* IndexedElementGetter */,
               void 0,
               node2.rangeWithoutTrivia,
               node2.rangeWithoutTrivia,
@@ -8090,10 +8202,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 48 /* TypeIndexedSetterDeclaration */: {
+        case 48 /* IndexedElementSetterDeclaration */: {
           result.push(
             this.createItem(
-              17 /* TypeIndexedSetter */,
+              17 /* IndexedElementSetter */,
               void 0,
               node2.rangeWithoutTrivia,
               node2.rangeWithoutTrivia,
@@ -8102,10 +8214,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 28 /* PackageMethodTypeDeclaration */: {
+        case 28 /* PackageFunctionTypeDeclaration */: {
           result.push(
             this.createItem(
-              6 /* MethodType */,
+              6 /* FunctionType */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8150,10 +8262,10 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 58 /* NestedMethodDeclaration */: {
+        case 58 /* NestedFunctionDeclaration */: {
           result.push(
             this.createItem(
-              19 /* NestedMethod */,
+              19 /* NestedFunction */,
               node2.name.value,
               node2.rangeWithoutTrivia,
               node2.name.rangeWithoutTrivia,
@@ -8182,34 +8294,34 @@ var SourceFileItemsService = class {
       case 0 /* PackageAlias */:
         return name ?? `<${LocalizationHelper.localizeHelperPhrase(4 /* PackageAlias */, this.locale)}>`;
       case 1 /* PackageVariable */:
-      case 12 /* TypeVariable */:
-        return name ?? `<${LocalizationHelper.localizeHelperPhrase(5 /* Variable */, this.locale)}>`;
-      case 4 /* PackageMethod */:
-      case 15 /* TypeMethod */:
-      case 19 /* NestedMethod */:
+      case 12 /* Field */:
+        return name ?? `<${LocalizationHelper.localizeHelperPhrase(6 /* Variable */, this.locale)}>`;
+      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);
@@ -8311,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);
@@ -8325,6 +8437,7 @@ var RenameService = class {
           case "package":
           case "type-context":
           case "type-indexer":
+          case "package-name-tree-node":
             canBeRenamed = false;
             break;
           default:
@@ -8409,7 +8522,7 @@ var SelectionRangeService = class {
       case 34 /* StructuredTypeDeclarationBody */:
       case 39 /* VariantTypeDeclarationBody */:
       case 23 /* AliasTypeDeclarationBody */:
-      case 29 /* MethodTypeDeclarationBody */:
+      case 29 /* FunctionTypeDeclarationBody */:
       case 83 /* TextTemplateSpan */:
       case 82 /* TextTemplateSpanList */:
         return true;
@@ -8453,7 +8566,7 @@ var SemanticTokensService = class {
             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,
@@ -8470,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;
@@ -8487,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()))
                 )
               );
             }
@@ -8505,11 +8618,11 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 78 /* 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,
@@ -8519,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()))
                 )
               );
             }
@@ -8558,23 +8671,27 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 27 /* 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 === 58 /* 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 === 52 /* 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 === 53 /* OperatorDeclaration */) {
@@ -8590,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);
     }
@@ -8652,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 = [
@@ -8802,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();
@@ -8821,10 +8938,10 @@ var TypeParameterSignatureHelpProvider = class {
     const expression = unwrapParenthesizedExpressions(node.expression);
     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();
@@ -8834,20 +8951,20 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 78 /* 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();
@@ -8859,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;
   }
@@ -8885,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 */:
@@ -8915,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 {
@@ -8977,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;
@@ -8987,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);
   }
@@ -9011,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);
@@ -9139,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(
@@ -9181,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;
@@ -11623,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:
@@ -11633,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 */:
@@ -11686,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()) {
@@ -11700,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,
@@ -11746,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();
@@ -11755,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);
     }
@@ -11799,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) {
@@ -11809,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());
@@ -11818,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();
@@ -11845,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();
@@ -11858,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();
@@ -11871,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 */));
@@ -11892,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;
@@ -11951,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) {
@@ -12021,14 +12138,16 @@ 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":
         return this.convertParameterType(type);
       case "union":
         return this.convertUnionType(type);
+      case "intersection":
+        return this.convertIntersectionType(type);
       case "unresolved":
         return this.convertUnresolvedType(type);
       default:
@@ -12055,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) {
@@ -12085,6 +12204,10 @@ var EntityToSyntax = class {
     const constituentTypes = type.originalTypes.map((t) => this.convertType(t));
     return SyntaxFactory.unionTypeSpecifier(constituentTypes);
   }
+  convertIntersectionType(type) {
+    const constituentTypes = type.originalTypes.map((t) => this.convertType(t));
+    return SyntaxFactory.intersectionTypeSpecifier(constituentTypes);
+  }
   convertUnresolvedType(_type) {
     return SyntaxFactory.namedTypeSpecifier("~\u041E\u0431\u044A\u0435\u043A\u0442");
   }
@@ -12249,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();
@@ -12257,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;
@@ -12269,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;
             }
@@ -12338,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());
             }
@@ -12380,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];
@@ -12397,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) {
@@ -12415,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) {
@@ -12537,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();
@@ -12546,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;
@@ -12567,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 */) {
@@ -13161,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 */:
@@ -13169,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;
@@ -13193,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;
@@ -13501,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;
@@ -13531,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;
@@ -13617,7 +13740,7 @@ ${e}`);
   }
   convertSemanticTokenKind(kind) {
     switch (kind) {
-      case 0 /* MethodBlockLiteralParameter */:
+      case 0 /* FunctionBlockLiteralParameter */:
         return "keyword.art";
       case 1 /* SpecialVariable */:
         return "keyword.art";
@@ -13625,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;