@artel/artc 0.6.25223 → 0.6.25224

package/build/api/ApiServices.js

@@ -35,6 +35,8 @@ import {
   IndexerDeclaration_typeMember,
   IndexerTranslation,
   IndexerTranslationParameterClause,
+  IntersectionTypeSpecifier,
+  IntersectionTypeSpecifierTypeList,
   JavaScriptInterfacePackageImplementationConfig,
   JsonConfigurationFileNameSet,
   Keyword,
@@ -182,7 +184,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-DZNNWICP.js";
+} from "../chunk-24QZJOMF.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -302,7 +304,7 @@ var AddPropertyAssignmentService = class {
     let result;
     let leftValueText;
     if (propertyName !== void 0) {
-      if (assignmentNode.left.kind !== 78 /* PropertyAccessExpression */) {
+      if (assignmentNode.left.kind !== 80 /* PropertyAccessExpression */) {
         return void 0;
       }
       const propertyReceiver = assignmentNode.left.expression;
@@ -319,7 +321,7 @@ var AddPropertyAssignmentService = class {
     const reassignmentText = `${leftValueText} = ${value}`;
     const subprogramBody = this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(assignmentNode);
     if (subprogramBody !== void 0) {
-      const lastStatement = subprogramBody.expressionOrStatementList.kind === 92 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
+      const lastStatement = subprogramBody.expressionOrStatementList.kind === 94 /* StatementList */ ? subprogramBody.expressionOrStatementList?.statements.last() : subprogramBody.expressionOrStatementList;
       let editRangeStart;
       let indentationText;
       if (lastStatement !== void 0) {
@@ -351,9 +353,9 @@ var AddPropertyAssignmentService = class {
   ifShouldBeAssignedAtTheEndOfSubprogramThenBody(node) {
     const parent = node.parent.parent;
     switch (parent.kind) {
-      case 93 /* StatementBlock */:
+      case 95 /* StatementBlock */:
         return this.getContainingSubprogram(parent)?.block;
-      case 94 /* FunctionBlock */:
+      case 96 /* FunctionBlock */:
         return void 0;
       default:
         Debug.never(parent);
@@ -372,23 +374,23 @@ var AddPropertyAssignmentService = class {
 };
 function isSubprogramDeclaration(node) {
   switch (node.kind) {
-    case 25 /* PackageConstructorDeclaration */:
-    case 26 /* PackageEntryPointDeclaration */:
-    case 27 /* PackageMethodDeclaration */:
-    case 36 /* PackageVariableGetterDeclaration */:
-    case 37 /* PackageVariableSetterDeclaration */:
-    case 45 /* TypeConstructorDeclaration */:
-    case 46 /* TypeDestructorDeclaration */:
-    case 47 /* TypeIndexedGetterDeclaration */:
-    case 48 /* TypeIndexedSetterDeclaration */:
-    case 50 /* TypeDereferencedVariableGetterDeclaration */:
-    case 51 /* TypeDereferencedVariableSetterDeclaration */:
-    case 52 /* TypeMethodDeclaration */:
-    case 55 /* TypeVariableGetterDeclaration */:
-    case 56 /* TypeVariableSetterDeclaration */:
-    case 58 /* NestedMethodDeclaration */:
-    case 67 /* MethodBlockLiteral */:
-    case 74 /* MethodLiteral */:
+    case 27 /* PackageConstructorDeclaration */:
+    case 28 /* PackageEntryPointDeclaration */:
+    case 29 /* PackageMethodDeclaration */:
+    case 38 /* PackageVariableGetterDeclaration */:
+    case 39 /* PackageVariableSetterDeclaration */:
+    case 47 /* TypeConstructorDeclaration */:
+    case 48 /* TypeDestructorDeclaration */:
+    case 49 /* TypeIndexedGetterDeclaration */:
+    case 50 /* TypeIndexedSetterDeclaration */:
+    case 52 /* TypeDereferencedVariableGetterDeclaration */:
+    case 53 /* TypeDereferencedVariableSetterDeclaration */:
+    case 54 /* TypeMethodDeclaration */:
+    case 57 /* TypeVariableGetterDeclaration */:
+    case 58 /* TypeVariableSetterDeclaration */:
+    case 60 /* NestedMethodDeclaration */:
+    case 69 /* MethodBlockLiteral */:
+    case 76 /* MethodLiteral */:
       return true;
     default:
       Debug.typeIsAssignableTo();
@@ -734,6 +736,14 @@ var SyntaxFactory = class {
       new UnionTypeSpecifierTypeList(this.createTokenSeparatedElements(typeSpecifiers, 17 /* Bar */))
     );
   }
+  static intersectionTypeSpecifier(typeSpecifiers) {
+    return new IntersectionTypeSpecifier(
+      new IntersectionTypeSpecifierTypeList(this.createTokenSeparatedElements(
+        typeSpecifiers,
+        10 /* Ampersand */
+      ))
+    );
+  }
   static nullableTypeSpecifier(typeSpecifier) {
     const questionToken = this.token(49 /* Question */);
     return new NullableTypeSpecifier(typeSpecifier, questionToken);
@@ -1552,8 +1562,35 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeVariantTypeDeclarationBody(node.body);
   }
   writeUnionTypeSpecifier(node) {
-    for (let i = 0; i < node.typeList.elements.length; i++) {
-      const element = node.typeList.elements[i];
+    this.writeUnionTypeSpecifierTypeList(node.typeList);
+  }
+  writeUnionTypeSpecifierTypeList(node) {
+    for (let i = 0; i < node.elements.length; i++) {
+      const element = node.elements[i];
+      if (element.kind === 0 /* Token */) {
+        this.writeWhitespace();
+        this.writeToken(element);
+      } else {
+        if (i > 0) {
+          this.writeWhitespace();
+        }
+        const areParenthesisRequired = this.doesUnionTypeElementRequireParenthesis(element);
+        if (areParenthesisRequired) {
+          this.writeCode("(");
+        }
+        this.writeTypeSpecifier(element, false);
+        if (areParenthesisRequired) {
+          this.writeCode(")");
+        }
+      }
+    }
+  }
+  writeIntersectionTypeSpecifier(node) {
+    this.writeIntersectionTypeSpecifierTypeList(node.typeList);
+  }
+  writeIntersectionTypeSpecifierTypeList(node) {
+    for (let i = 0; i < node.elements.length; i++) {
+      const element = node.elements[i];
       if (element.kind === 0 /* Token */) {
         this.writeWhitespace();
         this.writeToken(element);
@@ -1561,7 +1598,7 @@ var SyntaxToCode = class _SyntaxToCode {
         if (i > 0) {
           this.writeWhitespace();
         }
-        const areParenthesisRequired = this.doesConstituentTypeRequireParenthesis(element);
+        const areParenthesisRequired = this.doesIntersectionTypeElementRequireParenthesis(element);
         if (areParenthesisRequired) {
           this.writeCode("(");
         }
@@ -1588,25 +1625,51 @@ var SyntaxToCode = class _SyntaxToCode {
     }
     this.writeToken(node.questionToken);
   }
-  doesConstituentTypeRequireParenthesis(node) {
+  doesUnionTypeElementRequireParenthesis(node) {
+    switch (node.kind) {
+      case 11 /* UnionTypeSpecifier */:
+        return true;
+      case 17 /* AnonymousTypeSpecifier */: {
+        switch (node.typeDeclaration.body.kind) {
+          case 31 /* MethodTypeDeclarationBody */:
+            return true;
+          case 36 /* StructuredTypeDeclarationBody */:
+          case 41 /* VariantTypeDeclarationBody */:
+            return false;
+          default:
+            Debug.never(node.typeDeclaration.body);
+        }
+      }
+      case 10 /* NamedTypeSpecifier */:
+      case 15 /* ParenthesizedTypeSpecifier */:
+      case 16 /* NullableTypeSpecifier */:
+      case 18 /* InvalidTypeSpecifier */:
+      case 13 /* IntersectionTypeSpecifier */:
+        return false;
+      default:
+        Debug.never(node);
+    }
+  }
+  doesIntersectionTypeElementRequireParenthesis(node) {
     switch (node.kind) {
       case 11 /* UnionTypeSpecifier */:
+      case 13 /* IntersectionTypeSpecifier */:
         return true;
-      case 15 /* AnonymousTypeSpecifier */: {
+      case 17 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 29 /* MethodTypeDeclarationBody */:
+          case 31 /* MethodTypeDeclarationBody */:
             return true;
-          case 34 /* StructuredTypeDeclarationBody */:
-          case 39 /* VariantTypeDeclarationBody */:
+          case 36 /* StructuredTypeDeclarationBody */:
+          case 41 /* VariantTypeDeclarationBody */:
             return false;
           default:
             Debug.never(node.typeDeclaration.body);
         }
       }
       case 10 /* NamedTypeSpecifier */:
-      case 13 /* ParenthesizedTypeSpecifier */:
-      case 14 /* NullableTypeSpecifier */:
-      case 16 /* InvalidTypeSpecifier */:
+      case 15 /* ParenthesizedTypeSpecifier */:
+      case 16 /* NullableTypeSpecifier */:
+      case 18 /* InvalidTypeSpecifier */:
         return false;
       default:
         Debug.never(node);
@@ -1615,12 +1678,13 @@ var SyntaxToCode = class _SyntaxToCode {
   doesTypeMadeNullableRequireParenthesis(node) {
     switch (node.kind) {
       case 11 /* UnionTypeSpecifier */:
-      case 15 /* AnonymousTypeSpecifier */:
+      case 13 /* IntersectionTypeSpecifier */:
+      case 17 /* AnonymousTypeSpecifier */:
         return true;
       case 10 /* NamedTypeSpecifier */:
-      case 13 /* ParenthesizedTypeSpecifier */:
-      case 14 /* NullableTypeSpecifier */:
-      case 16 /* InvalidTypeSpecifier */:
+      case 15 /* ParenthesizedTypeSpecifier */:
+      case 16 /* NullableTypeSpecifier */:
+      case 18 /* InvalidTypeSpecifier */:
         return false;
       default:
         Debug.never(node);
@@ -1645,7 +1709,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeNodeDefault(node);
   }
   writeDeclarationBody(node, addLeadingNewLineOrWhitespace = true) {
-    if (node.expressionOrStatementList.kind !== 92 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
+    if (node.expressionOrStatementList.kind !== 94 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
       this.writeWhitespace();
       this.writeFunctionBlock(node, false);
     } else {
@@ -1955,153 +2019,155 @@ var SyntaxToCode = class _SyntaxToCode {
       [9 /* PackagePath */]: this.prototype.writePackagePath,
       [10 /* NamedTypeSpecifier */]: this.prototype.writeNamedTypeSpecifier,
       [11 /* UnionTypeSpecifier */]: this.prototype.writeUnionTypeSpecifier,
-      [13 /* ParenthesizedTypeSpecifier */]: this.prototype.writeParenthesizedTypeSpecifier,
-      [14 /* NullableTypeSpecifier */]: this.prototype.writeNullableTypeSpecifier,
-      [15 /* AnonymousTypeSpecifier */]: this.prototype.writeAnonymousTypeSpecifier,
-      [22 /* PackageAliasTypeDeclaration */]: this.prototype.writePackageAliasTypeDeclaration,
-      [24 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
-      [25 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
-      [26 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
-      [27 /* PackageMethodDeclaration */]: this.prototype.writePackageMethodDeclaration,
-      [28 /* PackageMethodTypeDeclaration */]: this.prototype.writePackageMethodTypeDeclaration,
-      [29 /* MethodTypeDeclarationBody */]: this.prototype.writeMethodTypeDeclarationBody,
-      [30 /* BaseTypeList */]: this.prototype.writeBaseTypeList,
-      [32 /* TypeMemberDeclarationBlock */]: this.prototype.writeTypeMemberDeclarationBlock,
-      [33 /* PackageStructuredTypeDeclaration */]: this.prototype.writePackageStructuredTypeDeclaration,
-      [34 /* StructuredTypeDeclarationBody */]: this.prototype.writeStructuredTypeDeclarationBody,
-      [35 /* PackageVariableDeclaration */]: this.prototype.writePackageVariableDeclaration,
-      [36 /* PackageVariableGetterDeclaration */]: this.prototype.writePackageVariableGetterDeclaration,
-      [37 /* PackageVariableSetterDeclaration */]: this.prototype.writePackageVariableSetterDeclaration,
-      [38 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
-      [39 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
-      [44 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
-      [45 /* TypeConstructorDeclaration */]: this.prototype.writeTypeConstructorDeclaration,
-      [46 /* TypeDestructorDeclaration */]: this.prototype.writeTypeDestructorDeclaration,
-      [47 /* TypeIndexedGetterDeclaration */]: this.prototype.writeTypeIndexedGetterDeclaration,
-      [48 /* TypeIndexedSetterDeclaration */]: this.prototype.writeTypeIndexedSetterDeclaration,
-      [50 /* TypeDereferencedVariableGetterDeclaration */]: this.prototype.writeTypeDereferencedVariableGetterDeclaration,
-      [51 /* TypeDereferencedVariableSetterDeclaration */]: this.prototype.writeTypeDereferencedVariableSetterDeclaration,
-      [52 /* TypeMethodDeclaration */]: this.prototype.writeTypeMethodDeclaration,
-      [53 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
-      [54 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
-      [55 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
-      [56 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
-      [93 /* StatementBlock */]: this.prototype.writeStatementBlock,
-      [94 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
-      [135 /* QualifiedName */]: this.prototype.writeQualifiedName,
-      [142 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
-      [143 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
-      [144 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [145 /* Argument */]: this.prototype.writeArgument,
-      [147 /* Tag */]: this.prototype.writeTag,
-      [149 /* Modifier */]: this.prototype.writeModifier,
-      [150 /* ParameterClause */]: this.prototype.writeParameterClause,
-      [151 /* ParameterList */]: this.prototype.writeParameterList,
-      [152 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [154 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
-      [17 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
-      [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
-      [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
+      [13 /* IntersectionTypeSpecifier */]: this.prototype.writeIntersectionTypeSpecifier,
+      [15 /* ParenthesizedTypeSpecifier */]: this.prototype.writeParenthesizedTypeSpecifier,
+      [16 /* NullableTypeSpecifier */]: this.prototype.writeNullableTypeSpecifier,
+      [17 /* AnonymousTypeSpecifier */]: this.prototype.writeAnonymousTypeSpecifier,
+      [24 /* PackageAliasTypeDeclaration */]: this.prototype.writePackageAliasTypeDeclaration,
+      [26 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
+      [27 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
+      [28 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
+      [29 /* PackageMethodDeclaration */]: this.prototype.writePackageMethodDeclaration,
+      [30 /* PackageMethodTypeDeclaration */]: this.prototype.writePackageMethodTypeDeclaration,
+      [31 /* MethodTypeDeclarationBody */]: this.prototype.writeMethodTypeDeclarationBody,
+      [32 /* BaseTypeList */]: this.prototype.writeBaseTypeList,
+      [34 /* TypeMemberDeclarationBlock */]: this.prototype.writeTypeMemberDeclarationBlock,
+      [35 /* PackageStructuredTypeDeclaration */]: this.prototype.writePackageStructuredTypeDeclaration,
+      [36 /* StructuredTypeDeclarationBody */]: this.prototype.writeStructuredTypeDeclarationBody,
+      [37 /* PackageVariableDeclaration */]: this.prototype.writePackageVariableDeclaration,
+      [38 /* PackageVariableGetterDeclaration */]: this.prototype.writePackageVariableGetterDeclaration,
+      [39 /* PackageVariableSetterDeclaration */]: this.prototype.writePackageVariableSetterDeclaration,
+      [40 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
+      [41 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
+      [46 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
+      [47 /* TypeConstructorDeclaration */]: this.prototype.writeTypeConstructorDeclaration,
+      [48 /* TypeDestructorDeclaration */]: this.prototype.writeTypeDestructorDeclaration,
+      [49 /* TypeIndexedGetterDeclaration */]: this.prototype.writeTypeIndexedGetterDeclaration,
+      [50 /* TypeIndexedSetterDeclaration */]: this.prototype.writeTypeIndexedSetterDeclaration,
+      [52 /* TypeDereferencedVariableGetterDeclaration */]: this.prototype.writeTypeDereferencedVariableGetterDeclaration,
+      [53 /* TypeDereferencedVariableSetterDeclaration */]: this.prototype.writeTypeDereferencedVariableSetterDeclaration,
+      [54 /* TypeMethodDeclaration */]: this.prototype.writeTypeMethodDeclaration,
+      [55 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
+      [56 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
+      [57 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
+      [58 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
+      [95 /* StatementBlock */]: this.prototype.writeStatementBlock,
+      [96 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
+      [137 /* QualifiedName */]: this.prototype.writeQualifiedName,
+      [144 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
+      [145 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
+      [146 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
+      [147 /* Argument */]: this.prototype.writeArgument,
+      [149 /* Tag */]: this.prototype.writeTag,
+      [151 /* Modifier */]: this.prototype.writeModifier,
+      [152 /* ParameterClause */]: this.prototype.writeParameterClause,
+      [153 /* ParameterList */]: this.prototype.writeParameterList,
+      [154 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [156 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [19 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
+      [20 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
+      [21 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
       [6 /* PackageGroupImportDirective */]: this.prototype.writeNodeDefault,
       [7 /* PackageImportList */]: this.prototype.writeNodeDefault,
-      [12 /* UnionTypeSpecifierTypeList */]: this.prototype.writeNodeDefault,
-      [16 /* InvalidTypeSpecifier */]: this.prototype.writeNodeDefault,
-      [20 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
-      [21 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
-      [23 /* AliasTypeDeclarationBody */]: this.prototype.writeNodeDefault,
-      [31 /* TypeMemberDeclarationList */]: this.prototype.writeNodeDefault,
-      [40 /* TypeExtensionDeclaration */]: this.prototype.writeNodeDefault,
-      [41 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
-      [42 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
-      [43 /* InvalidPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [49 /* TypeIndexerParameterClause */]: this.prototype.writeNodeDefault,
-      [57 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [58 /* NestedMethodDeclaration */]: this.prototype.writeNodeDefault,
-      [59 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [60 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [61 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
-      [62 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
-      [63 /* AssertionExpression */]: this.prototype.writeNodeDefault,
-      [64 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
-      [65 /* AsExpression */]: this.prototype.writeNodeDefault,
-      [66 /* BinaryExpression */]: this.prototype.writeNodeDefault,
-      [67 /* MethodBlockLiteral */]: this.prototype.writeNodeDefault,
-      [68 /* ArgumentList */]: this.prototype.writeNodeDefault,
-      [69 /* CallExpression */]: this.prototype.writeNodeDefault,
-      [70 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
-      [71 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
-      [72 /* InvalidExpression */]: this.prototype.writeNodeDefault,
-      [73 /* IsExpression */]: this.prototype.writeNodeDefault,
-      [74 /* MethodLiteral */]: this.prototype.writeNodeDefault,
-      [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,
-      [95 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
-      [96 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
-      [97 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [98 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [99 /* TryStatement */]: this.prototype.writeNodeDefault,
-      [100 /* CatchClause */]: this.prototype.writeNodeDefault,
-      [101 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [102 /* FinallyClause */]: this.prototype.writeNodeDefault,
-      [103 /* EmptyStatement */]: this.prototype.writeNodeDefault,
-      [104 /* ErrorStatement */]: this.prototype.writeNodeDefault,
-      [105 /* ImportantStatement */]: this.prototype.writeNodeDefault,
-      [106 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
-      [107 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
-      [108 /* ForStatement */]: this.prototype.writeNodeDefault,
-      [109 /* IfStatement */]: this.prototype.writeNodeDefault,
-      [110 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
-      [111 /* ElseIfClause */]: this.prototype.writeNodeDefault,
-      [112 /* ElseClause */]: this.prototype.writeNodeDefault,
-      [113 /* InvalidStatement */]: this.prototype.writeNodeDefault,
-      [114 /* NestedMethodDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [115 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [116 /* LoopStatement */]: this.prototype.writeNodeDefault,
-      [117 /* ReturnStatement */]: this.prototype.writeNodeDefault,
-      [118 /* CaseClauseList */]: this.prototype.writeNodeDefault,
-      [119 /* SwitchStatement */]: this.prototype.writeNodeDefault,
-      [120 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
-      [121 /* CaseClause */]: this.prototype.writeNodeDefault,
-      [122 /* WhileStatement */]: this.prototype.writeNodeDefault,
-      [123 /* YieldStatement */]: this.prototype.writeNodeDefault,
-      [124 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
-      [125 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
-      [126 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
-      [127 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
-      [128 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
-      [129 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
-      [130 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
-      [131 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
-      [132 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
-      [133 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
-      [134 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
-      [136 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
-      [137 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
-      [138 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
-      [139 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
-      [140 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [141 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [146 /* TagList */]: this.prototype.writeNodeDefault,
-      [148 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [153 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [155 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [156 /* TypeAnnotation */]: this.prototype.writeNodeDefault
+      [12 /* UnionTypeSpecifierTypeList */]: this.prototype.writeUnionTypeSpecifierTypeList,
+      [14 /* IntersectionTypeSpecifierTypeList */]: this.prototype.writeIntersectionTypeSpecifierTypeList,
+      [18 /* InvalidTypeSpecifier */]: this.prototype.writeNodeDefault,
+      [22 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
+      [23 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
+      [25 /* AliasTypeDeclarationBody */]: this.prototype.writeNodeDefault,
+      [33 /* TypeMemberDeclarationList */]: this.prototype.writeNodeDefault,
+      [42 /* TypeExtensionDeclaration */]: this.prototype.writeNodeDefault,
+      [43 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
+      [44 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
+      [45 /* InvalidPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
+      [51 /* TypeIndexerParameterClause */]: this.prototype.writeNodeDefault,
+      [59 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
+      [60 /* NestedMethodDeclaration */]: this.prototype.writeNodeDefault,
+      [61 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [62 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [63 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
+      [64 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
+      [65 /* AssertionExpression */]: this.prototype.writeNodeDefault,
+      [66 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
+      [67 /* AsExpression */]: this.prototype.writeNodeDefault,
+      [68 /* BinaryExpression */]: this.prototype.writeNodeDefault,
+      [69 /* MethodBlockLiteral */]: this.prototype.writeNodeDefault,
+      [70 /* ArgumentList */]: this.prototype.writeNodeDefault,
+      [71 /* CallExpression */]: this.prototype.writeNodeDefault,
+      [72 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
+      [73 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
+      [74 /* InvalidExpression */]: this.prototype.writeNodeDefault,
+      [75 /* IsExpression */]: this.prototype.writeNodeDefault,
+      [76 /* MethodLiteral */]: this.prototype.writeNodeDefault,
+      [77 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
+      [78 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
+      [79 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [80 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
+      [81 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
+      [82 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
+      [83 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [84 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [85 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [86 /* TokenExpression */]: this.prototype.writeNodeDefault,
+      [87 /* KeywordExpression */]: this.prototype.writeNodeDefault,
+      [88 /* ObjectExpression */]: this.prototype.writeNodeDefault,
+      [89 /* BaseExpression */]: this.prototype.writeNodeDefault,
+      [90 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
+      [91 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
+      [92 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
+      [93 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
+      [94 /* StatementList */]: this.prototype.writeNodeDefault,
+      [97 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
+      [98 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
+      [99 /* DisposeStatement */]: this.prototype.writeNodeDefault,
+      [100 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [101 /* TryStatement */]: this.prototype.writeNodeDefault,
+      [102 /* CatchClause */]: this.prototype.writeNodeDefault,
+      [103 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [104 /* FinallyClause */]: this.prototype.writeNodeDefault,
+      [105 /* EmptyStatement */]: this.prototype.writeNodeDefault,
+      [106 /* ErrorStatement */]: this.prototype.writeNodeDefault,
+      [107 /* ImportantStatement */]: this.prototype.writeNodeDefault,
+      [108 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
+      [109 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
+      [110 /* ForStatement */]: this.prototype.writeNodeDefault,
+      [111 /* IfStatement */]: this.prototype.writeNodeDefault,
+      [112 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
+      [113 /* ElseIfClause */]: this.prototype.writeNodeDefault,
+      [114 /* ElseClause */]: this.prototype.writeNodeDefault,
+      [115 /* InvalidStatement */]: this.prototype.writeNodeDefault,
+      [116 /* NestedMethodDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [117 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [118 /* LoopStatement */]: this.prototype.writeNodeDefault,
+      [119 /* ReturnStatement */]: this.prototype.writeNodeDefault,
+      [120 /* CaseClauseList */]: this.prototype.writeNodeDefault,
+      [121 /* SwitchStatement */]: this.prototype.writeNodeDefault,
+      [122 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
+      [123 /* CaseClause */]: this.prototype.writeNodeDefault,
+      [124 /* WhileStatement */]: this.prototype.writeNodeDefault,
+      [125 /* YieldStatement */]: this.prototype.writeNodeDefault,
+      [126 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
+      [127 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
+      [128 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
+      [129 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
+      [130 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
+      [131 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
+      [132 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
+      [133 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
+      [134 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
+      [135 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
+      [136 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
+      [138 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
+      [139 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
+      [140 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
+      [141 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
+      [142 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [143 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [148 /* TagList */]: this.prototype.writeNodeDefault,
+      [150 /* ModifierList */]: this.prototype.writeNodeDefault,
+      [155 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [157 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [158 /* TypeAnnotation */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2287,7 +2353,7 @@ var TranslationsGenerationService = class {
       return void 0;
     }
     let result;
-    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
+    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 141 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2299,7 +2365,7 @@ var TranslationsGenerationService = class {
         result = generator.generateMissingTypeMemberTranslations(tokenOrKeyword.parent);
       }
     }
-    if (result === void 0 && tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */) {
+    if (result === void 0 && tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2325,7 +2391,7 @@ var TranslationsGenerationService = class {
     if (tokenOrKeyword === void 0) {
       return false;
     }
-    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */)) {
+    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */)) {
       return false;
     }
     const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
@@ -2333,7 +2399,7 @@ var TranslationsGenerationService = class {
       return false;
     }
     const generator = new TranslationsGenerator(analyzer, sourceFile, translationPackage, sourceFile.package.dialect);
-    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 139 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
+    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 141 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
 var TranslationsGenerator = class _TranslationsGenerator {
@@ -2360,7 +2426,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
       };
       const memberTranslationsCode = Query.from(memberEntities).mapAndFilter((m) => this.createPackageMemberTranslationNode(m)).uniqueWithComparator(compareNodes).map((n) => {
         const code = new SyntaxToCode(n, syntaxToCodeOptions).convert();
-        if (n.kind === 139 /* TypeTranslation */) {
+        if (n.kind === 141 /* TypeTranslation */) {
           const startOffset = Math.max(code.indexOf(newLine), 0);
           return this.addNewLineBeforeArrowsInTranslation(
             code,
@@ -2392,7 +2458,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
   generateMissingTranslationsForPartiallyTranslatedTypes(translationsDeclaration) {
     const result = new Array();
     for (const translation of translationsDeclaration.translationList.translationDeclarations) {
-      if (translation.kind === 139 /* TypeTranslation */) {
+      if (translation.kind === 141 /* TypeTranslation */) {
         const edits = this.generateMissingTypeMemberTranslations(translation);
         if (edits !== void 0) {
           result.push(...edits);
@@ -2489,13 +2555,13 @@ var TranslationsGenerator = class _TranslationsGenerator {
   }
   detectIndentationStepForTypeMemberTranslations(node) {
     let indentationStepSize;
-    if (node.kind === 139 /* TypeTranslation */) {
+    if (node.kind === 141 /* TypeTranslation */) {
       indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(node, this._sourceFile);
     }
     if (indentationStepSize === void 0) {
-      const translationsDeclarations = node.kind === 21 /* TranslationsDeclaration */ ? node : node.parent.parent;
+      const translationsDeclarations = node.kind === 23 /* TranslationsDeclaration */ ? node : node.parent.parent;
       for (const member of translationsDeclarations.translationList.translationDeclarations) {
-        if (member.kind === 139 /* TypeTranslation */) {
+        if (member.kind === 141 /* TypeTranslation */) {
           indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(member, this._sourceFile);
           if (indentationStepSize !== void 0) {
             break;
@@ -2776,13 +2842,13 @@ var ValueArgumentFactory = class _ValueArgumentFactory {
 var SignatureForNode = class _SignatureForNode {
   static getSignaturesForNode(analyzer, node) {
     switch (node.kind) {
-      case 69 /* CallExpression */:
+      case 71 /* CallExpression */:
         return _SignatureForNode.getSignaturesForCallExpression(analyzer, node);
-      case 70 /* AutotypeCallExpression */:
+      case 72 /* AutotypeCallExpression */:
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
-      case 71 /* IndexedAccessExpression */:
+      case 73 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
-      case 147 /* Tag */:
+      case 149 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
       default:
         Debug.never(node);
@@ -2920,7 +2986,7 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         result = false;
         break;
       }
-      if (argument.expression === void 0 || argument.expression.kind === 72 /* InvalidExpression */) {
+      if (argument.expression === void 0 || argument.expression.kind === 74 /* InvalidExpression */) {
         continue;
       }
       const targetParameterType = targetParameter.getType();
@@ -3158,7 +3224,7 @@ var CompletionService = class {
     if (syntaxContext.isInComment || syntaxContext.isInStringOrChar) {
       return { kind: "none" };
     }
-    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 53 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 52 /* TypeMethodDeclaration */)) {
+    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 55 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 54 /* TypeMethodDeclaration */)) {
       return new OperatorNameCompletionContext(syntaxContext.isInQuotedIdentifier);
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
@@ -3176,7 +3242,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 === 78 /* PropertyAccessExpression */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 80 /* PropertyAccessExpression */) {
       const propertyAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(propertyAccess.expression);
@@ -3217,7 +3283,7 @@ var CompletionService = class {
         typeExtensionLookup
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 137 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
       const namedTypeSpecifier = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveNamedTypeSpecifier(namedTypeSpecifier);
       const segmentIndex = Math.floor(
@@ -3225,7 +3291,7 @@ var CompletionService = class {
       );
       if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
         let completionInIsOrAsExpressionInfo;
-        if (namedTypeSpecifier.parent.kind === 73 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
+        if (namedTypeSpecifier.parent.kind === 75 /* IsExpression */ || namedTypeSpecifier.parent.kind === 67 /* AsExpression */) {
           completionInIsOrAsExpressionInfo = {
             expressionType: this._analyzer.type.ofExpression(namedTypeSpecifier.parent.expression)
           };
@@ -3259,7 +3325,7 @@ var CompletionService = class {
       }
       return { kind: "none" };
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 147 /* Tag */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 137 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 149 /* Tag */) {
       const tag = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveTag(tag);
       const segmentIndex = Math.floor(
@@ -3297,7 +3363,7 @@ var CompletionService = class {
     }
     if (syntaxContext.isUnqualifiedTypeContext !== void 0) {
       let completionInIsOrAsExpressionInfo;
-      if (tokenOrKeyword.parent.kind === 73 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+      if (tokenOrKeyword.parent.kind === 75 /* IsExpression */ || tokenOrKeyword.parent.kind === 67 /* AsExpression */) {
         completionInIsOrAsExpressionInfo = {
           expressionType: this._analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
@@ -3352,17 +3418,17 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 134 /* PackageImportTranslation */) {
+    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 136 /* PackageImportTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 139 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 133 /* MethodTypeTranslation */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 141 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 135 /* MethodTypeTranslation */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 131 /* PackageMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 133 /* PackageMethodTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3382,9 +3448,9 @@ var CompletionService = class {
         hasPrecedingKeyword
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 137 /* QualifiedName */) {
       const qualifiedName = tokenOrKeyword.parent;
-      if (qualifiedName.parent.kind === 134 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
+      if (qualifiedName.parent.kind === 136 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
         const precedingSegmentNames = qualifiedName.qualifiers.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
         const sourceLocale = translationPackage.getTranslatedPackage().getLocale();
         return new PackageImportCompletionContext(precedingSegmentNames, { sourceLocale });
@@ -3409,12 +3475,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 132 /* TypeMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 134 /* TypeMethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 126 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 128 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3444,21 +3510,21 @@ var CompletionService = class {
       let signatures;
       let valueArguments;
       switch (role.argumentList.parent.kind) {
-        case 69 /* CallExpression */:
+        case 71 /* CallExpression */:
           signatures = SignatureForNode.getSignaturesForCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(role.argumentList.parent);
           break;
-        case 70 /* AutotypeCallExpression */:
+        case 72 /* AutotypeCallExpression */:
           signatures = SignatureForNode.getSignaturesForAutotypeCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(
             role.argumentList.parent
           );
           break;
-        case 147 /* Tag */:
+        case 149 /* Tag */:
           signatures = SignatureForNode.getSignaturesForTag(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(role.argumentList.parent);
           break;
-        case 71 /* IndexedAccessExpression */:
+        case 73 /* IndexedAccessExpression */:
           signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
             this._analyzer,
             role.argumentList.parent
@@ -3498,6 +3564,11 @@ var CompletionService = class {
       }
       return { targetTypes: void 0, targetSignaturesParameters: void 0 };
     }
+    if (role.kind === "error-value") {
+      const errorType = this._analyzer.standardTypes.error;
+      const textType = this._analyzer.standardTypes.text;
+      return { targetTypes: [errorType, textType], targetSignaturesParameters: void 0 };
+    }
     if (role.kind === "function-block-expression") {
       const targetType = semanticContext.getContainingSubprogram()?.getReturnType();
       if (targetType !== void 0 && !targetType.equals(this._analyzer.standardTypes.none)) {
@@ -3603,7 +3674,7 @@ var CompletionService = class {
       kinds.add(30 /* Creation */).add(12 /* Function */).add(47 /* Destruction */).add(58 /* Get */).add(59 /* Set */);
     }
     if (syntaxContext.isStatementContext) {
-      kinds.add(7 /* Run */).add(34 /* For */).add(25 /* While */).add(26 /* Loop */).add(15 /* Return */).add(20 /* Error */).add(28 /* Yield */).add(32 /* BreakLoop */).add(33 /* ContinueLoop */).add(13 /* If */).add(44 /* Switch */).add(1 /* Let */).add(35 /* Const */).add(46 /* Dispose */).add(8 /* Try */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(7 /* Run */).add(34 /* For */).add(25 /* While */).add(26 /* Loop */).add(15 /* Return */).add(20 /* Error */).add(19 /* Important */).add(28 /* Yield */).add(32 /* BreakLoop */).add(33 /* ContinueLoop */).add(13 /* If */).add(44 /* Switch */).add(1 /* Let */).add(35 /* Const */).add(46 /* Dispose */).add(8 /* Try */).add(12 /* Function */).add(40 /* Async */);
     }
     if (this.isFromKeywordContext(positionDescription)) {
       kinds.add(9 /* From */);
@@ -3650,7 +3721,7 @@ var CompletionService = class {
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
       kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(12 /* Function */).add(40 /* Async */);
     }
-    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(40 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 74 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* MethodTypeDeclarationBody */)) {
+    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(40 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 60 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 76 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 31 /* MethodTypeDeclarationBody */)) {
       kinds.add(12 /* Function */);
     }
     return Query.from(kinds.values()).map(
@@ -3662,35 +3733,35 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 116 /* LoopStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 118 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 149 /* Modifier */;
+    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 151 /* Modifier */;
   }
   isElseOrElseIfKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 109 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 111 /* ElseIfClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 111 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 113 /* ElseIfClause */);
   }
   isCatchKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 101 /* TryStatement */;
   }
   isFinallyKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 99 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* CatchClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 101 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 102 /* CatchClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(57 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3700,17 +3771,17 @@ var CompletionService = class {
       return false;
     }
     const token = positionDescription.tokenOrKeyword.value;
-    return token.parent.kind === 60 /* EnumerationVariableDeclaration */ && (token.parent.parent.elements.length > 0 && token.parent.parent.elements[token.parent.parent.elements.length - 1] === token.parent || token.parent.parent.elements.length > 1 && token.parent.parent.elements[token.parent.parent.elements.length - 2] === token.parent);
+    return token.parent.kind === 62 /* EnumerationVariableDeclaration */ && (token.parent.parent.elements.length > 0 && token.parent.parent.elements[token.parent.parent.elements.length - 1] === token.parent || token.parent.parent.elements.length > 1 && token.parent.parent.elements[token.parent.parent.elements.length - 2] === token.parent);
   }
   isCaseKeywordContext(positionDescription, syntaxContext) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 121 /* CaseClause */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 123 /* CaseClause */) {
       return true;
     }
-    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 119 /* SwitchStatement */) {
+    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 121 /* SwitchStatement */) {
       return true;
     }
     return false;
@@ -3730,7 +3801,7 @@ var CompletionService = class {
     return result;
   }
   prioritizeItemsFromUnionType(items, type) {
-    const constituentTypeEntities = Query.from(type.unaliasedFlattenedTypes).mapAndFilter((t) => this.getEntityFromType(t)).uniqueToSet();
+    const constituentTypeEntities = Query.from(type.unaliasedFlattenedTypes).mapAndFilter((t) => t.getEntity()).uniqueToSet();
     for (const item of items) {
       if (item.kind === "named-type" && constituentTypeEntities.has(item.entity)) {
         item.prefix = "*";
@@ -3813,25 +3884,6 @@ var CompletionService = class {
     }
     return result;
   }
-  getEntityFromType(type) {
-    switch (type.kind) {
-      case "structured":
-        return type.getEntity();
-      case "variant":
-        return type.getEntity();
-      case "method":
-        return type.getEntity();
-      case "alias":
-        return type.getEntity();
-      case "parameter":
-        return type.getEntity();
-      case "unresolved":
-      case "union":
-        return void 0;
-      default:
-        Debug.never(type);
-    }
-  }
   getTypeCompletionItemInfosFromPackage(searchLocation) {
     return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
       if (m.value.kind === 2 /* Type */) {
@@ -4377,11 +4429,11 @@ function getRightmostChildExcludingValidEmptyNodes(node) {
 }
 function isInvalidNode(node) {
   switch (node.kind) {
-    case 72 /* InvalidExpression */:
-    case 43 /* InvalidPackageMemberDeclaration */:
-    case 113 /* InvalidStatement */:
-    case 57 /* InvalidTypeMemberDeclaration */:
-    case 16 /* InvalidTypeSpecifier */:
+    case 74 /* InvalidExpression */:
+    case 45 /* InvalidPackageMemberDeclaration */:
+    case 115 /* InvalidStatement */:
+    case 59 /* InvalidTypeMemberDeclaration */:
+    case 18 /* InvalidTypeSpecifier */:
       return true;
     case 0 /* Token */:
       return node.isMissing;
@@ -4821,7 +4873,7 @@ var MergedOverloadedMethodCompletionItemInfo = class {
     return this.firstOverloadInfo.getCompletionItemKind();
   }
   getDetails() {
-    const overloadsWord = LocalizationHelper.localizeHelperPhrase(6 /* Overloads */, this.ctx.locale);
+    const overloadsWord = LocalizationHelper.localizeHelperPhrase(7 /* Overloads */, this.ctx.locale);
     const overloadCountText = ` (+${overloadsWord}: ${this.overloadCount - 1})`;
     const originalDetails = this.firstOverloadInfo.getDetails();
     return originalDetails + overloadCountText;
@@ -5163,6 +5215,12 @@ var ExpressionRole_returnedValue = class {
     this.kind = "returned-value";
   }
 };
+var ExpressionRole_errorValue = class {
+  constructor(errorStatement) {
+    this.errorStatement = errorStatement;
+    this.kind = "error-value";
+  }
+};
 var ExpressionRole_functionBlockExpression = class {
   constructor(functionBlock) {
     this.functionBlock = functionBlock;
@@ -5205,7 +5263,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 === 147 /* Tag */;
+    const isUnqualifiedTagNameCompletionContext = positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(35 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 149 /* Tag */;
     let isTopLevelTranslationListContext;
     if (positionDescription.kind === "after-token-or-keyword") {
       isTopLevelTranslationListContext = this.isTopLevelTranslationListContext(positionDescription.tokenOrKeyword);
@@ -5231,52 +5289,52 @@ var SyntaxContextFactory = class {
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(57 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 59 /* LocalVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 61 /* LocalVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 35 /* PackageVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 37 /* PackageVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 54 /* TypeVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 56 /* TypeVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 144 /* ParameterDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 146 /* ParameterDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 145 /* Argument */) {
+      if (tokenOrKeyword.parent.kind === 147 /* Argument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 142 /* VariantDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 144 /* VariantDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 79 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 68 /* BinaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 81 /* TextTemplateLiteral */) {
+    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 83 /* TextTemplateLiteral */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.spanList.spans.at(0)?.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 83 /* TextTemplateSpan */) {
+    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 85 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5288,12 +5346,12 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 93 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* FunctionBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 96 /* FunctionBlock */) {
       const block = tokenOrKeyword.parent;
-      if (block.expressionOrStatementList.kind !== 92 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
+      if (block.expressionOrStatementList.kind !== 94 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
         return {
           isExpressionContext: { expressionRole: new ExpressionRole_functionBlockExpression(block) },
           isStatementContext: true
@@ -5305,27 +5363,27 @@ var SyntaxContextFactory = class {
         };
       }
     }
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 92 /* StatementList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 94 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(44 /* OpenParenthesis */)) {
-      if (tokenOrKeyword.parent.kind === 75 /* ParenthesizedExpression */) {
+      if (tokenOrKeyword.parent.kind === 77 /* ParenthesizedExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 79 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 81 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 69 /* CallExpression */) {
+      if (tokenOrKeyword.parent.kind === 71 /* CallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
+      if (tokenOrKeyword.parent.kind === 72 /* AutotypeCallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 147 /* Tag */) {
+      if (tokenOrKeyword.parent.kind === 149 /* Tag */) {
         const argumentList = tokenOrKeyword.parent.argumentList;
         if (argumentList !== void 0) {
           const expressionRole = new ExpressionRole_argument(argumentList, 0);
@@ -5333,16 +5391,16 @@ var SyntaxContextFactory = class {
         }
       }
     }
-    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 73 /* 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 */) {
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 63 /* ArrayLiteral */) {
       const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(24 /* Comma */)) {
-      if (tokenOrKeyword.parent.kind === 68 /* ArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 70 /* ArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5356,56 +5414,64 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_argument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 120 /* MatchExpressionList */) {
+      if (tokenOrKeyword.parent.kind === 122 /* MatchExpressionList */) {
         const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 62 /* ArrayLiteralElementList */) {
+      if (tokenOrKeyword.parent.kind === 64 /* ArrayLiteralElementList */) {
         const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 121 /* CaseClause */) {
+    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 123 /* CaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 117 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 119 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(44 /* Switch */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(20 /* Error */) && tokenOrKeyword.parent.kind === 106 /* ErrorStatement */) {
+      const expressionRole = new ExpressionRole_errorValue(tokenOrKeyword.parent);
+      return { isExpressionContext: { expressionRole }, isStatementContext: false };
+    }
+    if (tokenOrKeyword.isKeyword(19 /* Important */) && tokenOrKeyword.parent.kind === 107 /* ImportantStatement */) {
+      const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
+      return { isExpressionContext: { expressionRole }, isStatementContext: false };
+    }
+    if (tokenOrKeyword.isKeyword(44 /* Switch */) && tokenOrKeyword.parent.kind === 121 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 109 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 111 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 111 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 113 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 108 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 110 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* While */) && tokenOrKeyword.parent.kind === 122 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(25 /* While */) && tokenOrKeyword.parent.kind === 124 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 116 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(27 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 118 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(28 /* Yield */) && tokenOrKeyword.parent.kind === 123 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(28 /* Yield */) && tokenOrKeyword.parent.kind === 125 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(29 /* When */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isKeyword(29 /* When */) && tokenOrKeyword.parent.kind === 78 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 76 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 78 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.secondExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5424,52 +5490,52 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(51 /* Semicolon */) && (tokenOrKeyword.parent.kind === 2 /* PackageMemberDeclarationList */ || tokenOrKeyword.parent.kind === 4 /* PackageImportDirectiveList */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 40 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 33 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 38 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 22 /* PackageAliasTypeDeclaration */)) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 34 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 42 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 35 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 40 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 24 /* PackageAliasTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 94 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageMethodDeclaration */))) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 26 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 96 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 27 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 28 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 29 /* PackageMethodDeclaration */))) {
       return true;
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 26 /* PackageMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 27 /* PackageMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 28 /* PackageMethodTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 22 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 35 /* PackageVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 29 /* PackageMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 30 /* PackageMethodTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 24 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      36 /* PackageVariableGetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
+      38 /* PackageVariableGetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 39 /* PackageVariableSetterDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 149 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 151 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 149 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 151 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
   }
   static isTypeMemberDeclarationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 31 /* TypeMemberDeclarationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 33 /* TypeMemberDeclarationList */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 34 /* TypeMemberDeclarationBlock */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 44 /* TypeMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 46 /* TypeMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* TypeVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* TypeVariableGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* TypeVariableSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 47 /* TypeIndexedGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 48 /* TypeIndexedSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* TypeVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 57 /* TypeVariableGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 58 /* TypeVariableSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 49 /* TypeIndexedGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 50 /* TypeIndexedSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      50 /* TypeDereferencedVariableGetterDeclaration */
+      52 /* TypeDereferencedVariableGetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      51 /* TypeDereferencedVariableSetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 142 /* VariantDeclaration */)) {
+      53 /* TypeDereferencedVariableSetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 47 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 48 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 144 /* VariantDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 149 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 151 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 149 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 151 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5506,79 +5572,82 @@ 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 === 158 /* TypeAnnotation */) {
       return { allowsAnonymousTypes: true };
     }
-    if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
+    if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 36 /* StructuredTypeDeclarationBody */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
+    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 42 /* TypeExtensionDeclaration */)) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 152 /* TypeArgumentClause */) {
+    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 154 /* 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 === 32 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 155 /* TypeArgumentList */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 155 /* TypeArgumentList */ };
     }
-    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 147 /* Tag */) {
+    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 149 /* Tag */) {
       return { allowsAnonymousTypes: false };
     }
-    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 143 /* TypeParameterDeclaration */) {
+    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 145 /* TypeParameterDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 22 /* PackageAliasTypeDeclaration */) {
+    if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 24 /* PackageAliasTypeDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
+    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 75 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
+    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 67 /* AsExpression */) {
       return { allowsAnonymousTypes: true };
     }
     if (tokenOrKeyword.isToken(17 /* Bar */) && tokenOrKeyword.parent.kind === 12 /* UnionTypeSpecifierTypeList */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 13 /* ParenthesizedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(10 /* Ampersand */) && tokenOrKeyword.parent.kind === 14 /* IntersectionTypeSpecifierTypeList */) {
+      return { allowsAnonymousTypes: false };
+    }
+    if (tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 15 /* ParenthesizedTypeSpecifier */) {
       return { allowsAnonymousTypes: true };
     }
     return void 0;
   }
   static isTopLevelTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 20 /* TopLevelTranslationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 22 /* TopLevelTranslationList */) {
       return { translationsDeclaration: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 23 /* TranslationsDeclaration */) {
       return { translationsDeclaration: tokenOrKeyword.parent };
     }
     const packageImport = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      134 /* PackageImportTranslation */
+      136 /* PackageImportTranslation */
     );
     if (packageImport !== void 0) {
       return { translationsDeclaration: packageImport.parent.parent };
     }
-    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 139 /* TypeTranslation */);
+    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 141 /* TypeTranslation */);
     if (type !== void 0) {
       return { translationsDeclaration: type.parent.parent };
     }
     const methodType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      133 /* MethodTypeTranslation */
+      135 /* MethodTypeTranslation */
     );
     if (methodType !== void 0) {
       return { translationsDeclaration: methodType.parent.parent };
     }
     const variable = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      136 /* PackageVariableTranslation */
+      138 /* PackageVariableTranslation */
     );
     if (variable !== void 0) {
       return { translationsDeclaration: variable.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      131 /* PackageMethodTranslation */
+      133 /* PackageMethodTranslation */
     );
     if (method !== void 0) {
       return { translationsDeclaration: method.parent.parent };
@@ -5586,33 +5655,33 @@ var SyntaxContextFactory = class {
     return void 0;
   }
   static isTypeMemberTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 138 /* TypeMemberTranslationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 140 /* TypeMemberTranslationList */) {
       return { typeTranslation: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslation */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 141 /* TypeTranslation */) {
       return { typeTranslation: tokenOrKeyword.parent };
     }
-    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 128 /* IndexerTranslation */);
+    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 130 /* IndexerTranslation */);
     if (indexer !== void 0) {
       return { typeTranslation: indexer.parent.parent };
     }
     const constructor = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      126 /* ConstructorTranslation */
+      128 /* ConstructorTranslation */
     );
     if (constructor !== void 0) {
       return { typeTranslation: constructor.parent.parent };
     }
     const variableOrVariant = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      137 /* TypeVariableOrVariantTranslation */
+      139 /* TypeVariableOrVariantTranslation */
     );
     if (variableOrVariant !== void 0) {
       return { typeTranslation: variableOrVariant.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      132 /* TypeMethodTranslation */
+      134 /* TypeMethodTranslation */
     );
     if (method !== void 0) {
       return { typeTranslation: method.parent.parent };
@@ -5725,29 +5794,29 @@ var NodeSemanticInfoService = class {
   static ofTokenOrKeyword(analyzer, tokenOrKeyword, options6) {
     if (isIdentifier(tokenOrKeyword.value)) {
       return this.ofNonKeywordIdentifier(analyzer, tokenOrKeyword.value, options6);
-    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
+    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 72 /* AutotypeCallExpression */) {
       return this.ofAutotypeCallExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 79 /* PrefixUnaryExpression */) {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 68 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* TypeDereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* TypeDereferencedVariableSetterDeclaration */)) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 52 /* TypeDereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 53 /* TypeDereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 82 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 91 /* AssignmentStatement */) {
+    } else if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* TypeConstructorDeclaration */) {
+    } else if (tokenOrKeyword.isKeyword(30 /* Creation */) && tokenOrKeyword.parent.kind === 47 /* TypeConstructorDeclaration */) {
       return this.ofTypeConstructorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 90 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 92 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 86 /* ObjectExpression */) {
+    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 88 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 87 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 89 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* TypeIndexerParameterClause */) {
+    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 51 /* TypeIndexerParameterClause */) {
       return this.ofTypeIndexerDeclaration(analyzer, tokenOrKeyword.parent.parent);
-    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 73 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     }
     return void 0;
@@ -5760,11 +5829,11 @@ var NodeSemanticInfoService = class {
     let result;
     const parent = node.parent;
     switch (parent.kind) {
-      case 129 /* TranslationTypeParameterList */:
+      case 131 /* TranslationTypeParameterList */:
         break;
-      case 124 /* TranslationParameterList */:
+      case 126 /* TranslationParameterList */:
         break;
-      case 145 /* Argument */: {
+      case 147 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new SimpleWithLocalization(
@@ -5778,43 +5847,43 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 60 /* EnumerationVariableDeclaration */:
+      case 62 /* EnumerationVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofEnumerationVariableDeclaration(parent));
         break;
-      case 101 /* ErrorVariableDeclaration */:
+      case 103 /* ErrorVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofErrorVariableDeclaration(parent));
         break;
-      case 22 /* PackageAliasTypeDeclaration */:
+      case 24 /* PackageAliasTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageAliasTypeDeclaration(parent));
         break;
-      case 27 /* PackageMethodDeclaration */:
+      case 29 /* PackageMethodDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageMethodDeclaration(parent));
         break;
-      case 28 /* PackageMethodTypeDeclaration */:
+      case 30 /* PackageMethodTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageMethodTypeDeclaration(parent));
         break;
-      case 33 /* PackageStructuredTypeDeclaration */:
+      case 35 /* PackageStructuredTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageStructuredTypeDeclaration(parent));
         break;
-      case 35 /* PackageVariableDeclaration */:
+      case 37 /* PackageVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariableDeclaration(parent));
         break;
-      case 38 /* PackageVariantTypeDeclaration */:
+      case 40 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 88 /* IdentifierExpression */:
+      case 90 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
-      case 58 /* NestedMethodDeclaration */:
+      case 60 /* NestedMethodDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedMethodDeclaration(parent));
         break;
-      case 59 /* LocalVariableDeclaration */:
+      case 61 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
         break;
-      case 135 /* QualifiedName */:
+      case 137 /* QualifiedName */:
         result = this.ofQualifiedNameQualifier(analyzer, parent, node, options6);
         break;
-      case 136 /* PackageVariableTranslation */: {
+      case 138 /* PackageVariableTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getPackageVariableTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5834,7 +5903,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 137 /* TypeVariableOrVariantTranslation */: {
+      case 139 /* TypeVariableOrVariantTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getTypeVariableOrVariantTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5858,7 +5927,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 131 /* PackageMethodTranslation */: {
+      case 133 /* PackageMethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getPackageMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5882,7 +5951,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 132 /* TypeMethodTranslation */: {
+      case 134 /* TypeMethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getTypeMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5906,7 +5975,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 139 /* TypeTranslation */: {
+      case 141 /* TypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5926,7 +5995,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 133 /* MethodTypeTranslation */: {
+      case 135 /* MethodTypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getMethodTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5946,7 +6015,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 144 /* ParameterDeclaration */:
+      case 146 /* ParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofParameterDeclaration(parent));
         break;
       case 8 /* PackageImport */:
@@ -5955,30 +6024,30 @@ var NodeSemanticInfoService = class {
       case 9 /* PackagePath */:
         result = void 0;
         break;
-      case 78 /* PropertyAccessExpression */:
+      case 80 /* PropertyAccessExpression */:
         result = this.ofProperty(analyzer, parent, options6);
         break;
-      case 52 /* TypeMethodDeclaration */:
+      case 54 /* TypeMethodDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeMethodDeclaration(parent));
         break;
-      case 53 /* OperatorDeclaration */:
+      case 55 /* OperatorDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofOperatorDeclaration(parent));
         break;
-      case 54 /* TypeVariableDeclaration */:
+      case 56 /* TypeVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeVariableDeclaration(parent));
         break;
-      case 143 /* TypeParameterDeclaration */:
+      case 145 /* TypeParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeParameterDeclaration(parent));
         break;
-      case 142 /* VariantDeclaration */:
+      case 144 /* VariantDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofVariantDeclaration(parent));
         break;
-      case 36 /* PackageVariableGetterDeclaration */:
-      case 37 /* PackageVariableSetterDeclaration */:
+      case 38 /* PackageVariableGetterDeclaration */:
+      case 39 /* PackageVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedPackageVariableDeclaration(parent));
         break;
-      case 55 /* TypeVariableGetterDeclaration */:
-      case 56 /* TypeVariableSetterDeclaration */:
+      case 57 /* TypeVariableGetterDeclaration */:
+      case 58 /* TypeVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedTypeVariableDeclaration(parent));
         break;
       case 3 /* Keyword */:
@@ -6074,6 +6143,16 @@ var NodeSemanticInfoService = class {
       case "package-name-segment-access":
         result = this.ofPackageNameSegmentAccess(analyzer, meaning.packageTreeNode, node);
         break;
+      case "mixed-ambiguous-access": {
+        const targets = Query.from(meaning.entities).mapAndFilter((d) => {
+          const target = new EntityReferenceTarget(d.value, 0 /* Get */);
+          return new SimpleWithLocalization(target, d.localization);
+        }).toArray();
+        if (isNonEmptyArray(targets)) {
+          result = new ReferenceNodeSemanticInfo(targets, true);
+        }
+        break;
+      }
       case "unresolved":
         break;
       default:
@@ -6096,10 +6175,10 @@ var NodeSemanticInfoService = class {
     switch (node.parent.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.ofNamedTypeSpecifierNameQualifier(analyzer, node.parent, qualifier, options6);
-      case 147 /* Tag */:
+      case 149 /* Tag */:
         return this.ofTagNameQualifier(analyzer, node.parent, qualifier, options6);
-      case 42 /* ExtendedTypeClause */:
-      case 134 /* PackageImportTranslation */:
+      case 44 /* ExtendedTypeClause */:
+      case 136 /* PackageImportTranslation */:
         return void 0;
       default:
         Debug.never(node.parent);
@@ -6143,6 +6222,20 @@ var NodeSemanticInfoService = class {
       } else {
         Debug.never(resolvedQualifier);
       }
+    } else if (qualifierIndex === resolutionResult.resolvedQualifiers.length && resolutionResult.ambiguousDeclarations !== void 0) {
+      const targets = resolutionResult.ambiguousDeclarations.map((d) => {
+        switch (d.value.kind) {
+          case "entity":
+            return new SimpleWithLocalization(new EntityReferenceTarget(d.value.entity, 0 /* Get */), d.localization);
+          case "node":
+            return new SimpleWithLocalization(new PackageNameTreeNodeReferenceTarget(d.value.node), d.localization);
+          default:
+            Debug.never(d.value);
+        }
+      });
+      if (isNonEmptyArray(targets)) {
+        result = new ReferenceNodeSemanticInfo(targets, true);
+      }
     }
     if (result !== void 0 && options6.includeBetterReferenceTargets) {
       result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6157,7 +6250,7 @@ var NodeSemanticInfoService = class {
       const resolvedQualifier = resolutionResult.resolvedQualifiers[qualifierIndex];
       switch (resolvedQualifier.kind) {
         case "type": {
-          if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration") {
+          if (options6.preferredTargetOfExplicitConstructorCall === "type-declaration" || resolutionResult.meaning.kind !== "tag-type") {
             if (resolvedQualifier.suitableTypes.length > 0) {
               const targets = resolvedQualifier.suitableTypes.map((t) => new SimpleWithLocalization(new EntityReferenceTarget(t.value, 0 /* Get */), t.localization));
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
@@ -6166,14 +6259,12 @@ var NodeSemanticInfoService = class {
               result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
             }
           } else {
-            if (resolutionResult.meaning.kind === "tag-type") {
-              if (resolutionResult.meaning.suitableConstructors.length > 0) {
-                const targets = resolutionResult.meaning.suitableConstructors.map((t) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(t.value), t.localization));
-                result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), targets.length > 1);
-              } else if (resolutionResult.meaning.candidates.length > 0) {
-                const targets = resolutionResult.meaning.candidates.map((t) => new SimpleWithLocalization(new TypeConstructorReferenceTarget(t.value), t.localization));
-                result = new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), true);
-              }
+            if (resolutionResult.meaning.suitableConstructors.length > 0) {
+              const targets = resolutionResult.meaning.suitableConstructors.map((t) => new SimpleWithLocalization(new 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;
@@ -6215,6 +6306,20 @@ var NodeSemanticInfoService = class {
         default:
           Debug.never(resolvedQualifier);
       }
+    } else if (qualifierIndex === resolutionResult.resolvedQualifiers.length && resolutionResult.ambiguousDeclarations !== void 0) {
+      const targets = resolutionResult.ambiguousDeclarations.map((d) => {
+        switch (d.value.kind) {
+          case "entity":
+            return new SimpleWithLocalization(new EntityReferenceTarget(d.value.entity, 0 /* Get */), d.localization);
+          case "node":
+            return new SimpleWithLocalization(new PackageNameTreeNodeReferenceTarget(d.value.node), d.localization);
+          default:
+            Debug.never(d.value);
+        }
+      });
+      if (isNonEmptyArray(targets)) {
+        result = new ReferenceNodeSemanticInfo(targets, true);
+      }
     }
     if (result !== void 0 && options6.includeBetterReferenceTargets) {
       result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -6284,7 +6389,7 @@ var NodeSemanticInfoService = class {
         break;
       }
       case "mixed-ambiguous-access": {
-        const targets = Query.from(meaning.declarations).mapAndFilter((d) => {
+        const targets = meaning.declarations.map((d) => {
           let target;
           switch (d.value.kind) {
             case "method":
@@ -6300,15 +6405,13 @@ var NodeSemanticInfoService = class {
               target = new EntityReferenceTarget(d.value.value, 0 /* Get */);
               break;
             case "package-name-segment":
-              if (d.value.value.package !== void 0) {
-                target = new PackageReferenceTarget(d.value.value.package.value);
-              }
+              target = new PackageNameTreeNodeReferenceTarget(d.value.value);
               break;
             default:
               Debug.never(d.value);
           }
-          return target !== void 0 ? new SimpleWithLocalization(target, d.localization) : void 0;
-        }).toArray();
+          return new SimpleWithLocalization(target, d.localization);
+        });
         if (isNonEmptyArray(targets)) {
           result = new ReferenceNodeSemanticInfo(targets, true);
         }
@@ -6538,7 +6641,7 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 78 /* PropertyAccessExpression */) {
+    while (parent.kind === 80 /* PropertyAccessExpression */) {
       const meaning = analyzer.resolvePropertyAccessExpression(parent).meaning;
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
@@ -6577,11 +6680,11 @@ var NodeSemanticInfoService = class {
     }
     const parent = getParentSkippingParenthesizedExpressions(typeAccessExpression);
     let parentCallExpression;
-    if (parent.kind === 69 /* CallExpression */) {
+    if (parent.kind === 71 /* CallExpression */) {
       parentCallExpression = parent;
-    } else if (parent.kind === 89 /* GenericSpecializationExpression */) {
+    } else if (parent.kind === 91 /* GenericSpecializationExpression */) {
       const grandParent = getParentSkippingParenthesizedExpressions(parent);
-      if (grandParent.kind === 69 /* CallExpression */) {
+      if (grandParent.kind === 71 /* CallExpression */) {
         parentCallExpression = grandParent;
       }
     }
@@ -6741,6 +6844,12 @@ var PackageReferenceTarget = class {
     this.kind = "package";
   }
 };
+var PackageNameTreeNodeReferenceTarget = class {
+  constructor(node) {
+    this.node = node;
+    this.kind = "package-name-tree-node";
+  }
+};
 var TypeContextReferenceTarget = class {
   constructor(type, typeContextKind) {
     this.type = type;
@@ -6826,59 +6935,59 @@ function getEntitySourceLocations(analyzer, entity) {
       const node = definition.node;
       let range;
       switch (node.kind) {
-        case 17 /* AnonymousMethodTypeDeclaration */:
-        case 18 /* AnonymousStructuredTypeDeclaration */:
-        case 19 /* AnonymousVariantTypeDeclaration */:
-        case 67 /* MethodBlockLiteral */:
-        case 74 /* MethodLiteral */:
+        case 19 /* AnonymousMethodTypeDeclaration */:
+        case 20 /* AnonymousStructuredTypeDeclaration */:
+        case 21 /* AnonymousVariantTypeDeclaration */:
+        case 69 /* MethodBlockLiteral */:
+        case 76 /* MethodLiteral */:
           range = node.rangeWithoutTrivia;
           break;
-        case 22 /* PackageAliasTypeDeclaration */:
-        case 27 /* PackageMethodDeclaration */:
-        case 28 /* PackageMethodTypeDeclaration */:
-        case 33 /* PackageStructuredTypeDeclaration */:
-        case 38 /* PackageVariantTypeDeclaration */:
-        case 58 /* NestedMethodDeclaration */:
-        case 52 /* TypeMethodDeclaration */:
-        case 143 /* TypeParameterDeclaration */:
-        case 53 /* OperatorDeclaration */:
+        case 24 /* PackageAliasTypeDeclaration */:
+        case 29 /* PackageMethodDeclaration */:
+        case 30 /* PackageMethodTypeDeclaration */:
+        case 35 /* PackageStructuredTypeDeclaration */:
+        case 40 /* PackageVariantTypeDeclaration */:
+        case 60 /* NestedMethodDeclaration */:
+        case 54 /* TypeMethodDeclaration */:
+        case 145 /* TypeParameterDeclaration */:
+        case 55 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
-        case 45 /* TypeConstructorDeclaration */:
+        case 47 /* TypeConstructorDeclaration */:
           range = node.creationKeyword.rangeWithoutTrivia;
           break;
-        case 46 /* TypeDestructorDeclaration */:
+        case 48 /* TypeDestructorDeclaration */:
           range = node.destructionKeyword.rangeWithoutTrivia;
           break;
         case 8 /* PackageImport */:
           Debug.assertNotNull(node.alias);
           range = node.alias.rangeWithoutTrivia;
           break;
-        case 40 /* TypeExtensionDeclaration */:
+        case 42 /* TypeExtensionDeclaration */:
           range = node.plusEqualsToken.rangeWithoutTrivia;
           break;
-        case 36 /* PackageVariableGetterDeclaration */:
+        case 38 /* PackageVariableGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 37 /* PackageVariableSetterDeclaration */:
+        case 39 /* PackageVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 55 /* TypeVariableGetterDeclaration */:
+        case 57 /* TypeVariableGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 56 /* TypeVariableSetterDeclaration */:
+        case 58 /* TypeVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 47 /* TypeIndexedGetterDeclaration */:
+        case 49 /* TypeIndexedGetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 48 /* TypeIndexedSetterDeclaration */:
+        case 50 /* TypeIndexedSetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 50 /* TypeDereferencedVariableGetterDeclaration */:
+        case 52 /* TypeDereferencedVariableGetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
-        case 51 /* TypeDereferencedVariableSetterDeclaration */:
+        case 53 /* TypeDereferencedVariableSetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
         default:
@@ -7000,9 +7109,13 @@ var DefinitionService = class {
         return getEntitySourceLocations(analyzer, target.parameter.entity);
       case "type-value-parameter":
         return getEntitySourceLocations(analyzer, target.parameter.getEntity());
-      case "package": {
+      case "package":
         return [new SourceLocation(sourceFile, tokenOrKeyword.value.rangeWithoutTrivia)];
-      }
+      case "package-name-tree-node":
+        if (target.node.package !== void 0) {
+          return [new SourceLocation(sourceFile, tokenOrKeyword.value.rangeWithoutTrivia)];
+        }
+        return void 0;
       case "type-context": {
         const entity = target.type.getEntity();
         if (entity !== void 0) {
@@ -7036,6 +7149,8 @@ var DefinitionService = class {
         return target.parameter.entity;
       case "package":
         return target.package_;
+      case "package-name-tree-node":
+        return target.node.package?.value;
       case "type-context":
         return target.type.getEntity();
       case "type-indexer":
@@ -7117,7 +7232,7 @@ var ReferencesService = class {
               }
             }
             if (!options6.onlyNamed) {
-              if (node.kind === 70 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
+              if (node.kind === 72 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
                 const semanticInfo = NodeSemanticInfoService.ofAutotypeCallExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7129,7 +7244,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 77 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 79 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -7145,7 +7260,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 66 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
+              if (node.kind === 68 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofBinaryExpressionOperator(
                   analyzer,
                   node,
@@ -7161,7 +7276,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 50 /* TypeDereferencedVariableGetterDeclaration */ || node.kind === 51 /* TypeDereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
+              if ((node.kind === 52 /* TypeDereferencedVariableGetterDeclaration */ || node.kind === 53 /* TypeDereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceOperatorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7173,7 +7288,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 80 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 82 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -7189,7 +7304,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 91 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 93 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -7205,7 +7320,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 45 /* TypeConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
+              if (node.kind === 47 /* TypeConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
                 const semanticInfo = NodeSemanticInfoService.ofTypeConstructorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7217,7 +7332,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 86 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 88 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7229,7 +7344,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 87 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 89 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7241,7 +7356,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 47 /* TypeIndexedGetterDeclaration */ || node.kind === 48 /* TypeIndexedSetterDeclaration */) && restrictions.canBeIndexer) {
+              if ((node.kind === 49 /* TypeIndexedGetterDeclaration */ || node.kind === 50 /* TypeIndexedSetterDeclaration */) && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofTypeIndexerDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7253,7 +7368,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 71 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
+              if (node.kind === 73 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedAccessExpressionOperator(
                   analyzer,
                   node,
@@ -7399,6 +7514,11 @@ var ReferencesService = class {
             target.localization,
             accessKindToReferenceKind(target.value.accessKind)
           );
+        case "package-name-tree-node":
+          if (target.value.node.package !== void 0) {
+            return new DefinitionInfo(target.value.node.package.value, target.localization, 0 /* Read */);
+          }
+          return void 0;
         default:
           Debug.never(target.value);
       }
@@ -7630,9 +7750,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 88 /* IdentifierExpression */:
+      case 90 /* IdentifierExpression */:
         return parent;
-      case 78 /* PropertyAccessExpression */:
+      case 80 /* PropertyAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7653,9 +7773,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 88 /* IdentifierExpression */:
+      case 90 /* IdentifierExpression */:
         return true;
-      case 78 /* PropertyAccessExpression */:
+      case 80 /* PropertyAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7663,35 +7783,35 @@ var EvaluatableExpressionService = class {
   }
   isNamedDeclaration(node) {
     switch (node.kind) {
-      case 60 /* EnumerationVariableDeclaration */:
+      case 62 /* EnumerationVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 22 /* PackageAliasTypeDeclaration */:
+      case 24 /* PackageAliasTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 27 /* PackageMethodDeclaration */:
+      case 29 /* PackageMethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 28 /* PackageMethodTypeDeclaration */:
+      case 30 /* PackageMethodTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 33 /* PackageStructuredTypeDeclaration */:
+      case 35 /* PackageStructuredTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 35 /* PackageVariableDeclaration */:
+      case 37 /* PackageVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 38 /* PackageVariantTypeDeclaration */:
+      case 40 /* PackageVariantTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 58 /* NestedMethodDeclaration */:
+      case 60 /* NestedMethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 59 /* LocalVariableDeclaration */:
+      case 61 /* LocalVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 144 /* ParameterDeclaration */:
+      case 146 /* ParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 52 /* TypeMethodDeclaration */:
+      case 54 /* TypeMethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 54 /* TypeVariableDeclaration */:
+      case 56 /* TypeVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 143 /* TypeParameterDeclaration */:
+      case 145 /* TypeParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 142 /* VariantDeclaration */:
+      case 144 /* VariantDeclaration */:
         return { nameIdentifier: node.name };
-      case 101 /* ErrorVariableDeclaration */:
+      case 103 /* ErrorVariableDeclaration */:
         return { nameIdentifier: node.name };
       default:
         return void 0;
@@ -7863,6 +7983,8 @@ var HoverService = class {
       }
       case "package":
         return new Hover(this._displayService.displayPackage(firstTarget.value.package_), range);
+      case "package-name-tree-node":
+        return new Hover(this._displayService.displayPackageNameTreeNode(firstTarget.value.node), range);
       case "type-context": {
         if (firstTarget.value.typeContextKind === "object") {
           const keywordText = this._displayService.displayKeyword(4 /* Object */);
@@ -7948,7 +8070,7 @@ var SourceFileItemsService = class {
           }
           break;
         }
-        case 35 /* PackageVariableDeclaration */: {
+        case 37 /* PackageVariableDeclaration */: {
           result.push(
             this.createItem(
               1 /* PackageVariable */,
@@ -7960,7 +8082,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 36 /* PackageVariableGetterDeclaration */: {
+        case 38 /* PackageVariableGetterDeclaration */: {
           result.push(
             this.createItem(
               2 /* PackageVariableGetter */,
@@ -7972,7 +8094,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 37 /* PackageVariableSetterDeclaration */: {
+        case 39 /* PackageVariableSetterDeclaration */: {
           result.push(
             this.createItem(
               3 /* PackageVariableSetter */,
@@ -7984,7 +8106,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 27 /* PackageMethodDeclaration */: {
+        case 29 /* PackageMethodDeclaration */: {
           result.push(
             this.createItem(
               4 /* PackageMethod */,
@@ -7996,7 +8118,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 33 /* PackageStructuredTypeDeclaration */: {
+        case 35 /* PackageStructuredTypeDeclaration */: {
           result.push(
             this.createItem(
               5 /* StructuredType */,
@@ -8008,7 +8130,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 54 /* TypeVariableDeclaration */: {
+        case 56 /* TypeVariableDeclaration */: {
           result.push(
             this.createItem(
               12 /* TypeVariable */,
@@ -8020,7 +8142,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 55 /* TypeVariableGetterDeclaration */: {
+        case 57 /* TypeVariableGetterDeclaration */: {
           result.push(
             this.createItem(
               13 /* TypeVariableGetter */,
@@ -8032,7 +8154,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 56 /* TypeVariableSetterDeclaration */: {
+        case 58 /* TypeVariableSetterDeclaration */: {
           result.push(
             this.createItem(
               14 /* TypeVariableSetter */,
@@ -8044,7 +8166,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 52 /* TypeMethodDeclaration */: {
+        case 54 /* TypeMethodDeclaration */: {
           result.push(
             this.createItem(
               15 /* TypeMethod */,
@@ -8056,7 +8178,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 45 /* TypeConstructorDeclaration */: {
+        case 47 /* TypeConstructorDeclaration */: {
           result.push(
             this.createItem(
               10 /* TypeConstructor */,
@@ -8068,7 +8190,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 46 /* TypeDestructorDeclaration */: {
+        case 48 /* TypeDestructorDeclaration */: {
           result.push(this.createItem(
             11 /* TypeDestructor */,
             void 0,
@@ -8078,7 +8200,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 47 /* TypeIndexedGetterDeclaration */: {
+        case 49 /* TypeIndexedGetterDeclaration */: {
           result.push(
             this.createItem(
               16 /* TypeIndexedGetter */,
@@ -8090,7 +8212,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 48 /* TypeIndexedSetterDeclaration */: {
+        case 50 /* TypeIndexedSetterDeclaration */: {
           result.push(
             this.createItem(
               17 /* TypeIndexedSetter */,
@@ -8102,7 +8224,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 28 /* PackageMethodTypeDeclaration */: {
+        case 30 /* PackageMethodTypeDeclaration */: {
           result.push(
             this.createItem(
               6 /* MethodType */,
@@ -8114,7 +8236,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 38 /* PackageVariantTypeDeclaration */: {
+        case 40 /* PackageVariantTypeDeclaration */: {
           result.push(
             this.createItem(
               7 /* VariantType */,
@@ -8126,7 +8248,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 142 /* VariantDeclaration */: {
+        case 144 /* VariantDeclaration */: {
           result.push(
             this.createItem(
               9 /* Variant */,
@@ -8138,7 +8260,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 143 /* TypeParameterDeclaration */: {
+        case 145 /* TypeParameterDeclaration */: {
           result.push(
             this.createItem(
               18 /* TypeParameter */,
@@ -8150,7 +8272,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 58 /* NestedMethodDeclaration */: {
+        case 60 /* NestedMethodDeclaration */: {
           result.push(
             this.createItem(
               19 /* NestedMethod */,
@@ -8183,7 +8305,7 @@ var SourceFileItemsService = class {
         return name ?? `<${LocalizationHelper.localizeHelperPhrase(4 /* PackageAlias */, this.locale)}>`;
       case 1 /* PackageVariable */:
       case 12 /* TypeVariable */:
-        return name ?? `<${LocalizationHelper.localizeHelperPhrase(5 /* Variable */, this.locale)}>`;
+        return name ?? `<${LocalizationHelper.localizeHelperPhrase(6 /* Variable */, this.locale)}>`;
       case 4 /* PackageMethod */:
       case 15 /* TypeMethod */:
       case 19 /* NestedMethod */:
@@ -8325,6 +8447,7 @@ var RenameService = class {
           case "package":
           case "type-context":
           case "type-indexer":
+          case "package-name-tree-node":
             canBeRenamed = false;
             break;
           default:
@@ -8374,7 +8497,7 @@ var SelectionRangeService = class {
       if (!this.nodeShouldBeSkipped(child) && !child.rangeWithoutTrivia.equals(result.range)) {
         result = new SelectionRange(child.rangeWithoutTrivia, result);
       }
-      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 81 /* TextTemplateLiteral */) {
+      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 83 /* TextTemplateLiteral */) {
         const textContentStart = child.rangeWithoutTrivia.start + 1;
         const textContentEnd = child.rangeWithoutTrivia.end - 1;
         if (offset >= textContentStart && offset < textContentEnd) {
@@ -8405,13 +8528,13 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 156 /* TypeAnnotation */:
-      case 34 /* StructuredTypeDeclarationBody */:
-      case 39 /* VariantTypeDeclarationBody */:
-      case 23 /* AliasTypeDeclarationBody */:
-      case 29 /* MethodTypeDeclarationBody */:
-      case 83 /* TextTemplateSpan */:
-      case 82 /* TextTemplateSpanList */:
+      case 158 /* TypeAnnotation */:
+      case 36 /* StructuredTypeDeclarationBody */:
+      case 41 /* VariantTypeDeclarationBody */:
+      case 25 /* AliasTypeDeclarationBody */:
+      case 31 /* MethodTypeDeclarationBody */:
+      case 85 /* TextTemplateSpan */:
+      case 84 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8449,7 +8572,7 @@ var SemanticTokensService = class {
             controller.stopChildrenTraverse();
             return;
           }
-          if (node.kind === 88 /* IdentifierExpression */) {
+          if (node.kind === 90 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.value.getEntity();
@@ -8505,7 +8628,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 78 /* PropertyAccessExpression */) {
+          if (node.kind === 80 /* PropertyAccessExpression */) {
             const meaning = analyzer.resolvePropertyAccessExpression(node).meaning;
             if (meaning.kind === "static-variable-access") {
               const entity = meaning.variable.value.getEntity();
@@ -8549,7 +8672,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 142 /* VariantDeclaration */) {
+          if (node.kind === 144 /* VariantDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8558,7 +8681,7 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 27 /* PackageMethodDeclaration */) {
+          if (node.kind === 29 /* PackageMethodDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8567,17 +8690,17 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 58 /* NestedMethodDeclaration */) {
+          if (node.kind === 60 /* NestedMethodDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 5 /* NestedMethod */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
             );
           }
-          if (node.kind === 52 /* TypeMethodDeclaration */) {
+          if (node.kind === 54 /* TypeMethodDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 6 /* TypeMethod */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
             );
           }
-          if (node.kind === 53 /* OperatorDeclaration */) {
+          if (node.kind === 55 /* OperatorDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 7 /* Operator */, new SemanticTokenModifiers().makeDeclaration())
             );
@@ -8733,7 +8856,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 === 154 /* 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);
@@ -8778,9 +8901,9 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 89 /* GenericSpecializationExpression */:
+      case 91 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
-      case 147 /* Tag */:
+      case 149 /* Tag */:
         return this.getSignaturesForTag(node);
       default:
         Debug.never(node);
@@ -8819,7 +8942,7 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
-    if (expression.kind === 88 /* IdentifierExpression */) {
+    if (expression.kind === 90 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "method-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
@@ -8834,7 +8957,7 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 78 /* PropertyAccessExpression */) {
+    if (expression.kind === 80 /* PropertyAccessExpression */) {
       const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
       let accessedMethods;
       if (meaning.kind === "instance-method-access") {
@@ -9087,7 +9210,7 @@ var ValueParametersSignatureHelpProvider = class {
     let node = token.parent;
     while (node !== void 0) {
       switch (node.kind) {
-        case 69 /* CallExpression */: {
+        case 71 /* CallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
@@ -9095,7 +9218,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 70 /* AutotypeCallExpression */: {
+        case 72 /* AutotypeCallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
@@ -9103,7 +9226,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 71 /* IndexedAccessExpression */: {
+        case 73 /* IndexedAccessExpression */: {
           if (this._offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
@@ -9111,7 +9234,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 147 /* Tag */: {
+        case 149 /* Tag */: {
           if (node.openParenthesisToken !== void 0 && this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && node.argumentList !== void 0 && (node.closeParenthesisToken === void 0 || node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this._offset);
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(node);
@@ -12029,6 +12152,8 @@ var EntityToSyntax = class {
         return this.convertParameterType(type);
       case "union":
         return this.convertUnionType(type);
+      case "intersection":
+        return this.convertIntersectionType(type);
       case "unresolved":
         return this.convertUnresolvedType(type);
       default:
@@ -12085,6 +12210,10 @@ var EntityToSyntax = class {
     const constituentTypes = type.originalTypes.map((t) => this.convertType(t));
     return SyntaxFactory.unionTypeSpecifier(constituentTypes);
   }
+  convertIntersectionType(type) {
+    const constituentTypes = type.originalTypes.map((t) => this.convertType(t));
+    return SyntaxFactory.intersectionTypeSpecifier(constituentTypes);
+  }
   convertUnresolvedType(_type) {
     return SyntaxFactory.namedTypeSpecifier("~\u041E\u0431\u044A\u0435\u043A\u0442");
   }
@@ -13269,7 +13398,7 @@ var LanguageServer = class {
       const sourceFileContext = yield this.getSourceFileContext(uri, token);
       if (sourceFileContext !== void 0) {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
-        if (node?.kind === 91 /* AssignmentStatement */) {
+        if (node?.kind === 93 /* AssignmentStatement */) {
           const sourceFileEdit = this._addPropertyAssignmentService.createEditWithAssignment(
             sourceFileContext.sourceFile,
             node,
@@ -13306,7 +13435,7 @@ var LanguageServer = class {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
         if (node !== void 0) {
           let nodeForRange = node;
-          if (node.kind === 91 /* AssignmentStatement */) {
+          if (node.kind === 93 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);