@artel/artc 0.6.25217 → 0.6.25219

package/build/api/ApiServices.js

@@ -6,9 +6,9 @@ import {
   AnonymousStructuredTypeDeclaration,
   AnonymousTypeSpecifier,
   AnonymousVariantTypeDeclaration,
+  ArgumentList,
   BaseTypeList,
   Cached,
-  CallArgumentList,
   CancelledError,
   CompilationLoader,
   ConfigurationConverter,
@@ -44,6 +44,7 @@ import {
   LocalizationContext,
   LocalizationHelper,
   Logger,
+  MethodDeclaration_accessedMethod,
   MethodDeclaration_entity,
   MethodDeclaration_substitutedMethod,
   MethodDeclaration_typeMember,
@@ -88,8 +89,6 @@ import {
   Query,
   Range,
   Scanner,
-  SetterParameterClause,
-  SetterParameterDeclaration,
   SinglePackageImportDirective,
   SourceFile,
   SourcePackageDependencyGraph,
@@ -153,7 +152,6 @@ import {
   VariableDeclaration_entity,
   VariableDeclaration_typeMember,
   VariantDeclaration,
-  VariantLookup,
   VariantTypeDeclarationBody,
   WellKnownDeclarationsLoadError,
   __async,
@@ -182,7 +180,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-TXAEJ2GI.js";
+} from "../chunk-IYSH7MAQ.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -267,7 +265,7 @@ function cast(value) {
 }
 
 // source/services/LanguageServer.ts
-import { atomic as atomic6, atomicRun as atomicRun3 } from "reactronic";
+import { atomicBlock as atomicBlock6, atomicRun as atomicRun3 } from "reactronic";
 import * as ls3 from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { URI as URI2 } from "vscode-uri";
@@ -370,9 +368,10 @@ var AddPropertyAssignmentService = class {
       case 74 /* MethodLiteral */:
       case 53 /* OperatorDeclaration */:
         return void 0;
-      case 98 /* RunStatement */:
+      case 97 /* RunStatement */:
         return this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(parent);
-      case 99 /* OnErrorClause */:
+      case 98 /* TryStatement */:
+      case 99 /* CatchClause */:
       case 101 /* FinallyClause */:
       case 106 /* ForStatement */:
       case 107 /* IfStatement */:
@@ -440,7 +439,7 @@ var SyntaxFactory = class {
     }
     const packagePath = this.packagePath(pathSegments);
     const packageImport = new PackageImport(aliasIdentifier, equalsToken, packagePath);
-    const importKeyword = this.keyword(17 /* Import */);
+    const importKeyword = this.keyword(18 /* Import */);
     return new SinglePackageImportDirective(importKeyword, packageImport);
   }
   static packagePath(segments) {
@@ -451,7 +450,7 @@ var SyntaxFactory = class {
   static packageAliasTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const typeKeyword = this.keyword(15 /* Type */);
+    const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(57 /* Equals */);
@@ -484,7 +483,7 @@ var SyntaxFactory = class {
   static packageMethodDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const functionKeyword = this.keyword(11 /* Function */);
+    const functionKeyword = this.keyword(12 /* Function */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const parameterClause = this.parameterClause(parameters);
@@ -503,7 +502,7 @@ var SyntaxFactory = class {
   static packageMethodTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const typeKeyword = this.keyword(15 /* Type */);
+    const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(57 /* Equals */);
@@ -518,7 +517,7 @@ var SyntaxFactory = class {
     );
   }
   static methodTypeDeclarationBody(parameters, returnTypeSpecifier) {
-    const functionKeyword = this.keyword(11 /* Function */);
+    const functionKeyword = this.keyword(12 /* Function */);
     const parameterClause = this.parameterClause(parameters);
     const returnTypeAnnotation = this.createTypeAnnotation(returnTypeSpecifier);
     return new MethodTypeDeclarationBody(void 0, functionKeyword, parameterClause, returnTypeAnnotation);
@@ -526,7 +525,7 @@ var SyntaxFactory = class {
   static packageStructuredTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const typeKeyword = this.keyword(15 /* Type */);
+    const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(57 /* Equals */);
@@ -583,24 +582,17 @@ var SyntaxFactory = class {
       body
     );
   }
-  static packageVariableSetterDeclaration(tags, modifiers, name, setterParameterClause, body) {
+  static packageVariableSetterDeclaration(tags, modifiers, name, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const setKeyword = this.keyword(58 /* Set */);
     const nameIdentifier = this.createIdentifier(name);
-    return new PackageVariableSetterDeclaration(
-      tagList,
-      modifierList,
-      setKeyword,
-      nameIdentifier,
-      setterParameterClause,
-      body
-    );
+    return new PackageVariableSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
   }
   static packageVariantTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const typeKeyword = this.keyword(15 /* Type */);
+    const typeKeyword = this.keyword(16 /* Type */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(57 /* Equals */);
@@ -652,24 +644,17 @@ var SyntaxFactory = class {
       body
     );
   }
-  static typeVariableSetterDeclaration(tags, modifiers, name, setterParameterClause, body) {
+  static typeVariableSetterDeclaration(tags, modifiers, name, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const setKeyword = this.keyword(58 /* Set */);
     const nameIdentifier = this.createIdentifier(name);
-    return new TypeVariableSetterDeclaration(
-      tagList,
-      modifierList,
-      setKeyword,
-      nameIdentifier,
-      setterParameterClause,
-      body
-    );
+    return new TypeVariableSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body);
   }
   static typeMethodDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const functionKeyword = this.keyword(11 /* Function */);
+    const functionKeyword = this.keyword(12 /* Function */);
     const nameIdentifier = this.createIdentifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const parameterClause = this.parameterClause(parameters);
@@ -688,7 +673,7 @@ var SyntaxFactory = class {
   static typeConstructorDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
-    const creationKeyword = this.keyword(28 /* Creation */);
+    const creationKeyword = this.keyword(29 /* Creation */);
     const parameterClause = this.parameterClause(parameters);
     return new TypeConstructorDeclaration(tagList, modifierList, creationKeyword, parameterClause, body);
   }
@@ -714,19 +699,12 @@ var SyntaxFactory = class {
       body
     );
   }
-  static typeIndexedSetterDeclaration(tags, modifiers, parameters, setterParameterClause, body) {
+  static typeIndexedSetterDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags);
     const modifierList = new ModifierList(modifiers);
     const getKeyword = this.keyword(58 /* Set */);
     const parameterClause = this.indexerParameterClause(parameters);
-    return new TypeIndexedSetterDeclaration(
-      tagList,
-      modifierList,
-      getKeyword,
-      parameterClause,
-      setterParameterClause,
-      body
-    );
+    return new TypeIndexedSetterDeclaration(tagList, modifierList, getKeyword, parameterClause, body);
   }
   static typeMemberGroupDeclaration(tags, modifiers, members) {
     const tagList = new TagList(tags);
@@ -821,27 +799,31 @@ var SyntaxFactory = class {
     }
     return new ParameterDeclaration(tagList, nameIdentifier, typeAnnotation, equalsToken, defaultValue);
   }
-  static setterParameterClause(name, typeSpecifier) {
-    const openParenthesisToken = this.token(44 /* OpenParenthesis */);
-    const nameIdentifier = this.createIdentifier(name);
-    const typeAnnotation = this.typeAnnotation(typeSpecifier);
-    const parameterDeclaration = new SetterParameterDeclaration(nameIdentifier, typeAnnotation);
-    const closeParenthesisToken = this.token(21 /* CloseParenthesis */);
-    return new SetterParameterClause(openParenthesisToken, parameterDeclaration, closeParenthesisToken);
-  }
-  static tag(typeSpecifier, callArguments) {
+  static tag(name, typeArguments, args) {
     const hashSignToken = this.token(35 /* HashSign */);
+    const qualifiedNameIdentifiers = typeof name === "string" ? [this.createIdentifier(name)] : name.map((s) => this.createIdentifier(s));
+    const qualifiedName = new QualifiedName(
+      this.createTokenSeparatedElements(qualifiedNameIdentifiers, 26 /* Dot */)
+    );
+    const typeArgumentClause = typeArguments !== void 0 ? this.typeArgumentClause(typeArguments) : void 0;
     let openParenthesisToken;
-    let callArgumentList;
+    let argumentList;
     let closeParenthesisToken;
-    if (callArguments !== void 0) {
+    if (args !== void 0) {
       openParenthesisToken = this.token(44 /* OpenParenthesis */);
-      callArgumentList = new CallArgumentList(
-        this.createTokenSeparatedElements(callArguments, 24 /* Comma */)
+      argumentList = new ArgumentList(
+        this.createTokenSeparatedElements(args, 24 /* Comma */)
       );
       closeParenthesisToken = this.token(21 /* CloseParenthesis */);
     }
-    return new Tag(hashSignToken, typeSpecifier, openParenthesisToken, callArgumentList, closeParenthesisToken);
+    return new Tag(
+      hashSignToken,
+      qualifiedName,
+      typeArgumentClause,
+      openParenthesisToken,
+      argumentList,
+      closeParenthesisToken
+    );
   }
   static modifier(value, level) {
     const valueKeyword = this.keyword(value);
@@ -901,7 +883,7 @@ var SyntaxFactory = class {
     return new PackageVariableTranslation(sourceNameIdentifier, minusGreaterThanToken, translatedNameIdentifier);
   }
   static packageMethodTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
-    const functionKeyword = this.keyword(11 /* Function */);
+    const functionKeyword = this.keyword(12 /* Function */);
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
@@ -921,7 +903,7 @@ var SyntaxFactory = class {
     );
   }
   static typeTranslation(sourceName, sourceTypeParameters, translatedName, translatedTypeParameters, members) {
-    const typeKeyword = this.keyword(15 /* Type */);
+    const typeKeyword = this.keyword(16 /* Type */);
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const minusGreaterThanToken = this.token(42 /* MinusGreaterThan */);
@@ -948,7 +930,7 @@ var SyntaxFactory = class {
     );
   }
   static methodTypeTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
-    const typeKeyword = this.keyword(15 /* Type */);
+    const typeKeyword = this.keyword(16 /* Type */);
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
@@ -978,7 +960,7 @@ var SyntaxFactory = class {
     );
   }
   static typeMethodTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
-    const functionKeyword = this.keyword(11 /* Function */);
+    const functionKeyword = this.keyword(12 /* Function */);
     const sourceNameIdentifier = this.createIdentifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
@@ -998,7 +980,7 @@ var SyntaxFactory = class {
     );
   }
   static constructorTranslation(sourceParameters, translatedParameters) {
-    const creationKeyword = this.keyword(28 /* Creation */);
+    const creationKeyword = this.keyword(29 /* Creation */);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
     const minusGreaterThanToken = this.token(42 /* MinusGreaterThan */);
     const translatedParameterClause = this.translationParameterClause(translatedParameters);
@@ -1179,10 +1161,6 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeKeyword(node.setKeyword);
     this.writeWhitespace();
     this.writeToken(node.name);
-    if (node.setterParameterClause !== void 0) {
-      this.writeWhitespace();
-      this.writeSetterParameterClause(node.setterParameterClause);
-    }
     if (node.body !== void 0) {
       this.writeDeclarationBody(node.body);
     }
@@ -1360,10 +1338,6 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeKeyword(node.setKeyword);
     this.writeWhitespace();
     this.writeToken(node.name);
-    if (node.setterParameterClause !== void 0) {
-      this.writeWhitespace();
-      this.writeSetterParameterClause(node.setterParameterClause);
-    }
     if (node.body !== void 0) {
       this.writeDeclarationBody(node.body);
     }
@@ -1438,10 +1412,6 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeToken(node.parameterClause.openSquareBracketToken);
     this.writeParameterList(node.parameterClause.parameterList);
     this.writeToken(node.parameterClause.closeSquareBracketToken);
-    if (node.setterParameterClause !== void 0) {
-      this.writeWhitespace();
-      this.writeSetterParameterClause(node.setterParameterClause);
-    }
     if (node.body !== void 0) {
       this.writeDeclarationBody(node.body);
     }
@@ -1463,10 +1433,6 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeKeyword(node.setKeyword);
     this.writeWhitespace();
     this.writeToken(node.caretToken);
-    if (node.setterParameterClause !== void 0) {
-      this.writeWhitespace();
-      this.writeSetterParameterClause(node.setterParameterClause);
-    }
     if (node.body !== void 0) {
       this.writeDeclarationBody(node.body);
     }
@@ -1532,12 +1498,6 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeExpression(node.defaultValue);
     }
   }
-  writeSetterParameterClause(node) {
-    this.writeToken(node.openParenthesisToken);
-    this.writeToken(node.parameterDeclaration.name);
-    this.writeTypeAnnotation(node.parameterDeclaration.typeAnnotation, true);
-    this.writeToken(node.closeParenthesisToken);
-  }
   writeDeclarationTags(tagList) {
     if (tagList.tags.length > 0) {
       this.writeWhitespaceSeparatedList(tagList.tags, (t) => this.writeTag(t));
@@ -1546,10 +1506,13 @@ var SyntaxToCode = class _SyntaxToCode {
   }
   writeTag(node) {
     this.writeToken(node.hashSignToken);
-    this.writeNamedTypeSpecifier(node.typeSpecifier);
-    if (node.openParenthesisToken !== void 0 && node.callArgumentList !== void 0 && node.closeParenthesisToken !== void 0) {
+    this.writeQualifiedName(node.name);
+    if (node.typeArgumentClause !== void 0) {
+      this.writeTypeArgumentClause(node.typeArgumentClause);
+    }
+    if (node.openParenthesisToken !== void 0 && node.argumentList !== void 0 && node.closeParenthesisToken !== void 0) {
       this.writeToken(node.openParenthesisToken);
-      this.writeCommaSeparatedList(node.callArgumentList.elements, (n) => this.writeCallArgument(n));
+      this.writeCommaSeparatedList(node.argumentList.elements, (n) => this.writeArgument(n));
       this.writeToken(node.closeParenthesisToken);
     }
   }
@@ -1564,7 +1527,6 @@ var SyntaxToCode = class _SyntaxToCode {
   writeModifier(node) {
     this.writeKeyword(node.value);
     if (node.openParenthesisToken !== void 0 && node.level !== void 0 && node.closeParenthesisToken !== void 0) {
-      this.writeWhitespace();
       this.writeToken(node.openParenthesisToken);
       this.writeKeyword(node.level);
       this.writeToken(node.closeParenthesisToken);
@@ -1690,7 +1652,7 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeToken(node.greaterThanToken);
     }
   }
-  writeCallArgument(node) {
+  writeArgument(node) {
     this.writeNodeDefault(node);
   }
   writeExpression(node) {
@@ -2037,14 +1999,13 @@ var SyntaxToCode = class _SyntaxToCode {
       [139 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
       [140 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
       [141 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [142 /* CallArgument */]: this.prototype.writeCallArgument,
+      [142 /* Argument */]: this.prototype.writeArgument,
       [144 /* Tag */]: this.prototype.writeTag,
       [146 /* Modifier */]: this.prototype.writeModifier,
       [147 /* ParameterClause */]: this.prototype.writeParameterClause,
       [148 /* ParameterList */]: this.prototype.writeParameterList,
-      [149 /* SetterParameterClause */]: this.prototype.writeSetterParameterClause,
-      [151 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [153 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [149 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [151 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
       [17 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
       [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
       [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
@@ -2072,7 +2033,7 @@ var SyntaxToCode = class _SyntaxToCode {
       [65 /* AsExpression */]: this.prototype.writeNodeDefault,
       [66 /* BinaryExpression */]: this.prototype.writeNodeDefault,
       [67 /* MethodBlockLiteral */]: this.prototype.writeNodeDefault,
-      [68 /* CallArgumentList */]: this.prototype.writeNodeDefault,
+      [68 /* ArgumentList */]: this.prototype.writeNodeDefault,
       [69 /* CallExpression */]: this.prototype.writeNodeDefault,
       [70 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
       [71 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
@@ -2100,9 +2061,9 @@ var SyntaxToCode = class _SyntaxToCode {
       [94 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
       [95 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
       [96 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [97 /* RunStatementClauseList */]: this.prototype.writeNodeDefault,
-      [98 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [99 /* OnErrorClause */]: this.prototype.writeNodeDefault,
+      [97 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [98 /* TryStatement */]: this.prototype.writeNodeDefault,
+      [99 /* CatchClause */]: this.prototype.writeNodeDefault,
       [100 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
       [101 /* FinallyClause */]: this.prototype.writeNodeDefault,
       [102 /* EmptyStatement */]: this.prototype.writeNodeDefault,
@@ -2143,10 +2104,9 @@ var SyntaxToCode = class _SyntaxToCode {
       [138 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
       [143 /* TagList */]: this.prototype.writeNodeDefault,
       [145 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [150 /* SetterParameterDeclaration */]: this.prototype.writeNodeDefault,
-      [152 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [154 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [155 /* TypeAnnotation */]: this.prototype.writeNodeDefault
+      [150 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [152 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [153 /* TypeAnnotation */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2157,14 +2117,14 @@ var SyntaxToCode = class _SyntaxToCode {
   }
 };
 var modifierSortOrder = {
-  [34 /* Hidden */]: 0,
-  [39 /* Static */]: 1,
-  [16 /* Basic */]: 2,
-  [36 /* Redefinable */]: 3,
-  [35 /* Abstract */]: 4,
-  [37 /* Redefined */]: 5,
-  [38 /* Async */]: 6,
-  [33 /* Const */]: 7
+  [35 /* Hidden */]: 0,
+  [40 /* Static */]: 1,
+  [17 /* Basic */]: 2,
+  [37 /* Redefinable */]: 3,
+  [36 /* Abstract */]: 4,
+  [38 /* Redefined */]: 5,
+  [39 /* Async */]: 6,
+  [34 /* Const */]: 7
 };
 
 // source/services/TreeUtils.ts
@@ -2520,17 +2480,6 @@ var TranslationsGenerator = class _TranslationsGenerator {
         result.push(indexer);
       }
     }
-    if (entity.kind === 2 /* VariantType */) {
-      const translatedVariants = new Set(this._translationPackage.getVariants(entity)?.get().map((m) => m.value));
-      for (const variant of entity.getVariants().get()) {
-        if (variant.isHidden() !== void 0) {
-          continue;
-        }
-        if (!translatedVariants.has(variant)) {
-          result.push(variant);
-        }
-      }
-    }
     return result;
   }
   detectIndentationForPackageMemberTranslations(translationsDeclaration) {
@@ -2586,14 +2535,14 @@ var TranslationsGenerator = class _TranslationsGenerator {
   }
   collectNotTranslatedPackageMembers() {
     const result = new Array();
-    const translatedPackageMembers = new Set(this._translationPackage.getMembers().getNamedMembers().map((m) => m.value.getEntity()));
+    const translatedPackageMembers = new Set(this._translationPackage.getMembers().getNamedMembers().map((m) => m.value));
     const membersOfTargetPackage = this._translationPackage.getTranslatedPackage().getMembers();
     for (const member of membersOfTargetPackage.getNamedMembers()) {
       if (member.isHidden() !== void 0) {
         continue;
       }
-      if (!translatedPackageMembers.has(member.getEntity())) {
-        result.push(member.getEntity());
+      if (!translatedPackageMembers.has(member)) {
+        result.push(member);
       }
     }
     return result;
@@ -2602,15 +2551,15 @@ var TranslationsGenerator = class _TranslationsGenerator {
     switch (entity.kind) {
       case 0 /* Variable */:
         return this.createPackageVariableTranslation(entity);
-      case 5 /* Method */:
+      case 1 /* Method */:
         return this.createPackageMethodTranslation(entity);
-      case 2 /* VariantType */:
-      case 12 /* StructuredType */:
-      case 14 /* AliasType */:
-        return this.createPackageTypeWithMembersTranslation(entity);
-      case 11 /* MethodType */:
-        return this.createPackageMethodTypeTranslation(entity);
-      case 17 /* TypeExtension */:
+      case 2 /* Type */:
+        if (entity.typeEntityKind === 0 /* Method */) {
+          return this.createPackageMethodTypeTranslation(entity);
+        } else {
+          return this.createPackageTypeWithMembersTranslation(entity);
+        }
+      case 11 /* TypeExtension */:
         return void 0;
       default:
         Debug.never(entity);
@@ -2642,17 +2591,15 @@ var TranslationsGenerator = class _TranslationsGenerator {
     switch (entity.kind) {
       case 0 /* Variable */:
         return this.createTypeVariableTranslation(entity);
-      case 5 /* Method */:
+      case 1 /* Method */:
         return this.createTypeMethodTranslation(entity);
-      case 9 /* Constructor */:
+      case 7 /* Constructor */:
         return this.createConstructorTranslation(entity);
-      case 7 /* Indexer */:
+      case 5 /* Indexer */:
         return this.createIndexerTranslation(entity);
-      case 1 /* Variant */:
-        return this.createVariantTranslation(entity);
-      case 8 /* DereferenceOperator */:
-      case 10 /* Destructor */:
-      case 15 /* Operator */:
+      case 6 /* DereferenceOperator */:
+      case 8 /* Destructor */:
+      case 9 /* Operator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -2676,10 +2623,6 @@ var TranslationsGenerator = class _TranslationsGenerator {
     const parameters = entity.getValueParameters().map((p) => this.getNameText(p.getName()));
     return SyntaxFactory.indexerTranslation(parameters, parameters);
   }
-  createVariantTranslation(entity) {
-    const name = this.getNameText(entity.getName());
-    return SyntaxFactory.typeVariableOrVariantTranslation(name, name);
-  }
   getNameText(name) {
     const flags = name.flags & ~16 /* ConflictResolvingParameterName */;
     return name.getPreferredUnescapedOriginal(flags);
@@ -2799,17 +2742,17 @@ function isGenerateMissingTranslationsCodeActionData(value) {
 // source/services/signature-help/SignatureWithValueParameters.ts
 var ValueArgumentFactory = class _ValueArgumentFactory {
   static createValueArgumentsOfCallExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromList(node.callArgumentList);
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
   }
   static createValueArgumentsOfAutotypeCallExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromList(node.callArgumentList);
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
   }
   static createValueArgumentsOfIndexedAccessExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentsList);
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
   }
   static createValueArgumentsOfTag(node) {
-    if (node.callArgumentList !== void 0) {
-      return _ValueArgumentFactory.createValueArgumentsFromList(node.callArgumentList);
+    if (node.argumentList !== void 0) {
+      return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
     }
     return [];
   }
@@ -2866,16 +2809,7 @@ var SignatureForNode = class _SignatureForNode {
       if (info.suitableMethods.length === 1) {
         suitableSignatureIndex = info.candidates.indexOf(info.suitableMethods[0]);
       }
-      const signatures = info.candidates.map((c) => {
-        switch (c.value.kind) {
-          case "entity":
-            return new MethodEntitySignature({ value: c.value.value, localization: c.localization });
-          case "type-member":
-            return new TypeMethodSignature({ value: c.value.value, localization: c.localization });
-          case "substituted-method":
-            return new SubstitutedMethodSignature({ value: c.value.value, localization: c.localization });
-        }
-      });
+      const signatures = info.candidates.map((c) => new AccessedMethodSignature(c));
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
     if (meaning.kind === "object-method-call") {
@@ -2914,8 +2848,8 @@ var SignatureForNode = class _SignatureForNode {
     }
   }
   static getSignaturesForTag(analyzer, node) {
-    const meaning = analyzer.getTagMeaning(node);
-    if (meaning.kind === "resolved") {
+    const meaning = analyzer.resolveTag(node).meaning;
+    if (meaning.kind === "tag-type") {
       let suitableSignatureIndex;
       if (meaning.suitableConstructors.length === 1) {
         suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableConstructors[0]);
@@ -2923,6 +2857,14 @@ var SignatureForNode = class _SignatureForNode {
       const signatures = meaning.candidates.map((c) => new ConstructorSignature(c));
       return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
     }
+    if (meaning.kind === "tag-method") {
+      let suitableSignatureIndex;
+      if (meaning.suitableMethods.length === 1) {
+        suitableSignatureIndex = meaning.candidates.indexOf(meaning.suitableMethods[0]);
+      }
+      const signatures = meaning.candidates.map((c) => new AccessedMethodSignature(c));
+      return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
+    }
     if (meaning.kind === "unresolved") {
       return void 0;
     }
@@ -3031,47 +2973,9 @@ var MatchedSignature = class {
     this.matchResult = matchResult;
   }
 };
-var MethodEntitySignature = class {
+var AccessedMethodSignature = class {
   constructor(method) {
-    this.kind = "method-entity";
-    this._valueParameters = new Cached();
-    this.method = method;
-  }
-  getValueParameters() {
-    return this._valueParameters.getOrInsertWith(() => {
-      const localizedSignature = EntityLocalizationHelper.getLocalizedMethodSignature(
-        this.method.value,
-        this.method.localization
-      );
-      return Query.from(this.method.value.getValueParameters()).zip(
-        localizedSignature.getValueParameterNames(),
-        (p, n) => new UniversalValueParameter(n.value, p.getType(), p, n.localization)
-      ).toArray();
-    });
-  }
-};
-var TypeMethodSignature = class {
-  constructor(method) {
-    this.kind = "type-method";
-    this._valueParameters = new Cached();
-    this.method = method;
-  }
-  getValueParameters() {
-    return this._valueParameters.getOrInsertWith(() => {
-      const localizedSignature = EntityLocalizationHelper.getLocalizedMethodSignature(
-        this.method.value.getEntity(),
-        this.method.localization
-      );
-      return Query.from(this.method.value.getValueParameters()).zip(
-        localizedSignature.getValueParameterNames(),
-        (p, n) => new UniversalValueParameter(n.value, p.getType(), p.getEntity(), n.localization)
-      ).toArray();
-    });
-  }
-};
-var SubstitutedMethodSignature = class {
-  constructor(method) {
-    this.kind = "substituted-method";
+    this.kind = "accessed-method";
     this._valueParameters = new Cached();
     this.method = method;
   }
@@ -3263,7 +3167,7 @@ var CompletionService = class {
       return new OperatorNameCompletionContext(syntaxContext.isInQuotedIdentifier);
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 5 /* SinglePackageImportDirective */) {
+    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 5 /* SinglePackageImportDirective */) {
       return new PackageImportCompletionContext([], void 0);
     }
     if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 8 /* PackageImport */) {
@@ -3360,6 +3264,42 @@ var CompletionService = class {
       }
       return { kind: "none" };
     }
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 132 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 144 /* Tag */) {
+      const tag = tokenOrKeyword.parent.parent;
+      const resolutionResult = this._analyzer.resolveTag(tag);
+      const segmentIndex = Math.floor(
+        tag.name.parts.indexOf(tokenOrKeyword.value) / 2
+      );
+      if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
+        const resolvedQualifier = resolutionResult.resolvedQualifiers[segmentIndex];
+        if (resolvedQualifier.kind === "package-name-segment") {
+          let lookup;
+          if (resolvedQualifier.packageTreeNode.package !== void 0) {
+            lookup = new PackageMemberLookup(
+              resolvedQualifier.packageTreeNode.package.value,
+              semanticContext.getLocalizationContext()
+            );
+          }
+          const hidingMatcher = semanticContext.getHidingMatcher();
+          const typeSearchLocation = new PackageNameSegmentTypeSearchLocation(
+            resolvedQualifier.packageTreeNode,
+            lookup,
+            hidingMatcher
+          );
+          return new TagCompletionContext(typeSearchLocation);
+        }
+        if (resolvedQualifier.kind === "package-alias") {
+          const package_ = resolvedQualifier.packageAlias.getPackage();
+          if (package_ !== void 0) {
+            const lookup = new PackageMemberLookup(package_, semanticContext.getLocalizationContext());
+            const hidingMatcher = semanticContext.getHidingMatcher();
+            const typeSearchLocation = new PackageAliasTypeSearchLocation(lookup, hidingMatcher);
+            return new TagCompletionContext(typeSearchLocation);
+          }
+        }
+      }
+      return { kind: "none" };
+    }
     if (syntaxContext.isUnqualifiedTypeContext !== void 0) {
       let completionInIsOrAsExpressionInfo;
       if (tokenOrKeyword.parent.kind === 73 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
@@ -3371,6 +3311,11 @@ var CompletionService = class {
       const typeSearchLocation = new ScopeTypeSearchLocation(lookup);
       return new TypeCompletionContext(typeSearchLocation, completionInIsOrAsExpressionInfo);
     }
+    if (syntaxContext.isUnqualifiedTagNameCompletionContext) {
+      const lookup = semanticContext.getScopeLookup();
+      const typeSearchLocation = new ScopeTypeSearchLocation(lookup);
+      return new TagCompletionContext(typeSearchLocation);
+    }
     if (syntaxContext.isExpressionContext !== void 0) {
       const lookup = semanticContext.getScopeLookup();
       const { targetTypes, targetSignaturesParameters } = this.getTargetTypesAndTargetSignaturesParameters(syntaxContext.isExpressionContext.expressionRole, semanticContext);
@@ -3412,17 +3357,17 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 131 /* PackageImportTranslation */) {
+    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 131 /* PackageImportTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(15 /* Type */) && (tokenOrKeyword.parent.kind === 136 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 130 /* MethodTypeTranslation */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 136 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 130 /* MethodTypeTranslation */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 128 /* PackageMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 128 /* PackageMethodTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3469,12 +3414,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 129 /* TypeMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 129 /* TypeMethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 123 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(29 /* Creation */) && tokenOrKeyword.parent.kind === 123 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3612,6 +3557,9 @@ var CompletionService = class {
       case "type":
         result = this.getTypeCompletionItemInfos(completionContext);
         break;
+      case "tag":
+        result = this.getTagCompletionItemInfos(completionContext);
+        break;
       case "expression":
         result = this.getExpressionCompletionItemInfos(completionContext);
         break;
@@ -3644,29 +3592,29 @@ var CompletionService = class {
     }
     const kinds = /* @__PURE__ */ new Set();
     if (syntaxContext.isPackageMemberDeclarationListContext) {
-      kinds.add(17 /* Import */).add(7 /* Run */).add(28 /* Creation */).add(11 /* Function */).add(16 /* Basic */).add(15 /* Type */).add(57 /* Get */).add(58 /* Set */).add(54 /* Translations */);
+      kinds.add(18 /* Import */).add(7 /* Run */).add(29 /* Creation */).add(12 /* Function */).add(17 /* Basic */).add(16 /* Type */).add(57 /* Get */).add(58 /* Set */).add(54 /* Translations */);
     }
     if (syntaxContext.isPackageMemberDeclarationListContext || syntaxContext.isTypeMemberDeclarationListContext) {
-      kinds.add(34 /* Hidden */).add(39 /* Static */).add(36 /* Redefinable */).add(35 /* Abstract */).add(37 /* Redefined */).add(38 /* Async */).add(33 /* Const */);
+      kinds.add(35 /* Hidden */).add(40 /* Static */).add(37 /* Redefinable */).add(36 /* Abstract */).add(38 /* Redefined */).add(39 /* Async */).add(34 /* Const */);
     }
     if (syntaxContext.isTypeMemberDeclarationListContext) {
-      kinds.add(28 /* Creation */).add(11 /* Function */).add(46 /* Destruction */).add(57 /* Get */).add(58 /* Set */);
+      kinds.add(29 /* Creation */).add(12 /* Function */).add(46 /* Destruction */).add(57 /* Get */).add(58 /* Set */);
     }
     if (syntaxContext.isStatementContext) {
-      kinds.add(7 /* Run */).add(32 /* For */).add(23 /* While */).add(24 /* Loop */).add(14 /* Return */).add(18 /* Error */).add(26 /* Yield */).add(44 /* Await */).add(30 /* BreakLoop */).add(31 /* ContinueLoop */).add(12 /* If */).add(42 /* Switch */).add(1 /* Let */).add(33 /* Const */).add(45 /* Dispose */).add(11 /* Function */).add(38 /* Async */);
+      kinds.add(7 /* Run */).add(33 /* For */).add(24 /* While */).add(25 /* Loop */).add(15 /* Return */).add(19 /* Error */).add(27 /* Yield */).add(31 /* BreakLoop */).add(32 /* ContinueLoop */).add(13 /* If */).add(43 /* Switch */).add(1 /* Let */).add(34 /* Const */).add(45 /* Dispose */).add(12 /* Function */).add(39 /* Async */);
     }
     if (this.isFromKeywordContext(positionDescription)) {
-      kinds.add(8 /* From */);
+      kinds.add(9 /* From */);
     }
     if (syntaxContext.isExpressionContext !== void 0) {
-      kinds.add(41 /* Not */).add(51 /* Yes */).add(52 /* No */).add(56 /* None */).add(38 /* Async */).add(11 /* Function */).add(53 /* Reference */).add(2 /* Autotype */);
+      kinds.add(42 /* Not */).add(51 /* Yes */).add(52 /* No */).add(56 /* None */).add(39 /* Async */).add(12 /* Function */).add(53 /* Reference */).add(2 /* Autotype */);
       if (positionDescription.kind === "after-token-or-keyword") {
         const container = semanticContext.getContainingTypeOrTypeExtension();
         if (container !== void 0) {
           kinds.add(4 /* Object */);
           if (container.kind === "type") {
             const typeEntity = container.value;
-            if (typeEntity?.kind === 12 /* StructuredType */ && typeEntity.getBaseObjectType() !== void 0 || typeEntity?.kind === 2 /* VariantType */ || typeEntity?.kind === 14 /* AliasType */) {
+            if (typeEntity?.typeEntityKind === 1 /* Structured */ && typeEntity.getBaseObjectType() !== void 0 || typeEntity?.typeEntityKind === 3 /* Variant */ || typeEntity?.typeEntityKind === 4 /* Alias */) {
               kinds.add(55 /* Base */);
             }
           }
@@ -3674,31 +3622,31 @@ var CompletionService = class {
       }
     }
     if (this.isTypeKindCompletionContext(positionDescription)) {
-      kinds.add(4 /* Object */).add(5 /* PlainObject */).add(3 /* Aspect */).add(6 /* Variant */).add(11 /* Function */).add(38 /* Async */);
+      kinds.add(4 /* Object */).add(5 /* PlainObject */).add(3 /* Aspect */).add(6 /* Variant */).add(12 /* Function */).add(39 /* Async */);
     }
     if (this.isCaseKeywordContext(positionDescription, syntaxContext)) {
-      kinds.add(43 /* Case */);
+      kinds.add(44 /* Case */);
     }
     if (this.isRunStatementAccessorListContext(positionDescription)) {
-      kinds.add(29 /* OnError */).add(19 /* Finally */);
+      kinds.add(30 /* Catch */).add(20 /* Finally */);
     }
     if (this.isElseOrElseIfKeywordContext(positionDescription)) {
-      kinds.add(9 /* Else */).add(10 /* ElseIf */);
+      kinds.add(10 /* Else */).add(11 /* ElseIf */);
     }
     if (syntaxContext.precedingExpression !== void 0) {
-      kinds.add(40 /* As */).add(13 /* Is */).add(20 /* And */).add(21 /* Or */).add(22 /* Xor */).add(27 /* When */);
+      kinds.add(41 /* As */).add(14 /* Is */).add(21 /* And */).add(22 /* Or */).add(23 /* Xor */).add(28 /* When */);
     }
     if (this.isModifierLevelContext(positionDescription)) {
       kinds.add(50 /* InType */).add(47 /* InHierarchy */).add(48 /* InFile */).add(49 /* InPackage */);
     }
     if (this.isRepeatWhileKeywordContext(positionDescription)) {
-      kinds.add(25 /* RepeatWhile */);
+      kinds.add(26 /* RepeatWhile */);
     }
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
-      kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(11 /* Function */).add(38 /* Async */);
+      kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(12 /* Function */).add(39 /* Async */);
     }
-    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(38 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 74 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* MethodTypeDeclarationBody */)) {
-      kinds.add(11 /* Function */);
+    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(39 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 74 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* MethodTypeDeclarationBody */)) {
+      kinds.add(12 /* Function */);
     }
     return Query.from(kinds.values()).map(
       (k) => LocalizationHelper.localizeKeyword(k, this._locale, this._dialect).map((v) => new KeywordCompletionItemInfo(this.completionItemInfoContext, k, v))
@@ -3730,7 +3678,7 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 98 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 99 /* OnErrorClause */ || tokenOrKeyword.parent.parent.kind === 101 /* FinallyClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 97 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 99 /* CatchClause */ || tokenOrKeyword.parent.parent.kind === 101 /* FinallyClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(57 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3756,22 +3704,7 @@ var CompletionService = class {
     return false;
   }
   getExpressionCompletionItemInfos(ctx) {
-    let query = Query.empty();
-    if (ctx.targetTypes !== void 0) {
-      const variantType = this.getTargetVariantType(ctx.targetTypes);
-      if (variantType !== void 0) {
-        const variantLookup = new VariantLookup(variantType.getEntity(), ctx.localizationContext);
-        query = query.chain(variantLookup.get().map(
-          (v) => new VariantCompletionItemInfo(
-            this.completionItemInfoContext,
-            v.value,
-            v.name,
-            v.requiresExplicitOriginalName
-          )
-        ).toArray());
-      }
-    }
-    query = query.chain(this.getScopeCompletionItemInfos(ctx.lookup));
+    let query = this.getScopeCompletionItemInfos(ctx.lookup);
     if (ctx.targetSignaturesValueParameters !== void 0) {
       query = query.chain(this.getCompletionItemInfosForTargetSignaturesValueParameters(ctx.targetSignaturesValueParameters));
     }
@@ -3793,19 +3726,6 @@ var CompletionService = class {
       }
     }
   }
-  getTargetVariantType(targetTypes) {
-    let variantType;
-    for (const targetType of targetTypes) {
-      const type = this._analyzer.getUnambiguousTargetVariantType(targetType);
-      if (variantType === void 0) {
-        variantType = type;
-      } else {
-        variantType = void 0;
-        break;
-      }
-    }
-    return variantType;
-  }
   getCompletionItemInfosForTargetSignaturesValueParameters(valueParameters) {
     return valueParameters.map((p) => new TargetSignatureValueParameterCompletionItemInfo(this.completionItemInfoContext, p));
   }
@@ -3847,19 +3767,7 @@ var CompletionService = class {
           }
         }
         case "type": {
-          return this.createTypeEntityCompletionItemInfo(
-            d.value.value.getEntity(),
-            d.name,
-            d.requiresExplicitOriginalName
-          );
-        }
-        case "variant": {
-          return new VariantCompletionItemInfo(
-            this.completionItemInfoContext,
-            d.value.value,
-            d.name,
-            d.requiresExplicitOriginalName
-          );
+          return this.createTypeEntityCompletionItemInfo(d.value.value, d.name, d.requiresExplicitOriginalName);
         }
         case "package-alias":
           return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value.value);
@@ -3913,34 +3821,34 @@ var CompletionService = class {
     }
   }
   getTypeCompletionItemInfosFromPackage(searchLocation) {
-    return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).mapAndFilter((m) => {
-      if (m.value.kind === "type") {
+    return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+      if (m.value.kind === 2 /* Type */) {
         return new NamedTypeCompletionItemInfo(
           this.completionItemInfoContext,
-          m.value.getEntity(),
+          m.value,
           m.name,
           m.requiresExplicitOriginalName
         );
       }
       return void 0;
-    }).toArray();
+    }).filter((i) => i !== void 0);
   }
   getTypeCompletionItemInfosFromPackageNameSegment(searchLocation) {
     let query = Query.from(searchLocation.packageTreeNode.getChildren()).map((c) => new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, c.name));
     if (searchLocation.packageMemberLookup !== void 0) {
       const lookup = searchLocation.packageMemberLookup;
       query = query.chain(
-        lookup.getNamedMembers(searchLocation.hidingMatcher).mapAndFilter((m) => {
-          if (m.value.kind === "type") {
+        lookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+          if (m.value.kind === 2 /* Type */) {
             return new NamedTypeCompletionItemInfo(
               this.completionItemInfoContext,
-              m.value.getEntity(),
+              m.value,
               m.name,
               m.requiresExplicitOriginalName
             );
           }
           return void 0;
-        })
+        }).filter((i) => i !== void 0)
       );
     }
     return query.toArray();
@@ -3951,7 +3859,7 @@ var CompletionService = class {
         case "type": {
           return new NamedTypeCompletionItemInfo(
             this.completionItemInfoContext,
-            d.value.value.getEntity(),
+            d.value.value,
             d.name,
             d.requiresExplicitOriginalName
           );
@@ -3965,8 +3873,98 @@ var CompletionService = class {
       }
     });
   }
+  getTagCompletionItemInfos(ctx) {
+    let result;
+    switch (ctx.searchLocation.kind) {
+      case "scope":
+        result = this.getTagCompletionItemInfosFromScope(ctx.searchLocation);
+        break;
+      case "package-alias":
+        result = this.getTagCompletionItemInfosFromPackage(ctx.searchLocation);
+        break;
+      case "package-name-segment":
+        result = this.getTagCompletionItemInfosFromPackageNameSegment(ctx.searchLocation);
+        break;
+    }
+    return result;
+  }
+  getTagCompletionItemInfosFromPackage(searchLocation) {
+    return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+      if (m.value.kind === 2 /* Type */) {
+        return new NamedTypeCompletionItemInfo(
+          this.completionItemInfoContext,
+          m.value,
+          m.name,
+          m.requiresExplicitOriginalName
+        );
+      } else if (m.value.kind === 1 /* Method */) {
+        return new MethodEntityCompletionItemInfo(
+          this.completionItemInfoContext,
+          m.value,
+          m.name,
+          m.requiresExplicitOriginalName
+        );
+      }
+      return void 0;
+    }).filter((i) => i !== void 0);
+  }
+  getTagCompletionItemInfosFromPackageNameSegment(searchLocation) {
+    let query = Query.from(searchLocation.packageTreeNode.getChildren()).map((c) => new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, c.name));
+    if (searchLocation.packageMemberLookup !== void 0) {
+      const lookup = searchLocation.packageMemberLookup;
+      query = query.chain(
+        lookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+          if (m.value.kind === 2 /* Type */) {
+            return new NamedTypeCompletionItemInfo(
+              this.completionItemInfoContext,
+              m.value,
+              m.name,
+              m.requiresExplicitOriginalName
+            );
+          } else if (m.value.kind === 1 /* Method */) {
+            return new MethodEntityCompletionItemInfo(
+              this.completionItemInfoContext,
+              m.value,
+              m.name,
+              m.requiresExplicitOriginalName
+            );
+          }
+          return void 0;
+        }).filter((i) => i !== void 0)
+      );
+    }
+    return query.toArray();
+  }
+  getTagCompletionItemInfosFromScope(searchLocation) {
+    return searchLocation.lookup.getNamedDeclarations().map((d) => {
+      switch (d.value.kind) {
+        case "type":
+          return new NamedTypeCompletionItemInfo(
+            this.completionItemInfoContext,
+            d.value.value,
+            d.name,
+            d.requiresExplicitOriginalName
+          );
+        case "method":
+          return new MethodEntityCompletionItemInfo(
+            this.completionItemInfoContext,
+            d.value.value.getEntity(),
+            d.name,
+            d.requiresExplicitOriginalName
+          );
+        case "package-name-segment":
+          return new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, d.name.value);
+        case "package-alias":
+          return new PackageAliasEntityCompletionItemInfo(this.completionItemInfoContext, d.value.value);
+        case "variable":
+          return void 0;
+        default:
+          Debug.never(d.value);
+      }
+    }).filter((i) => i !== void 0);
+  }
   getPackageAliasMemberCompletionItemInfos(ctx) {
-    return ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m.value, m.name, m.requiresExplicitOriginalName)).toArray();
+    return ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m.value, m.name, m.requiresExplicitOriginalName));
   }
   getPackageNameSegmentCompletionItemInfos(ctx) {
     let query = Query.from(ctx.packageTreeNode.getChildren()).map((c) => new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, c.name));
@@ -3980,22 +3978,22 @@ var CompletionService = class {
   }
   packageMemberToCompletionItemInfo(member, name, isNameExplicitlyOriginal) {
     switch (member.kind) {
-      case "variable":
+      case 0 /* Variable */:
         return new VariableEntityCompletionItemInfo(
           this.completionItemInfoContext,
-          member.value,
+          member,
           name,
           isNameExplicitlyOriginal
         );
-      case "method":
+      case 1 /* Method */:
         return new MethodEntityCompletionItemInfo(
           this.completionItemInfoContext,
-          member.value,
+          member,
           name,
           isNameExplicitlyOriginal
         );
-      case "type":
-        return this.createTypeEntityCompletionItemInfo(member.value.getEntity(), name, isNameExplicitlyOriginal);
+      case 2 /* Type */:
+        return this.createTypeEntityCompletionItemInfo(member, name, isNameExplicitlyOriginal);
       default:
         Debug.never(member);
     }
@@ -4012,37 +4010,27 @@ var CompletionService = class {
   }
   getTypeMemberCompletionItemInfos(ctx) {
     const type = this._analyzer.excludeNoneFromType(ctx.type);
-    if (type.kind === "variant" && ctx.isStaticAccess) {
-      const variantLookup = new VariantLookup(type.getEntity(), ctx.localizationContext);
-      return variantLookup.get().map((v) => new VariantCompletionItemInfo(
-        this.completionItemInfoContext,
-        v.value,
-        v.name,
-        v.requiresExplicitOriginalName
-      )).toArray();
-    } else {
-      const memberLookup = new TypeMemberLookup(this._analyzer, type, ctx.localizationContext);
-      return memberLookup.getNamedMembers(ctx.hidingMatcher, ctx.typeExtensionsLookup).filter((m) => m.value.isStatic() === ctx.isStaticAccess).map((m) => {
-        switch (m.value.kind) {
-          case "method":
-            return new TypeMethodCompletionItemInfo(
-              this.completionItemInfoContext,
-              m.value,
-              m.name,
-              m.requiresExplicitOriginalName
-            );
-          case "variable":
-            return new TypeVariableCompletionItemInfo(
-              this.completionItemInfoContext,
-              m.value,
-              m.name,
-              m.requiresExplicitOriginalName
-            );
-          default:
-            Debug.never(m.value);
-        }
-      }).chain(Query.from(memberLookup.getOperators(ctx.hidingMatcher, ctx.typeExtensionsLookup)).filter((m) => m.value.isStatic() === ctx.isStaticAccess).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization))).toArray();
-    }
+    const memberLookup = new TypeMemberLookup(this._analyzer, type, ctx.localizationContext);
+    return memberLookup.getNamedMembers(ctx.hidingMatcher, ctx.typeExtensionsLookup).filter((m) => m.value.isStatic() === ctx.isStaticAccess).map((m) => {
+      switch (m.value.kind) {
+        case "method":
+          return new TypeMethodCompletionItemInfo(
+            this.completionItemInfoContext,
+            m.value,
+            m.name,
+            m.requiresExplicitOriginalName
+          );
+        case "variable":
+          return new TypeVariableCompletionItemInfo(
+            this.completionItemInfoContext,
+            m.value,
+            m.name,
+            m.requiresExplicitOriginalName
+          );
+        default:
+          Debug.never(m.value);
+      }
+    }).concat(memberLookup.getOperators(ctx.hidingMatcher, ctx.typeExtensionsLookup).filter((m) => m.value.isStatic() === ctx.isStaticAccess).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization)));
   }
   getPackageImportCompletionItemInfos(ctx) {
     const result = this._analyzer.packageImports.getPackagesAvailableForImport(this._sourceFile.package).map((p) => p.getImportName()).filter((n) => {
@@ -4076,10 +4064,10 @@ 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 === "method") {
+        if (d.value.kind === 1 /* Method */) {
           return new AliasesSourceMethodCompletionItemInfo(
             this.completionItemInfoContext,
-            d.value.value,
+            d.value,
             !ctx.hasPrecedingKeyword,
             displayService_
           );
@@ -4088,10 +4076,10 @@ var CompletionService = class {
       });
     } else if (ctx.translationKind === 3 /* Type */) {
       result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).mapAndFilter((d) => {
-        if (d.value.kind === "type") {
+        if (d.value.kind === 2 /* Type */) {
           return new AliasesSourcePackageTypeCompletionItemInfo(
             this.completionItemInfoContext,
-            d.value.value.getEntity(),
+            d.value,
             !ctx.hasPrecedingKeyword,
             displayService_
           );
@@ -4110,31 +4098,31 @@ var CompletionService = class {
         }
       }
       result = Query.from(packageNameItems ?? []).chain(
-        Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).mapAndFilter((d) => {
-          if (d.value.kind === "variable") {
-            return new AliasesSourceVariableCompletionItemInfo(
-              this.completionItemInfoContext,
-              d.value.value,
-              displayService_
-            );
-          }
-          if (d.value.kind === "method") {
-            return new AliasesSourceMethodCompletionItemInfo(
-              this.completionItemInfoContext,
-              d.value.value,
-              !ctx.hasPrecedingKeyword,
-              displayService_
-            );
-          }
-          if (d.value.kind === "type") {
-            return new AliasesSourcePackageTypeCompletionItemInfo(
-              this.completionItemInfoContext,
-              d.value.value.getEntity(),
-              !ctx.hasPrecedingKeyword,
-              displayService_
-            );
+        Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).map((d) => {
+          switch (d.value.kind) {
+            case 0 /* Variable */:
+              return new AliasesSourceVariableCompletionItemInfo(
+                this.completionItemInfoContext,
+                d.value,
+                displayService_
+              );
+            case 1 /* Method */:
+              return new AliasesSourceMethodCompletionItemInfo(
+                this.completionItemInfoContext,
+                d.value,
+                !ctx.hasPrecedingKeyword,
+                displayService_
+              );
+            case 2 /* Type */:
+              return new AliasesSourcePackageTypeCompletionItemInfo(
+                this.completionItemInfoContext,
+                d.value,
+                !ctx.hasPrecedingKeyword,
+                displayService_
+              );
+            default:
+              Debug.never(d.value);
           }
-          return void 0;
         })
       );
     } else {
@@ -4142,9 +4130,9 @@ var CompletionService = class {
     }
     if (!ctx.hasPrecedingKeyword) {
       const keywords = [
-        17 /* Import */,
-        15 /* Type */,
-        11 /* Function */
+        18 /* Import */,
+        16 /* Type */,
+        12 /* Function */
       ];
       result = result.chain(
         Query.from(keywords).map(
@@ -4160,7 +4148,7 @@ 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 === 5 /* Method */) {
+          if (m.kind === 1 /* Method */) {
             return new AliasesSourceMethodCompletionItemInfo(
               this.completionItemInfoContext,
               m,
@@ -4185,7 +4173,7 @@ var CompletionService = class {
         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 === 5 /* Method */) {
+          } else if (m.kind === 1 /* Method */) {
             return new AliasesSourceMethodCompletionItemInfo(
               this.completionItemInfoContext,
               m,
@@ -4214,8 +4202,8 @@ var CompletionService = class {
     }
     if (!ctx.hasPrecedingKeyword) {
       const keywords = [
-        11 /* Function */,
-        28 /* Creation */
+        12 /* Function */,
+        29 /* Creation */
       ];
       result = result.chain(
         Query.from(keywords).map(
@@ -4429,6 +4417,12 @@ var TypeCompletionContext = class {
     this.kind = "type";
   }
 };
+var TagCompletionContext = class {
+  constructor(searchLocation) {
+    this.searchLocation = searchLocation;
+    this.kind = "tag";
+  }
+};
 var OperatorNameCompletionContext = class {
   constructor(nameToken) {
     this.nameToken = nameToken;
@@ -4572,7 +4566,7 @@ var TypeVariableCompletionItemInfo = class {
     return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
   }
   getCompletionItemKind() {
-    return 2 /* TypeVariable */;
+    return this.variable.isVariant() ? 12 /* Variant */ : 2 /* TypeVariable */;
   }
   getDetails() {
     return this.ctx.displayService.displayVariableDeclaration(
@@ -4646,33 +4640,6 @@ var OperatorCompletionItemInfo = class {
     return void 0;
   }
 };
-var VariantCompletionItemInfo = class {
-  constructor(ctx, variant, name, isNameExplicitlyOriginal) {
-    this.ctx = ctx;
-    this.variant = variant;
-    this.name = name;
-    this.isNameExplicitlyOriginal = isNameExplicitlyOriginal;
-    this.kind = "variant";
-  }
-  getLabel() {
-    return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
-  }
-  getCompletionItemKind() {
-    return 12 /* Variant */;
-  }
-  getDetails() {
-    return this.ctx.displayService.displayVariantEntity(this.variant, this.name.localization);
-  }
-  getInsertText() {
-    return void 0;
-  }
-  getSortText() {
-    return void 0;
-  }
-  getEditRange() {
-    return void 0;
-  }
-};
 var VariableEntityCompletionItemInfo = class {
   constructor(ctx, entity, name, isNameExplicitlyOriginal) {
     this.ctx = ctx;
@@ -4689,7 +4656,7 @@ var VariableEntityCompletionItemInfo = class {
       case "package":
         return 7 /* PackageVariable */;
       case "type":
-        return 2 /* TypeVariable */;
+        return this.entity.isVariant() ? 12 /* Variant */ : 2 /* TypeVariable */;
       case "parameter":
         return 10 /* ParameterVariable */;
       case "local":
@@ -4765,14 +4732,14 @@ var NamedTypeCompletionItemInfo = class {
     return `${this.prefix}${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
   }
   getCompletionItemKind() {
-    switch (this.entity.kind) {
-      case 2 /* VariantType */:
+    switch (this.entity.typeEntityKind) {
+      case 3 /* Variant */:
         return 16 /* VariantType */;
-      case 6 /* TypeParameter */:
+      case 2 /* Parameter */:
         return 17 /* TypeParameter */;
-      case 11 /* MethodType */:
+      case 0 /* Method */:
         return 18 /* MethodType */;
-      case 12 /* StructuredType */:
+      case 1 /* Structured */:
         if (this.entity.isRefObject()) {
           return 13 /* RefObjectType */;
         } else if (this.entity.isPlainObject()) {
@@ -4782,7 +4749,7 @@ var NamedTypeCompletionItemInfo = class {
         } else {
           return 20 /* InvalidType */;
         }
-      case 14 /* AliasType */:
+      case 4 /* Alias */:
         return 19 /* AliasType */;
       default:
         Debug.never(this.entity);
@@ -4981,12 +4948,12 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
     return this.ctx.getInsertTextForName(this.typeEntity.getName());
   }
   getCompletionItemKind() {
-    switch (this.typeEntity.kind) {
-      case 2 /* VariantType */:
+    switch (this.typeEntity.typeEntityKind) {
+      case 3 /* Variant */:
         return 16 /* VariantType */;
-      case 11 /* MethodType */:
+      case 0 /* Method */:
         return 18 /* MethodType */;
-      case 12 /* StructuredType */: {
+      case 1 /* Structured */: {
         if (this.typeEntity.isRefObject()) {
           return 13 /* RefObjectType */;
         } else if (this.typeEntity.isPlainObject()) {
@@ -4996,7 +4963,7 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
         }
         return 20 /* InvalidType */;
       }
-      case 14 /* AliasType */:
+      case 4 /* Alias */:
         return 19 /* AliasType */;
     }
   }
@@ -5015,20 +4982,20 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
   }
   getDisplayServiceTypeDeclaration() {
     const localization = Localization.Original.ofEntity(this.typeEntity);
-    switch (this.typeEntity.kind) {
-      case 2 /* VariantType */:
+    switch (this.typeEntity.typeEntityKind) {
+      case 3 /* Variant */:
         return new TypeDeclaration_variant(
           new TypeDeclarationVariant_entity(this.typeEntity, localization)
         );
-      case 11 /* MethodType */:
+      case 0 /* Method */:
         return new TypeDeclaration_method(
           new TypeDeclarationMethod_entity(this.typeEntity, localization)
         );
-      case 12 /* StructuredType */:
+      case 1 /* Structured */:
         return new TypeDeclaration_structured(
           new TypeDeclarationStructured_entity(this.typeEntity, localization)
         );
-      case 14 /* AliasType */:
+      case 4 /* Alias */:
         return new TypeDeclaration_alias(
           new TypeDeclarationAlias_entity(this.typeEntity, localization)
         );
@@ -5091,7 +5058,7 @@ var AliasesSourceTypeConstructorCompletionItemInfo = class {
         Localization.Original.ofEntity(this.constructor_)
       );
       const displayParts = this.displayService.getConstructorDeclarationDisplayParts(constructorDeclaration);
-      const creationKeyword = this.displayService.displayKeyword(28 /* Creation */);
+      const creationKeyword = this.displayService.displayKeyword(29 /* Creation */);
       return creationKeyword + displayParts.valueParametersStart + displayParts.valueParameters.map((p) => p.toString()).join(displayParts.valueParameterSeparator) + displayParts.valueParametersEnd;
     });
   }
@@ -5105,7 +5072,7 @@ var AliasesSourceTypeConstructorCompletionItemInfo = class {
     return this.label;
   }
   getInsertText() {
-    const creationKeyword = this.includeOnCreateKeyword ? this.displayService.displayKeyword(28 /* Creation */) : "";
+    const creationKeyword = this.includeOnCreateKeyword ? this.displayService.displayKeyword(29 /* Creation */) : "";
     const parameters = this.constructor_.getValueParameters().map((p) => this.ctx.getInsertTextForName(p.getName(), true)).join(", ");
     return `${creationKeyword}(${parameters})`;
   }
@@ -5143,7 +5110,7 @@ var OperatorNameCompletionItemInfo = class {
   }
 };
 var SyntaxContext = class {
-  constructor(isInComment, isInStringOrChar, isInQuotedIdentifier, isPackageMemberDeclarationListContext, isTypeMemberDeclarationListContext, isStatementContext, isExpressionContext, precedingExpression, isUnqualifiedTypeContext, isTopLevelTranslationListContext, isTypeMemberTranslationListContext) {
+  constructor(isInComment, isInStringOrChar, isInQuotedIdentifier, isPackageMemberDeclarationListContext, isTypeMemberDeclarationListContext, isStatementContext, isExpressionContext, precedingExpression, isUnqualifiedTypeContext, isUnqualifiedTagNameCompletionContext, isTopLevelTranslationListContext, isTypeMemberTranslationListContext) {
     this.isInComment = isInComment;
     this.isInStringOrChar = isInStringOrChar;
     this.isInQuotedIdentifier = isInQuotedIdentifier;
@@ -5153,11 +5120,12 @@ var SyntaxContext = class {
     this.isExpressionContext = isExpressionContext;
     this.precedingExpression = precedingExpression;
     this.isUnqualifiedTypeContext = isUnqualifiedTypeContext;
+    this.isUnqualifiedTagNameCompletionContext = isUnqualifiedTagNameCompletionContext;
     this.isTopLevelTranslationListContext = isTopLevelTranslationListContext;
     this.isTypeMemberTranslationListContext = isTypeMemberTranslationListContext;
   }
 };
-var ExpressionRole_callArgument = class {
+var ExpressionRole_argument = class {
   constructor(argumentList, index) {
     this.argumentList = argumentList;
     this.index = index;
@@ -5218,6 +5186,7 @@ var SyntaxContextFactory = class {
     if (positionDescription.kind === "after-token-or-keyword") {
       isUnqualifiedTypeContext = this.isUnqualifiedTypeContext(positionDescription.tokenOrKeyword);
     }
+    const isUnqualifiedTagNameCompletionContext = positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(35 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 144 /* Tag */;
     let isTopLevelTranslationListContext;
     if (positionDescription.kind === "after-token-or-keyword") {
       isTopLevelTranslationListContext = this.isTopLevelTranslationListContext(positionDescription.tokenOrKeyword);
@@ -5236,6 +5205,7 @@ var SyntaxContextFactory = class {
       isExpressionContext,
       precedingExpression,
       isUnqualifiedTypeContext,
+      isUnqualifiedTagNameCompletionContext,
       isTopLevelTranslationListContext,
       isTypeMemberTranslationListContext
     );
@@ -5262,7 +5232,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 142 /* CallArgument */) {
+      if (tokenOrKeyword.parent.kind === 142 /* Argument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5315,23 +5285,23 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
       if (tokenOrKeyword.parent.kind === 69 /* CallExpression */) {
-        const expressionRole = new ExpressionRole_callArgument(tokenOrKeyword.parent.callArgumentList, 0);
+        const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
       if (tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
-        const expressionRole = new ExpressionRole_callArgument(tokenOrKeyword.parent.callArgumentList, 0);
+        const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
       if (tokenOrKeyword.parent.kind === 144 /* Tag */) {
-        const callArgumentList = tokenOrKeyword.parent.callArgumentList;
-        if (callArgumentList !== void 0) {
-          const expressionRole = new ExpressionRole_callArgument(callArgumentList, 0);
+        const argumentList = tokenOrKeyword.parent.argumentList;
+        if (argumentList !== void 0) {
+          const expressionRole = new ExpressionRole_argument(argumentList, 0);
           return { isExpressionContext: { expressionRole }, isStatementContext: false };
         }
       }
     }
     if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
-      const expressionRole = new ExpressionRole_callArgument(tokenOrKeyword.parent.argumentsList, 0);
+      const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 61 /* ArrayLiteral */) {
@@ -5339,7 +5309,7 @@ var SyntaxContextFactory = class {
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(24 /* Comma */)) {
-      if (tokenOrKeyword.parent.kind === 68 /* CallArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 68 /* ArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5350,7 +5320,7 @@ var SyntaxContextFactory = class {
             }
           }
         }
-        const expressionRole = new ExpressionRole_callArgument(argumentList, index);
+        const expressionRole = new ExpressionRole_argument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
       if (tokenOrKeyword.parent.kind === 117 /* MatchExpressionList */) {
@@ -5362,43 +5332,43 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(43 /* Case */) && tokenOrKeyword.parent.kind === 118 /* SwitchStatementCaseClause */) {
+    if (tokenOrKeyword.isKeyword(44 /* Case */) && tokenOrKeyword.parent.kind === 118 /* SwitchStatementCaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Return */) && tokenOrKeyword.parent.kind === 114 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 114 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(42 /* Switch */) && tokenOrKeyword.parent.kind === 116 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(43 /* Switch */) && tokenOrKeyword.parent.kind === 116 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(12 /* If */) && tokenOrKeyword.parent.kind === 107 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 107 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(10 /* ElseIf */) && tokenOrKeyword.parent.kind === 109 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 109 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(8 /* From */) && tokenOrKeyword.parent.kind === 106 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 106 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(23 /* While */) && tokenOrKeyword.parent.kind === 119 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(24 /* While */) && tokenOrKeyword.parent.kind === 119 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 113 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(26 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 113 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(26 /* Yield */) && tokenOrKeyword.parent.kind === 120 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(27 /* Yield */) && tokenOrKeyword.parent.kind === 120 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* When */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isKeyword(28 /* When */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5503,20 +5473,20 @@ var SyntaxContextFactory = class {
     return result;
   }
   static isUnqualifiedTypeContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 155 /* TypeAnnotation */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 153 /* TypeAnnotation */) {
       return { allowsAnonymousTypes: true };
     }
     if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(15 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 151 /* TypeArgumentClause */) {
+    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 149 /* TypeArgumentClause */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 152 /* TypeArgumentList */)) {
-      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 152 /* TypeArgumentList */ };
+    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 150 /* TypeArgumentList */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 150 /* TypeArgumentList */ };
     }
     if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 144 /* Tag */) {
       return { allowsAnonymousTypes: false };
@@ -5527,10 +5497,10 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 22 /* PackageAliasTypeDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(13 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
+    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isKeyword(40 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+    if (tokenOrKeyword.isKeyword(41 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
       return { allowsAnonymousTypes: true };
     }
     if (tokenOrKeyword.isToken(17 /* Bar */) && tokenOrKeyword.parent.kind === 12 /* UnionTypeSpecifierTypeList */) {
@@ -5731,7 +5701,7 @@ var NodeSemanticInfoService = class {
       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(28 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* TypeConstructorDeclaration */) {
+    } else if (tokenOrKeyword.isKeyword(29 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* TypeConstructorDeclaration */) {
       return this.ofTypeConstructorDeclaration(analyzer, tokenOrKeyword.parent);
     } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 90 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
@@ -5758,7 +5728,7 @@ var NodeSemanticInfoService = class {
         break;
       case 121 /* TranslationParameterList */:
         break;
-      case 142 /* CallArgument */: {
+      case 142 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new SimpleWithLocalization(
@@ -5975,9 +5945,6 @@ var NodeSemanticInfoService = class {
       case 56 /* TypeVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedTypeVariableDeclaration(parent));
         break;
-      case 150 /* SetterParameterDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofSetterParameterDeclaration(parent));
-        break;
       case 3 /* Keyword */:
         break;
       default:
@@ -5990,18 +5957,10 @@ var NodeSemanticInfoService = class {
     let result;
     const meaning = analyzer.resolvePropertyAccessExpression(node).meaning;
     switch (meaning.kind) {
-      case "variant-access": {
-        const target = new SimpleWithLocalization(
-          new EntityReferenceTarget(meaning.variant.value, 0 /* Get */),
-          meaning.variant.localization
-        );
-        result = new ReferenceNodeSemanticInfo([target], false);
-        break;
-      }
       case "instance-variable-access": {
         const target = new SimpleWithLocalization(new TypeVariableReferenceTarget(
           meaning.variable.value,
-          meaning.access.kind
+          meaning.accessKind
         ), meaning.variable.localization);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
@@ -6009,7 +5968,7 @@ var NodeSemanticInfoService = class {
       case "static-variable-access": {
         const target = new SimpleWithLocalization(new TypeVariableReferenceTarget(
           meaning.variable.value,
-          meaning.access.kind
+          meaning.accessKind
         ), meaning.variable.localization);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
@@ -6017,7 +5976,7 @@ var NodeSemanticInfoService = class {
       case "package-variable-access": {
         const target = new SimpleWithLocalization(new EntityReferenceTarget(
           meaning.variable.value,
-          meaning.access.kind
+          meaning.accessKind
         ), meaning.variable.localization);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
@@ -6058,7 +6017,7 @@ var NodeSemanticInfoService = class {
           );
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         } else {
-          result = this.ofMaybeConstructorCall(analyzer, meaning.suitableTypes, node, options6);
+          result = this.ofMaybeConstructorCallExpression(analyzer, meaning.suitableTypes, node, options6);
         }
         break;
       case "package-name-segment-access":
@@ -6084,19 +6043,70 @@ var NodeSemanticInfoService = class {
   }
   static ofQualifiedNameQualifier(analyzer, node, qualifier, options6) {
     switch (node.parent.kind) {
-      case 10 /* NamedTypeSpecifier */: {
-        let result;
-        const resolutionResult = analyzer.resolveNamedTypeSpecifier(node.parent);
-        const qualifierIndex = node.qualifiers.toArray().indexOf(qualifier);
-        if (qualifierIndex >= 0 && qualifierIndex < resolutionResult.resolvedQualifiers.length) {
-          const resolvedQualifier = resolutionResult.resolvedQualifiers[qualifierIndex];
-          if (resolvedQualifier.kind === "package-alias") {
-            const target = new SimpleWithLocalization(
-              new EntityReferenceTarget(resolvedQualifier.packageAlias, 0 /* Get */),
-              new Localization.Original(resolvedQualifier.packageAlias.getContainingPackage().getLocale())
-            );
-            result = new ReferenceNodeSemanticInfo([target], false);
-          } else if (resolvedQualifier.kind === "type") {
+      case 10 /* NamedTypeSpecifier */:
+        return this.ofNamedTypeSpecifierNameQualifier(analyzer, node.parent, qualifier, options6);
+      case 144 /* Tag */:
+        return this.ofTagNameQualifier(analyzer, node.parent, qualifier, options6);
+      case 42 /* ExtendedTypeClause */:
+      case 131 /* PackageImportTranslation */:
+        return void 0;
+      default:
+        Debug.never(node.parent);
+    }
+  }
+  static ofNamedTypeSpecifierNameQualifier(analyzer, node, qualifier, options6) {
+    let result;
+    const resolutionResult = analyzer.resolveNamedTypeSpecifier(node);
+    const qualifierIndex = node.qualifiedName.qualifiers.toArray().indexOf(qualifier);
+    if (qualifierIndex >= 0 && qualifierIndex < resolutionResult.resolvedQualifiers.length) {
+      const resolvedQualifier = resolutionResult.resolvedQualifiers[qualifierIndex];
+      if (resolvedQualifier.kind === "package-alias") {
+        const target = new SimpleWithLocalization(
+          new EntityReferenceTarget(resolvedQualifier.packageAlias, 0 /* Get */),
+          new Localization.Original(resolvedQualifier.packageAlias.getContainingPackage().getLocale())
+        );
+        result = new ReferenceNodeSemanticInfo([target], false);
+      } else if (resolvedQualifier.kind === "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);
+        } else if (resolvedQualifier.candidates.length > 0) {
+          const targets = resolvedQualifier.candidates.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
+          result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
+        }
+      } else if (resolvedQualifier.kind === "package-name-segment") {
+        let currentIndex = qualifierIndex;
+        while (currentIndex + 1 < resolutionResult.resolvedQualifiers.length && resolutionResult.resolvedQualifiers[currentIndex + 1].kind === "package-name-segment") {
+          currentIndex++;
+        }
+        const qualifier2 = resolutionResult.resolvedQualifiers[currentIndex];
+        if (qualifier2.kind === "package-name-segment" && qualifier2.packageTreeNode.package !== void 0) {
+          const target = new SimpleWithLocalization(
+            new PackageReferenceTarget(qualifier2.packageTreeNode.package.value),
+            new Localization.Original(qualifier2.packageTreeNode.package.value.getLocale())
+          );
+          result = new ReferenceNodeSemanticInfo([target], false);
+        } else {
+          result = void 0;
+        }
+      } else {
+        Debug.never(resolvedQualifier);
+      }
+    }
+    if (result !== void 0 && options6.includeBetterReferenceTargets) {
+      result = this.getBetterReferenceTargetsOrPreserve(result);
+    }
+    return result;
+  }
+  static ofTagNameQualifier(analyzer, node, qualifier, options6) {
+    let result;
+    const resolutionResult = analyzer.resolveTag(node);
+    const qualifierIndex = node.name.qualifiers.toArray().indexOf(qualifier);
+    if (qualifierIndex >= 0 && qualifierIndex < resolutionResult.resolvedQualifiers.length) {
+      const resolvedQualifier = resolutionResult.resolvedQualifiers[qualifierIndex];
+      switch (resolvedQualifier.kind) {
+        case "type": {
+          if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration") {
             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);
@@ -6104,55 +6114,72 @@ var NodeSemanticInfoService = class {
               const targets = resolvedQualifier.candidates.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
             }
-          } else if (resolvedQualifier.kind === "package-name-segment") {
-            let currentIndex = qualifierIndex;
-            while (currentIndex + 1 < resolutionResult.resolvedQualifiers.length && resolutionResult.resolvedQualifiers[currentIndex + 1].kind === "package-name-segment") {
-              currentIndex++;
-            }
-            const qualifier2 = resolutionResult.resolvedQualifiers[currentIndex];
-            if (qualifier2.kind === "package-name-segment" && qualifier2.packageTreeNode.package !== void 0) {
-              const target = new SimpleWithLocalization(
-                new PackageReferenceTarget(qualifier2.packageTreeNode.package.value),
-                new Localization.Original(qualifier2.packageTreeNode.package.value.getLocale())
-              );
-              result = new ReferenceNodeSemanticInfo([target], false);
-            } else {
-              result = void 0;
+          } 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);
+              }
             }
+          }
+          break;
+        }
+        case "method":
+          if (resolvedQualifier.suitableMethods.length > 0) {
+            const targets = resolvedQualifier.suitableMethods.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));
+            result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
+          }
+          break;
+        case "package-name-segment": {
+          let currentIndex = qualifierIndex;
+          while (currentIndex + 1 < resolutionResult.resolvedQualifiers.length && resolutionResult.resolvedQualifiers[currentIndex + 1].kind === "package-name-segment") {
+            currentIndex++;
+          }
+          const qualifier2 = resolutionResult.resolvedQualifiers[currentIndex];
+          if (qualifier2.kind === "package-name-segment" && qualifier2.packageTreeNode.package !== void 0) {
+            const target = new SimpleWithLocalization(
+              new PackageReferenceTarget(qualifier2.packageTreeNode.package.value),
+              new Localization.Original(qualifier2.packageTreeNode.package.value.getLocale())
+            );
+            result = new ReferenceNodeSemanticInfo([target], false);
           } else {
-            Debug.never(resolvedQualifier);
+            result = void 0;
           }
+          break;
         }
-        if (result !== void 0 && options6.includeBetterReferenceTargets) {
-          result = this.getBetterReferenceTargetsOrPreserve(result);
+        case "package-alias": {
+          const target = new SimpleWithLocalization(
+            new EntityReferenceTarget(resolvedQualifier.packageAlias, 0 /* Get */),
+            new Localization.Original(resolvedQualifier.packageAlias.getContainingPackage().getLocale())
+          );
+          result = new ReferenceNodeSemanticInfo([target], false);
+          break;
         }
-        return result;
+        default:
+          Debug.never(resolvedQualifier);
       }
-      case 42 /* ExtendedTypeClause */:
-      case 131 /* PackageImportTranslation */:
-        return void 0;
-      default:
-        Debug.never(node.parent);
     }
+    if (result !== void 0 && options6.includeBetterReferenceTargets) {
+      result = this.getBetterReferenceTargetsOrPreserve(result);
+    }
+    return result;
   }
   static ofIdentifierExpression(analyzer, node, options6) {
     let result;
     const meaning = analyzer.resolveIdentifierExpression(node).meaning;
     switch (meaning.kind) {
-      case "variant-access": {
-        const target = new SimpleWithLocalization(
-          new EntityReferenceTarget(meaning.variant.value, 0 /* Get */),
-          meaning.variant.localization
-        );
-        result = new ReferenceNodeSemanticInfo([target], false);
-        break;
-      }
       case "type-access":
         if (meaning.suitableTypes.length === 0 && meaning.candidates.length > 0) {
           const targets = meaning.candidates.map((c) => new SimpleWithLocalization(new EntityReferenceTarget(c.value, 0 /* Get */), c.localization));
           result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
         } else {
-          result = this.ofMaybeConstructorCall(analyzer, meaning.suitableTypes, node, options6);
+          result = this.ofMaybeConstructorCallExpression(analyzer, meaning.suitableTypes, node, options6);
         }
         break;
       case "method-access":
@@ -6174,13 +6201,13 @@ var NodeSemanticInfoService = class {
         const variable = meaning.variable;
         if (variable.value.kind === "entity") {
           const target = new SimpleWithLocalization(
-            new EntityReferenceTarget(variable.value.value, meaning.access.kind),
+            new EntityReferenceTarget(variable.value.value, meaning.accessKind),
             variable.localization
           );
           result = new ReferenceNodeSemanticInfo([target], false);
         } else if (variable.value.kind === "type-member") {
           const target = new SimpleWithLocalization(
-            new TypeVariableReferenceTarget(variable.value.value, meaning.access.kind),
+            new TypeVariableReferenceTarget(variable.value.value, meaning.accessKind),
             variable.localization
           );
           result = new ReferenceNodeSemanticInfo([target], false);
@@ -6206,11 +6233,14 @@ var NodeSemanticInfoService = class {
           let target;
           switch (d.value.kind) {
             case "method":
+              target = new EntityReferenceTarget(d.value.value.getEntity(), 0 /* Get */);
+              break;
             case "variable":
-            case "type":
               target = new EntityReferenceTarget(d.value.value.getEntity(), 0 /* Get */);
               break;
-            case "variant":
+            case "type":
+              target = new EntityReferenceTarget(d.value.value, 0 /* Get */);
+              break;
             case "package-alias":
               target = new EntityReferenceTarget(d.value.value, 0 /* Get */);
               break;
@@ -6338,7 +6368,7 @@ var NodeSemanticInfoService = class {
     const meaning = analyzer.getDereferenceExpressionMeaning(node);
     if (meaning.kind === "resolved") {
       const target = new SimpleWithLocalization(
-        new TypeDereferenceOperatorReferenceTarget(meaning.operator.value, meaning.access.kind),
+        new TypeDereferenceOperatorReferenceTarget(meaning.operator.value, meaning.accessKind),
         meaning.operator.localization
       );
       let result = new ReferenceNodeSemanticInfo([target], false);
@@ -6474,7 +6504,7 @@ var NodeSemanticInfoService = class {
       false
     );
   }
-  static ofMaybeConstructorCall(analyzer, types, typeAccessExpression, options6) {
+  static ofMaybeConstructorCallExpression(analyzer, types, typeAccessExpression, options6) {
     if (types.length === 0) {
       return void 0;
     }
@@ -6501,17 +6531,14 @@ var NodeSemanticInfoService = class {
     }
     if (parentCallExpression !== void 0) {
       const meaning = analyzer.getCallExpressionMeaning(parentCallExpression);
-      if (meaning.kind === "constructor-call" && meaning.suitableConstructors.length > 0) {
-        const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(c.value), c.localization));
-        let betterTargets;
-        if (options6.includeBetterReferenceTargets && typeEntities.length > 0 && meaning.suitableConstructors.some((c) => c.value.getEntity().getDefinition().kind !== 0 /* Source */)) {
-          betterTargets = typeEntities.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
-        }
-        return new ReferenceNodeSemanticInfo(
-          createNonEmptyArray(targets),
-          targets.length > 1,
-          createNonEmptyArray(betterTargets)
-        );
+      if (meaning.kind === "constructor-call") {
+        if (meaning.suitableConstructors.length > 0) {
+          const targets = meaning.suitableConstructors.map((c) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(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));
+          return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
+        }
       }
     }
     if (typeEntities.length > 0) {
@@ -6560,7 +6587,7 @@ var NodeSemanticInfoService = class {
             );
           }
         }
-      } else if (currentTarget.value.kind === "entity" && currentTarget.value.entity.kind === 5 /* Method */) {
+      } else if (currentTarget.value.kind === "entity" && currentTarget.value.entity.kind === 1 /* Method */) {
       }
       if (betterTarget !== void 0) {
         result = betterTarget;
@@ -6696,7 +6723,7 @@ var SimpleWithLocalization = class {
 
 // source/services/Utils.ts
 function getEntitySourceLocations(analyzer, entity) {
-  if (entity.kind === 16 /* Package */) {
+  if (entity.kind === 12 /* Package */) {
     return void 0;
   }
   let result;
@@ -6717,7 +6744,7 @@ function getEntitySourceLocations(analyzer, entity) {
         Debug.never(definition.value);
       }
     }
-  } else if (entity.kind === 7 /* Indexer */) {
+  } else if (entity.kind === 5 /* Indexer */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       result = definition.nodes.map((d) => {
@@ -6726,7 +6753,7 @@ function getEntitySourceLocations(analyzer, entity) {
         return new SourceLocation(sourceFile, range);
       });
     }
-  } else if (entity.kind === 8 /* DereferenceOperator */) {
+  } else if (entity.kind === 6 /* DereferenceOperator */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       result = definition.nodes.map((d) => {
@@ -6756,7 +6783,6 @@ function getEntitySourceLocations(analyzer, entity) {
         case 58 /* NestedMethodDeclaration */:
         case 52 /* TypeMethodDeclaration */:
         case 140 /* TypeParameterDeclaration */:
-        case 139 /* VariantDeclaration */:
         case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
@@ -7003,7 +7029,7 @@ var ReferencesService = class {
       const result = [];
       const restrictions = this.getReferenceRestrictions(definition, options6);
       let semanticInfoOptions;
-      if (definition.value.kind === 9 /* Constructor */) {
+      if (definition.value.kind === 7 /* Constructor */) {
         semanticInfoOptions = {
           preferredTargetOfExplicitConstructorCall: "constructor-declaration",
           includeBetterReferenceTargets: true
@@ -7323,7 +7349,7 @@ var ReferencesService = class {
   getReferenceRestrictions(definition, _options) {
     const result = new ReferenceRestrictions();
     let namedDefinitionInfo;
-    if (definition.value.kind === 9 /* Constructor */) {
+    if (definition.value.kind === 7 /* Constructor */) {
       const type = definition.value.getContainer().getContextualType();
       if (type !== void 0) {
         namedDefinitionInfo = this.isEntityWithRegularName(type);
@@ -7334,11 +7360,11 @@ var ReferencesService = class {
     if (namedDefinitionInfo !== void 0) {
       result.canBeIdentifier = true;
     }
-    if (definition.value.kind === 9 /* Constructor */) {
+    if (definition.value.kind === 7 /* Constructor */) {
       result.canBeAutotypeCall = true;
       result.canBeConstructorDeclaration = true;
     }
-    if (definition.value.kind === 15 /* Operator */) {
+    if (definition.value.kind === 9 /* Operator */) {
       const operatorKind = definition.value.getOperatorKind();
       if (isUnaryOperator(operatorKind)) {
         result.canBePrefixUnaryOperator = true;
@@ -7347,17 +7373,17 @@ var ReferencesService = class {
         result.canBeAssignmentStatementOperator = true;
       }
     }
-    if (definition.value.kind === 8 /* DereferenceOperator */) {
+    if (definition.value.kind === 6 /* DereferenceOperator */) {
       result.canBeDereferenceOperator = true;
     }
-    if (isTypeEntity(definition.value) || definition.value.kind === 9 /* Constructor */) {
+    if (isTypeEntity(definition.value) || definition.value.kind === 7 /* Constructor */) {
       result.canBeObjectExpression = true;
       result.canBeBaseExpression = true;
     }
-    if (definition.value.kind === 5 /* Method */) {
+    if (definition.value.kind === 1 /* Method */) {
       result.canBeBaseExpression = true;
     }
-    if (definition.value.kind === 7 /* Indexer */) {
+    if (definition.value.kind === 5 /* Indexer */) {
       result.canBeIndexer = true;
     }
     return result;
@@ -7391,46 +7417,50 @@ var ReferencesService = class {
     switch (entity.kind) {
       case 0 /* Variable */:
         return { name: entity.getName() };
-      case 1 /* Variant */:
-        return { name: entity.getName() };
-      case 2 /* VariantType */: {
-        const naming = entity.getNaming();
-        if (naming.kind === "named") {
-          return { name: naming.value };
-        }
-        return void 0;
-      }
-      case 5 /* Method */:
-        return { name: entity.getName() };
-      case 6 /* TypeParameter */:
-        return { name: entity.getName() };
-      case 11 /* MethodType */: {
-        const naming = entity.getNaming();
-        if (naming.kind === "named") {
-          return { name: naming.value };
-        }
-        return void 0;
-      }
-      case 12 /* StructuredType */: {
-        const naming = entity.getNaming();
-        if (naming.kind === "named") {
-          return { name: naming.value };
+      case 2 /* Type */: {
+        switch (entity.typeEntityKind) {
+          case 0 /* Method */: {
+            const naming = entity.getNaming();
+            if (naming.kind === "named") {
+              return { name: naming.value };
+            }
+            return void 0;
+          }
+          case 1 /* Structured */: {
+            const naming = entity.getNaming();
+            if (naming.kind === "named") {
+              return { name: naming.value };
+            }
+            return void 0;
+          }
+          case 2 /* Parameter */:
+            return { name: entity.getName() };
+          case 3 /* Variant */: {
+            const naming = entity.getNaming();
+            if (naming.kind === "named") {
+              return { name: naming.value };
+            }
+            return void 0;
+          }
+          case 4 /* Alias */:
+            return { name: entity.getName() };
+          default:
+            Debug.never(entity);
         }
-        return void 0;
       }
-      case 13 /* PackageAlias */:
+      case 1 /* Method */:
         return { name: entity.getName() };
-      case 14 /* AliasType */:
+      case 10 /* PackageAlias */:
         return { name: entity.getName() };
       case 3 /* Getter */:
       case 4 /* Setter */:
-      case 9 /* Constructor */:
-      case 10 /* Destructor */:
-      case 7 /* Indexer */:
-      case 8 /* DereferenceOperator */:
-      case 16 /* Package */:
-      case 17 /* TypeExtension */:
-      case 15 /* Operator */:
+      case 7 /* Constructor */:
+      case 8 /* Destructor */:
+      case 5 /* Indexer */:
+      case 6 /* DereferenceOperator */:
+      case 12 /* Package */:
+      case 11 /* TypeExtension */:
+      case 9 /* Operator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -8077,14 +8107,14 @@ var SourceFileItemsService = class {
       case 4 /* PackageMethod */:
       case 15 /* TypeMethod */:
       case 19 /* NestedMethod */:
-        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(11 /* Function */, this.locale, this.dialect)}>`;
+        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(12 /* Function */, this.locale, this.dialect)}>`;
       case 5 /* StructuredType */:
       case 6 /* MethodType */:
       case 7 /* VariantType */:
       case 8 /* InvalidType */:
-        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(15 /* Type */, this.locale, this.dialect)}>`;
+        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(16 /* Type */, this.locale, this.dialect)}>`;
       case 10 /* TypeConstructor */:
-        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(28 /* Creation */, this.locale, this.dialect);
+        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(29 /* Creation */, this.locale, this.dialect);
       case 11 /* TypeDestructor */:
         return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(46 /* Destruction */, this.locale, this.dialect);
       case 9 /* Variant */:
@@ -8291,7 +8321,7 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 155 /* TypeAnnotation */:
+      case 153 /* TypeAnnotation */:
       case 34 /* StructuredTypeDeclarationBody */:
       case 39 /* VariantTypeDeclarationBody */:
       case 23 /* AliasTypeDeclarationBody */:
@@ -8339,29 +8369,37 @@ var SemanticTokensService = class {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.value.getEntity();
-              const specialVariableInfo = variable.isSpecial();
-              if (specialVariableInfo !== void 0) {
-                let semanticTokenKind;
-                switch (specialVariableInfo.kind) {
-                  case "result":
-                  case "param":
-                  case "value":
-                    semanticTokenKind = 1 /* SpecialVariable */;
-                    break;
-                  case "implicit-method-block-parameter":
-                    semanticTokenKind = 0 /* MethodBlockLiteralParameter */;
-                    break;
-                  case "backing":
-                  case "param-object-member":
-                    semanticTokenKind = void 0;
-                    break;
-                  default:
-                    Debug.never(specialVariableInfo);
-                }
-                if (semanticTokenKind !== void 0) {
-                  result.push(
-                    new SemanticToken(node.rangeWithoutTrivia, semanticTokenKind, new SemanticTokenModifiers())
-                  );
+              if (variable.subkind === "type" && variable.isVariant()) {
+                result.push(
+                  new SemanticToken(
+                    node.rangeWithoutTrivia,
+                    3 /* Variant */,
+                    new SemanticTokenModifiers().makeConst()
+                  )
+                );
+              } else {
+                const specialVariableInfo = variable.isSpecial();
+                if (specialVariableInfo !== void 0) {
+                  let semanticTokenKind;
+                  switch (specialVariableInfo.kind) {
+                    case "result":
+                    case "value":
+                      semanticTokenKind = 1 /* SpecialVariable */;
+                      break;
+                    case "implicit-method-block-parameter":
+                      semanticTokenKind = 0 /* MethodBlockLiteralParameter */;
+                      break;
+                    case "backing":
+                      semanticTokenKind = void 0;
+                      break;
+                    default:
+                      Debug.never(specialVariableInfo);
+                  }
+                  if (semanticTokenKind !== void 0) {
+                    result.push(
+                      new SemanticToken(node.rangeWithoutTrivia, semanticTokenKind, new SemanticTokenModifiers())
+                    );
+                  }
                 }
               }
             }
@@ -8375,15 +8413,6 @@ var SemanticTokensService = class {
                 )
               );
             }
-            if (meaning.kind === "variant-access") {
-              result.push(
-                new SemanticToken(
-                  node.rangeWithoutTrivia,
-                  3 /* Variant */,
-                  new SemanticTokenModifiers().makeConst()
-                )
-              );
-            }
             if (meaning.kind === "operator-access") {
               result.push(new SemanticToken(
                 node.rangeWithoutTrivia,
@@ -8394,14 +8423,17 @@ var SemanticTokensService = class {
           }
           if (node.kind === 78 /* PropertyAccessExpression */) {
             const meaning = analyzer.resolvePropertyAccessExpression(node).meaning;
-            if (meaning.kind === "variant-access") {
-              result.push(
-                new SemanticToken(
-                  node.propertyName.rangeWithoutTrivia,
-                  3 /* Variant */,
-                  new SemanticTokenModifiers().makeConst()
-                )
-              );
+            if (meaning.kind === "static-variable-access") {
+              const entity = meaning.variable.value.getEntity();
+              if (entity.subkind === "type" && entity.isVariant()) {
+                result.push(
+                  new SemanticToken(
+                    node.propertyName.rangeWithoutTrivia,
+                    3 /* Variant */,
+                    new SemanticTokenModifiers().makeConst()
+                  )
+                );
+              }
             }
             let suitableMethods;
             switch (meaning.kind) {
@@ -8601,7 +8633,7 @@ var TypeParameterSignatureHelpProvider = class {
         const infos = signatures.map(
           (s) => convertSignatureDisplayPartsToSignatureInfo(s.getDisplayParts(), argumentIndex)
         );
-        const activeSignature = Query.from(signatures).filter((s) => s.getArity() >= argumentCount).first() ?? Query.from(signatures).maxByValue((s) => s.getArity());
+        const activeSignature = Query.from(signatures).first((s) => s.getArity() >= argumentCount) ?? Query.from(signatures).maxByValue((s) => s.getArity());
         if (activeSignature !== void 0) {
           const activeSignatureIndex = signatures.indexOf(activeSignature);
           result = new SignatureHelp(infos, activeSignatureIndex);
@@ -8617,7 +8649,7 @@ var TypeParameterSignatureHelpProvider = class {
     }
     let node = token.parent;
     while (node !== void 0) {
-      if (node.kind === 151 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
+      if (node.kind === 149 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
         const argumentIndex = this.getArgumentIndex(node.typeArgumentList, this._offset);
         const argumentCount = this.countArguments(node.typeArgumentList);
         return new NodeWithTypeArgumentsInfo(node.parent, argumentIndex, argumentCount);
@@ -8664,6 +8696,8 @@ var TypeParameterSignatureHelpProvider = class {
         return this.getSignaturesForNamedTypeSpecifier(node);
       case 89 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
+      case 144 /* Tag */:
+        return this.getSignaturesForTag(node);
       default:
         Debug.never(node);
     }
@@ -8678,6 +8712,27 @@ var TypeParameterSignatureHelpProvider = class {
     }
     return void 0;
   }
+  getSignaturesForTag(node) {
+    const resolutionResult = this._analyzer.resolveTag(node);
+    if (resolutionResult.resolvedQualifiers.length > 0) {
+      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") {
+          return Query.from(resolutionResult.meaning.candidates).mapAndFilter((d) => {
+            if (d.value.kind === "substituted-method") {
+              return this.getSignatureForSubstitutedMethod(d.value.value, d.localization);
+            }
+            return void 0;
+          }).toArray();
+        } else {
+          return void 0;
+        }
+      }
+    }
+    return void 0;
+  }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
     if (expression.kind === 88 /* IdentifierExpression */) {
@@ -8725,12 +8780,12 @@ var TypeParameterSignatureHelpProvider = class {
     switch (method.kind) {
       case "entity":
         if (method.entity.getTypeParametersArity() > 0) {
-          result = new MethodEntitySignature2(this.signatureContext, method.entity, localization);
+          result = new MethodEntitySignature(this.signatureContext, method.entity, localization);
         }
         break;
       case "type-member":
         if (method.method.getTypeParametersArity() > 0) {
-          result = new TypeMethodSignature2(this.signatureContext, method.method, localization);
+          result = new TypeMethodSignature(this.signatureContext, method.method, localization);
         }
         break;
       default:
@@ -8740,28 +8795,28 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignatureForNamedType(type) {
     let result = void 0;
-    switch (type.kind) {
-      case 12 /* StructuredType */:
+    switch (type.typeEntityKind) {
+      case 1 /* Structured */:
         if (type.getArity() > 0) {
           result = new StructuredTypeSignature(this.signatureContext, type);
         }
         break;
-      case 11 /* MethodType */:
+      case 0 /* Method */:
         if (type.getArity() > 0) {
           result = new MethodTypeSignature2(this.signatureContext, type);
         }
         break;
-      case 2 /* VariantType */:
+      case 3 /* Variant */:
         if (type.getArity() > 0) {
           result = new VariantTypeSignature(this.signatureContext, type);
         }
         break;
-      case 14 /* AliasType */:
+      case 4 /* Alias */:
         if (type.getArity() > 0) {
           result = new AliasTypeSignature(this.signatureContext, type);
         }
         break;
-      case 6 /* TypeParameter */:
+      case 2 /* Parameter */:
         break;
       default:
         Debug.never(type);
@@ -8776,7 +8831,7 @@ var NodeWithTypeArgumentsInfo = class {
     this.argumentCount = argumentCount;
   }
 };
-var MethodEntitySignature2 = class {
+var MethodEntitySignature = class {
   constructor(ctx, method, localization) {
     this.ctx = ctx;
     this.method = method;
@@ -8792,7 +8847,7 @@ var MethodEntitySignature2 = class {
     return this.ctx.convertMethodDisplayParts(displayParts);
   }
 };
-var TypeMethodSignature2 = class {
+var TypeMethodSignature = class {
   constructor(ctx, method, localization) {
     this.ctx = ctx;
     this.method = method;
@@ -8951,7 +9006,7 @@ var ValueParametersSignatureHelpProvider = class {
         case 69 /* CallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(node);
-            const argumentIndex = this.getArgumentIndexInList(node.callArgumentList.elements, this._offset);
+            const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             return new NodeWithValueArgumentsInfo(node, valueArguments, argumentIndex);
           }
           break;
@@ -8959,7 +9014,7 @@ var ValueParametersSignatureHelpProvider = class {
         case 70 /* AutotypeCallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(node);
-            const argumentIndex = this.getArgumentIndexInList(node.callArgumentList.elements, this._offset);
+            const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             return new NodeWithValueArgumentsInfo(node, valueArguments, argumentIndex);
           }
           break;
@@ -8967,14 +9022,14 @@ var ValueParametersSignatureHelpProvider = class {
         case 71 /* IndexedAccessExpression */: {
           if (this._offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(node);
-            const argumentIndex = this.getArgumentIndexInList(node.argumentsList.elements, this._offset);
+            const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             return new NodeWithValueArgumentsInfo(node, valueArguments, argumentIndex);
           }
           break;
         }
         case 144 /* Tag */: {
-          if (node.openParenthesisToken !== void 0 && this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && node.callArgumentList !== void 0 && (node.closeParenthesisToken === void 0 || node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
-            const argumentIndex = this.getArgumentIndexInList(node.callArgumentList.elements, this._offset);
+          if (node.openParenthesisToken !== void 0 && this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && node.argumentList !== void 0 && (node.closeParenthesisToken === void 0 || node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
+            const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(node);
             return new NodeWithValueArgumentsInfo(node, valueArguments, argumentIndex);
           }
@@ -9000,24 +9055,8 @@ var ValueParametersSignatureHelpProvider = class {
   }
   getSignatureDisplayParts(signature) {
     switch (signature.kind) {
-      case "method-entity": {
-        const method = new MethodDeclaration_entity(
-          signature.method.value,
-          signature.method.localization
-        );
-        const displayParts = this.signatureContext.displayService.getMethodDeclarationDisplayParts(method);
-        return this.signatureContext.convertMethodDisplayParts(displayParts);
-      }
-      case "type-method": {
-        const method = new MethodDeclaration_typeMember(
-          signature.method.value,
-          signature.method.localization
-        );
-        const displayParts = this.signatureContext.displayService.getMethodDeclarationDisplayParts(method);
-        return this.signatureContext.convertMethodDisplayParts(displayParts);
-      }
-      case "substituted-method": {
-        const method = new MethodDeclaration_substitutedMethod(
+      case "accessed-method": {
+        const method = new MethodDeclaration_accessedMethod(
           signature.method.value,
           signature.method.localization
         );
@@ -9114,16 +9153,16 @@ var SignatureInfo = class {
 };
 
 // source/services/source-generation/SourceGenerationService.ts
-import { atomicRun as atomicRun2, ObservableMap as ObservableMap6, ObservableObject as ObservableObject7, reactive as reactive6, Transaction as Transaction4 } from "reactronic";
+import { atomicRun as atomicRun2, TriggeringMap as TriggeringMap6, TriggeringObject as TriggeringObject7, reaction as reaction6, Transaction as Transaction4 } from "reactronic";
 
 // source/services/workspace/ClientTrackedSourceFiles.ts
-import { ObservableMap, ObservableObject, unobservable, ReactiveSystem, atomic } from "reactronic";
-var ClientTrackedSourceFiles = class extends ObservableObject {
+import { TriggeringMap, TriggeringObject, trigger, ReactiveSystem, atomicBlock } from "reactronic";
+var ClientTrackedSourceFiles = class extends TriggeringObject {
   constructor() {
     super(...arguments);
-    this.items = new ObservableMap();
+    this.items = new TriggeringMap();
   }
-  // @cached
+  // @cache
   get unsaved() {
     return Query.from(this.items.entries()).filter((e) => !e[1].isSaved).toMap((e) => e[0], (e) => e[1]);
   }
@@ -9174,18 +9213,18 @@ var ClientTrackedSourceFiles = class extends ObservableObject {
   }
 };
 __decorateClass([
-  atomic
+  atomicBlock
 ], ClientTrackedSourceFiles.prototype, "track", 1);
 __decorateClass([
-  atomic
+  atomicBlock
 ], ClientTrackedSourceFiles.prototype, "update", 1);
 __decorateClass([
-  atomic
+  atomicBlock
 ], ClientTrackedSourceFiles.prototype, "save", 1);
 __decorateClass([
-  atomic
+  atomicBlock
 ], ClientTrackedSourceFiles.prototype, "close", 1);
-var ClientTrackedSourceFile = class extends ObservableObject {
+var ClientTrackedSourceFile = class extends TriggeringObject {
   constructor(uri, text, version, isSaved) {
     super();
     this.uri = uri;
@@ -9201,7 +9240,7 @@ var ClientTrackedSourceFile = class extends ObservableObject {
   }
 };
 __decorateClass([
-  unobservable
+  trigger(false)
 ], ClientTrackedSourceFile.prototype, "uri", 2);
 var ClientTrackedSourceFileSnapshot = class {
   constructor(uri, text, version, isSaved) {
@@ -9215,15 +9254,15 @@ var ClientTrackedSourceFileSnapshot = class {
 // source/services/workspace/CompilationController.ts
 import {
   Indicator,
-  ObservableObject as ObservableObject2,
+  TriggeringObject as TriggeringObject2,
   ReactiveSystem as ReactiveSystem2,
   Reentrance,
   Transaction,
-  atomic as atomic2,
+  atomicBlock as atomicBlock2,
   nonReactiveRun,
   options,
-  reactive,
-  unobservable as unobservable2
+  reaction,
+  trigger as trigger2
 } from "reactronic";
 var highPriorityDiagnosticsCollectionIndicator = Indicator.create(
   "HighPriorityDiagnosticsCollectionIndicator",
@@ -9232,7 +9271,7 @@ var highPriorityDiagnosticsCollectionIndicator = Indicator.create(
   100
 );
 var backgroundDiagnosticsCollectionThrottleTimeMs = 3e3;
-var CompilationController = class extends ObservableObject2 {
+var CompilationController = class extends TriggeringObject2 {
   constructor(config) {
     super();
     this.isConfigurationsProcessingEnabled = false;
@@ -9714,72 +9753,72 @@ var CompilationController = class extends ObservableObject2 {
   }
 };
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "mainCompilationReloadIndicator", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "configurationControllersUpdateIndictor", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_mainAnalyzerChangedIndicator", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_fileSystemTree", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "config", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_rootDirectory", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_previousCompilationLoadResult", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_sourceFilesForWhichDiagnosticsWereReported", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_checkedConfigurationVersionByPackageUri", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_tsInteropInputs", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_tsInteropInputsKey", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_tsProgramLoaderInputs", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], CompilationController.prototype, "_configurationsOfPackagesOutsideProject", 2);
 __decorateClass([
-  atomic2
+  atomicBlock2
 ], CompilationController.prototype, "notifyReportedSourceFileDiagnostics", 1);
 __decorateClass([
-  reactive,
+  reaction,
   options({ reentrance: Reentrance.cancelPrevious, order: 24 })
 ], CompilationController.prototype, "reloadMainCompilation", 1);
 __decorateClass([
-  reactive,
+  reaction,
   options({ order: 25 })
 ], CompilationController.prototype, "updateState", 1);
 __decorateClass([
-  reactive,
+  reaction,
   options({ order: 20 })
 ], CompilationController.prototype, "updateConfigurationControllers", 1);
 __decorateClass([
-  reactive,
+  reaction,
   options({ order: 21 })
 ], CompilationController.prototype, "onConfigurationsUpdated", 1);
 __decorateClass([
-  reactive
+  reaction
 ], CompilationController.prototype, "onMainAnalyzerChanged", 1);
 __decorateClass([
-  reactive,
+  reaction,
   options({ reentrance: Reentrance.cancelAndWaitPrevious })
 ], CompilationController.prototype, "collectDiagnosticsInBackground", 1);
 __decorateClass([
-  reactive,
+  reaction,
   options({ reentrance: Reentrance.waitAndRestart })
 ], CompilationController.prototype, "onRawPackageConfigurationsUpdated", 1);
 var TsProgramLoaderInputs = class {
@@ -9841,11 +9880,11 @@ var ReadonlyCompilationState = class {
   }
 };
 __decorateClass([
-  atomic2,
+  atomicBlock2,
   options({ reentrance: Reentrance.runSideBySide, indicator: highPriorityDiagnosticsCollectionIndicator })
 ], ReadonlyCompilationState.prototype, "collectSourceFileDiagnosticsWithHighPriority", 1);
 __decorateClass([
-  atomic2,
+  atomicBlock2,
   options({ reentrance: Reentrance.runSideBySide })
 ], ReadonlyCompilationState.prototype, "collectSourceFileDiagnosticsWithLowPriority", 1);
 var DiagnosticsCollectionSummary = class {
@@ -9853,7 +9892,7 @@ var DiagnosticsCollectionSummary = class {
     this.hasErrors = hasErrors;
   }
 };
-var ConfigurationController = class extends ObservableObject2 {
+var ConfigurationController = class extends TriggeringObject2 {
   constructor(rootDirectory, packageUri, mainCompilationController) {
     super();
     // private _compilationState: ReadonlyCompilationState | undefined = undefined
@@ -9934,7 +9973,7 @@ var ConfigurationController = class extends ObservableObject2 {
       this._convertedConfigurationVersion++;
     });
   }
-  // @reactive
+  // @reaction
   // @options({ reentrance: Reentrance.cancelPrevious, order: 21 })
   // private async reloadCompilation(): Promise<void> {
   //   if (!this._mainCompilationController.isConfigurationsProcessingEnabled) {
@@ -9981,7 +10020,7 @@ var ConfigurationController = class extends ObservableObject2 {
   //     }
   //   }
   // }
-  // @reactive
+  // @reaction
   // @options({ reentrance: Reentrance.cancelPrevious, order: 22 })
   // private async analyze(): Promise<void> {
   //   if (!this._mainCompilationController.isConfigurationsProcessingEnabled) {
@@ -10015,11 +10054,11 @@ var ConfigurationController = class extends ObservableObject2 {
   //     }
   //   }
   // }
-  // @reactive
+  // @reaction
   // private diagnosticsChanged(): void {
   //   this._configurationDiagnostics // подписка
   // }
-  // @reactive
+  // @reaction
   // @options({ reentrance: Reentrance.cancelAndWaitPrevious })
   // private async reportDiagnostics(): Promise<void> {
   //   if (!this._mainCompilationController.isConfigurationsProcessingEnabled) {
@@ -10045,7 +10084,7 @@ var ConfigurationController = class extends ObservableObject2 {
   //     }
   //   }
   // }
-  // @reactive
+  // @reaction
   // @options({ reentrance: Reentrance.cancelPrevious, order: 23 })
   // private async interpretConfiguration(): Promise<void> {
   //   if (!this._mainCompilationController.isConfigurationsProcessingEnabled) {
@@ -10087,23 +10126,23 @@ var ConfigurationController = class extends ObservableObject2 {
   // }
 };
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], ConfigurationController.prototype, "packageUri", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], ConfigurationController.prototype, "processingIndicator", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], ConfigurationController.prototype, "rootDirectory", 2);
 __decorateClass([
-  unobservable2
+  trigger2(false)
 ], ConfigurationController.prototype, "_mainCompilationController", 2);
 __decorateClass([
-  reactive,
+  reaction,
   options({ reentrance: Reentrance.cancelPrevious, order: 21 })
 ], ConfigurationController.prototype, "updateJsonConfigurationFile", 1);
 __decorateClass([
-  reactive,
+  reaction,
   options({ reentrance: Reentrance.cancelPrevious, order: 22 })
 ], ConfigurationController.prototype, "processConfiguration", 1);
 var ConfigurationDirectory = class {
@@ -10165,31 +10204,31 @@ var TsInteropInputsCache = class {
 
 // source/services/workspace/FileSystemTreeProviderBasedOnWatchedFileSystem.ts
 import {
-  atomic as atomic3,
+  atomicBlock as atomicBlock3,
   Indicator as Indicator2,
   nonReactiveRun as nonReactiveRun2,
-  ObservableArray,
-  ObservableMap as ObservableMap2,
-  ObservableObject as ObservableObject3,
+  TriggeringArray,
+  TriggeringMap as TriggeringMap2,
+  TriggeringObject as TriggeringObject3,
   options as options2,
-  reactive as reactive2,
+  reaction as reaction2,
   ReactiveSystem as ReactiveSystem3,
   Transaction as Transaction2,
-  unobservable as unobservable3
+  trigger as trigger3
 } from "reactronic";
-var FileSystemTreeProviderBasedOnWatchedFileSystem = class extends ObservableObject3 {
+var FileSystemTreeProviderBasedOnWatchedFileSystem = class extends TriggeringObject3 {
   // Используется в качестве множества.
   constructor(fileSystem, notificationsPublisher, namesOfDirectoriesToIgnore, additionalUrisOfDirectoriesToLoad) {
     super();
     this.fileSystemTree = new FileSystemTree(true);
-    this.loadedWorkspaceFolderByUri = new ObservableMap2();
+    this.loadedWorkspaceFolderByUri = new TriggeringMap2();
     this._workspaceFolderUris = void 0;
     this._trackedSourceFiles = void 0;
     this._isInitialized = false;
     this._lastCheckedWorkspaceFolderUris = new Array();
     this._taskQueue = new TaskQueue();
     this._lastCheckedTrackedSourceFileInfoVersionByUri = /* @__PURE__ */ new Map();
-    this._loadedDirectoryUris = new ObservableMap2();
+    this._loadedDirectoryUris = new TriggeringMap2();
     this._fileSystem = fileSystem;
     this._notificationsPublisher = notificationsPublisher;
     this._listener = this.onFileSystemUpdated.bind(this);
@@ -10557,7 +10596,7 @@ var FileSystemTreeProviderBasedOnWatchedFileSystem = class extends ObservableObj
       this.fileSystemTree.deleteFileOrDirectory(uri);
     }
   }
-  // @reactive
+  // @reaction
   // @options({ order: 0 })
   // protected unloadWorkspaceFoldersThatNoLongerContainArtelProject(): void {
   //   if (this.isMissingConfigurationDirectoryAllowed) {
@@ -10682,65 +10721,65 @@ var FileSystemTreeProviderBasedOnWatchedFileSystem = class extends ObservableObj
   // }
 };
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "fileSystemTree", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "loadedWorkspaceFolderByUri", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_fileSystem", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_notificationsPublisher", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_listener", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_lastCheckedWorkspaceFolderUris", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_taskQueue", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_namesOfDirectoriesToIgnore", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_additionalUrisOfDirectoriesToLoad", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_lastCheckedTrackedSourceFileInfoVersionByUri", 2);
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "_loadedDirectoryUris", 2);
 __decorateClass([
-  reactive2
+  reaction2
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "onTrackedSourceFilesUpdated", 1);
 __decorateClass([
-  reactive2
+  reaction2
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "onWorkspaceFolderUrisUpdated", 1);
 __decorateClass([
-  reactive2,
+  reaction2,
   options2({ order: 0 })
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "updateLoadedWorkspaceFolders", 1);
 __decorateClass([
-  reactive2
+  reaction2
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "loadAdditionalDirectories", 1);
 __decorateClass([
-  atomic3
+  atomicBlock3
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "addWorkspaceFoldersWorker", 1);
 __decorateClass([
-  atomic3
+  atomicBlock3
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "removeWorkspaceFoldersWorker", 1);
 __decorateClass([
-  atomic3
+  atomicBlock3
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "onFileSystemTreeUpdatedWorker", 1);
 __decorateClass([
-  atomic3
+  atomicBlock3
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "stopTrackingSourceFile", 1);
 __decorateClass([
-  atomic3
+  atomicBlock3
 ], FileSystemTreeProviderBasedOnWatchedFileSystem.prototype, "updateFileSystemTree", 1);
 var SimpleFileSystemUpdateNotificationsPublisher = class {
   constructor() {
@@ -10816,10 +10855,10 @@ var FileSystemTreeUpdate_deleteDirectory = class {
     return this.uri;
   }
 };
-var TaskQueue = class extends ObservableObject3 {
+var TaskQueue = class extends TriggeringObject3 {
   constructor() {
     super();
-    this._tasks = new ObservableArray();
+    this._tasks = new TriggeringArray();
     this._currentTask = void 0;
     this._processTasksIndicator = Indicator2.create("ProcessTasks", -1, -1, 1e3);
     ReactiveSystem3.getOperation(this.processTasks).configure({ indicator: this._processTasksIndicator });
@@ -10875,25 +10914,25 @@ var TaskQueue = class extends ObservableObject3 {
   }
 };
 __decorateClass([
-  unobservable3
+  trigger3(false)
 ], TaskQueue.prototype, "_tasks", 2);
 __decorateClass([
-  atomic3
+  atomicBlock3
 ], TaskQueue.prototype, "addTask", 1);
 __decorateClass([
-  reactive2
+  reaction2
 ], TaskQueue.prototype, "processTasks", 1);
 __decorateClass([
-  reactive2
+  reaction2
 ], TaskQueue.prototype, "executeTask", 1);
 
 // source/services/workspace/ManuallyUpdatedFileSystemTreeProvider.ts
-import { ObservableMap as ObservableMap3, ObservableObject as ObservableObject4, options as options3, reactive as reactive3, ReactiveSystem as ReactiveSystem4, unobservable as unobservable4 } from "reactronic";
-var ManuallyUpdatedFileSystemTreeProvider = class extends ObservableObject4 {
+import { TriggeringMap as TriggeringMap3, TriggeringObject as TriggeringObject4, options as options3, reaction as reaction3, ReactiveSystem as ReactiveSystem4, trigger as trigger4 } from "reactronic";
+var ManuallyUpdatedFileSystemTreeProvider = class extends TriggeringObject4 {
   constructor() {
     super(...arguments);
     this.fileSystemTree = new FileSystemTree(true, true);
-    this.loadedWorkspaceFolderByUri = new ObservableMap3();
+    this.loadedWorkspaceFolderByUri = new TriggeringMap3();
     this._workspaceFolderUris = void 0;
     this._trackedSourceFiles = void 0;
     this._lastCheckedTrackedSourceFileInfoByUri = /* @__PURE__ */ new Map();
@@ -10992,59 +11031,59 @@ var ManuallyUpdatedFileSystemTreeProvider = class extends ObservableObject4 {
   }
 };
 __decorateClass([
-  unobservable4
+  trigger4(false)
 ], ManuallyUpdatedFileSystemTreeProvider.prototype, "fileSystemTree", 2);
 __decorateClass([
-  unobservable4
+  trigger4(false)
 ], ManuallyUpdatedFileSystemTreeProvider.prototype, "loadedWorkspaceFolderByUri", 2);
 __decorateClass([
-  unobservable4
+  trigger4(false)
 ], ManuallyUpdatedFileSystemTreeProvider.prototype, "_lastCheckedTrackedSourceFileInfoByUri", 2);
 __decorateClass([
-  unobservable4
+  trigger4(false)
 ], ManuallyUpdatedFileSystemTreeProvider.prototype, "_manuallyCreatedSourceFileTextByUri", 2);
 __decorateClass([
-  reactive3
+  reaction3
 ], ManuallyUpdatedFileSystemTreeProvider.prototype, "onTrackedSourceFilesUpdated", 1);
 __decorateClass([
-  reactive3,
+  reaction3,
   options3({ order: 0 })
 ], ManuallyUpdatedFileSystemTreeProvider.prototype, "updateLoadedWorkspaceFolderByUri", 1);
 
 // source/services/workspace/Workspace.ts
 import {
-  ObservableArray as ObservableArray4,
-  ObservableMap as ObservableMap5,
-  ObservableObject as ObservableObject6,
+  TriggeringArray as TriggeringArray4,
+  TriggeringMap as TriggeringMap5,
+  TriggeringObject as TriggeringObject6,
   ReactiveSystem as ReactiveSystem6,
   Reentrance as Reentrance2,
   Transaction as Transaction3,
-  atomic as atomic5,
+  atomicBlock as atomicBlock5,
   atomicRun,
-  cached,
+  cache,
   nonReactiveRun as nonReactiveRun3,
   options as options5,
-  reactive as reactive5,
-  unobservable as unobservable6
+  reaction as reaction5,
+  trigger as trigger6
 } from "reactronic";
 
 // source/services/workspace/WorkspaceFiles.ts
 import {
-  ObservableArray as ObservableArray3,
-  ObservableMap as ObservableMap4,
-  ObservableObject as ObservableObject5,
+  TriggeringArray as TriggeringArray3,
+  TriggeringMap as TriggeringMap4,
+  TriggeringObject as TriggeringObject5,
   options as options4,
-  unobservable as unobservable5,
-  reactive as reactive4,
+  trigger as trigger5,
+  reaction as reaction4,
   ReactiveSystem as ReactiveSystem5,
-  atomic as atomic4
+  atomicBlock as atomicBlock4
 } from "reactronic";
-var WorkspaceFiles = class extends ObservableObject5 {
+var WorkspaceFiles = class extends TriggeringObject5 {
   constructor(fileSystemTreeProvider) {
     super();
     this.trackedSourceFiles = new ClientTrackedSourceFiles();
-    this.workspaceFolderUris = new ObservableArray3();
-    this.workspaceFolderWithArtelProjectByUri = new ObservableMap4();
+    this.workspaceFolderUris = new TriggeringArray3();
+    this.workspaceFolderWithArtelProjectByUri = new TriggeringMap4();
     this._fileSystemTreeProvider = fileSystemTreeProvider;
     this._fileSystemTreeProvider.initialize(this.workspaceFolderUris, this.trackedSourceFiles);
   }
@@ -11143,39 +11182,39 @@ var WorkspaceFiles = class extends ObservableObject5 {
   }
 };
 __decorateClass([
-  unobservable5
+  trigger5(false)
 ], WorkspaceFiles.prototype, "workspaceFolderUris", 2);
 __decorateClass([
-  unobservable5
+  trigger5(false)
 ], WorkspaceFiles.prototype, "workspaceFolderWithArtelProjectByUri", 2);
 __decorateClass([
-  unobservable5
+  trigger5(false)
 ], WorkspaceFiles.prototype, "_fileSystemTreeProvider", 2);
 __decorateClass([
-  atomic4
+  atomicBlock4
 ], WorkspaceFiles.prototype, "addWorkspaceFolders", 1);
 __decorateClass([
-  atomic4
+  atomicBlock4
 ], WorkspaceFiles.prototype, "removeWorkspaceFolders", 1);
 __decorateClass([
-  atomic4
+  atomicBlock4
 ], WorkspaceFiles.prototype, "trackSourceFile", 1);
 __decorateClass([
-  atomic4
+  atomicBlock4
 ], WorkspaceFiles.prototype, "updateTrackedSourceFile", 1);
 __decorateClass([
-  reactive4,
+  reaction4,
   options4({ order: 1 })
 ], WorkspaceFiles.prototype, "updateWorkspaceFolderWithArtelProjectByUri", 1);
 
 // source/services/workspace/Workspace.ts
-var _Workspace = class _Workspace extends ObservableObject6 {
+var _Workspace = class _Workspace extends TriggeringObject6 {
   constructor(config) {
     super();
     this.isReadyToAcceptWorkspaceDiagnostics = false;
-    this._compilationControllers = new ObservableArray4();
-    // ObservableMap используется в качестве Set'а.
-    this._controllersWithOpenedFiles = new ObservableMap5();
+    this._compilationControllers = new TriggeringArray4();
+    // TriggeringMap используется в качестве Set'а.
+    this._controllersWithOpenedFiles = new TriggeringMap5();
     this._atLeastOneFileOfCompilationHasBeenOpened = false;
     this._standardPackageContents = new Cached();
     this._tsInteropInputsCache = new TsInteropInputsCache();
@@ -11445,39 +11484,39 @@ var _Workspace = class _Workspace extends ObservableObject6 {
   }
 };
 __decorateClass([
-  unobservable6
+  trigger6(false)
 ], _Workspace.prototype, "_config", 2);
 __decorateClass([
-  unobservable6
+  trigger6(false)
 ], _Workspace.prototype, "_atLeastOneFileOfCompilationHasBeenOpened", 2);
 __decorateClass([
-  unobservable6
+  trigger6(false)
 ], _Workspace.prototype, "_files", 2);
 __decorateClass([
-  unobservable6
+  trigger6(false)
 ], _Workspace.prototype, "_standardPackageContents", 2);
 __decorateClass([
-  unobservable6
+  trigger6(false)
 ], _Workspace.prototype, "_tsInteropInputsCache", 2);
 __decorateClass([
-  cached
+  cache
 ], _Workspace.prototype, "compilationControllerByUri", 1);
 __decorateClass([
-  atomic5
+  atomicBlock5
 ], _Workspace.prototype, "notifyClosedTextDocument", 1);
 __decorateClass([
-  reactive5,
+  reaction5,
   options5({ order: 10 })
 ], _Workspace.prototype, "updateCompilationControllers", 1);
 __decorateClass([
-  reactive5,
+  reaction5,
   options5({ reentrance: Reentrance2.cancelPrevious })
 ], _Workspace.prototype, "processControllersWithUnprocessedConfigs", 1);
 __decorateClass([
-  reactive5
+  reaction5
 ], _Workspace.prototype, "updateIsDiagnosticsCollectionInBackgroundEnabled", 1);
 __decorateClass([
-  reactive5,
+  reaction5,
   options5({ reentrance: Reentrance2.cancelPrevious })
 ], _Workspace.prototype, "updateControllersWithOpenedFiles", 1);
 var Workspace = _Workspace;
@@ -11493,22 +11532,30 @@ var EntityToSyntax = class {
     return this.convertPackage(this._entity);
   }
   convertPackage(entity) {
-    const namedPackageMembers = entity.getMembers().getNamedMembers().flatMap((m) => this.convertNamedPackageMember(m.getEntity()));
+    const namedPackageMembers = entity.getMembers().getNamedMembers().flatMap((m) => this.convertNamedPackageMember(m));
     return SyntaxFactory.sourceFile([], namedPackageMembers);
   }
   convertNamedPackageMember(entity) {
     switch (entity.kind) {
       case 0 /* Variable */:
         return this.convertPackageVariable(entity);
-      case 2 /* VariantType */:
-        return this.convertPackageVariantType(entity);
-      case 5 /* Method */:
+      case 1 /* Method */:
         return this.convertPackageMethod(entity);
-      case 11 /* MethodType */:
+      case 2 /* Type */:
+        return this.convertPackageType(entity);
+      default:
+        Debug.never(entity);
+    }
+  }
+  convertPackageType(entity) {
+    switch (entity.typeEntityKind) {
+      case 0 /* Method */:
         return this.convertPackageMethodType(entity);
-      case 12 /* StructuredType */:
+      case 1 /* Structured */:
         return this.convertPackageStructuredType(entity);
-      case 14 /* AliasType */:
+      case 3 /* Variant */:
+        return this.convertPackageVariantType(entity);
+      case 4 /* Alias */:
         return this.convertPackageAliasType(entity);
       default:
         Debug.never(entity);
@@ -11517,7 +11564,7 @@ var EntityToSyntax = class {
   convertPackageVariable(entity) {
     const commonModifiers = new Array();
     if (entity.isConstant()) {
-      commonModifiers.push(SyntaxFactory.modifier(33 /* Const */));
+      commonModifiers.push(SyntaxFactory.modifier(34 /* Const */));
     }
     const name = this.getEntityName(entity);
     const type = this.convertType(entity.getType());
@@ -11542,7 +11589,7 @@ var EntityToSyntax = class {
         if (isHidden !== void 0) {
           modifiers.push(this.createHidingModifier(isHidden));
         }
-        result.push(SyntaxFactory.packageVariableSetterDeclaration(tags, modifiers, name, void 0, void 0));
+        result.push(SyntaxFactory.packageVariableSetterDeclaration(tags, modifiers, name, void 0));
       }
     } else {
       const tags = this.convertTags(entity.getTags());
@@ -11559,7 +11606,7 @@ var EntityToSyntax = class {
     const tags = this.convertTags(entity.getTags());
     const modifiers = new Array();
     if (entity.isAsync()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Async */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Async */));
     }
     const isHidden = entity.isHidden();
     if (isHidden !== void 0) {
@@ -11636,21 +11683,24 @@ var EntityToSyntax = class {
     return variables.concat(indexers, constructors, methods, destructors);
   }
   convertTypeVariable(entity) {
+    if (entity.isVariant()) {
+      return this.convertVariant(entity);
+    }
     const commonModifiers = new Array();
     if (entity.isConstant()) {
-      commonModifiers.push(SyntaxFactory.modifier(33 /* Const */));
+      commonModifiers.push(SyntaxFactory.modifier(34 /* Const */));
     }
     if (entity.isStatic()) {
-      commonModifiers.push(SyntaxFactory.modifier(39 /* Static */));
+      commonModifiers.push(SyntaxFactory.modifier(40 /* Static */));
     }
     if (entity.isAbstract()) {
-      commonModifiers.push(SyntaxFactory.modifier(35 /* Abstract */));
+      commonModifiers.push(SyntaxFactory.modifier(36 /* Abstract */));
     }
     if (entity.isRedefinable()) {
-      commonModifiers.push(SyntaxFactory.modifier(36 /* Redefinable */));
+      commonModifiers.push(SyntaxFactory.modifier(37 /* Redefinable */));
     }
     if (entity.isRedefined()) {
-      commonModifiers.push(SyntaxFactory.modifier(37 /* Redefined */));
+      commonModifiers.push(SyntaxFactory.modifier(38 /* Redefined */));
     }
     const name = this.getEntityName(entity);
     const type = this.convertType(entity.getType());
@@ -11675,7 +11725,7 @@ var EntityToSyntax = class {
         if (isHidden !== void 0) {
           modifiers.push(this.createHidingModifier(isHidden));
         }
-        result.push(SyntaxFactory.typeVariableSetterDeclaration(tags, modifiers, name, void 0, void 0));
+        result.push(SyntaxFactory.typeVariableSetterDeclaration(tags, modifiers, name, void 0));
       }
     } else {
       const tags = this.convertTags(entity.getTags());
@@ -11696,16 +11746,16 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isStatic()) {
-      modifiers.push(SyntaxFactory.modifier(39 /* Static */));
+      modifiers.push(SyntaxFactory.modifier(40 /* Static */));
     }
     if (entity.isAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(35 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(36 /* Abstract */));
     }
     if (entity.isRedefinable()) {
-      modifiers.push(SyntaxFactory.modifier(36 /* Redefinable */));
+      modifiers.push(SyntaxFactory.modifier(37 /* Redefinable */));
     }
     if (entity.isRedefined()) {
-      modifiers.push(SyntaxFactory.modifier(37 /* Redefined */));
+      modifiers.push(SyntaxFactory.modifier(38 /* Redefined */));
     }
     const name = this.getEntityName(entity);
     const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
@@ -11721,7 +11771,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(35 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(36 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
     return SyntaxFactory.typeConstructorDeclaration(tags, modifiers, parameters, void 0);
@@ -11734,7 +11784,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(35 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(36 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
     return SyntaxFactory.typeDestructorDeclaration(tags, modifiers, parameters, void 0);
@@ -11742,10 +11792,10 @@ var EntityToSyntax = class {
   convertTypeIndexer(entity) {
     const commonModifiers = new Array();
     if (entity.isStatic()) {
-      commonModifiers.push(SyntaxFactory.modifier(39 /* Static */));
+      commonModifiers.push(SyntaxFactory.modifier(40 /* Static */));
     }
     if (entity.isAbstract()) {
-      commonModifiers.push(SyntaxFactory.modifier(35 /* Abstract */));
+      commonModifiers.push(SyntaxFactory.modifier(36 /* Abstract */));
     }
     const parameters = this.convertValueParameters(entity.getValueParameters());
     const result = new Array();
@@ -11765,14 +11815,11 @@ var EntityToSyntax = class {
     if (setterEntity !== void 0) {
       const tags = this.convertTags(setterEntity.getTags());
       const modifiers = Array.from(commonModifiers);
-      const declaration = SyntaxFactory.typeIndexedSetterDeclaration(tags, modifiers, parameters, void 0, void 0);
+      const declaration = SyntaxFactory.typeIndexedSetterDeclaration(tags, modifiers, parameters, void 0);
       result.push(declaration);
     }
     return result;
   }
-  convertVariants(variants) {
-    return variants.get().map((v) => this.convertVariant(v));
-  }
   convertVariant(entity) {
     const tags = this.convertTags(entity.getTags());
     const name = this.getEntityName(entity);
@@ -11817,8 +11864,8 @@ var EntityToSyntax = class {
     return SyntaxFactory.aliasTypeDeclarationBody(aliasedType, members);
   }
   createVariantTypeDeclarationBody(entity) {
-    const variants = this.convertVariants(entity.getVariants());
-    return SyntaxFactory.variantTypeDeclarationBody(variants);
+    const members = this.convertTypeEntityMembers(entity.getMembers());
+    return SyntaxFactory.variantTypeDeclarationBody(members);
   }
   createMethodTypeDeclarationBody(entity) {
     const parameters = this.convertValueParameters(entity.getValueParameters());
@@ -11876,7 +11923,7 @@ var EntityToSyntax = class {
       default:
         Debug.never(hiding);
     }
-    return SyntaxFactory.modifier(34 /* Hidden */, levelKeyword);
+    return SyntaxFactory.modifier(35 /* Hidden */, levelKeyword);
   }
   convertTags(_entityTags) {
     return [];
@@ -11964,13 +12011,13 @@ var EntityToSyntax = class {
 };
 
 // source/services/source-generation/SourceGenerationService.ts
-var SourceGenerationService = class extends ObservableObject7 {
+var SourceGenerationService = class extends TriggeringObject7 {
   constructor(_trackedSourceFiles, _tsLibrariesProvider, _standardPackageContentsProviders) {
     super();
     this._trackedSourceFiles = _trackedSourceFiles;
     this._tsLibrariesProvider = _tsLibrariesProvider;
     this._standardPackageContentsProviders = _standardPackageContentsProviders;
-    this._generatedPackageStates = new ObservableMap6();
+    this._generatedPackageStates = new TriggeringMap6();
   }
   get compilationControllers() {
     return Array.from(this._generatedPackageStates.values()).map((s) => s.compilationController);
@@ -12126,7 +12173,7 @@ var SourceGenerationService = class extends ObservableObject7 {
         } else {
           return false;
         }
-      case 5 /* Method */:
+      case 1 /* Method */:
         if (entity.subkind === "package") {
           return true;
         } else if (entity.subkind === "type") {
@@ -12134,33 +12181,37 @@ var SourceGenerationService = class extends ObservableObject7 {
         } else {
           return false;
         }
-      case 1 /* Variant */:
-        return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainingEntity());
-      case 12 /* StructuredType */:
-      case 2 /* VariantType */:
-      case 11 /* MethodType */:
-        if (entity.subkind === "package") {
-          return true;
+      case 2 /* Type */:
+        switch (entity.typeEntityKind) {
+          case 1 /* Structured */:
+          case 3 /* Variant */:
+          case 0 /* Method */: {
+            if (entity.subkind === "package") {
+              return true;
+            }
+            return true;
+          }
+          case 4 /* Alias */:
+            return true;
+          case 2 /* Parameter */:
+            return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainingEntity());
+          default:
+            Debug.never(entity);
         }
-        return true;
-      case 14 /* AliasType */:
-        return true;
       case 3 /* Getter */:
       case 4 /* Setter */:
         return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getOwningEntity());
-      case 6 /* TypeParameter */:
-        return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainingEntity());
-      case 7 /* Indexer */:
-      case 8 /* DereferenceOperator */:
-      case 9 /* Constructor */:
-      case 10 /* Destructor */:
-      case 15 /* Operator */:
+      case 5 /* Indexer */:
+      case 6 /* DereferenceOperator */:
+      case 7 /* Constructor */:
+      case 8 /* Destructor */:
+      case 9 /* Operator */:
         return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainer().getEntity());
-      case 13 /* PackageAlias */:
+      case 10 /* PackageAlias */:
         return false;
-      case 16 /* Package */:
+      case 12 /* Package */:
         return false;
-      case 17 /* TypeExtension */:
+      case 11 /* TypeExtension */:
         return true;
       default:
         Debug.never(entity);
@@ -12180,7 +12231,7 @@ var SourceGenerationService = class extends ObservableObject7 {
   }
 };
 __decorateClass([
-  reactive6
+  reaction6
 ], SourceGenerationService.prototype, "onOpenedSourceFilesChanged", 1);
 var deleteGeneratedPackageTimeoutMs = 1e4;
 var GeneratedPackageState = class {
@@ -12203,37 +12254,40 @@ var EntityFinder = class {
     switch (entity.kind) {
       case 0 /* Variable */:
         return this.findVariableEntity(entity);
-      case 5 /* Method */:
+      case 1 /* Method */:
         return this.findMethodEntity(entity);
-      case 2 /* VariantType */:
-      case 12 /* StructuredType */:
-      case 11 /* MethodType */: {
-        if (entity.subkind === "package") {
-          return this.findPackageTypeEntityByNameAndArity(this.getEntityName(entity), entity.getArity());
+      case 2 /* Type */:
+        switch (entity.typeEntityKind) {
+          case 3 /* Variant */:
+          case 1 /* Structured */:
+          case 0 /* Method */: {
+            if (entity.subkind === "package") {
+              return this.findPackageTypeEntityByNameAndArity(this.getEntityName(entity), entity.getArity());
+            }
+            return void 0;
+          }
+          case 4 /* Alias */:
+            return this.findPackageTypeEntityByNameAndArity(this.getEntityName(entity), entity.getArity());
+          case 2 /* Parameter */:
+            return this.findTypeParameterEntity(entity);
+          default:
+            Debug.never(entity);
         }
-        return void 0;
-      }
-      case 14 /* AliasType */:
-        return this.findPackageTypeEntityByNameAndArity(this.getEntityName(entity), entity.getArity());
-      case 9 /* Constructor */:
+      case 7 /* Constructor */:
         return this.findConstructorEntity(entity);
-      case 10 /* Destructor */:
+      case 8 /* Destructor */:
         return this.findDestructorEntity(entity);
-      case 15 /* Operator */:
+      case 9 /* Operator */:
         return this.findOperatorEntity(entity);
-      case 7 /* Indexer */:
+      case 5 /* Indexer */:
         return this.findIndexerEntity(entity);
-      case 8 /* DereferenceOperator */:
+      case 6 /* DereferenceOperator */:
         return this.findDereferenceOperatorEntity(entity);
-      case 1 /* Variant */:
-        return this.findVariantEntity(entity);
-      case 6 /* TypeParameter */:
-        return this.findTypeParameterEntity(entity);
-      case 13 /* PackageAlias */:
+      case 10 /* PackageAlias */:
       case 3 /* Getter */:
       case 4 /* Setter */:
-      case 16 /* Package */:
-      case 17 /* TypeExtension */:
+      case 12 /* Package */:
+      case 11 /* TypeExtension */:
         return void 0;
       default:
         Debug.never(entity);
@@ -12241,7 +12295,7 @@ var EntityFinder = class {
   }
   findVariableEntity(entity) {
     if (entity.subkind === "package") {
-      return this._packageEntity.getMembers().getNamedMembersByName(this.getEntityName(entity)).at(0)?.getEntity();
+      return this._packageEntity.getMembers().getNamedMembersByName(this.getEntityName(entity)).at(0);
     } else if (entity.subkind === "type") {
       const containingType = this.findEntity(entity.getContainer().getEntity());
       if (containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType)) {
@@ -12262,7 +12316,7 @@ var EntityFinder = class {
   findMethodEntity(entity) {
     switch (entity.subkind) {
       case "package": {
-        const members = this._packageEntity.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === "method").map((m) => m.value);
+        const members = this._packageEntity.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === 1 /* Method */);
         if (members.length === 0) {
           return void 0;
         } else if (members.length === 1) {
@@ -12282,7 +12336,7 @@ var EntityFinder = class {
         if (!(containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType))) {
           return void 0;
         }
-        const members = containingType.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === 5 /* Method */);
+        const members = containingType.getMembers().getNamedMembersByName(this.getEntityName(entity)).filter((m) => m.kind === 1 /* Method */);
         if (members.length === 0) {
           return void 0;
         } else if (members.length === 1) {
@@ -12385,13 +12439,6 @@ var EntityFinder = class {
       return void 0;
     }
   }
-  findVariantEntity(entity) {
-    const containingType = this.findEntity(entity.getContainingEntity());
-    if (!(containingType !== void 0 && containingType.kind === 2 /* VariantType */)) {
-      return void 0;
-    }
-    return containingType.getVariants().getByName(this.getEntityName(entity))[0];
-  }
   findTypeParameterEntity(entity) {
     const containingEntity = this.findEntity(entity.getContainingEntity());
     const index = entity.getContainingEntity().getTypeParameters().indexOf(entity);
@@ -12402,34 +12449,33 @@ var EntityFinder = class {
     }
   }
   findPackageTypeEntityByNameAndArity(name, arity) {
-    return this._packageEntity.getMembers().getNamedMembersByName(name).filter((m) => m.kind === "type").find((m) => m.value.getArity() === arity)?.getEntity();
+    return this._packageEntity.getMembers().getNamedMembersByName(name).filter((m) => m.kind === 2 /* Type */).find((m) => m.getArity() === arity);
   }
   ifEntityWithParametersThenParameters(entity) {
     switch (entity.kind) {
-      case 5 /* Method */:
+      case 1 /* Method */:
         return entity.getValueParameters();
-      case 7 /* Indexer */:
+      case 5 /* Indexer */:
         return entity.getValueParameters();
-      case 9 /* Constructor */:
+      case 7 /* Constructor */:
         return entity.getValueParameters();
-      case 10 /* Destructor */:
+      case 8 /* Destructor */:
         return entity.getValueParameters();
-      case 11 /* MethodType */:
-        return entity.getValueParameters();
-      case 15 /* Operator */:
+      case 2 /* Type */: {
+        if (entity.typeEntityKind === 0 /* Method */) {
+          return entity.getValueParameters();
+        }
+        return void 0;
+      }
+      case 9 /* Operator */:
         return entity.getValueParameters();
       case 0 /* Variable */:
-      case 1 /* Variant */:
-      case 2 /* VariantType */:
       case 3 /* Getter */:
       case 4 /* Setter */:
-      case 6 /* TypeParameter */:
-      case 12 /* StructuredType */:
-      case 13 /* PackageAlias */:
-      case 14 /* AliasType */:
-      case 16 /* Package */:
-      case 17 /* TypeExtension */:
-      case 8 /* DereferenceOperator */:
+      case 10 /* PackageAlias */:
+      case 12 /* Package */:
+      case 11 /* TypeExtension */:
+      case 6 /* DereferenceOperator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -12437,29 +12483,25 @@ var EntityFinder = class {
   }
   ifEntityWithTypeParametersThenParameters(entity) {
     switch (entity.kind) {
-      case 5 /* Method */:
+      case 1 /* Method */:
         return entity.getTypeParameters();
-      case 11 /* MethodType */:
-        return entity.getTypeParameters();
-      case 2 /* VariantType */:
-        return entity.getTypeParameters();
-      case 12 /* StructuredType */:
-        return entity.getTypeParameters();
-      case 14 /* AliasType */:
-        return entity.getTypeParameters();
-      case 10 /* Destructor */:
-      case 9 /* Constructor */:
-      case 7 /* Indexer */:
-      case 8 /* DereferenceOperator */:
+      case 2 /* Type */: {
+        if (entity.typeEntityKind !== 2 /* Parameter */) {
+          return entity.getTypeParameters();
+        }
+        return void 0;
+      }
+      case 8 /* Destructor */:
+      case 7 /* Constructor */:
+      case 5 /* Indexer */:
+      case 6 /* DereferenceOperator */:
       case 0 /* Variable */:
-      case 1 /* Variant */:
       case 3 /* Getter */:
       case 4 /* Setter */:
-      case 6 /* TypeParameter */:
-      case 13 /* PackageAlias */:
-      case 16 /* Package */:
-      case 17 /* TypeExtension */:
-      case 15 /* Operator */:
+      case 10 /* PackageAlias */:
+      case 12 /* Package */:
+      case 11 /* TypeExtension */:
+      case 9 /* Operator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -12586,7 +12628,7 @@ var LanguageServer = class {
       Logger.info("\u041D\u0430\u0447\u0430\u0442\u0430 \u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044F \u0441\u0435\u0440\u0432\u0438\u0441\u043E\u0432.");
       const initializeStartTime = performance.now();
       this._clientCapabilities = params.capabilities;
-      setUserLocale("ru");
+      setUserLocale(params.initializationOptions?.localeOverride ?? params.locale ?? "en");
       let workspaceFolderUris;
       if (params.initializationOptions?.workspaceFoldersOverride !== void 0) {
         workspaceFolderUris = params.initializationOptions.workspaceFoldersOverride.map((f) => this.convertVscodeUriToUri(URI2.parse(f.uri)));
@@ -13726,7 +13768,7 @@ ${e}`);
   }
 };
 __decorateClass([
-  atomic6
+  atomicBlock6
 ], LanguageServer.prototype, "onDidChangeWorkspaceFolders", 1);
 var FileSystemSynchronizationMode;
 ((FileSystemSynchronizationMode2) => {