@artel/artc 0.6.25216 → 0.6.25218

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-TJG64G2K.js";
+} from "../chunk-SK7ZBC3X.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";
@@ -302,7 +300,7 @@ var AddPropertyAssignmentService = class {
     let result;
     let leftValueText;
     if (propertyName !== void 0) {
-      if (assignmentNode.left.kind !== 79 /* PropertyAccessExpression */) {
+      if (assignmentNode.left.kind !== 78 /* PropertyAccessExpression */) {
         return void 0;
       }
       const propertyReceiver = assignmentNode.left.expression;
@@ -367,12 +365,13 @@ var AddPropertyAssignmentService = class {
       case 56 /* TypeVariableSetterDeclaration */:
       case 58 /* NestedMethodDeclaration */:
       case 67 /* MethodBlockLiteral */:
-      case 75 /* MethodLiteral */:
+      case 74 /* MethodLiteral */:
       case 53 /* OperatorDeclaration */:
         return void 0;
-      case 99 /* RunStatement */:
+      case 98 /* RunStatement */:
         return this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(parent);
-      case 100 /* OnErrorClause */:
+      case 99 /* TryStatement */:
+      case 100 /* CatchClause */:
       case 102 /* FinallyClause */:
       case 107 /* ForStatement */:
       case 108 /* IfStatement */:
@@ -414,7 +413,7 @@ function isSubprogramDeclaration(node) {
     case 56 /* TypeVariableSetterDeclaration */:
     case 58 /* NestedMethodDeclaration */:
     case 67 /* MethodBlockLiteral */:
-    case 75 /* MethodLiteral */:
+    case 74 /* MethodLiteral */:
       return true;
     default:
       Debug.typeIsAssignableTo();
@@ -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) {
@@ -2032,19 +1994,18 @@ var SyntaxToCode = class _SyntaxToCode {
       [54 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
       [55 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
       [56 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
-      [94 /* StatementBlock */]: this.prototype.writeStatementBlock,
+      [93 /* StatementBlock */]: this.prototype.writeStatementBlock,
       [133 /* QualifiedName */]: this.prototype.writeQualifiedName,
       [140 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
       [141 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
       [142 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [143 /* CallArgument */]: this.prototype.writeCallArgument,
+      [143 /* Argument */]: this.prototype.writeArgument,
       [145 /* Tag */]: this.prototype.writeTag,
       [147 /* Modifier */]: this.prototype.writeModifier,
       [148 /* ParameterClause */]: this.prototype.writeParameterClause,
       [149 /* ParameterList */]: this.prototype.writeParameterList,
-      [150 /* SetterParameterClause */]: this.prototype.writeSetterParameterClause,
-      [152 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [154 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [150 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [152 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
       [17 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
       [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
       [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
@@ -2072,38 +2033,38 @@ 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 /* IndexedAccessArgumentList */]: this.prototype.writeNodeDefault,
-      [72 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
-      [73 /* InvalidExpression */]: this.prototype.writeNodeDefault,
-      [74 /* IsExpression */]: this.prototype.writeNodeDefault,
-      [75 /* MethodLiteral */]: this.prototype.writeNodeDefault,
-      [76 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
-      [77 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
-      [78 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
-      [79 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
-      [80 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
-      [81 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
-      [82 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
-      [83 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
-      [84 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
-      [85 /* TokenExpression */]: this.prototype.writeNodeDefault,
-      [86 /* KeywordExpression */]: this.prototype.writeNodeDefault,
-      [87 /* ObjectExpression */]: this.prototype.writeNodeDefault,
-      [88 /* BaseExpression */]: this.prototype.writeNodeDefault,
-      [89 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
-      [90 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
-      [91 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
-      [92 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
-      [93 /* StatementList */]: this.prototype.writeNodeDefault,
-      [95 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
-      [96 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
-      [97 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [98 /* RunStatementClauseList */]: this.prototype.writeNodeDefault,
-      [99 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [100 /* OnErrorClause */]: this.prototype.writeNodeDefault,
+      [71 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
+      [72 /* InvalidExpression */]: this.prototype.writeNodeDefault,
+      [73 /* IsExpression */]: this.prototype.writeNodeDefault,
+      [74 /* MethodLiteral */]: this.prototype.writeNodeDefault,
+      [75 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
+      [76 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
+      [77 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [78 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
+      [79 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
+      [80 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
+      [81 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [82 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [83 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [84 /* TokenExpression */]: this.prototype.writeNodeDefault,
+      [85 /* KeywordExpression */]: this.prototype.writeNodeDefault,
+      [86 /* ObjectExpression */]: this.prototype.writeNodeDefault,
+      [87 /* BaseExpression */]: this.prototype.writeNodeDefault,
+      [88 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
+      [89 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
+      [90 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
+      [91 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
+      [92 /* StatementList */]: this.prototype.writeNodeDefault,
+      [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 /* TryStatement */]: this.prototype.writeNodeDefault,
+      [100 /* CatchClause */]: this.prototype.writeNodeDefault,
       [101 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
       [102 /* FinallyClause */]: this.prototype.writeNodeDefault,
       [103 /* EmptyStatement */]: this.prototype.writeNodeDefault,
@@ -2144,10 +2105,9 @@ var SyntaxToCode = class _SyntaxToCode {
       [139 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
       [144 /* TagList */]: this.prototype.writeNodeDefault,
       [146 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [151 /* SetterParameterDeclaration */]: this.prototype.writeNodeDefault,
-      [153 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [155 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [156 /* TypeAnnotation */]: this.prototype.writeNodeDefault
+      [151 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [153 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [154 /* TypeAnnotation */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2158,14 +2118,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
@@ -2521,17 +2481,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) {
@@ -2587,14 +2536,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;
@@ -2603,15 +2552,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);
@@ -2643,17 +2592,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);
@@ -2677,10 +2624,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);
@@ -2740,7 +2683,7 @@ var CodeActionsService = class {
     }
     const result = new Array();
     const diagnosticCodeSet = new Set(diagnosticCodes);
-    if (diagnosticCodeSet.has(103 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(104 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
+    if (diagnosticCodeSet.has(104 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(105 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
       const data = { onlyTypeMembers: false };
       result.push(CodeAction.unresolved(
         "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u044B.",
@@ -2799,56 +2742,38 @@ function isGenerateMissingTranslationsCodeActionData(value) {
 
 // source/services/signature-help/SignatureWithValueParameters.ts
 var ValueArgumentFactory = class _ValueArgumentFactory {
-  static {
-    this.createValueArgumentFromCallArgument = (argument) => new ValueArgument(argument.name?.value, argument.value);
-  }
-  static {
-    this.createValueArgumentFromIndexerArgument = (argument) => new ValueArgument(void 0, argument);
-  }
   static createValueArgumentsOfCallExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromListElement(
-      node.callArgumentList.elements,
-      _ValueArgumentFactory.createValueArgumentFromCallArgument
-    );
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
   }
   static createValueArgumentsOfAutotypeCallExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromListElement(
-      node.callArgumentList.elements,
-      _ValueArgumentFactory.createValueArgumentFromCallArgument
-    );
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
   }
   static createValueArgumentsOfIndexedAccessExpression(node) {
-    return _ValueArgumentFactory.createValueArgumentsFromListElement(
-      node.argumentsList.elements,
-      _ValueArgumentFactory.createValueArgumentFromIndexerArgument
-    );
+    return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
   }
   static createValueArgumentsOfTag(node) {
-    if (node.callArgumentList !== void 0) {
-      return _ValueArgumentFactory.createValueArgumentsFromListElement(
-        node.callArgumentList.elements,
-        _ValueArgumentFactory.createValueArgumentFromCallArgument
-      );
+    if (node.argumentList !== void 0) {
+      return _ValueArgumentFactory.createValueArgumentsFromList(node.argumentList);
     }
     return [];
   }
-  static createValueArgumentsFromListElement(elements, createValueArgument) {
+  static createValueArgumentsFromList(list) {
     const result = new Array();
     let previousElementIsArgument = false;
-    for (const element of elements) {
+    for (const element of list.elements) {
       if (element.kind === 0 /* Token */) {
         if (!previousElementIsArgument) {
           result.push(new ValueArgument(void 0, void 0));
         }
         previousElementIsArgument = false;
       } else {
-        result.push(createValueArgument(element));
+        result.push(new ValueArgument(element.name?.value, element.value));
         previousElementIsArgument = true;
       }
     }
-    if (elements.length > 0 && elements[elements.length - 1].kind === 0 /* Token */) {
+    if (list.elements.length > 0 && list.elements[list.elements.length - 1].kind === 0 /* Token */) {
       result.push(new ValueArgument(void 0, void 0));
-    } else if (elements.length === 0) {
+    } else if (list.elements.length === 0) {
       result.push(new ValueArgument(void 0, void 0));
     }
     return result;
@@ -2861,7 +2786,7 @@ var SignatureForNode = class _SignatureForNode {
         return _SignatureForNode.getSignaturesForCallExpression(analyzer, node);
       case 70 /* AutotypeCallExpression */:
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
-      case 72 /* IndexedAccessExpression */:
+      case 71 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
       case 145 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
@@ -2885,16 +2810,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") {
@@ -2916,26 +2832,25 @@ var SignatureForNode = class _SignatureForNode {
     return void 0;
   }
   static getSignaturesForIndexedAccessExpression(analyzer, node) {
-    const meaning = analyzer.getIndexedAccessExpressionMeaning(node);
-    let indexer;
+    const meaning = analyzer.resolveIndexedAccessExpression(node).meaning;
     switch (meaning.kind) {
-      case "resolved":
-        indexer = meaning.indexer;
-        break;
+      case "resolved": {
+        let suitableSignatureIndex;
+        if (meaning.singleSuitableIndexer !== void 0) {
+          suitableSignatureIndex = meaning.candidates.indexOf(meaning.singleSuitableIndexer);
+        }
+        const signatures = meaning.candidates.map((i) => new IndexerSignature(i));
+        return new SignaturesWithSingleSuitable(signatures, suitableSignatureIndex);
+      }
       case "unresolved":
-        break;
+        return void 0;
       default:
         Debug.never(meaning);
     }
-    if (indexer !== void 0) {
-      const signature = new IndexerSignature(indexer);
-      return new SignaturesWithSingleSuitable([signature], 0);
-    }
-    return void 0;
   }
   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]);
@@ -2943,6 +2858,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;
     }
@@ -3003,7 +2926,7 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         result = false;
         break;
       }
-      if (argument.expression === void 0 || argument.expression.kind === 73 /* InvalidExpression */) {
+      if (argument.expression === void 0 || argument.expression.kind === 72 /* InvalidExpression */) {
         continue;
       }
       const targetParameterType = targetParameter.getType();
@@ -3051,47 +2974,9 @@ var MatchedSignature = class {
     this.matchResult = matchResult;
   }
 };
-var MethodEntitySignature = 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 {
+var AccessedMethodSignature = class {
   constructor(method) {
-    this.kind = "substituted-method";
+    this.kind = "accessed-method";
     this._valueParameters = new Cached();
     this.method = method;
   }
@@ -3283,7 +3168,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 */) {
@@ -3297,7 +3182,7 @@ var CompletionService = class {
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || this.tokenOrKeywordIsPackageImportListChild(tokenOrKeyword)) {
       return new PackageImportCompletionContext([], void 0);
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 79 /* PropertyAccessExpression */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 78 /* PropertyAccessExpression */) {
       const propertyAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(propertyAccess.expression);
@@ -3346,7 +3231,7 @@ var CompletionService = class {
       );
       if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
         let completionInIsOrAsExpressionInfo;
-        if (namedTypeSpecifier.parent.kind === 74 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
+        if (namedTypeSpecifier.parent.kind === 73 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
           completionInIsOrAsExpressionInfo = {
             expressionType: this._analyzer.type.ofExpression(namedTypeSpecifier.parent.expression)
           };
@@ -3380,9 +3265,45 @@ var CompletionService = class {
       }
       return { kind: "none" };
     }
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 133 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 145 /* 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 === 74 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+      if (tokenOrKeyword.parent.kind === 73 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
         completionInIsOrAsExpressionInfo = {
           expressionType: this._analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
@@ -3391,6 +3312,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);
@@ -3432,17 +3358,17 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 132 /* PackageImportTranslation */) {
+    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 132 /* PackageImportTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(15 /* Type */) && (tokenOrKeyword.parent.kind === 137 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 131 /* MethodTypeTranslation */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 137 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 131 /* MethodTypeTranslation */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 129 /* PackageMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 129 /* PackageMethodTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3489,12 +3415,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 130 /* TypeMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 130 /* TypeMethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 124 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(29 /* Creation */) && tokenOrKeyword.parent.kind === 124 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3538,6 +3464,15 @@ var CompletionService = class {
           signatures = SignatureForNode.getSignaturesForTag(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(role.argumentList.parent);
           break;
+        case 71 /* IndexedAccessExpression */:
+          signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
+            this._analyzer,
+            role.argumentList.parent
+          );
+          valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(role.argumentList.parent);
+          break;
+        default:
+          Debug.never(role.argumentList.parent);
       }
       if (signatures !== void 0) {
         return this.getTargetTypesAndTargetSignaturesParametersFromSignatures(
@@ -3549,22 +3484,6 @@ var CompletionService = class {
         return { targetTypes: void 0, targetSignaturesParameters: void 0 };
       }
     }
-    if (role.kind === "indexed-access-argument") {
-      const signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
-        this._analyzer,
-        role.argumentList.parent
-      );
-      const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(role.argumentList.parent);
-      if (signatures !== void 0) {
-        return this.getTargetTypesAndTargetSignaturesParametersFromSignatures(
-          signatures.values,
-          valueArguments,
-          role.index
-        );
-      } else {
-        return { targetTypes: void 0, targetSignaturesParameters: void 0 };
-      }
-    }
     if (role.kind === "array-element") {
       let type = this._analyzer.type.ofExpression(role.array);
       type = this._analyzer.excludeNoneFromType(type);
@@ -3639,6 +3558,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;
@@ -3671,29 +3593,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(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(16 /* Basic */).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 */);
             }
           }
@@ -3701,31 +3623,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 === 75 /* 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))
@@ -3736,7 +3658,7 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 114 /* LoopStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 114 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
@@ -3750,14 +3672,14 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 108 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.thenBlock || tokenOrKeyword.parent.parent.kind === 110 /* ElseIfClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 108 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.thenBlock || tokenOrKeyword.parent.parent.kind === 110 /* ElseIfClause */);
   }
   isRunStatementAccessorListContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 99 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* OnErrorClause */ || tokenOrKeyword.parent.parent.kind === 102 /* FinallyClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 98 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* CatchClause */ || tokenOrKeyword.parent.parent.kind === 102 /* FinallyClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(57 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3774,7 +3696,7 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 119 /* SwitchStatementCaseClause */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 119 /* SwitchStatementCaseClause */) {
       return true;
     }
     if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 117 /* SwitchStatement */) {
@@ -3783,22 +3705,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));
     }
@@ -3820,19 +3727,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));
   }
@@ -3874,19 +3768,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);
@@ -3940,34 +3822,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();
@@ -3978,7 +3860,7 @@ var CompletionService = class {
         case "type": {
           return new NamedTypeCompletionItemInfo(
             this.completionItemInfoContext,
-            d.value.value.getEntity(),
+            d.value.value,
             d.name,
             d.requiresExplicitOriginalName
           );
@@ -3992,8 +3874,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));
@@ -4007,22 +3979,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);
     }
@@ -4039,37 +4011,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) => {
@@ -4088,11 +4050,7 @@ var CompletionService = class {
   }
   getTopLevelAliasListCompletionItemInfos(ctx) {
     let result;
-    const displayService_ = new DisplayService(
-      this._analyzer,
-      new LocalizationContext([], ctx.sourceLocale),
-      this._dialect
-    );
+    const displayService_ = new DisplayService(this._analyzer, ctx.sourceLocale, this._dialect);
     if (ctx.translationKind === 1 /* PackageImport */) {
       let items;
       if (this._sourceFile.package.kind === "translation") {
@@ -4107,10 +4065,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_
           );
@@ -4119,10 +4077,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_
           );
@@ -4141,31 +4099,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 {
@@ -4173,9 +4131,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(
@@ -4188,14 +4146,10 @@ var CompletionService = class {
   getTypeAliasMemberListItemInfos(ctx) {
     let result = Query.empty();
     if (ctx.typeEntity !== void 0) {
-      const displayService_ = new DisplayService(
-        this._analyzer,
-        new LocalizationContext([], ctx.sourceLocale),
-        this._dialect
-      );
+      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,
@@ -4220,7 +4174,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,
@@ -4249,8 +4203,8 @@ var CompletionService = class {
     }
     if (!ctx.hasPrecedingKeyword) {
       const keywords = [
-        11 /* Function */,
-        28 /* Creation */
+        12 /* Function */,
+        29 /* Creation */
       ];
       result = result.chain(
         Query.from(keywords).map(
@@ -4411,7 +4365,7 @@ function getRightmostChildExcludingValidEmptyNodes(node) {
 }
 function isInvalidNode(node) {
   switch (node.kind) {
-    case 73 /* InvalidExpression */:
+    case 72 /* InvalidExpression */:
     case 43 /* InvalidPackageMemberDeclaration */:
     case 111 /* InvalidStatement */:
     case 57 /* InvalidTypeMemberDeclaration */:
@@ -4464,6 +4418,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;
@@ -4607,7 +4567,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(
@@ -4681,33 +4641,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;
@@ -4724,7 +4657,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":
@@ -4800,14 +4733,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()) {
@@ -4817,7 +4750,7 @@ var NamedTypeCompletionItemInfo = class {
         } else {
           return 20 /* InvalidType */;
         }
-      case 14 /* AliasType */:
+      case 4 /* Alias */:
         return 19 /* AliasType */;
       default:
         Debug.never(this.entity);
@@ -5016,12 +4949,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()) {
@@ -5031,7 +4964,7 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
         }
         return 20 /* InvalidType */;
       }
-      case 14 /* AliasType */:
+      case 4 /* Alias */:
         return 19 /* AliasType */;
     }
   }
@@ -5050,20 +4983,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)
         );
@@ -5126,7 +5059,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;
     });
   }
@@ -5140,7 +5073,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})`;
   }
@@ -5178,7 +5111,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;
@@ -5188,24 +5121,18 @@ 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;
     this.kind = "call-argument";
   }
 };
-var ExpressionRole_indexedAccessArgument = class {
-  constructor(argumentList, index) {
-    this.argumentList = argumentList;
-    this.index = index;
-    this.kind = "indexed-access-argument";
-  }
-};
 var ExpressionRole_arrayElement = class {
   constructor(array) {
     this.array = array;
@@ -5260,6 +5187,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 === 145 /* Tag */;
     let isTopLevelTranslationListContext;
     if (positionDescription.kind === "after-token-or-keyword") {
       isTopLevelTranslationListContext = this.isTopLevelTranslationListContext(positionDescription.tokenOrKeyword);
@@ -5278,13 +5206,14 @@ var SyntaxContextFactory = class {
       isExpressionContext,
       precedingExpression,
       isUnqualifiedTypeContext,
+      isUnqualifiedTagNameCompletionContext,
       isTopLevelTranslationListContext,
       isTypeMemberTranslationListContext
     );
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(57 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5304,7 +5233,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 143 /* CallArgument */) {
+      if (tokenOrKeyword.parent.kind === 143 /* Argument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5313,11 +5242,11 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 78 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5325,11 +5254,11 @@ var SyntaxContextFactory = class {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 82 /* TextTemplateLiteral */) {
+    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 81 /* TextTemplateLiteral */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.spanList.spans.at(0)?.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 84 /* TextTemplateSpan */) {
+    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 83 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5341,39 +5270,39 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 93 /* StatementList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 92 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(44 /* OpenParenthesis */)) {
-      if (tokenOrKeyword.parent.kind === 76 /* ParenthesizedExpression */) {
+      if (tokenOrKeyword.parent.kind === 75 /* ParenthesizedExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 80 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 79 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         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 === 145 /* 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 === 72 /* IndexedAccessExpression */) {
-      const expressionRole = new ExpressionRole_indexedAccessArgument(tokenOrKeyword.parent.argumentsList, 0);
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+      const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 61 /* ArrayLiteral */) {
@@ -5381,21 +5310,7 @@ var SyntaxContextFactory = class {
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(24 /* Comma */)) {
-      if (tokenOrKeyword.parent.kind === 68 /* CallArgumentList */) {
-        const argumentList = tokenOrKeyword.parent;
-        let index = 0;
-        for (const element of argumentList.elements) {
-          if (element.kind === 0 /* Token */) {
-            index++;
-            if (element === tokenOrKeyword.value) {
-              break;
-            }
-          }
-        }
-        const expressionRole = new ExpressionRole_callArgument(argumentList, index);
-        return { isExpressionContext: { expressionRole }, isStatementContext: false };
-      }
-      if (tokenOrKeyword.parent.kind === 71 /* IndexedAccessArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 68 /* ArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5406,7 +5321,7 @@ var SyntaxContextFactory = class {
             }
           }
         }
-        const expressionRole = new ExpressionRole_indexedAccessArgument(argumentList, index);
+        const expressionRole = new ExpressionRole_argument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
       if (tokenOrKeyword.parent.kind === 118 /* MatchExpressionList */) {
@@ -5418,47 +5333,47 @@ var SyntaxContextFactory = class {
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(43 /* Case */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatementCaseClause */) {
+    if (tokenOrKeyword.isKeyword(44 /* Case */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatementCaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Return */) && tokenOrKeyword.parent.kind === 115 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 115 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(42 /* Switch */) && tokenOrKeyword.parent.kind === 117 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(43 /* Switch */) && tokenOrKeyword.parent.kind === 117 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(12 /* If */) && tokenOrKeyword.parent.kind === 108 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 108 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(10 /* ElseIf */) && tokenOrKeyword.parent.kind === 110 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 110 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(8 /* From */) && tokenOrKeyword.parent.kind === 107 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 107 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(23 /* While */) && tokenOrKeyword.parent.kind === 120 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(24 /* While */) && tokenOrKeyword.parent.kind === 120 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 114 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(26 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 114 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(26 /* Yield */) && tokenOrKeyword.parent.kind === 121 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(27 /* Yield */) && tokenOrKeyword.parent.kind === 121 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* When */) && tokenOrKeyword.parent.kind === 77 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isKeyword(28 /* When */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 77 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.secondExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5480,7 +5395,7 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 40 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 33 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 38 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 22 /* PackageAliasTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageMethodDeclaration */))) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageMethodDeclaration */))) {
       return true;
     }
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
@@ -5559,20 +5474,20 @@ var SyntaxContextFactory = class {
     return result;
   }
   static isUnqualifiedTypeContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 156 /* TypeAnnotation */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 154 /* 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 === 152 /* TypeArgumentClause */) {
+    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 150 /* TypeArgumentClause */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */)) {
-      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */ };
+    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 151 /* TypeArgumentList */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 151 /* TypeArgumentList */ };
     }
     if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 145 /* Tag */) {
       return { allowsAnonymousTypes: false };
@@ -5583,10 +5498,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 === 74 /* 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 */) {
@@ -5777,27 +5692,27 @@ var NodeSemanticInfoService = class {
       return this.ofNonKeywordIdentifier(analyzer, tokenOrKeyword.value, options6);
     } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
       return this.ofAutotypeCallExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 78 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* TypeDereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* TypeDereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 81 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    } 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 === 91 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 90 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 87 /* ObjectExpression */) {
+    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 86 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(55 /* Base */) && tokenOrKeyword.parent.kind === 88 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(55 /* Base */) && tokenOrKeyword.parent.kind === 87 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options6);
     } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* TypeIndexerParameterClause */) {
       return this.ofTypeIndexerDeclaration(analyzer, tokenOrKeyword.parent.parent);
-    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 72 /* IndexedAccessExpression */) {
+    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     }
     return void 0;
@@ -5814,7 +5729,7 @@ var NodeSemanticInfoService = class {
         break;
       case 122 /* TranslationParameterList */:
         break;
-      case 143 /* CallArgument */: {
+      case 143 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new SimpleWithLocalization(
@@ -5852,7 +5767,7 @@ var NodeSemanticInfoService = class {
       case 38 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 89 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
       case 58 /* NestedMethodDeclaration */:
@@ -6005,7 +5920,7 @@ var NodeSemanticInfoService = class {
       case 9 /* PackagePath */:
         result = void 0;
         break;
-      case 79 /* PropertyAccessExpression */:
+      case 78 /* PropertyAccessExpression */:
         result = this.ofProperty(analyzer, parent, options6);
         break;
       case 52 /* TypeMethodDeclaration */:
@@ -6031,9 +5946,6 @@ var NodeSemanticInfoService = class {
       case 56 /* TypeVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedTypeVariableDeclaration(parent));
         break;
-      case 151 /* SetterParameterDeclaration */:
-        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofSetterParameterDeclaration(parent));
-        break;
       case 3 /* Keyword */:
         break;
       default:
@@ -6046,18 +5958,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;
@@ -6065,7 +5969,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;
@@ -6073,7 +5977,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;
@@ -6114,7 +6018,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":
@@ -6140,19 +6044,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 145 /* Tag */:
+        return this.ofTagNameQualifier(analyzer, node.parent, qualifier, options6);
+      case 42 /* ExtendedTypeClause */:
+      case 132 /* 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);
@@ -6160,55 +6115,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 132 /* 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":
@@ -6230,13 +6202,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);
@@ -6262,11 +6234,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;
@@ -6312,19 +6287,28 @@ var NodeSemanticInfoService = class {
     return new DefinitionNodeSemanticInfo(entity);
   }
   static ofIndexedAccessExpressionOperator(analyzer, node, options6) {
-    const meaning = analyzer.getIndexedAccessExpressionMeaning(node);
+    const meaning = analyzer.resolveIndexedAccessExpression(node).meaning;
     if (meaning.kind === "resolved") {
-      const target = new SimpleWithLocalization(
-        new TypeIndexerReferenceTarget(meaning.indexer.value, meaning.access.kind),
-        meaning.indexer.localization
-      );
-      let result = new ReferenceNodeSemanticInfo([target], false);
-      if (options6.includeBetterReferenceTargets) {
+      let result;
+      if (isNonEmptyArray(meaning.suitableIndexers)) {
+        result = createIndexersReference(
+          meaning.suitableIndexers,
+          meaning.accessKind,
+          meaning.suitableIndexers.length > 1
+        );
+      } else if (isNonEmptyArray(meaning.candidates)) {
+        result = createIndexersReference(meaning.candidates, meaning.accessKind, true);
+      }
+      if (result !== void 0 && options6.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
       }
       return result;
     }
     return void 0;
+    function createIndexersReference(indexers, accessKind, isAmbiguous) {
+      const targets = indexers.map((i) => new SimpleWithLocalization(new TypeIndexerReferenceTarget(i.value, accessKind), i.localization));
+      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
+    }
   }
   static ofAssignmentStatementOperator(analyzer, node, options6) {
     const operatorKind = analyzer.getBinaryOperatorKindIfCompoundAssignmentOperator(node.operator);
@@ -6385,7 +6369,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);
@@ -6499,7 +6483,7 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 79 /* PropertyAccessExpression */) {
+    while (parent.kind === 78 /* PropertyAccessExpression */) {
       const meaning = analyzer.resolvePropertyAccessExpression(parent).meaning;
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
@@ -6521,7 +6505,7 @@ var NodeSemanticInfoService = class {
       false
     );
   }
-  static ofMaybeConstructorCall(analyzer, types, typeAccessExpression, options6) {
+  static ofMaybeConstructorCallExpression(analyzer, types, typeAccessExpression, options6) {
     if (types.length === 0) {
       return void 0;
     }
@@ -6540,7 +6524,7 @@ var NodeSemanticInfoService = class {
     let parentCallExpression;
     if (parent.kind === 69 /* CallExpression */) {
       parentCallExpression = parent;
-    } else if (parent.kind === 90 /* GenericSpecializationExpression */) {
+    } else if (parent.kind === 89 /* GenericSpecializationExpression */) {
       const grandParent = getParentSkippingParenthesizedExpressions(parent);
       if (grandParent.kind === 69 /* CallExpression */) {
         parentCallExpression = grandParent;
@@ -6548,17 +6532,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) {
@@ -6607,7 +6588,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;
@@ -6743,7 +6724,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;
@@ -6764,7 +6745,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) => {
@@ -6773,7 +6754,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) => {
@@ -6792,7 +6773,7 @@ function getEntitySourceLocations(analyzer, entity) {
         case 18 /* AnonymousStructuredTypeDeclaration */:
         case 19 /* AnonymousVariantTypeDeclaration */:
         case 67 /* MethodBlockLiteral */:
-        case 75 /* MethodLiteral */:
+        case 74 /* MethodLiteral */:
           range = node.rangeWithoutTrivia;
           break;
         case 22 /* PackageAliasTypeDeclaration */:
@@ -6803,7 +6784,6 @@ function getEntitySourceLocations(analyzer, entity) {
         case 58 /* NestedMethodDeclaration */:
         case 52 /* TypeMethodDeclaration */:
         case 141 /* TypeParameterDeclaration */:
-        case 140 /* VariantDeclaration */:
         case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
@@ -7050,7 +7030,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
@@ -7092,7 +7072,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 78 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 77 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -7136,7 +7116,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 81 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 80 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -7152,7 +7132,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 92 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 91 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -7180,7 +7160,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 87 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 86 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7192,7 +7172,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 88 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 87 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7216,7 +7196,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 72 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
+              if (node.kind === 71 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedAccessExpressionOperator(
                   analyzer,
                   node,
@@ -7370,7 +7350,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);
@@ -7381,11 +7361,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;
@@ -7394,17 +7374,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;
@@ -7438,46 +7418,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);
@@ -7589,9 +7573,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 89 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         return parent;
-      case 79 /* PropertyAccessExpression */:
+      case 78 /* PropertyAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7612,9 +7596,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 89 /* IdentifierExpression */:
+      case 88 /* IdentifierExpression */:
         return true;
-      case 79 /* PropertyAccessExpression */:
+      case 78 /* PropertyAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -8124,14 +8108,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 */:
@@ -8307,7 +8291,7 @@ var SelectionRangeService = class {
       if (!this.nodeShouldBeSkipped(child) && !child.rangeWithoutTrivia.equals(result.range)) {
         result = new SelectionRange(child.rangeWithoutTrivia, result);
       }
-      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 82 /* TextTemplateLiteral */) {
+      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 81 /* TextTemplateLiteral */) {
         const textContentStart = child.rangeWithoutTrivia.start + 1;
         const textContentEnd = child.rangeWithoutTrivia.end - 1;
         if (offset >= textContentStart && offset < textContentEnd) {
@@ -8338,13 +8322,13 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 156 /* TypeAnnotation */:
+      case 154 /* TypeAnnotation */:
       case 34 /* StructuredTypeDeclarationBody */:
       case 39 /* VariantTypeDeclarationBody */:
       case 23 /* AliasTypeDeclarationBody */:
       case 29 /* MethodTypeDeclarationBody */:
-      case 84 /* TextTemplateSpan */:
-      case 83 /* TextTemplateSpanList */:
+      case 83 /* TextTemplateSpan */:
+      case 82 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8382,33 +8366,41 @@ var SemanticTokensService = class {
             controller.stopChildrenTraverse();
             return;
           }
-          if (node.kind === 89 /* IdentifierExpression */) {
+          if (node.kind === 88 /* IdentifierExpression */) {
             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())
+                    );
+                  }
                 }
               }
             }
@@ -8422,15 +8414,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,
@@ -8439,16 +8422,19 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 79 /* PropertyAccessExpression */) {
+          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) {
@@ -8648,7 +8634,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);
@@ -8664,7 +8650,7 @@ var TypeParameterSignatureHelpProvider = class {
     }
     let node = token.parent;
     while (node !== void 0) {
-      if (node.kind === 152 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
+      if (node.kind === 150 /* 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);
@@ -8709,8 +8695,10 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 90 /* GenericSpecializationExpression */:
+      case 89 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
+      case 145 /* Tag */:
+        return this.getSignaturesForTag(node);
       default:
         Debug.never(node);
     }
@@ -8725,9 +8713,30 @@ 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 === 89 /* IdentifierExpression */) {
+    if (expression.kind === 88 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "method-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
@@ -8742,7 +8751,7 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 79 /* PropertyAccessExpression */) {
+    if (expression.kind === 78 /* PropertyAccessExpression */) {
       const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
       let accessedMethods;
       if (meaning.kind === "instance-method-access") {
@@ -8772,12 +8781,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:
@@ -8787,28 +8796,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);
@@ -8823,7 +8832,7 @@ var NodeWithTypeArgumentsInfo = class {
     this.argumentCount = argumentCount;
   }
 };
-var MethodEntitySignature2 = class {
+var MethodEntitySignature = class {
   constructor(ctx, method, localization) {
     this.ctx = ctx;
     this.method = method;
@@ -8839,7 +8848,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;
@@ -8998,7 +9007,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;
@@ -9006,22 +9015,22 @@ 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;
         }
-        case 72 /* IndexedAccessExpression */: {
+        case 71 /* IndexedAccessExpression */: {
           if (this._offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(node);
-            const argumentIndex = this.getArgumentIndexInList(node.argumentsList.elements, this._offset);
+            const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             return new NodeWithValueArgumentsInfo(node, valueArguments, argumentIndex);
           }
           break;
         }
         case 145 /* 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);
           }
@@ -9047,24 +9056,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
         );
@@ -9161,16 +9154,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]);
   }
@@ -9221,18 +9214,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;
@@ -9248,7 +9241,7 @@ var ClientTrackedSourceFile = class extends ObservableObject {
   }
 };
 __decorateClass([
-  unobservable
+  trigger(false)
 ], ClientTrackedSourceFile.prototype, "uri", 2);
 var ClientTrackedSourceFileSnapshot = class {
   constructor(uri, text, version, isSaved) {
@@ -9262,15 +9255,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",
@@ -9279,7 +9272,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;
@@ -9761,72 +9754,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 {
@@ -9888,11 +9881,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 {
@@ -9900,7 +9893,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
@@ -9981,7 +9974,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) {
@@ -10028,7 +10021,7 @@ var ConfigurationController = class extends ObservableObject2 {
   //     }
   //   }
   // }
-  // @reactive
+  // @reaction
   // @options({ reentrance: Reentrance.cancelPrevious, order: 22 })
   // private async analyze(): Promise<void> {
   //   if (!this._mainCompilationController.isConfigurationsProcessingEnabled) {
@@ -10062,11 +10055,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) {
@@ -10092,7 +10085,7 @@ var ConfigurationController = class extends ObservableObject2 {
   //     }
   //   }
   // }
-  // @reactive
+  // @reaction
   // @options({ reentrance: Reentrance.cancelPrevious, order: 23 })
   // private async interpretConfiguration(): Promise<void> {
   //   if (!this._mainCompilationController.isConfigurationsProcessingEnabled) {
@@ -10134,23 +10127,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 {
@@ -10212,31 +10205,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);
@@ -10604,7 +10597,7 @@ var FileSystemTreeProviderBasedOnWatchedFileSystem = class extends ObservableObj
       this.fileSystemTree.deleteFileOrDirectory(uri);
     }
   }
-  // @reactive
+  // @reaction
   // @options({ order: 0 })
   // protected unloadWorkspaceFoldersThatNoLongerContainArtelProject(): void {
   //   if (this.isMissingConfigurationDirectoryAllowed) {
@@ -10729,65 +10722,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() {
@@ -10863,10 +10856,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 });
@@ -10922,25 +10915,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();
@@ -11039,59 +11032,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);
   }
@@ -11190,39 +11183,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();
@@ -11492,39 +11485,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;
@@ -11540,22 +11533,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);
@@ -11564,7 +11565,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());
@@ -11589,7 +11590,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());
@@ -11606,7 +11607,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) {
@@ -11683,21 +11684,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());
@@ -11722,7 +11726,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());
@@ -11743,16 +11747,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());
@@ -11768,7 +11772,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);
@@ -11781,7 +11785,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);
@@ -11789,10 +11793,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();
@@ -11812,14 +11816,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);
@@ -11864,8 +11865,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());
@@ -11923,7 +11924,7 @@ var EntityToSyntax = class {
       default:
         Debug.never(hiding);
     }
-    return SyntaxFactory.modifier(34 /* Hidden */, levelKeyword);
+    return SyntaxFactory.modifier(35 /* Hidden */, levelKeyword);
   }
   convertTags(_entityTags) {
     return [];
@@ -12011,13 +12012,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);
@@ -12173,7 +12174,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") {
@@ -12181,33 +12182,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);
@@ -12227,7 +12232,7 @@ var SourceGenerationService = class extends ObservableObject7 {
   }
 };
 __decorateClass([
-  reactive6
+  reaction6
 ], SourceGenerationService.prototype, "onOpenedSourceFilesChanged", 1);
 var deleteGeneratedPackageTimeoutMs = 1e4;
 var GeneratedPackageState = class {
@@ -12250,37 +12255,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);
@@ -12288,7 +12296,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)) {
@@ -12309,7 +12317,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) {
@@ -12329,7 +12337,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) {
@@ -12432,13 +12440,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);
@@ -12449,34 +12450,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 */:
-        return entity.getValueParameters();
-      case 7 /* Indexer */:
+      case 1 /* Method */:
         return entity.getValueParameters();
-      case 9 /* Constructor */:
+      case 5 /* Indexer */:
         return entity.getValueParameters();
-      case 10 /* Destructor */:
+      case 7 /* Constructor */:
         return entity.getValueParameters();
-      case 11 /* MethodType */:
+      case 8 /* Destructor */:
         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);
@@ -12484,29 +12484,25 @@ var EntityFinder = class {
   }
   ifEntityWithTypeParametersThenParameters(entity) {
     switch (entity.kind) {
-      case 5 /* Method */:
-        return entity.getTypeParameters();
-      case 11 /* MethodType */:
-        return entity.getTypeParameters();
-      case 2 /* VariantType */:
-        return entity.getTypeParameters();
-      case 12 /* StructuredType */:
+      case 1 /* Method */:
         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);
@@ -13190,7 +13186,7 @@ var LanguageServer = class {
       const sourceFileContext = yield this.getSourceFileContext(uri, token);
       if (sourceFileContext !== void 0) {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
-        if (node?.kind === 92 /* AssignmentStatement */) {
+        if (node?.kind === 91 /* AssignmentStatement */) {
           const sourceFileEdit = this._addPropertyAssignmentService.createEditWithAssignment(
             sourceFileContext.sourceFile,
             node,
@@ -13227,7 +13223,7 @@ var LanguageServer = class {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
         if (node !== void 0) {
           let nodeForRange = node;
-          if (node.kind === 92 /* AssignmentStatement */) {
+          if (node.kind === 91 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);
@@ -13773,7 +13769,7 @@ ${e}`);
   }
 };
 __decorateClass([
-  atomic6
+  atomicBlock6
 ], LanguageServer.prototype, "onDidChangeWorkspaceFolders", 1);
 var FileSystemSynchronizationMode;
 ((FileSystemSynchronizationMode2) => {