@artel/artc 0.6.25283 → 0.6.25284

package/build/api/ApiServices.js

@@ -69,6 +69,7 @@ import {
   NamedTypeSpecifier,
   NamedType_alias,
   NamedType_function,
+  NamedType_reduced,
   NamedType_structured,
   NamedType_variant,
   NodeModulesDirectoryName,
@@ -87,6 +88,7 @@ import {
   PackageMemberGroupDeclaration,
   PackageMemberLookup,
   PackageName,
+  PackageReducedTypeDeclaration,
   PackageStructuredTypeDeclaration,
   PackageVariableDeclaration,
   PackageVariableGetterDeclaration,
@@ -105,6 +107,7 @@ import {
   QualifiedName,
   Query,
   Range,
+  ReducedTypeDeclarationBody,
   Scanner,
   SinglePackageImportDirective,
   SourceFile,
@@ -133,14 +136,6 @@ import {
   TypeAnnotation,
   TypeArgumentClause,
   TypeArgumentList,
-  TypeDeclarationAlias_entity,
-  TypeDeclarationFunction_entity,
-  TypeDeclarationStructured_entity,
-  TypeDeclarationVariant_entity,
-  TypeDeclaration_alias,
-  TypeDeclaration_function,
-  TypeDeclaration_structured,
-  TypeDeclaration_variant,
   TypeMemberDeclarationBlock,
   TypeMemberDeclarationList,
   TypeMemberGroupDeclaration,
@@ -188,7 +183,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldTask
-} from "../chunk-2Q4QKW7T.js";
+} from "../chunk-CGOSDN2E.js";
 
 // source/services/CustomRequests.ts
 import * as ls from "vscode-languageserver";
@@ -241,7 +236,7 @@ var SyntaxFactory = class {
     }
     const packageName = this.packageName(pathSegments);
     const packageImport = new PackageImport(aliasIdentifier, equalsToken, packageName, void 0);
-    const importKeyword = this.keyword(18 /* Import */);
+    const importKeyword = this.keyword(19 /* Import */);
     return new SinglePackageImportDirective(importKeyword, packageImport, void 0);
   }
   static packageName(segments) {
@@ -252,7 +247,7 @@ var SyntaxFactory = class {
   static packageAliasTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const typeKeyword = this.keyword(16 /* Type */);
+    const typeKeyword = this.keyword(17 /* Type */);
     const nameIdentifier = this.identifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(64 /* Equals */);
@@ -271,6 +266,45 @@ var SyntaxFactory = class {
     const memberBlock = members !== void 0 ? this.typeMemberDeclarationBlock(members) : void 0;
     return new AliasTypeDeclarationBody(aliasedTypeSpecifier, memberBlock, void 0);
   }
+  static packageReducedTypeDeclaration(tags, modifiers, name, typeParameters, body) {
+    const tagList = new TagList(tags, void 0);
+    const modifierList = new ModifierList(modifiers, void 0);
+    const typeKeyword = this.keyword(17 /* Type */);
+    const nameIdentifier = this.identifier(name);
+    const typeParameterClause = this.createTypeParameterClause(typeParameters);
+    const equalsToken = this.token(64 /* Equals */);
+    return new PackageReducedTypeDeclaration(
+      tagList,
+      modifierList,
+      typeKeyword,
+      nameIdentifier,
+      typeParameterClause,
+      equalsToken,
+      body,
+      void 0
+    );
+  }
+  static reducedTypeDeclarationBody(reductionSourceSpecifier, preservedTypes, members) {
+    const reducedObjectKeyword = this.keyword(6 /* ReducedObject */);
+    let commaToken;
+    let preservedTypeList;
+    if (preservedTypes !== void 0 && preservedTypes.length > 0) {
+      commaToken = this.token(26 /* Comma */);
+      preservedTypeList = new BaseTypeList(
+        this.createSeparatedElements(preservedTypes, 26 /* Comma */),
+        void 0
+      );
+    }
+    const memberBlock = this.typeMemberDeclarationBlock(members);
+    return new ReducedTypeDeclarationBody(
+      reducedObjectKeyword,
+      reductionSourceSpecifier,
+      commaToken,
+      preservedTypeList,
+      memberBlock,
+      void 0
+    );
+  }
   static packageMemberGroupDeclaration(tags, modifiers, declarations) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
@@ -287,7 +321,7 @@ var SyntaxFactory = class {
   static packageFunctionDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const functionKeyword = this.keyword(12 /* Function */);
+    const functionKeyword = this.keyword(13 /* Function */);
     const nameIdentifier = this.identifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const parameterClause = this.parameterClause(parameters);
@@ -307,7 +341,7 @@ var SyntaxFactory = class {
   static packageFunctionTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const typeKeyword = this.keyword(16 /* Type */);
+    const typeKeyword = this.keyword(17 /* Type */);
     const nameIdentifier = this.identifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(64 /* Equals */);
@@ -323,7 +357,7 @@ var SyntaxFactory = class {
     );
   }
   static functionTypeDeclarationBody(parameters, returnTypeSpecifier) {
-    const functionKeyword = this.keyword(12 /* Function */);
+    const functionKeyword = this.keyword(13 /* Function */);
     const parameterClause = this.parameterClause(parameters);
     const returnTypeAnnotation = this.createTypeAnnotation(returnTypeSpecifier);
     return new FunctionTypeDeclarationBody(
@@ -337,7 +371,7 @@ var SyntaxFactory = class {
   static packageStructuredTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const typeKeyword = this.keyword(16 /* Type */);
+    const typeKeyword = this.keyword(17 /* Type */);
     const nameIdentifier = this.identifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(64 /* Equals */);
@@ -385,7 +419,7 @@ var SyntaxFactory = class {
   static packageVariableGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const getKeyword = this.keyword(58 /* Get */);
+    const getKeyword = this.keyword(59 /* Get */);
     const nameIdentifier = this.identifier(name);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
     return new PackageVariableGetterDeclaration(
@@ -401,14 +435,14 @@ var SyntaxFactory = class {
   static packageVariableSetterDeclaration(tags, modifiers, name, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const setKeyword = this.keyword(59 /* Set */);
+    const setKeyword = this.keyword(60 /* Set */);
     const nameIdentifier = this.identifier(name);
     return new PackageVariableSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body, void 0);
   }
   static packageVariantTypeDeclaration(tags, modifiers, name, typeParameters, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const typeKeyword = this.keyword(16 /* Type */);
+    const typeKeyword = this.keyword(17 /* Type */);
     const nameIdentifier = this.identifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const equalsToken = this.token(64 /* Equals */);
@@ -424,7 +458,7 @@ var SyntaxFactory = class {
     );
   }
   static variantTypeDeclarationBody(members) {
-    const variantKeyword = this.keyword(6 /* Variant */);
+    const variantKeyword = this.keyword(7 /* Variant */);
     const memberBlock = this.typeMemberDeclarationBlock(members);
     return new VariantTypeDeclarationBody(variantKeyword, void 0, memberBlock, void 0);
   }
@@ -450,7 +484,7 @@ var SyntaxFactory = class {
   static fieldGetterDeclaration(tags, modifiers, name, typeSpecifier, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const getKeyword = this.keyword(58 /* Get */);
+    const getKeyword = this.keyword(59 /* Get */);
     const nameIdentifier = this.identifier(name);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
     return new FieldGetterDeclaration(
@@ -466,14 +500,14 @@ var SyntaxFactory = class {
   static fieldSetterDeclaration(tags, modifiers, name, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const setKeyword = this.keyword(59 /* Set */);
+    const setKeyword = this.keyword(60 /* Set */);
     const nameIdentifier = this.identifier(name);
     return new FieldSetterDeclaration(tagList, modifierList, setKeyword, nameIdentifier, body, void 0);
   }
   static methodDeclaration(tags, modifiers, name, typeParameters, parameters, returnTypeSpecifier, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const functionKeyword = this.keyword(12 /* Function */);
+    const functionKeyword = this.keyword(13 /* Function */);
     const nameIdentifier = this.identifier(name);
     const typeParameterClause = this.createTypeParameterClause(typeParameters);
     const parameterClause = this.parameterClause(parameters);
@@ -493,21 +527,21 @@ var SyntaxFactory = class {
   static constructorDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const creationKeyword = this.keyword(31 /* Creation */);
+    const creationKeyword = this.keyword(32 /* Creation */);
     const parameterClause = this.parameterClause(parameters);
     return new ConstructorDeclaration(tagList, modifierList, creationKeyword, parameterClause, body, void 0);
   }
   static destructorDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const destructionKeyword = this.keyword(47 /* Destruction */);
+    const destructionKeyword = this.keyword(48 /* Destruction */);
     const parameterClause = this.parameterClause(parameters);
     return new DestructorDeclaration(tagList, modifierList, destructionKeyword, parameterClause, body, void 0);
   }
   static indexedElementGetterDeclaration(tags, modifiers, parameters, typeSpecifier, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const getKeyword = this.keyword(58 /* Get */);
+    const getKeyword = this.keyword(59 /* Get */);
     const parameterClause = this.indexParameterClause(parameters);
     const typeAnnotation = this.typeAnnotation(typeSpecifier);
     return new IndexedElementGetterDeclaration(
@@ -523,7 +557,7 @@ var SyntaxFactory = class {
   static indexedElementSetterDeclaration(tags, modifiers, parameters, body) {
     const tagList = new TagList(tags, void 0);
     const modifierList = new ModifierList(modifiers, void 0);
-    const getKeyword = this.keyword(59 /* Set */);
+    const getKeyword = this.keyword(60 /* Set */);
     const parameterClause = this.indexParameterClause(parameters);
     return new IndexedElementSetterDeclaration(tagList, modifierList, getKeyword, parameterClause, body, void 0);
   }
@@ -706,7 +740,7 @@ var SyntaxFactory = class {
     return new FunctionBlock(openBraceToken, statementList, closeBraceToken, void 0);
   }
   static nullLiteral() {
-    return new KeywordExpression(this.keyword(57 /* Null */), void 0);
+    return new KeywordExpression(this.keyword(58 /* Null */), void 0);
   }
   static integerLiteral(value) {
     return new TokenExpression(this.token(2 /* IntegerLiteral */, value.toString()), void 0);
@@ -714,7 +748,7 @@ var SyntaxFactory = class {
   static translationsDeclaration(translations) {
     const tagList = new TagList([], void 0);
     const modifierList = new ModifierList([], void 0);
-    const translationsKeyword = this.keyword(55 /* Translations */);
+    const translationsKeyword = this.keyword(56 /* Translations */);
     const openBraceToken = this.token(46 /* OpenBrace */);
     const translationList = new TopLevelTranslationList(translations, void 0);
     const closeBraceToken = this.token(22 /* CloseBrace */);
@@ -740,7 +774,7 @@ var SyntaxFactory = class {
     );
   }
   static packageFunctionTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
-    const functionKeyword = this.keyword(12 /* Function */);
+    const functionKeyword = this.keyword(13 /* Function */);
     const sourceNameIdentifier = this.identifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
@@ -761,7 +795,7 @@ var SyntaxFactory = class {
     );
   }
   static typeTranslation(sourceName, sourceTypeParameters, translatedName, translatedTypeParameters, members) {
-    const typeKeyword = this.keyword(16 /* Type */);
+    const typeKeyword = this.keyword(17 /* Type */);
     const sourceNameIdentifier = this.identifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const minusGreaterThanToken = this.token(45 /* MinusGreaterThan */);
@@ -789,7 +823,7 @@ var SyntaxFactory = class {
     );
   }
   static functionTypeTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
-    const typeKeyword = this.keyword(16 /* Type */);
+    const typeKeyword = this.keyword(17 /* Type */);
     const sourceNameIdentifier = this.identifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
@@ -821,7 +855,7 @@ var SyntaxFactory = class {
     );
   }
   static methodTranslation(sourceName, sourceTypeParameters, sourceParameters, translatedName, translatedTypeParameters, translatedParameters) {
-    const functionKeyword = this.keyword(12 /* Function */);
+    const functionKeyword = this.keyword(13 /* Function */);
     const sourceNameIdentifier = this.identifier(sourceName);
     const sourceTypeParameterClause = this.createTranslationTypeParameterClause(sourceTypeParameters);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
@@ -842,7 +876,7 @@ var SyntaxFactory = class {
     );
   }
   static constructorTranslation(sourceParameters, translatedParameters) {
-    const creationKeyword = this.keyword(31 /* Creation */);
+    const creationKeyword = this.keyword(32 /* Creation */);
     const sourceParameterClause = this.translationParameterClause(sourceParameters);
     const minusGreaterThanToken = this.token(45 /* MinusGreaterThan */);
     const translatedParameterClause = this.translationParameterClause(translatedParameters);
@@ -1097,6 +1131,32 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeTypeMemberDeclarationBlock(node.body.memberBlock);
     }
   }
+  writePackageReducedTypeDeclaration(node) {
+    this.writeDeclarationTags(node.tagList);
+    this.writeDeclarationModifiers(node.modifierList);
+    this.writeKeyword(node.typeKeyword);
+    this.writeWhitespace();
+    this.writeToken(node.name);
+    if (node.typeParameterClause !== void 0) {
+      this.writeTypeParameterClause(node.typeParameterClause);
+    }
+    this.writeWhitespace();
+    this.writeToken(node.equalsToken);
+    this.writeWhitespace();
+    this.writeKeyword(node.body.reducedObjectKeyword);
+    this.writeWhitespace();
+    this.writeTypeSpecifier(node.body.reductionSourceSpecifier, false);
+    if (node.body.commaToken !== void 0) {
+      this.writeToken(node.body.commaToken);
+      if (node.body.preservedTypeList !== void 0 && node.body.preservedTypeList.elements.length > 0) {
+        this.writeWhitespace();
+        this.writeBaseTypeList(node.body.preservedTypeList);
+      }
+    }
+    if (node.body.memberBlock !== void 0) {
+      this.writeTypeMemberDeclarationBlock(node.body.memberBlock);
+    }
+  }
   writePackageVariantTypeDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
@@ -1517,10 +1577,10 @@ var SyntaxToCode = class _SyntaxToCode {
         return true;
       case 15 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 27 /* FunctionTypeDeclarationBody */:
+          case 29 /* FunctionTypeDeclarationBody */:
             return true;
-          case 32 /* StructuredTypeDeclarationBody */:
-          case 37 /* VariantTypeDeclarationBody */:
+          case 34 /* StructuredTypeDeclarationBody */:
+          case 39 /* VariantTypeDeclarationBody */:
             return false;
           default:
             Debug.never(node.typeDeclaration.body);
@@ -1543,10 +1603,10 @@ var SyntaxToCode = class _SyntaxToCode {
         return true;
       case 15 /* AnonymousTypeSpecifier */: {
         switch (node.typeDeclaration.body.kind) {
-          case 27 /* FunctionTypeDeclarationBody */:
+          case 29 /* FunctionTypeDeclarationBody */:
             return true;
-          case 32 /* StructuredTypeDeclarationBody */:
-          case 37 /* VariantTypeDeclarationBody */:
+          case 34 /* StructuredTypeDeclarationBody */:
+          case 39 /* VariantTypeDeclarationBody */:
             return false;
           default:
             Debug.never(node.typeDeclaration.body);
@@ -1595,7 +1655,7 @@ var SyntaxToCode = class _SyntaxToCode {
     this.writeNodeDefault(node);
   }
   writeDeclarationBody(node, addLeadingNewLineOrWhitespace = true) {
-    if (node.expressionOrStatementList.kind !== 93 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
+    if (node.expressionOrStatementList.kind !== 95 /* StatementList */ || node.expressionOrStatementList.elements.length === 0) {
       this.writeWhitespace();
       this.writeFunctionBlock(node, false);
     } else {
@@ -1817,7 +1877,7 @@ var SyntaxToCode = class _SyntaxToCode {
   writeKeyword(keyword) {
     if (keyword.isMissing) {
       let preferredFlags;
-      if (keyword.parent.kind === 154 /* Modifier */) {
+      if (keyword.parent.kind === 156 /* Modifier */) {
         preferredFlags = this.getModifierPreferredFlags(keyword.parent);
       } else {
         preferredFlags = 12290 /* SingularNeuNoun */;
@@ -1840,37 +1900,38 @@ var SyntaxToCode = class _SyntaxToCode {
   getModifierPreferredFlags(modifier) {
     const modifierTarget = modifier.parent.parent;
     switch (modifierTarget.kind) {
-      case 25 /* PackageFunctionDeclaration */:
-      case 35 /* PackageVariableSetterDeclaration */:
-      case 54 /* FieldSetterDeclaration */:
-      case 46 /* IndexedElementSetterDeclaration */:
-      case 49 /* DereferencedVariableSetterDeclaration */:
-      case 50 /* MethodDeclaration */:
-      case 51 /* OperatorDeclaration */:
-      case 24 /* PackageEntryPointDeclaration */:
+      case 27 /* PackageFunctionDeclaration */:
+      case 37 /* PackageVariableSetterDeclaration */:
+      case 56 /* FieldSetterDeclaration */:
+      case 48 /* IndexedElementSetterDeclaration */:
+      case 51 /* DereferencedVariableSetterDeclaration */:
+      case 52 /* MethodDeclaration */:
+      case 53 /* OperatorDeclaration */:
+      case 26 /* PackageEntryPointDeclaration */:
         return 10242 /* SingularFemNoun */;
       case 20 /* PackageAliasTypeDeclaration */:
-      case 31 /* PackageStructuredTypeDeclaration */:
-      case 36 /* PackageVariantTypeDeclaration */:
-      case 26 /* PackageFunctionTypeDeclaration */:
+      case 22 /* PackageReducedTypeDeclaration */:
+      case 33 /* PackageStructuredTypeDeclaration */:
+      case 38 /* PackageVariantTypeDeclaration */:
+      case 28 /* PackageFunctionTypeDeclaration */:
         return 9218 /* SingularMasNoun */;
-      case 33 /* PackageVariableDeclaration */:
-      case 34 /* PackageVariableGetterDeclaration */:
-      case 38 /* TypeExtensionDeclaration */:
-      case 23 /* PackageConstructorDeclaration */:
-      case 43 /* ConstructorDeclaration */:
-      case 44 /* DestructorDeclaration */:
-      case 45 /* IndexedElementGetterDeclaration */:
-      case 48 /* DereferencedVariableGetterDeclaration */:
-      case 52 /* FieldDeclaration */:
-      case 53 /* FieldGetterDeclaration */:
-      case 147 /* VariantValueDeclaration */:
-      case 41 /* MissingPackageMemberDeclaration */:
-      case 55 /* MissingTypeMemberDeclaration */:
+      case 35 /* PackageVariableDeclaration */:
+      case 36 /* PackageVariableGetterDeclaration */:
+      case 40 /* TypeExtensionDeclaration */:
+      case 25 /* PackageConstructorDeclaration */:
+      case 45 /* ConstructorDeclaration */:
+      case 46 /* DestructorDeclaration */:
+      case 47 /* IndexedElementGetterDeclaration */:
+      case 50 /* DereferencedVariableGetterDeclaration */:
+      case 54 /* FieldDeclaration */:
+      case 55 /* FieldGetterDeclaration */:
+      case 149 /* VariantValueDeclaration */:
+      case 43 /* MissingPackageMemberDeclaration */:
+      case 57 /* MissingTypeMemberDeclaration */:
         return 12290 /* SingularNeuNoun */;
-      case 42 /* TypeMemberGroupDeclaration */:
-      case 22 /* PackageMemberGroupDeclaration */:
-      case 123 /* TranslationsDeclaration */:
+      case 44 /* TypeMemberGroupDeclaration */:
+      case 24 /* PackageMemberGroupDeclaration */:
+      case 125 /* TranslationsDeclaration */:
         return 16386 /* PluralNoun */;
       default:
         Debug.never(modifierTarget);
@@ -1949,153 +2010,155 @@ var SyntaxToCode = class _SyntaxToCode {
       [14 /* NullableTypeSpecifier */]: this.prototype.writeNullableTypeSpecifier,
       [15 /* AnonymousTypeSpecifier */]: this.prototype.writeAnonymousTypeSpecifier,
       [20 /* PackageAliasTypeDeclaration */]: this.prototype.writePackageAliasTypeDeclaration,
-      [22 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
-      [23 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
-      [24 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
-      [25 /* PackageFunctionDeclaration */]: this.prototype.writePackageFunctionDeclaration,
-      [26 /* PackageFunctionTypeDeclaration */]: this.prototype.writePackageFunctionTypeDeclaration,
-      [27 /* FunctionTypeDeclarationBody */]: this.prototype.writeFunctionTypeDeclarationBody,
-      [28 /* BaseTypeList */]: this.prototype.writeBaseTypeList,
-      [30 /* TypeMemberDeclarationBlock */]: this.prototype.writeTypeMemberDeclarationBlock,
-      [31 /* PackageStructuredTypeDeclaration */]: this.prototype.writePackageStructuredTypeDeclaration,
-      [32 /* StructuredTypeDeclarationBody */]: this.prototype.writeStructuredTypeDeclarationBody,
-      [33 /* PackageVariableDeclaration */]: this.prototype.writePackageVariableDeclaration,
-      [34 /* PackageVariableGetterDeclaration */]: this.prototype.writePackageVariableGetterDeclaration,
-      [35 /* PackageVariableSetterDeclaration */]: this.prototype.writePackageVariableSetterDeclaration,
-      [36 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
-      [37 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
-      [42 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
-      [43 /* ConstructorDeclaration */]: this.prototype.writeConstructorDeclaration,
-      [44 /* DestructorDeclaration */]: this.prototype.writeDestructorDeclaration,
-      [45 /* IndexedElementGetterDeclaration */]: this.prototype.writeIndexedElementGetterDeclaration,
-      [46 /* IndexedElementSetterDeclaration */]: this.prototype.writeIndexedElementSetterDeclaration,
-      [48 /* DereferencedVariableGetterDeclaration */]: this.prototype.writeDereferencedVariableGetterDeclaration,
-      [49 /* DereferencedVariableSetterDeclaration */]: this.prototype.writeDereferencedVariableSetterDeclaration,
-      [50 /* MethodDeclaration */]: this.prototype.writeMethodDeclaration,
-      [51 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
-      [52 /* FieldDeclaration */]: this.prototype.writeFieldDeclaration,
-      [53 /* FieldGetterDeclaration */]: this.prototype.writeFieldGetterDeclaration,
-      [54 /* FieldSetterDeclaration */]: this.prototype.writeFieldSetterDeclaration,
-      [94 /* StatementBlock */]: this.prototype.writeStatementBlock,
-      [95 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
-      [135 /* QualifiedName */]: this.prototype.writeQualifiedName,
-      [147 /* VariantValueDeclaration */]: this.prototype.writeVariantValueDeclaration,
-      [148 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
-      [149 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [150 /* Argument */]: this.prototype.writeArgument,
-      [152 /* Tag */]: this.prototype.writeTag,
-      [154 /* Modifier */]: this.prototype.writeModifier,
-      [155 /* ParameterClause */]: this.prototype.writeParameterClause,
-      [156 /* ParameterList */]: this.prototype.writeParameterList,
-      [157 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [159 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [22 /* PackageReducedTypeDeclaration */]: this.prototype.writePackageReducedTypeDeclaration,
+      [24 /* PackageMemberGroupDeclaration */]: this.prototype.writePackageMemberGroupDeclaration,
+      [25 /* PackageConstructorDeclaration */]: this.prototype.writePackageConstructorDeclaration,
+      [26 /* PackageEntryPointDeclaration */]: this.prototype.writePackageEntryPointDeclaration,
+      [27 /* PackageFunctionDeclaration */]: this.prototype.writePackageFunctionDeclaration,
+      [28 /* PackageFunctionTypeDeclaration */]: this.prototype.writePackageFunctionTypeDeclaration,
+      [29 /* FunctionTypeDeclarationBody */]: this.prototype.writeFunctionTypeDeclarationBody,
+      [30 /* BaseTypeList */]: this.prototype.writeBaseTypeList,
+      [32 /* TypeMemberDeclarationBlock */]: this.prototype.writeTypeMemberDeclarationBlock,
+      [33 /* PackageStructuredTypeDeclaration */]: this.prototype.writePackageStructuredTypeDeclaration,
+      [34 /* StructuredTypeDeclarationBody */]: this.prototype.writeStructuredTypeDeclarationBody,
+      [35 /* PackageVariableDeclaration */]: this.prototype.writePackageVariableDeclaration,
+      [36 /* PackageVariableGetterDeclaration */]: this.prototype.writePackageVariableGetterDeclaration,
+      [37 /* PackageVariableSetterDeclaration */]: this.prototype.writePackageVariableSetterDeclaration,
+      [38 /* PackageVariantTypeDeclaration */]: this.prototype.writePackageVariantTypeDeclaration,
+      [39 /* VariantTypeDeclarationBody */]: this.prototype.writeVariantTypeDeclarationBody,
+      [44 /* TypeMemberGroupDeclaration */]: this.prototype.writeTypeMemberGroupDeclaration,
+      [45 /* ConstructorDeclaration */]: this.prototype.writeConstructorDeclaration,
+      [46 /* DestructorDeclaration */]: this.prototype.writeDestructorDeclaration,
+      [47 /* IndexedElementGetterDeclaration */]: this.prototype.writeIndexedElementGetterDeclaration,
+      [48 /* IndexedElementSetterDeclaration */]: this.prototype.writeIndexedElementSetterDeclaration,
+      [50 /* DereferencedVariableGetterDeclaration */]: this.prototype.writeDereferencedVariableGetterDeclaration,
+      [51 /* DereferencedVariableSetterDeclaration */]: this.prototype.writeDereferencedVariableSetterDeclaration,
+      [52 /* MethodDeclaration */]: this.prototype.writeMethodDeclaration,
+      [53 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
+      [54 /* FieldDeclaration */]: this.prototype.writeFieldDeclaration,
+      [55 /* FieldGetterDeclaration */]: this.prototype.writeFieldGetterDeclaration,
+      [56 /* FieldSetterDeclaration */]: this.prototype.writeFieldSetterDeclaration,
+      [96 /* StatementBlock */]: this.prototype.writeStatementBlock,
+      [97 /* FunctionBlock */]: this.prototype.writeFunctionBlock,
+      [137 /* QualifiedName */]: this.prototype.writeQualifiedName,
+      [149 /* VariantValueDeclaration */]: this.prototype.writeVariantValueDeclaration,
+      [150 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
+      [151 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
+      [152 /* Argument */]: this.prototype.writeArgument,
+      [154 /* Tag */]: this.prototype.writeTag,
+      [156 /* Modifier */]: this.prototype.writeModifier,
+      [157 /* ParameterClause */]: this.prototype.writeParameterClause,
+      [158 /* ParameterList */]: this.prototype.writeParameterList,
+      [159 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [161 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
       [17 /* AnonymousFunctionTypeDeclaration */]: this.prototype.writeAnonymousFunctionTypeDeclaration,
       [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
       [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
       [6 /* PackageGroupImportDirective */]: this.prototype.writeNodeDefault,
       [7 /* PackageImportList */]: this.prototype.writeNodeDefault,
       [16 /* MissingTypeSpecifier */]: this.prototype.writeNodeDefault,
-      [124 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
-      [123 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
+      [126 /* TopLevelTranslationList */]: this.prototype.writeNodeDefault,
+      [125 /* TranslationsDeclaration */]: this.prototype.writeTranslationsDeclaration,
       [21 /* AliasTypeDeclarationBody */]: this.prototype.writeNodeDefault,
-      [29 /* TypeMemberDeclarationList */]: this.prototype.writeNodeDefault,
-      [38 /* TypeExtensionDeclaration */]: this.prototype.writeNodeDefault,
-      [39 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
-      [40 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
-      [41 /* MissingPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [47 /* IndexParameterClause */]: this.prototype.writeNodeDefault,
-      [55 /* MissingTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [56 /* NestedFunctionDeclaration */]: this.prototype.writeNodeDefault,
-      [57 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [58 /* ForStatementVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [59 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
-      [60 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
-      [61 /* AssertionExpression */]: this.prototype.writeNodeDefault,
-      [62 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
-      [63 /* AsExpression */]: this.prototype.writeNodeDefault,
-      [64 /* BinaryExpression */]: this.prototype.writeNodeDefault,
-      [66 /* FunctionBlockLiteral */]: this.prototype.writeNodeDefault,
-      [67 /* ArgumentList */]: this.prototype.writeNodeDefault,
-      [68 /* CallExpression */]: this.prototype.writeNodeDefault,
-      [69 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
-      [70 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
-      [71 /* MissingExpression */]: this.prototype.writeNodeDefault,
-      [72 /* IsExpression */]: this.prototype.writeNodeDefault,
-      [65 /* FunctionLiteral */]: this.prototype.writeNodeDefault,
-      [73 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
-      [74 /* ConditionalExpression */]: this.prototype.writeNodeDefault,
-      [75 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
-      [76 /* MemberAccessExpression */]: this.prototype.writeNodeDefault,
-      [77 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
-      [78 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
-      [84 /* TextLiteral */]: this.prototype.writeNodeDefault,
-      [85 /* LocalizableTextLiteral */]: this.prototype.writeNodeDefault,
-      [79 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
-      [80 /* LocalizableTextTemplateLiteral */]: this.prototype.writeNodeDefault,
-      [81 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
-      [82 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
-      [83 /* TokenExpression */]: this.prototype.writeNodeDefault,
-      [86 /* KeywordExpression */]: this.prototype.writeNodeDefault,
-      [87 /* ObjectExpression */]: this.prototype.writeNodeDefault,
-      [88 /* BaseExpression */]: this.prototype.writeNodeDefault,
-      [89 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
-      [90 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
-      [91 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
-      [92 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
-      [93 /* StatementList */]: this.prototype.writeNodeDefault,
-      [96 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
-      [97 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
-      [98 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [99 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [100 /* TryStatement */]: this.prototype.writeNodeDefault,
-      [101 /* CatchClause */]: this.prototype.writeNodeDefault,
-      [102 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [103 /* FinallyClause */]: this.prototype.writeNodeDefault,
-      [104 /* ErrorStatement */]: this.prototype.writeNodeDefault,
-      [105 /* ImportantStatement */]: this.prototype.writeNodeDefault,
-      [106 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
-      [107 /* ForStatement */]: this.prototype.writeNodeDefault,
-      [108 /* IfStatement */]: this.prototype.writeNodeDefault,
-      [109 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
-      [110 /* ElseIfClause */]: this.prototype.writeNodeDefault,
-      [111 /* ElseClause */]: this.prototype.writeNodeDefault,
-      [112 /* MissingStatement */]: this.prototype.writeNodeDefault,
-      [113 /* NestedFunctionDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [114 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [115 /* LoopStatement */]: this.prototype.writeNodeDefault,
-      [116 /* ReturnStatement */]: this.prototype.writeNodeDefault,
-      [117 /* CaseClauseList */]: this.prototype.writeNodeDefault,
-      [118 /* SwitchStatement */]: this.prototype.writeNodeDefault,
-      [119 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
-      [120 /* CaseClause */]: this.prototype.writeNodeDefault,
-      [121 /* WhileStatement */]: this.prototype.writeNodeDefault,
-      [122 /* YieldStatement */]: this.prototype.writeNodeDefault,
-      [125 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
-      [126 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
-      [127 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
-      [128 /* IndexParameterTranslationClause */]: this.prototype.writeIndexParameterTranslationClause,
-      [129 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
-      [130 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
-      [131 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
-      [132 /* PackageFunctionTranslationDeclaration */]: this.prototype.writePackageFunctionTranslation,
-      [133 /* MethodTranslation */]: this.prototype.writeMethodTranslation,
-      [134 /* FunctionTypeTranslationDeclaration */]: this.prototype.writeFunctionTypeTranslation,
-      [136 /* PackageVariableTranslationDeclaration */]: this.prototype.writePackageVariableTranslation,
-      [137 /* FieldOrVariantTranslation */]: this.prototype.writeFieldOrVariantTranslation,
-      [138 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
-      [139 /* TypeTranslationDeclaration */]: this.prototype.writeTypeTranslation,
-      [140 /* TextTranslationDeclaration */]: this.prototype.writeNodeDefault,
-      [141 /* TextTranslationFunctionDeclaration */]: this.prototype.writeNodeDefault,
-      [151 /* TagList */]: this.prototype.writeNodeDefault,
-      [153 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [158 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [160 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [161 /* TypeAnnotation */]: this.prototype.writeNodeDefault,
-      [142 /* TranslationTextLiteral */]: this.prototype.writeNodeDefault,
-      [143 /* TranslationTextTemplate */]: this.prototype.writeNodeDefault,
-      [144 /* TranslationTextTemplateSpanList */]: this.prototype.writeNodeDefault,
-      [145 /* TranslationTextTemplateSpan */]: this.prototype.writeNodeDefault,
-      [146 /* TranslationTextTemplateParameter */]: this.prototype.writeNodeDefault
+      [23 /* ReducedTypeDeclarationBody */]: this.prototype.writeNodeDefault,
+      [31 /* TypeMemberDeclarationList */]: this.prototype.writeNodeDefault,
+      [40 /* TypeExtensionDeclaration */]: this.prototype.writeNodeDefault,
+      [41 /* ExtendedTypeClauseCommaList */]: this.prototype.writeNodeDefault,
+      [42 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
+      [43 /* MissingPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
+      [49 /* IndexParameterClause */]: this.prototype.writeNodeDefault,
+      [57 /* MissingTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
+      [58 /* NestedFunctionDeclaration */]: this.prototype.writeNodeDefault,
+      [59 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [60 /* ForStatementVariableDeclaration */]: 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,
+      [68 /* FunctionBlockLiteral */]: this.prototype.writeNodeDefault,
+      [69 /* ArgumentList */]: this.prototype.writeNodeDefault,
+      [70 /* CallExpression */]: this.prototype.writeNodeDefault,
+      [71 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
+      [72 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
+      [73 /* MissingExpression */]: this.prototype.writeNodeDefault,
+      [74 /* IsExpression */]: this.prototype.writeNodeDefault,
+      [67 /* FunctionLiteral */]: this.prototype.writeNodeDefault,
+      [75 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
+      [76 /* ConditionalExpression */]: this.prototype.writeNodeDefault,
+      [77 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [78 /* MemberAccessExpression */]: this.prototype.writeNodeDefault,
+      [79 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
+      [80 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
+      [86 /* TextLiteral */]: this.prototype.writeNodeDefault,
+      [87 /* LocalizableTextLiteral */]: this.prototype.writeNodeDefault,
+      [81 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [82 /* LocalizableTextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [83 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [84 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [85 /* TokenExpression */]: this.prototype.writeNodeDefault,
+      [88 /* KeywordExpression */]: this.prototype.writeNodeDefault,
+      [89 /* ObjectExpression */]: this.prototype.writeNodeDefault,
+      [90 /* BaseExpression */]: this.prototype.writeNodeDefault,
+      [91 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
+      [92 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
+      [93 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
+      [94 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
+      [95 /* StatementList */]: this.prototype.writeNodeDefault,
+      [98 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
+      [99 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
+      [100 /* DisposeStatement */]: this.prototype.writeNodeDefault,
+      [101 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [102 /* TryStatement */]: this.prototype.writeNodeDefault,
+      [103 /* CatchClause */]: this.prototype.writeNodeDefault,
+      [104 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [105 /* FinallyClause */]: this.prototype.writeNodeDefault,
+      [106 /* ErrorStatement */]: this.prototype.writeNodeDefault,
+      [107 /* ImportantStatement */]: this.prototype.writeNodeDefault,
+      [108 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
+      [109 /* ForStatement */]: this.prototype.writeNodeDefault,
+      [110 /* IfStatement */]: this.prototype.writeNodeDefault,
+      [111 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
+      [112 /* ElseIfClause */]: this.prototype.writeNodeDefault,
+      [113 /* ElseClause */]: this.prototype.writeNodeDefault,
+      [114 /* MissingStatement */]: this.prototype.writeNodeDefault,
+      [115 /* NestedFunctionDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [116 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
+      [117 /* LoopStatement */]: this.prototype.writeNodeDefault,
+      [118 /* ReturnStatement */]: this.prototype.writeNodeDefault,
+      [119 /* CaseClauseList */]: this.prototype.writeNodeDefault,
+      [120 /* SwitchStatement */]: this.prototype.writeNodeDefault,
+      [121 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
+      [122 /* CaseClause */]: this.prototype.writeNodeDefault,
+      [123 /* WhileStatement */]: this.prototype.writeNodeDefault,
+      [124 /* YieldStatement */]: this.prototype.writeNodeDefault,
+      [127 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
+      [128 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
+      [129 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
+      [130 /* IndexParameterTranslationClause */]: this.prototype.writeIndexParameterTranslationClause,
+      [131 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
+      [132 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
+      [133 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
+      [134 /* PackageFunctionTranslationDeclaration */]: this.prototype.writePackageFunctionTranslation,
+      [135 /* MethodTranslation */]: this.prototype.writeMethodTranslation,
+      [136 /* FunctionTypeTranslationDeclaration */]: this.prototype.writeFunctionTypeTranslation,
+      [138 /* PackageVariableTranslationDeclaration */]: this.prototype.writePackageVariableTranslation,
+      [139 /* FieldOrVariantTranslation */]: this.prototype.writeFieldOrVariantTranslation,
+      [140 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
+      [141 /* TypeTranslationDeclaration */]: this.prototype.writeTypeTranslation,
+      [142 /* TextTranslationDeclaration */]: this.prototype.writeNodeDefault,
+      [143 /* TextTranslationFunctionDeclaration */]: this.prototype.writeNodeDefault,
+      [153 /* TagList */]: this.prototype.writeNodeDefault,
+      [155 /* ModifierList */]: this.prototype.writeNodeDefault,
+      [160 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [162 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [163 /* TypeAnnotation */]: this.prototype.writeNodeDefault,
+      [144 /* TranslationTextLiteral */]: this.prototype.writeNodeDefault,
+      [145 /* TranslationTextTemplate */]: this.prototype.writeNodeDefault,
+      [146 /* TranslationTextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [147 /* TranslationTextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [148 /* TranslationTextTemplateParameter */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2107,13 +2170,13 @@ var SyntaxToCode = class _SyntaxToCode {
 var backSlashRegExp = /\\/g;
 var singleQuoteRegExp = /'/g;
 var modifierSortOrder = {
-  [37 /* Hidden */]: 0,
-  [41 /* Static */]: 1,
-  [17 /* Basic */]: 2,
-  [38 /* Abstract */]: 3,
-  [39 /* Override */]: 4,
-  [40 /* Async */]: 5,
-  [36 /* Const */]: 6
+  [38 /* Hidden */]: 0,
+  [42 /* Static */]: 1,
+  [18 /* Basic */]: 2,
+  [39 /* Abstract */]: 3,
+  [40 /* Override */]: 4,
+  [41 /* Async */]: 5,
+  [37 /* Const */]: 6
 };
 
 // source/services/TreeUtils.ts
@@ -2304,28 +2367,28 @@ var TranslationsGenerationService = class {
       return void 0;
     }
     let result;
-    if (tokenOrKeyword.isToken(9 /* Identifier */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslationDeclaration */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
+    if (tokenOrKeyword.isToken(9 /* Identifier */) && tokenOrKeyword.parent.kind === 141 /* TypeTranslationDeclaration */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
           analyzer,
           sourceFile,
           translationPackage,
-          sourceFile.package.locale,
-          sourceFile.package.dialect
+          sourceFile.locale,
+          sourceFile.dialect
         );
         result = generator.generateMissingTypeMemberTranslations(tokenOrKeyword.parent);
       }
     }
-    if (result === void 0 && tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 123 /* TranslationsDeclaration */) {
+    if (result === void 0 && tokenOrKeyword.isKeyword(56 /* Translations */) && tokenOrKeyword.parent.kind === 125 /* TranslationsDeclaration */) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
           analyzer,
           sourceFile,
           translationPackage,
-          sourceFile.package.locale,
-          sourceFile.package.dialect
+          sourceFile.locale,
+          sourceFile.dialect
         );
         if (onlyTypeMembers) {
           result = generator.generateMissingTranslationsForPartiallyTranslatedTypes(tokenOrKeyword.parent);
@@ -2344,7 +2407,7 @@ var TranslationsGenerationService = class {
     if (tokenOrKeyword === void 0) {
       return false;
     }
-    if (!(tokenOrKeyword.isKeyword(55 /* Translations */) && tokenOrKeyword.parent.kind === 123 /* TranslationsDeclaration */)) {
+    if (!(tokenOrKeyword.isKeyword(56 /* Translations */) && tokenOrKeyword.parent.kind === 125 /* TranslationsDeclaration */)) {
       return false;
     }
     const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
@@ -2355,10 +2418,10 @@ var TranslationsGenerationService = class {
       analyzer,
       sourceFile,
       translationPackage,
-      sourceFile.package.locale,
-      sourceFile.package.dialect
+      sourceFile.locale,
+      sourceFile.dialect
     );
-    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 139 /* TypeTranslationDeclaration */).mapAndFilter((t) => translationPackage.getPackageMemberTranslationTargets(t)?.values).flatMap((t) => t).any((t) => isPackageTypeEntity(t) && generator.collectNotTranslatedTypeMembers(t).length > 0);
+    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 141 /* TypeTranslationDeclaration */).mapAndFilter((t) => translationPackage.getPackageMemberTranslationTargets(t)?.values).flatMap((t) => t).any((t) => isPackageTypeEntity(t) && generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
 var TranslationsGenerator = class _TranslationsGenerator {
@@ -2386,7 +2449,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 /* TypeTranslationDeclaration */) {
+        if (n.kind === 141 /* TypeTranslationDeclaration */) {
           const startOffset = Math.max(code.indexOf(newLine), 0);
           return this.addNewLineBeforeArrowsInTranslation(
             code,
@@ -2418,7 +2481,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
   generateMissingTranslationsForPartiallyTranslatedTypes(translationsDeclaration) {
     const result = new Array();
     for (const translation of translationsDeclaration.translationList.translationDeclarations) {
-      if (translation.kind === 139 /* TypeTranslationDeclaration */) {
+      if (translation.kind === 141 /* TypeTranslationDeclaration */) {
         const edits = this.generateMissingTypeMemberTranslations(translation);
         if (edits !== void 0) {
           result.push(...edits);
@@ -2486,13 +2549,13 @@ var TranslationsGenerator = class _TranslationsGenerator {
   }
   detectIndentationStepForTypeMemberTranslations(node) {
     let indentationStepSize;
-    if (node.kind === 139 /* TypeTranslationDeclaration */) {
+    if (node.kind === 141 /* TypeTranslationDeclaration */) {
       indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(node, this.sourceFile);
     }
     if (indentationStepSize === void 0) {
-      const translationsDeclarations = node.kind === 123 /* TranslationsDeclaration */ ? node : node.parent.parent;
+      const translationsDeclarations = node.kind === 125 /* TranslationsDeclaration */ ? node : node.parent.parent;
       for (const member of translationsDeclarations.translationList.translationDeclarations) {
-        if (member.kind === 139 /* TypeTranslationDeclaration */) {
+        if (member.kind === 141 /* TypeTranslationDeclaration */) {
           indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(member, this.sourceFile);
           if (indentationStepSize !== void 0) {
             break;
@@ -2674,7 +2737,7 @@ var CodeActionsService = class {
     }
     const result = new Array();
     const diagnosticCodeSet = new Set(diagnosticCodes);
-    if (diagnosticCodeSet.has(2087 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(2088 /* TheFollowingDeclarationsAreNotTranslated0And1More */)) {
+    if (diagnosticCodeSet.has(2090 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(2091 /* TheFollowingDeclarationsAreNotTranslated0And1More */)) {
       const data = { onlyTypeMembers: false };
       result.push(CodeAction.unresolved(
         "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u044B.",
@@ -2773,13 +2836,13 @@ var ArgumentFactory = class _ArgumentFactory {
 var SignatureForNode = class _SignatureForNode {
   static getSignaturesForNode(analyzer, node) {
     switch (node.kind) {
-      case 68 /* CallExpression */:
+      case 70 /* CallExpression */:
         return _SignatureForNode.getSignaturesForCallExpression(analyzer, node);
-      case 69 /* AutotypeCallExpression */:
+      case 71 /* AutotypeCallExpression */:
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
-      case 70 /* IndexedAccessExpression */:
+      case 72 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
-      case 152 /* Tag */:
+      case 154 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
       default:
         Debug.never(node);
@@ -2984,7 +3047,7 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         result = false;
         break;
       }
-      if (argument.expression === void 0 || argument.expression.kind === 71 /* MissingExpression */) {
+      if (argument.expression === void 0 || argument.expression.kind === 73 /* MissingExpression */) {
         continue;
       }
       const targetParameterType = targetParameter.getType();
@@ -3117,8 +3180,8 @@ var CompletionService = class {
     this.sourceFile = sourceFile;
     this.analyzer = analyzer;
     this.completionItemInfoContext_.clear();
-    this.locale = sourceFile.package.locale;
-    this.dialect = sourceFile.package.dialect;
+    this.locale = sourceFile.locale;
+    this.dialect = sourceFile.dialect;
     const positionDescription = this.createPositionDescription(sourceFile.getSyntaxNode(), offset);
     const semanticContext = this.createSemanticContextAtPosition(positionDescription);
     const syntaxContext = SyntaxContextFactory.fromPositionDescription(sourceFile, positionDescription);
@@ -3193,11 +3256,11 @@ var CompletionService = class {
     if (syntaxContext.isInComment || syntaxContext.isInText) {
       return { kind: "none" };
     }
-    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 51 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 50 /* MethodDeclaration */)) {
+    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 53 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 52 /* MethodDeclaration */)) {
       return new OperatorNameCompletionContext(syntaxContext.isInQuotedIdentifier);
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isKeyword(18 /* Import */) && tokenOrKeyword.parent.kind === 5 /* SinglePackageImportDirective */) {
+    if (tokenOrKeyword.isKeyword(19 /* Import */) && tokenOrKeyword.parent.kind === 5 /* SinglePackageImportDirective */) {
       return new PackageImportCompletionContext([], void 0);
     }
     if (tokenOrKeyword.isToken(64 /* Equals */) && tokenOrKeyword.parent.kind === 8 /* PackageImport */) {
@@ -3211,7 +3274,7 @@ var CompletionService = class {
     if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || this.tokenOrKeywordIsPackageImportListChild(tokenOrKeyword)) {
       return new PackageImportCompletionContext([], void 0);
     }
-    if (tokenOrKeyword.isToken(28 /* Dot */) && tokenOrKeyword.parent.kind === 76 /* MemberAccessExpression */) {
+    if (tokenOrKeyword.isToken(28 /* Dot */) && tokenOrKeyword.parent.kind === 78 /* MemberAccessExpression */) {
       const memberAccess = tokenOrKeyword.parent;
       {
         const packageTreeNode = this.analyzer.getDenotedPackageNameTreeNode(memberAccess.expression);
@@ -3220,8 +3283,8 @@ var CompletionService = class {
           if (packageTreeNode.package !== void 0) {
             lookup = new PackageMemberLookup(packageTreeNode.package);
           }
-          const hidingMatcher2 = semanticContext.getHidingMatcher();
-          return new PackageNameSegmentCompletionContext(packageTreeNode, lookup, hidingMatcher2);
+          const lookupContext2 = semanticContext.getPackageMemberLookupContext();
+          return new PackageNameSegmentCompletionContext(packageTreeNode, lookup, lookupContext2);
         }
       }
       {
@@ -3230,18 +3293,22 @@ var CompletionService = class {
           const package_ = packageAlias.getPackage();
           if (package_ !== void 0) {
             const lookup = new PackageMemberLookup(package_);
-            const hidingMatcher2 = semanticContext.getHidingMatcher();
-            return new PackageAliasMemberCompletionContext(lookup, hidingMatcher2);
+            const lookupContext2 = semanticContext.getPackageMemberLookupContext();
+            return new PackageAliasMemberCompletionContext(lookup, lookupContext2);
           }
           return { kind: "none" };
         }
       }
       const type = this.analyzer.type.ofExpression(memberAccess.expression);
       const isStaticAccess = this.analyzer.isExpressionDenotingType(memberAccess.expression);
-      const hidingMatcher = semanticContext.getHidingMatcher();
-      return new TypeMemberCompletionContext(type, isStaticAccess, hidingMatcher, semanticContext);
+      let lookupOptions = isStaticAccess ? 2 /* OnlyStaticMembers */ : 1 /* OnlyInstanceMembers */;
+      if (this.analyzer.isPossiblyCastedBaseExpression(memberAccess.expression)) {
+        lookupOptions |= 8 /* CheckAccessibilityIgnoringReceiverType */;
+      }
+      const lookupContext = semanticContext.getTypeMemberLookupContext();
+      return new TypeMemberCompletionContext(type, lookupContext, lookupOptions);
     }
-    if (tokenOrKeyword.isToken(28 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(28 /* 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(
@@ -3249,7 +3316,7 @@ var CompletionService = class {
       );
       if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
         let completionInIsOrAsExpressionInfo;
-        if (namedTypeSpecifier.parent.kind === 72 /* IsExpression */ || namedTypeSpecifier.parent.kind === 63 /* AsExpression */) {
+        if (namedTypeSpecifier.parent.kind === 74 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
           completionInIsOrAsExpressionInfo = {
             expressionType: this.analyzer.type.ofExpression(namedTypeSpecifier.parent.expression)
           };
@@ -3260,11 +3327,11 @@ var CompletionService = class {
           if (resolvedQualifier.packageTreeNode.package !== void 0) {
             lookup = new PackageMemberLookup(resolvedQualifier.packageTreeNode.package);
           }
-          const hidingMatcher = semanticContext.getHidingMatcher();
+          const lookupContext = semanticContext.getPackageMemberLookupContext();
           const typeSearchLocation = new PackageNameSegmentTypeSearchLocation(
             resolvedQualifier.packageTreeNode,
             lookup,
-            hidingMatcher
+            lookupContext
           );
           return new TypeCompletionContext(typeSearchLocation, completionInIsOrAsExpressionInfo);
         }
@@ -3272,15 +3339,15 @@ var CompletionService = class {
           const package_ = resolvedQualifier.packageAlias.getPackage();
           if (package_ !== void 0) {
             const lookup = new PackageMemberLookup(package_);
-            const hidingMatcher = semanticContext.getHidingMatcher();
-            const typeSearchLocation = new PackageAliasTypeSearchLocation(lookup, hidingMatcher);
+            const lookupContext = semanticContext.getPackageMemberLookupContext();
+            const typeSearchLocation = new PackageAliasTypeSearchLocation(lookup, lookupContext);
             return new TypeCompletionContext(typeSearchLocation, completionInIsOrAsExpressionInfo);
           }
         }
       }
       return { kind: "none" };
     }
-    if (tokenOrKeyword.isToken(28 /* Dot */) && tokenOrKeyword.parent.kind === 135 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 152 /* Tag */) {
+    if (tokenOrKeyword.isToken(28 /* Dot */) && tokenOrKeyword.parent.kind === 137 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 154 /* Tag */) {
       const tag = tokenOrKeyword.parent.parent;
       const resolutionResult = this.analyzer.resolveTag(tag);
       const segmentIndex = Math.floor(
@@ -3293,11 +3360,11 @@ var CompletionService = class {
           if (resolvedQualifier.packageTreeNode.package !== void 0) {
             lookup = new PackageMemberLookup(resolvedQualifier.packageTreeNode.package);
           }
-          const hidingMatcher = semanticContext.getHidingMatcher();
+          const lookupContext = semanticContext.getPackageMemberLookupContext();
           const typeSearchLocation = new PackageNameSegmentTypeSearchLocation(
             resolvedQualifier.packageTreeNode,
             lookup,
-            hidingMatcher
+            lookupContext
           );
           return new TagCompletionContext(typeSearchLocation);
         }
@@ -3305,8 +3372,8 @@ var CompletionService = class {
           const package_ = resolvedQualifier.packageAlias.getPackage();
           if (package_ !== void 0) {
             const lookup = new PackageMemberLookup(package_);
-            const hidingMatcher = semanticContext.getHidingMatcher();
-            const typeSearchLocation = new PackageAliasTypeSearchLocation(lookup, hidingMatcher);
+            const lookupContext = semanticContext.getPackageMemberLookupContext();
+            const typeSearchLocation = new PackageAliasTagSearchLocation(lookup, lookupContext);
             return new TagCompletionContext(typeSearchLocation);
           }
         }
@@ -3315,7 +3382,7 @@ var CompletionService = class {
     }
     if (syntaxContext.isUnqualifiedTypeContext !== void 0) {
       let completionInIsOrAsExpressionInfo;
-      if (tokenOrKeyword.parent.kind === 72 /* IsExpression */ || tokenOrKeyword.parent.kind === 63 /* AsExpression */) {
+      if (tokenOrKeyword.parent.kind === 74 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
         completionInIsOrAsExpressionInfo = {
           expressionType: this.analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
@@ -3366,22 +3433,22 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (tokenOrKeyword.parent.kind === 139 /* TypeTranslationDeclaration */ || tokenOrKeyword.parent.kind === 134 /* FunctionTypeTranslationDeclaration */)) {
+    if (tokenOrKeyword.isKeyword(17 /* Type */) && (tokenOrKeyword.parent.kind === 141 /* TypeTranslationDeclaration */ || tokenOrKeyword.parent.kind === 136 /* FunctionTypeTranslationDeclaration */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 132 /* PackageFunctionTranslationDeclaration */) {
+    if (tokenOrKeyword.isKeyword(13 /* Function */) && tokenOrKeyword.parent.kind === 134 /* PackageFunctionTranslationDeclaration */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
     if (translationsDeclaration !== void 0) {
       const translatedPackageMemberLookup = new PackageMemberLookup(translationPackage.getTargetPackage());
-      const hidingMatcher = semanticContext.getHidingMatcher();
+      const lookupContext = semanticContext.getPackageMemberLookupContext();
       return new TopLevelTranslationListCompletionContext(
         translatedPackageMemberLookup,
-        hidingMatcher,
+        lookupContext,
         translationKind,
         hasPrecedingKeyword
       );
@@ -3405,12 +3472,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 133 /* MethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(13 /* Function */) && tokenOrKeyword.parent.kind === 135 /* MethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 127 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(32 /* Creation */) && tokenOrKeyword.parent.kind === 129 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3424,8 +3491,7 @@ var CompletionService = class {
           type = translationTargets[0];
         }
       }
-      const hidingMatcher = semanticContext.getHidingMatcher();
-      return new TypeMemberTranslationListCompletionContext(type, hidingMatcher, translationKind, hasPrecedingKeyword);
+      return new TypeMemberTranslationListCompletionContext(type, translationKind, hasPrecedingKeyword);
     }
     return void 0;
   }
@@ -3434,19 +3500,19 @@ var CompletionService = class {
       let signatures;
       let args;
       switch (role.argumentList.parent.kind) {
-        case 68 /* CallExpression */:
+        case 70 /* CallExpression */:
           signatures = SignatureForNode.getSignaturesForCallExpression(this.analyzer, role.argumentList.parent);
           args = ArgumentFactory.createArgumentsOfCallExpression(role.argumentList.parent);
           break;
-        case 69 /* AutotypeCallExpression */:
+        case 71 /* AutotypeCallExpression */:
           signatures = SignatureForNode.getSignaturesForAutotypeCallExpression(this.analyzer, role.argumentList.parent);
           args = ArgumentFactory.createArgumentsOfAutotypeCallExpression(role.argumentList.parent);
           break;
-        case 152 /* Tag */:
+        case 154 /* Tag */:
           signatures = SignatureForNode.getSignaturesForTag(this.analyzer, role.argumentList.parent);
           args = ArgumentFactory.createArgumentsOfTag(role.argumentList.parent);
           break;
-        case 70 /* IndexedAccessExpression */:
+        case 72 /* IndexedAccessExpression */:
           signatures = SignatureForNode.getSignaturesForIndexedAccessExpression(
             this.analyzer,
             role.argumentList.parent
@@ -3582,22 +3648,22 @@ var CompletionService = class {
     }
     const kinds = /* @__PURE__ */ new Set();
     if (syntaxContext.isPackageMemberDeclarationListContext) {
-      kinds.add(18 /* Import */).add(7 /* Run */).add(31 /* Creation */).add(12 /* Function */).add(17 /* Basic */).add(16 /* Type */).add(58 /* Get */).add(59 /* Set */).add(55 /* Translations */);
+      kinds.add(19 /* Import */).add(8 /* Run */).add(32 /* Creation */).add(13 /* Function */).add(18 /* Basic */).add(17 /* Type */).add(59 /* Get */).add(60 /* Set */).add(56 /* Translations */);
     }
     if (syntaxContext.isPackageMemberDeclarationListContext || syntaxContext.isTypeMemberDeclarationListContext) {
-      kinds.add(37 /* Hidden */).add(41 /* Static */).add(17 /* Basic */).add(38 /* Abstract */).add(39 /* Override */).add(40 /* Async */).add(36 /* Const */);
+      kinds.add(38 /* Hidden */).add(42 /* Static */).add(18 /* Basic */).add(39 /* Abstract */).add(40 /* Override */).add(41 /* Async */).add(37 /* Const */);
     }
     if (syntaxContext.isTypeMemberDeclarationListContext) {
-      kinds.add(31 /* Creation */).add(12 /* Function */).add(47 /* Destruction */).add(58 /* Get */).add(59 /* Set */);
+      kinds.add(32 /* Creation */).add(13 /* Function */).add(48 /* Destruction */).add(59 /* Get */).add(60 /* Set */);
     }
     if (syntaxContext.isStatementContext) {
-      kinds.add(7 /* Run */).add(35 /* For */).add(25 /* While */).add(26 /* Loop */).add(15 /* Return */).add(20 /* Error */).add(19 /* Important */).add(28 /* Yield */).add(33 /* BreakLoop */).add(34 /* ContinueLoop */).add(13 /* If */).add(44 /* Switch */).add(1 /* Let */).add(36 /* Const */).add(46 /* Dispose */).add(8 /* Try */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(8 /* Run */).add(36 /* For */).add(26 /* While */).add(27 /* Loop */).add(16 /* Return */).add(21 /* Error */).add(20 /* Important */).add(29 /* Yield */).add(34 /* BreakLoop */).add(35 /* ContinueLoop */).add(14 /* If */).add(45 /* Switch */).add(1 /* Let */).add(37 /* Const */).add(47 /* Dispose */).add(9 /* Try */).add(13 /* Function */).add(41 /* Async */);
     }
     if (this.isFromKeywordContext(positionDescription)) {
-      kinds.add(9 /* From */);
+      kinds.add(10 /* From */);
     }
     if (syntaxContext.isExpressionContext !== void 0) {
-      kinds.add(43 /* Not */).add(52 /* Yes */).add(53 /* No */).add(57 /* Null */).add(40 /* Async */).add(12 /* Function */).add(54 /* Reference */).add(2 /* Autotype */).add(30 /* Cond */);
+      kinds.add(44 /* Not */).add(53 /* Yes */).add(54 /* No */).add(58 /* Null */).add(41 /* Async */).add(13 /* Function */).add(55 /* Reference */).add(2 /* Autotype */).add(31 /* Cond */);
       if (positionDescription.kind === "after-token-or-keyword") {
         const container = semanticContext.getContainingTypeOrTypeExtension();
         if (container !== void 0) {
@@ -3605,41 +3671,41 @@ var CompletionService = class {
           if (container.kind === "type") {
             const typeEntity = container.value;
             if (typeEntity?.typeEntityKind === 1 /* Structured */ && typeEntity.getBaseObjectType() !== void 0 || typeEntity?.typeEntityKind === 3 /* Variant */ || typeEntity?.typeEntityKind === 4 /* Alias */) {
-              kinds.add(56 /* Base */);
+              kinds.add(57 /* Base */);
             }
           }
         }
       }
     }
     if (this.isTypeKindCompletionContext(positionDescription)) {
-      kinds.add(4 /* Object */).add(5 /* PlainObject */).add(3 /* Aspect */).add(6 /* Variant */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(4 /* Object */).add(5 /* PlainObject */).add(3 /* Aspect */).add(6 /* ReducedObject */).add(7 /* Variant */).add(13 /* Function */).add(41 /* Async */);
     }
     if (this.isCaseKeywordContext(positionDescription, syntaxContext)) {
-      kinds.add(45 /* Case */);
+      kinds.add(46 /* Case */);
     }
     if (this.isCatchKeywordContext(positionDescription)) {
-      kinds.add(32 /* Catch */);
+      kinds.add(33 /* Catch */);
     }
     if (this.isFinallyKeywordContext(positionDescription)) {
-      kinds.add(21 /* Finally */);
+      kinds.add(22 /* Finally */);
     }
     if (this.isElseOrElseIfKeywordContext(positionDescription)) {
-      kinds.add(10 /* Else */).add(11 /* ElseIf */);
+      kinds.add(11 /* Else */).add(12 /* ElseIf */);
     }
     if (syntaxContext.precedingExpression !== void 0) {
-      kinds.add(42 /* As */).add(14 /* Is */).add(22 /* And */).add(23 /* Or */).add(24 /* Xor */).add(29 /* When */);
+      kinds.add(43 /* As */).add(15 /* Is */).add(23 /* And */).add(24 /* Or */).add(25 /* Xor */).add(30 /* When */);
     }
     if (this.isModifierLevelContext(positionDescription)) {
-      kinds.add(51 /* InType */).add(48 /* InHierarchy */).add(49 /* InFile */).add(50 /* InPackage */);
+      kinds.add(52 /* InType */).add(49 /* InHierarchy */).add(50 /* InFile */).add(51 /* InPackage */);
     }
     if (this.isRepeatWhileKeywordContext(positionDescription)) {
-      kinds.add(27 /* RepeatWhile */);
+      kinds.add(28 /* RepeatWhile */);
     }
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
-      kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(12 /* Function */).add(40 /* Async */);
+      kinds.add(5 /* PlainObject */).add(4 /* Object */).add(7 /* Variant */).add(3 /* Aspect */).add(13 /* Function */).add(41 /* Async */);
     }
-    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(40 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 56 /* NestedFunctionDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 65 /* FunctionLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 27 /* FunctionTypeDeclarationBody */)) {
-      kinds.add(12 /* Function */);
+    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(41 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedFunctionDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 67 /* FunctionLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* FunctionTypeDeclarationBody */)) {
+      kinds.add(13 /* Function */);
     }
     return Query.from(kinds.values()).map((k) => LocalizationHelper.localizeKeyword(k, this.locale, this.dialect).map((v) => new KeywordCompletionItemInfo(this.completionItemInfoContext, k, v.value))).flatMap((i) => i).toArray();
   }
@@ -3648,35 +3714,35 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 115 /* LoopStatement */;
+    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 96 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 117 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(47 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 154 /* Modifier */;
+    return tokenOrKeyword.isToken(47 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 156 /* Modifier */;
   }
   isElseOrElseIfKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 108 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 110 /* ElseIfClause */);
+    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 96 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 110 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.block || tokenOrKeyword.parent.parent.kind === 112 /* ElseIfClause */);
   }
   isCatchKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 100 /* TryStatement */;
+    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 96 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 102 /* TryStatement */;
   }
   isFinallyKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 100 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 101 /* CatchClause */);
+    return tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 96 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 102 /* TryStatement */ || tokenOrKeyword.parent.parent.kind === 103 /* CatchClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(64 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3686,17 +3752,17 @@ var CompletionService = class {
       return false;
     }
     const token = positionDescription.tokenOrKeyword.value;
-    return token.parent.kind === 58 /* ForStatementVariableDeclaration */ && (token.parent === token.parent.parent.elementVariableDeclaration || token.parent === token.parent.parent.indexVariableDeclaration);
+    return token.parent.kind === 60 /* ForStatementVariableDeclaration */ && (token.parent === token.parent.parent.elementVariableDeclaration || token.parent === token.parent.parent.indexVariableDeclaration);
   }
   isCaseKeywordContext(positionDescription, syntaxContext) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 120 /* CaseClause */) {
+    if (tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 96 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 122 /* CaseClause */) {
       return true;
     }
-    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 118 /* SwitchStatement */) {
+    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 120 /* SwitchStatement */) {
       return true;
     }
     return false;
@@ -3780,7 +3846,7 @@ var CompletionService = class {
     return result;
   }
   getTypeCompletionItemInfosFromPackage(searchLocation) {
-    return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+    return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.lookupContext).map((m) => {
       if (m.kind === 2 /* Type */) {
         return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
       }
@@ -3792,7 +3858,7 @@ var CompletionService = class {
     if (searchLocation.packageMemberLookup !== void 0) {
       const lookup = searchLocation.packageMemberLookup;
       query = query.chain(
-        lookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+        lookup.getNamedMembers(searchLocation.lookupContext).map((m) => {
           if (m.kind === 2 /* Type */) {
             return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
           }
@@ -3833,7 +3899,7 @@ var CompletionService = class {
     return result;
   }
   getTagCompletionItemInfosFromPackage(searchLocation) {
-    return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+    return searchLocation.packageMemberLookup.getNamedMembers(searchLocation.lookupContext).map((m) => {
       if (m.kind === 2 /* Type */) {
         return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
       } else if (m.kind === 1 /* Function */) {
@@ -3847,7 +3913,7 @@ var CompletionService = class {
     if (searchLocation.packageMemberLookup !== void 0) {
       const lookup = searchLocation.packageMemberLookup;
       query = query.chain(
-        lookup.getNamedMembers(searchLocation.hidingMatcher).map((m) => {
+        lookup.getNamedMembers(searchLocation.lookupContext).map((m) => {
           if (m.kind === 2 /* Type */) {
             return new NamedTypeCompletionItemInfo(this.completionItemInfoContext, m);
           } else if (m.kind === 1 /* Function */) {
@@ -3878,14 +3944,14 @@ var CompletionService = class {
     }).filter((i) => i !== void 0);
   }
   getPackageAliasMemberCompletionItemInfos(ctx) {
-    return ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m));
+    return ctx.packageMemberLookup.getNamedMembers(ctx.lookupContext).map((m) => this.packageMemberToCompletionItemInfo(m));
   }
   getPackageNameSegmentCompletionItemInfos(ctx) {
     let query = Query.from(ctx.packageTreeNode.getChildren()).map((c) => new PackageNameSegmentCompletionItemInfo(this.completionItemInfoContext, c.name));
     if (ctx.packageMemberLookup !== void 0) {
       const lookup = ctx.packageMemberLookup;
       query = query.chain(
-        lookup.getNamedMembers(ctx.hidingMatcher).map((m) => this.packageMemberToCompletionItemInfo(m))
+        lookup.getNamedMembers(ctx.lookupContext).map((m) => this.packageMemberToCompletionItemInfo(m))
       );
     }
     return query.toArray();
@@ -3907,9 +3973,8 @@ var CompletionService = class {
   }
   getTypeMemberCompletionItemInfos(ctx) {
     const type = this.analyzer.excludeNullFromType(ctx.type);
-    const memberLookup = TypeMemberLookup.ofType(this.analyzer, type, this.locale);
-    const options7 = ctx.isStaticAccess ? 2 /* OnlyStaticMembers */ : 1 /* OnlyInstanceMembers */;
-    return memberLookup.getNamedMembers(options7, ctx.hidingMatcher, ctx.typeExtensionLookup).map((m) => {
+    const memberLookup = TypeMemberLookup.ofType(this.analyzer, type);
+    return memberLookup.getNamedMembers(ctx.lookupContext, ctx.lookupOptions).map((m) => {
       switch (m.kind) {
         case "method":
           return new MethodCompletionItemInfo(this.completionItemInfoContext, m);
@@ -3918,7 +3983,7 @@ var CompletionService = class {
         default:
           Debug.never(m);
       }
-    }).concat(memberLookup.getOperators(options7, ctx.hidingMatcher, ctx.typeExtensionLookup).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o)));
+    }).concat(memberLookup.getOperators(ctx.lookupContext, ctx.lookupOptions).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o)));
   }
   getPackageImportCompletionItemInfos(ctx) {
     const result = this.analyzer.packageImports.getPackagesAvailableForImport(this.sourceFile.package).map((p) => p.getName()).filter((n) => {
@@ -3936,7 +4001,7 @@ var CompletionService = class {
   getTopLevelAliasListCompletionItemInfos(ctx) {
     let result;
     if (ctx.translationKind === 1 /* Method */) {
-      result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).mapAndFilter((d) => {
+      result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.lookupContext)).mapAndFilter((d) => {
         if (d.kind === 1 /* Function */) {
           return new TranslationsSourceFunctionCompletionItemInfo(
             this.completionItemInfoContext,
@@ -3947,7 +4012,7 @@ var CompletionService = class {
         return void 0;
       });
     } else if (ctx.translationKind === 2 /* Type */) {
-      result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).mapAndFilter((d) => {
+      result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.lookupContext)).mapAndFilter((d) => {
         if (d.kind === 2 /* Type */) {
           return new TranslationsSourcePackageTypeCompletionItemInfo(
             this.completionItemInfoContext,
@@ -3958,7 +4023,7 @@ var CompletionService = class {
         return void 0;
       });
     } else if (ctx.translationKind === 0 /* Any */) {
-      result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.hidingMatcher)).map((d) => {
+      result = Query.from(ctx.packageMemberLookup.getNamedMembers(ctx.lookupContext)).map((d) => {
         switch (d.kind) {
           case 0 /* Variable */:
             return new TranslationsSourceVariableCompletionItemInfo(this.completionItemInfoContext, d);
@@ -3983,8 +4048,8 @@ var CompletionService = class {
     }
     if (!ctx.hasPrecedingKeyword) {
       const keywords = [
-        16 /* Type */,
-        12 /* Function */
+        17 /* Type */,
+        13 /* Function */
       ];
       result = result.chain(
         Query.from(keywords).map((k) => LocalizationHelper.localizeKeyword(k, this.locale, this.dialect).map((v) => new KeywordCompletionItemInfo(this.completionItemInfoContext, k, v.value))).flatMap((i) => i)
@@ -4041,8 +4106,8 @@ var CompletionService = class {
     }
     if (!ctx.hasPrecedingKeyword) {
       const keywords = [
-        12 /* Function */,
-        31 /* Creation */
+        13 /* Function */,
+        32 /* Creation */
       ];
       result = result.chain(
         Query.from(keywords).map((k) => LocalizationHelper.localizeKeyword(k, this.locale, this.dialect).map((v) => new KeywordCompletionItemInfo(this.completionItemInfoContext, k, v.value))).flatMap((i) => i)
@@ -4199,10 +4264,10 @@ function getRightmostChildExcludingValidEmptyNodes(node) {
 }
 function isInvalidNode(node) {
   switch (node.kind) {
-    case 71 /* MissingExpression */:
-    case 41 /* MissingPackageMemberDeclaration */:
-    case 112 /* MissingStatement */:
-    case 55 /* MissingTypeMemberDeclaration */:
+    case 73 /* MissingExpression */:
+    case 43 /* MissingPackageMemberDeclaration */:
+    case 114 /* MissingStatement */:
+    case 57 /* MissingTypeMemberDeclaration */:
     case 16 /* MissingTypeSpecifier */:
       return true;
     case 0 /* Token */:
@@ -4221,26 +4286,25 @@ var PackageImportCompletionContext = class {
   }
 };
 var TypeMemberCompletionContext = class {
-  constructor(type, isStaticAccess, hidingMatcher, typeExtensionLookup) {
+  constructor(type, lookupContext, lookupOptions) {
     this.type = type;
-    this.isStaticAccess = isStaticAccess;
-    this.hidingMatcher = hidingMatcher;
-    this.typeExtensionLookup = typeExtensionLookup;
+    this.lookupContext = lookupContext;
+    this.lookupOptions = lookupOptions;
     this.kind = "type-member";
   }
 };
 var PackageNameSegmentCompletionContext = class {
-  constructor(packageTreeNode, packageMemberLookup, hidingMatcher) {
+  constructor(packageTreeNode, packageMemberLookup, lookupContext) {
     this.packageTreeNode = packageTreeNode;
     this.packageMemberLookup = packageMemberLookup;
-    this.hidingMatcher = hidingMatcher;
+    this.lookupContext = lookupContext;
     this.kind = "package-name-segment";
   }
 };
 var PackageAliasMemberCompletionContext = class {
-  constructor(packageMemberLookup, hidingMatcher) {
+  constructor(packageMemberLookup, lookupContext) {
     this.packageMemberLookup = packageMemberLookup;
-    this.hidingMatcher = hidingMatcher;
+    this.lookupContext = lookupContext;
     this.kind = "package-alias-member";
   }
 };
@@ -4270,20 +4334,27 @@ var ScopeTypeSearchLocation = class {
   }
 };
 var PackageAliasTypeSearchLocation = class {
-  constructor(packageMemberLookup, hidingMatcher) {
+  constructor(packageMemberLookup, lookupContext) {
     this.packageMemberLookup = packageMemberLookup;
-    this.hidingMatcher = hidingMatcher;
+    this.lookupContext = lookupContext;
     this.kind = "package-alias";
   }
 };
 var PackageNameSegmentTypeSearchLocation = class {
-  constructor(packageTreeNode, packageMemberLookup, hidingMatcher) {
+  constructor(packageTreeNode, packageMemberLookup, lookupContext) {
     this.packageTreeNode = packageTreeNode;
     this.packageMemberLookup = packageMemberLookup;
-    this.hidingMatcher = hidingMatcher;
+    this.lookupContext = lookupContext;
     this.kind = "package-name-segment";
   }
 };
+var PackageAliasTagSearchLocation = class {
+  constructor(packageMemberLookup, lookupContext) {
+    this.packageMemberLookup = packageMemberLookup;
+    this.lookupContext = lookupContext;
+    this.kind = "package-alias";
+  }
+};
 var ExpressionCompletionContext = class {
   constructor(semanticContext, targetSignaturesParameters, targetTypes) {
     this.semanticContext = semanticContext;
@@ -4293,18 +4364,17 @@ var ExpressionCompletionContext = class {
   }
 };
 var TopLevelTranslationListCompletionContext = class {
-  constructor(packageMemberLookup, hidingMatcher, translationKind, hasPrecedingKeyword) {
+  constructor(packageMemberLookup, lookupContext, translationKind, hasPrecedingKeyword) {
     this.packageMemberLookup = packageMemberLookup;
-    this.hidingMatcher = hidingMatcher;
+    this.lookupContext = lookupContext;
     this.translationKind = translationKind;
     this.hasPrecedingKeyword = hasPrecedingKeyword;
     this.kind = "top-level-translation-list";
   }
 };
 var TypeMemberTranslationListCompletionContext = class {
-  constructor(typeEntity, hidingMatcher, translationKind, hasPrecedingKeyword) {
+  constructor(typeEntity, translationKind, hasPrecedingKeyword) {
     this.typeEntity = typeEntity;
-    this.hidingMatcher = hidingMatcher;
     this.translationKind = translationKind;
     this.hasPrecedingKeyword = hasPrecedingKeyword;
     this.kind = "type-member-translation-list";
@@ -4564,6 +4634,8 @@ var NamedTypeCompletionItemInfo = class {
       }
       case 4 /* Alias */:
         return 19 /* AliasType */;
+      case 5 /* Reduced */:
+        return 20 /* ReducedType */;
       default:
         Debug.never(this.entity);
     }
@@ -4592,7 +4664,7 @@ var KeywordCompletionItemInfo = class {
     return this.value;
   }
   getCompletionItemKind() {
-    return 21 /* Keyword */;
+    return 22 /* Keyword */;
   }
   getDetails() {
     return void 0;
@@ -4646,7 +4718,7 @@ var TargetSignatureParameterCompletionItemInfo = class {
     return `${this.ctx.getInsertTextForName(this.parameter.getName())} =`;
   }
   getCompletionItemKind() {
-    return 22 /* TargetSignatureParameter */;
+    return 23 /* TargetSignatureParameter */;
   }
   getDetails() {
     return this.ctx.displayService.displayParameterDeclaration(
@@ -4725,7 +4797,7 @@ var TranslationsSourceFunctionCompletionItemInfo = class {
     return this.ctx.displayService.displayFunctionDeclaration(new FunctionDeclaration_entity(this.func));
   }
   getInsertText() {
-    const keywordWithWhitespace = this.includeFunctionKeyword ? `${this.ctx.displayService.displayKeyword(12 /* Function */)} ` : "";
+    const keywordWithWhitespace = this.includeFunctionKeyword ? `${this.ctx.displayService.displayKeyword(13 /* Function */)} ` : "";
     const typeParameters = this.func.getTypeParameters().map((p) => this.ctx.getInsertTextForName(p.getName(), true)).join(", ");
     const typeParametersWithAngles = typeParameters.length > 0 ? `<${typeParameters}>` : "";
     const parameters = this.func.getParameters().map((p) => this.ctx.getInsertTextForName(p.getName(), true)).join(", ");
@@ -4769,14 +4841,17 @@ var TranslationsSourcePackageTypeCompletionItemInfo = class {
       }
       case 4 /* Alias */:
         return 19 /* AliasType */;
+      case 5 /* Reduced */:
+        return 20 /* ReducedType */;
+      default:
+        Debug.never(this.typeEntity);
     }
   }
   getDetails() {
-    const typeDeclaration = this.getDisplayServiceTypeDeclaration();
-    return this.ctx.displayService.displayTypeDeclaration(typeDeclaration);
+    return this.ctx.displayService.displayEntity(this.typeEntity);
   }
   getInsertText() {
-    const keywordWithWhitespace = this.includeTypeKeyword ? `${this.ctx.displayService.displayKeyword(16 /* Type */)} ` : "";
+    const keywordWithWhitespace = this.includeTypeKeyword ? `${this.ctx.displayService.displayKeyword(17 /* Type */)} ` : "";
     const typeParameters = this.typeEntity.getTypeParameters().map((p) => this.ctx.getInsertTextForName(p.getName(), true)).join(", ");
     const typeParametersWithAngles = typeParameters.length > 0 ? `<${typeParameters}>` : "";
     let result = `${keywordWithWhitespace}${this.ctx.getInsertTextForName(this.typeEntity.getName())}${typeParametersWithAngles}`;
@@ -4789,28 +4864,6 @@ var TranslationsSourcePackageTypeCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
-  getDisplayServiceTypeDeclaration() {
-    switch (this.typeEntity.typeEntityKind) {
-      case 3 /* Variant */:
-        return new TypeDeclaration_variant(
-          new TypeDeclarationVariant_entity(this.typeEntity)
-        );
-      case 0 /* Function */:
-        return new TypeDeclaration_function(
-          new TypeDeclarationFunction_entity(this.typeEntity)
-        );
-      case 1 /* Structured */:
-        return new TypeDeclaration_structured(
-          new TypeDeclarationStructured_entity(this.typeEntity)
-        );
-      case 4 /* Alias */:
-        return new TypeDeclaration_alias(
-          new TypeDeclarationAlias_entity(this.typeEntity)
-        );
-      default:
-        Debug.never(this.typeEntity);
-    }
-  }
   getEditRange() {
     return void 0;
   }
@@ -4857,7 +4910,7 @@ var TranslationsSourceConstructorCompletionItemInfo = class {
     return this.label_.getOrInsertWith(() => {
       const constructorDeclaration = new ConstructorDeclaration_entity(this.constructor_);
       const displayParts = this.ctx.displayService.getConstructorDeclarationDisplayParts(constructorDeclaration);
-      const creationKeyword = this.ctx.displayService.displayKeyword(31 /* Creation */);
+      const creationKeyword = this.ctx.displayService.displayKeyword(32 /* Creation */);
       return creationKeyword + displayParts.parametersStart + displayParts.parameters.map((p) => p.toString()).join(displayParts.parameterSeparator) + displayParts.parametersEnd;
     });
   }
@@ -4871,7 +4924,7 @@ var TranslationsSourceConstructorCompletionItemInfo = class {
     return this.label;
   }
   getInsertText() {
-    const creationKeyword = this.includeOnCreateKeyword ? this.ctx.displayService.displayKeyword(31 /* Creation */) : "";
+    const creationKeyword = this.includeOnCreateKeyword ? this.ctx.displayService.displayKeyword(32 /* Creation */) : "";
     const parameters = this.constructor_.getParameters().map((p) => this.ctx.getInsertTextForName(p.getName(), true)).join(", ");
     return `${creationKeyword}(${parameters})`;
   }
@@ -4893,7 +4946,7 @@ var OperatorNameCompletionItemInfo = class {
     return this.value;
   }
   getCompletionItemKind() {
-    return 23 /* OperatorName */;
+    return 24 /* OperatorName */;
   }
   getDetails() {
     return void 0;
@@ -4997,7 +5050,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(36 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 152 /* Tag */;
+    const isUnqualifiedTagNameCompletionContext = positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(36 /* HashSign */) && positionDescription.tokenOrKeyword.parent.kind === 154 /* Tag */;
     let isTopLevelTranslationListContext;
     if (positionDescription.kind === "after-token-or-keyword") {
       isTopLevelTranslationListContext = this.isTopLevelTranslationListContext(positionDescription.tokenOrKeyword);
@@ -5023,52 +5076,52 @@ var SyntaxContextFactory = class {
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(64 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 94 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 57 /* LocalVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 59 /* LocalVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 33 /* PackageVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 35 /* PackageVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 52 /* FieldDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 54 /* FieldDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 149 /* ParameterDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 151 /* ParameterDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 150 /* Argument */) {
+      if (tokenOrKeyword.parent.kind === 152 /* Argument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 147 /* VariantValueDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 149 /* VariantValueDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 94 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 75 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 64 /* BinaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(6 /* TextTemplateHead */) && (tokenOrKeyword.parent.kind === 79 /* TextTemplateLiteral */ || tokenOrKeyword.parent.kind === 80 /* LocalizableTextTemplateLiteral */)) {
+    if (tokenOrKeyword.isToken(6 /* TextTemplateHead */) && (tokenOrKeyword.parent.kind === 81 /* TextTemplateLiteral */ || tokenOrKeyword.parent.kind === 82 /* LocalizableTextTemplateLiteral */)) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.spanList.spans.at(0)?.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(7 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 82 /* TextTemplateSpan */) {
+    if (tokenOrKeyword.isToken(7 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 84 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5080,12 +5133,12 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 96 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 95 /* FunctionBlock */) {
+    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 97 /* FunctionBlock */) {
       const block = tokenOrKeyword.parent;
-      if (block.expressionOrStatementList.kind !== 93 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
+      if (block.expressionOrStatementList.kind !== 95 /* StatementList */ || block.expressionOrStatementList.statements.count() === 0) {
         return {
           isExpressionContext: { expressionRole: new ExpressionRole_functionBlockExpression(block) },
           isStatementContext: true
@@ -5097,48 +5150,48 @@ var SyntaxContextFactory = class {
         };
       }
     }
-    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 93 /* StatementList */) {
+    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 95 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(47 /* OpenParenthesis */)) {
-      if (tokenOrKeyword.parent.kind === 73 /* ParenthesizedExpression */) {
+      if (tokenOrKeyword.parent.kind === 75 /* ParenthesizedExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 77 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 79 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 68 /* CallExpression */) {
+      if (tokenOrKeyword.parent.kind === 70 /* CallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 69 /* AutotypeCallExpression */) {
+      if (tokenOrKeyword.parent.kind === 71 /* AutotypeCallExpression */) {
         const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 152 /* Tag */) {
+      if (tokenOrKeyword.parent.kind === 154 /* Tag */) {
         const argumentList = tokenOrKeyword.parent.argumentList;
         if (argumentList !== void 0) {
           const expressionRole = new ExpressionRole_argument(argumentList, 0);
           return { isExpressionContext: { expressionRole }, isStatementContext: false };
         }
       }
-      if (tokenOrKeyword.parent.kind === 74 /* ConditionalExpression */) {
+      if (tokenOrKeyword.parent.kind === 76 /* ConditionalExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isToken(48 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 70 /* IndexedAccessExpression */) {
+    if (tokenOrKeyword.isToken(48 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 72 /* IndexedAccessExpression */) {
       const expressionRole = new ExpressionRole_argument(tokenOrKeyword.parent.argumentList, 0);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(48 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 59 /* ArrayLiteral */) {
+    if (tokenOrKeyword.isToken(48 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 61 /* ArrayLiteral */) {
       const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(26 /* Comma */)) {
-      if (tokenOrKeyword.parent.kind === 67 /* ArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 69 /* ArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5152,71 +5205,71 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_argument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 119 /* MatchExpressionList */) {
+      if (tokenOrKeyword.parent.kind === 121 /* MatchExpressionList */) {
         const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 60 /* ArrayLiteralElementList */) {
+      if (tokenOrKeyword.parent.kind === 62 /* ArrayLiteralElementList */) {
         const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 74 /* ConditionalExpression */) {
-        if (tokenOrKeyword.value === tokenOrKeyword.parent.firstComma) {
+      if (tokenOrKeyword.parent.kind === 76 /* ConditionalExpression */) {
+        if (tokenOrKeyword.value === tokenOrKeyword.parent.firstCommaToken) {
           const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.firstExpression);
           return { isExpressionContext: { expressionRole }, isStatementContext: false };
         }
-        if (tokenOrKeyword.value === tokenOrKeyword.parent.secondComma) {
+        if (tokenOrKeyword.value === tokenOrKeyword.parent.secondCommaToken) {
           const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.secondExpression);
           return { isExpressionContext: { expressionRole }, isStatementContext: false };
         }
         return { isExpressionContext: void 0, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(45 /* Case */) && tokenOrKeyword.parent.kind === 120 /* CaseClause */) {
+    if (tokenOrKeyword.isKeyword(46 /* Case */) && tokenOrKeyword.parent.kind === 122 /* CaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(15 /* Return */) && tokenOrKeyword.parent.kind === 116 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(16 /* Return */) && tokenOrKeyword.parent.kind === 118 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(20 /* Error */) && tokenOrKeyword.parent.kind === 104 /* ErrorStatement */) {
+    if (tokenOrKeyword.isKeyword(21 /* 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 === 105 /* ImportantStatement */) {
+    if (tokenOrKeyword.isKeyword(20 /* 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 === 118 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(45 /* Switch */) && tokenOrKeyword.parent.kind === 120 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(13 /* If */) && tokenOrKeyword.parent.kind === 108 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(14 /* If */) && tokenOrKeyword.parent.kind === 110 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(11 /* ElseIf */) && tokenOrKeyword.parent.kind === 110 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(12 /* ElseIf */) && tokenOrKeyword.parent.kind === 112 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(9 /* From */) && tokenOrKeyword.parent.kind === 107 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(10 /* From */) && tokenOrKeyword.parent.kind === 109 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* While */) && tokenOrKeyword.parent.kind === 121 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(26 /* While */) && tokenOrKeyword.parent.kind === 123 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 115 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(28 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 117 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(28 /* Yield */) && tokenOrKeyword.parent.kind === 122 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(29 /* Yield */) && tokenOrKeyword.parent.kind === 124 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(30 /* Cond */) && tokenOrKeyword.parent.kind === 74 /* ConditionalExpression */) {
+    if (tokenOrKeyword.isKeyword(31 /* Cond */) && tokenOrKeyword.parent.kind === 76 /* ConditionalExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5235,65 +5288,65 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(58 /* Semicolon */) && (tokenOrKeyword.parent.kind === 2 /* PackageMemberDeclarationList */ || tokenOrKeyword.parent.kind === 4 /* PackageImportDirectiveList */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 30 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 38 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 31 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 36 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 20 /* PackageAliasTypeDeclaration */)) {
+    if (tokenOrKeyword.isToken(22 /* 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 === 20 /* PackageAliasTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 22 /* PackageReducedTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(22 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 123 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 22 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 95 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 23 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 24 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 25 /* PackageFunctionDeclaration */))) {
+    if (tokenOrKeyword.isToken(22 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 125 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 97 /* FunctionBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageFunctionDeclaration */))) {
       return true;
     }
-    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 22 /* PackageMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 25 /* PackageFunctionDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 26 /* PackageFunctionTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 20 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 33 /* PackageVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 5 /* SinglePackageImportDirective */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 27 /* PackageFunctionDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 28 /* PackageFunctionTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 20 /* PackageAliasTypeDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 35 /* PackageVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      34 /* PackageVariableGetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 35 /* PackageVariableSetterDeclaration */)) {
+      36 /* PackageVariableGetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 154 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 156 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(23 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 154 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(23 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 156 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    const tag = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 152 /* Tag */);
+    const tag = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 154 /* Tag */);
     if (tag !== void 0 && NodeTypeUtils.isPackageMemberDeclaration(tag.parent.parent)) {
       return true;
     }
     return false;
   }
   static isTypeMemberDeclarationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 29 /* TypeMemberDeclarationList */) {
+    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 31 /* TypeMemberDeclarationList */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 30 /* TypeMemberDeclarationBlock */) {
+    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */) {
       return true;
     }
-    if (tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 30 /* TypeMemberDeclarationBlock */ && tokenOrKeyword.parent.parent.kind === 42 /* TypeMemberGroupDeclaration */) {
+    if (tokenOrKeyword.isToken(22 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && tokenOrKeyword.parent.parent.kind === 44 /* TypeMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* FieldDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* FieldGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* FieldSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* FieldDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* FieldGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* FieldSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      45 /* IndexedElementGetterDeclaration */
+      47 /* IndexedElementGetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      46 /* IndexedElementSetterDeclaration */
+      48 /* IndexedElementSetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      48 /* DereferencedVariableGetterDeclaration */
+      50 /* DereferencedVariableGetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
-      49 /* DereferencedVariableSetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 50 /* MethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 51 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 43 /* ConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 44 /* DestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 147 /* VariantValueDeclaration */)) {
+      51 /* DereferencedVariableSetterDeclaration */
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* MethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* ConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* DestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 149 /* VariantValueDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 154 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 156 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(23 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 154 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(23 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 156 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    const tag = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 152 /* Tag */);
+    const tag = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 154 /* Tag */);
     if (tag !== void 0 && NodeTypeUtils.isTypeMemberDeclaration(tag.parent.parent)) {
       return true;
     }
@@ -5331,34 +5384,37 @@ var SyntaxContextFactory = class {
     return result;
   }
   static isUnqualifiedTypeContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(25 /* Colon */) && tokenOrKeyword.parent.kind === 161 /* TypeAnnotation */) {
+    if (tokenOrKeyword.isToken(25 /* Colon */) && tokenOrKeyword.parent.kind === 163 /* TypeAnnotation */) {
       return { allowsAnonymousTypes: true };
     }
-    if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 32 /* StructuredTypeDeclarationBody */) {
+    if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(16 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 38 /* TypeExtensionDeclaration */)) {
+    if (tokenOrKeyword.isKeyword(6 /* ReducedObject */) && tokenOrKeyword.parent.kind === 23 /* ReducedTypeDeclarationBody */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(37 /* LessThan */) && tokenOrKeyword.parent.kind === 157 /* TypeArgumentClause */) {
+    if (tokenOrKeyword.isKeyword(17 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
+      return { allowsAnonymousTypes: false };
+    }
+    if (tokenOrKeyword.isToken(37 /* LessThan */) && tokenOrKeyword.parent.kind === 159 /* TypeArgumentClause */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(26 /* Comma */) && (tokenOrKeyword.parent.kind === 28 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 158 /* TypeArgumentList */)) {
-      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 158 /* TypeArgumentList */ };
+    if (tokenOrKeyword.isToken(26 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 160 /* TypeArgumentList */ || tokenOrKeyword.parent.kind === 23 /* ReducedTypeDeclarationBody */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 160 /* TypeArgumentList */ };
     }
-    if (tokenOrKeyword.isToken(36 /* HashSign */) && tokenOrKeyword.parent.kind === 152 /* Tag */) {
+    if (tokenOrKeyword.isToken(36 /* HashSign */) && tokenOrKeyword.parent.kind === 154 /* Tag */) {
       return { allowsAnonymousTypes: false };
     }
-    if ((tokenOrKeyword.isToken(25 /* Colon */) || tokenOrKeyword.isToken(64 /* Equals */)) && tokenOrKeyword.parent.kind === 148 /* TypeParameterDeclaration */) {
+    if ((tokenOrKeyword.isToken(25 /* Colon */) || tokenOrKeyword.isToken(64 /* Equals */)) && tokenOrKeyword.parent.kind === 150 /* TypeParameterDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
     if (tokenOrKeyword.isToken(64 /* Equals */) && tokenOrKeyword.parent.kind === 20 /* PackageAliasTypeDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Is */) && tokenOrKeyword.parent.kind === 72 /* IsExpression */) {
+    if (tokenOrKeyword.isKeyword(15 /* Is */) && tokenOrKeyword.parent.kind === 74 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isKeyword(42 /* As */) && tokenOrKeyword.parent.kind === 63 /* AsExpression */) {
+    if (tokenOrKeyword.isKeyword(43 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
       return { allowsAnonymousTypes: true };
     }
     if (tokenOrKeyword.isToken(17 /* Bar */) && tokenOrKeyword.parent.kind === 11 /* UnionTypeSpecifier */) {
@@ -5373,36 +5429,36 @@ var SyntaxContextFactory = class {
     return void 0;
   }
   static isTopLevelTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 124 /* TopLevelTranslationList */) {
+    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 126 /* TopLevelTranslationList */) {
       return { translationsDeclaration: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 123 /* TranslationsDeclaration */) {
+    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 125 /* TranslationsDeclaration */) {
       return { translationsDeclaration: tokenOrKeyword.parent };
     }
     const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      139 /* TypeTranslationDeclaration */
+      141 /* TypeTranslationDeclaration */
     );
     if (type !== void 0) {
       return { translationsDeclaration: type.parent.parent };
     }
     const functionType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      134 /* FunctionTypeTranslationDeclaration */
+      136 /* FunctionTypeTranslationDeclaration */
     );
     if (functionType !== void 0) {
       return { translationsDeclaration: functionType.parent.parent };
     }
     const variable = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      136 /* PackageVariableTranslationDeclaration */
+      138 /* PackageVariableTranslationDeclaration */
     );
     if (variable !== void 0) {
       return { translationsDeclaration: variable.parent.parent };
     }
     const func = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      132 /* PackageFunctionTranslationDeclaration */
+      134 /* PackageFunctionTranslationDeclaration */
     );
     if (func !== void 0) {
       return { translationsDeclaration: func.parent.parent };
@@ -5410,33 +5466,33 @@ var SyntaxContextFactory = class {
     return void 0;
   }
   static isTypeMemberTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 138 /* TypeMemberTranslationList */) {
+    if (tokenOrKeyword.isToken(58 /* Semicolon */) && tokenOrKeyword.parent.kind === 140 /* TypeMemberTranslationList */) {
       return { typeTranslation: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 139 /* TypeTranslationDeclaration */) {
+    if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 141 /* TypeTranslationDeclaration */) {
       return { typeTranslation: tokenOrKeyword.parent };
     }
-    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 129 /* IndexerTranslation */);
+    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 131 /* IndexerTranslation */);
     if (indexer !== void 0) {
       return { typeTranslation: indexer.parent.parent };
     }
     const constructor = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      127 /* ConstructorTranslation */
+      129 /* ConstructorTranslation */
     );
     if (constructor !== void 0) {
       return { typeTranslation: constructor.parent.parent };
     }
     const variableOrVariant = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      137 /* FieldOrVariantTranslation */
+      139 /* FieldOrVariantTranslation */
     );
     if (variableOrVariant !== void 0) {
       return { typeTranslation: variableOrVariant.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      133 /* MethodTranslation */
+      135 /* MethodTranslation */
     );
     if (method !== void 0) {
       return { typeTranslation: method.parent.parent };
@@ -5549,41 +5605,41 @@ var NodeSemanticInfoService = class {
   static ofTokenOrKeyword(analyzer, tokenOrKeyword, options7) {
     if (isIdentifier(tokenOrKeyword.value)) {
       return this.ofNonKeywordIdentifier(analyzer, tokenOrKeyword.value, options7);
-    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 69 /* AutotypeCallExpression */) {
+    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 71 /* AutotypeCallExpression */) {
       return this.ofAutotypeCallExpression(analyzer, tokenOrKeyword.parent, options7);
-    } else if (tokenOrKeyword.parent.kind === 75 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 77 /* PrefixUnaryExpression */) {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options7);
-    } else if (tokenOrKeyword.parent.kind === 64 /* BinaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options7);
-    } else if (tokenOrKeyword.isToken(21 /* Caret */) && (tokenOrKeyword.parent.kind === 48 /* DereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 49 /* DereferencedVariableSetterDeclaration */)) {
+    } else if (tokenOrKeyword.isToken(21 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* DereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* DereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(21 /* Caret */) && tokenOrKeyword.parent.kind === 78 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(21 /* Caret */) && tokenOrKeyword.parent.kind === 80 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options7);
-    } else if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    } else if (tokenOrKeyword.parent.kind === 94 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options7);
-    } else if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 43 /* ConstructorDeclaration */) {
+    } else if (tokenOrKeyword.isKeyword(32 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* ConstructorDeclaration */) {
       return this.ofConstructorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 91 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 93 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isKeyword(12 /* Function */) && tokenOrKeyword.parent.kind === 65 /* FunctionLiteral */) {
+    } else if (tokenOrKeyword.isKeyword(13 /* Function */) && tokenOrKeyword.parent.kind === 67 /* FunctionLiteral */) {
       return this.ofRegularOrBlockFunctionLiteral(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 95 /* FunctionBlock */ && tokenOrKeyword.parent.parent.kind === 66 /* FunctionBlockLiteral */) {
+    } else if (tokenOrKeyword.isToken(46 /* OpenBrace */) && tokenOrKeyword.parent.kind === 97 /* FunctionBlock */ && tokenOrKeyword.parent.parent.kind === 68 /* FunctionBlockLiteral */) {
       return this.ofRegularOrBlockFunctionLiteral(analyzer, tokenOrKeyword.parent.parent);
-    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 87 /* ObjectExpression */) {
+    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 89 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options7);
-    } else if (tokenOrKeyword.isKeyword(56 /* Base */) && tokenOrKeyword.parent.kind === 88 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(57 /* Base */) && tokenOrKeyword.parent.kind === 90 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options7);
-    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 47 /* IndexParameterClause */) {
+    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* IndexParameterClause */) {
       return this.ofIndexedElementAccessorDeclaration(analyzer, tokenOrKeyword.parent.parent);
-    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 70 /* IndexedAccessExpression */) {
+    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 72 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options7);
-    } else if (tokenOrKeyword.isKeyword(31 /* Creation */) && tokenOrKeyword.parent.kind === 127 /* ConstructorTranslation */) {
+    } else if (tokenOrKeyword.isKeyword(32 /* Creation */) && tokenOrKeyword.parent.kind === 129 /* ConstructorTranslation */) {
       return this.ofConstructorTranslationSourceConstructor(analyzer, tokenOrKeyword.parent, options7);
-    } else if ((tokenOrKeyword.isToken(47 /* OpenParenthesis */) || tokenOrKeyword.isToken(23 /* CloseParenthesis */)) && tokenOrKeyword.parent.kind === 126 /* TranslationParameterClause */ && tokenOrKeyword.parent.parent.kind === 127 /* ConstructorTranslation */ && tokenOrKeyword.parent.parent.translatedParameterClause === tokenOrKeyword.parent) {
+    } else if ((tokenOrKeyword.isToken(47 /* OpenParenthesis */) || tokenOrKeyword.isToken(23 /* CloseParenthesis */)) && tokenOrKeyword.parent.kind === 128 /* TranslationParameterClause */ && tokenOrKeyword.parent.parent.kind === 129 /* ConstructorTranslation */ && tokenOrKeyword.parent.parent.translatedParameterClause === tokenOrKeyword.parent) {
       return this.ofConstructorTranslationTranslatedConstructor(analyzer, tokenOrKeyword.parent.parent, options7);
-    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 128 /* IndexParameterTranslationClause */ && tokenOrKeyword.parent.parent.kind === 129 /* IndexerTranslation */ && tokenOrKeyword.parent.parent.sourceParameterClause === tokenOrKeyword.parent) {
+    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 130 /* IndexParameterTranslationClause */ && tokenOrKeyword.parent.parent.kind === 131 /* IndexerTranslation */ && tokenOrKeyword.parent.parent.sourceParameterClause === tokenOrKeyword.parent) {
       return this.ofIndexerTranslationSourceIndexer(analyzer, tokenOrKeyword.parent.parent, options7);
-    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 128 /* IndexParameterTranslationClause */ && tokenOrKeyword.parent.parent.kind === 129 /* IndexerTranslation */ && tokenOrKeyword.parent.parent.translatedParameterClause === tokenOrKeyword.parent) {
+    } else if ((tokenOrKeyword.isToken(48 /* OpenSquareBracket */) || tokenOrKeyword.isToken(24 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 130 /* IndexParameterTranslationClause */ && tokenOrKeyword.parent.parent.kind === 131 /* IndexerTranslation */ && tokenOrKeyword.parent.parent.translatedParameterClause === tokenOrKeyword.parent) {
       return this.ofIndexerTranslationTranslatedIndexer(analyzer, tokenOrKeyword.parent.parent, options7);
     }
     return void 0;
@@ -5600,11 +5656,11 @@ var NodeSemanticInfoService = class {
     let result;
     const parent = node.parent;
     switch (parent.kind) {
-      case 130 /* TranslationTypeParameterList */:
+      case 132 /* TranslationTypeParameterList */:
         return this.ofTranslationTypeParameterListParameter(analyzer, node, parent, options7);
-      case 125 /* TranslationParameterList */:
+      case 127 /* TranslationParameterList */:
         return this.ofTranslationParameterListParameter(analyzer, node, parent, options7);
-      case 150 /* Argument */: {
+      case 152 /* Argument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new MatchResultParameterReferenceTarget(respectiveParameter, 0 /* Get */);
@@ -5615,46 +5671,49 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 58 /* ForStatementVariableDeclaration */:
+      case 60 /* ForStatementVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofForStatementVariableDeclaration(parent));
         break;
-      case 102 /* ErrorVariableDeclaration */:
+      case 104 /* ErrorVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofErrorVariableDeclaration(parent));
         break;
       case 20 /* PackageAliasTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageAliasTypeDeclaration(parent));
         break;
-      case 25 /* PackageFunctionDeclaration */:
+      case 22 /* PackageReducedTypeDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageReducedTypeDeclaration(parent));
+        break;
+      case 27 /* PackageFunctionDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionDeclaration(parent));
         break;
-      case 26 /* PackageFunctionTypeDeclaration */:
+      case 28 /* PackageFunctionTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageFunctionTypeDeclaration(parent));
         break;
-      case 31 /* PackageStructuredTypeDeclaration */:
+      case 33 /* PackageStructuredTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageStructuredTypeDeclaration(parent));
         break;
-      case 33 /* PackageVariableDeclaration */:
+      case 35 /* PackageVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariableDeclaration(parent));
         break;
-      case 36 /* PackageVariantTypeDeclaration */:
+      case 38 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 89 /* IdentifierExpression */:
+      case 91 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options7);
         break;
-      case 56 /* NestedFunctionDeclaration */:
+      case 58 /* NestedFunctionDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedFunctionDeclaration(parent));
         break;
-      case 57 /* LocalVariableDeclaration */:
+      case 59 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
         break;
-      case 135 /* QualifiedName */:
+      case 137 /* QualifiedName */:
         result = this.ofQualifiedNameQualifier(analyzer, parent, node, options7);
         break;
-      case 136 /* PackageVariableTranslationDeclaration */:
-      case 132 /* PackageFunctionTranslationDeclaration */:
-      case 139 /* TypeTranslationDeclaration */:
-      case 134 /* FunctionTypeTranslationDeclaration */: {
+      case 138 /* PackageVariableTranslationDeclaration */:
+      case 134 /* PackageFunctionTranslationDeclaration */:
+      case 141 /* TypeTranslationDeclaration */:
+      case 136 /* FunctionTypeTranslationDeclaration */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const translationTargets = translationPackage?.getPackageMemberTranslationTargets(parent);
         if (translationPackage !== void 0 && translationTargets !== void 0 && translationTargets.values.length > 0) {
@@ -5677,8 +5736,8 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 137 /* FieldOrVariantTranslation */:
-      case 133 /* MethodTranslation */: {
+      case 139 /* FieldOrVariantTranslation */:
+      case 135 /* MethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const translationTargets = translationPackage?.getTypeMemberTranslationTargets(parent);
         if (translationPackage !== void 0 && translationTargets !== void 0 && translationTargets.values.length > 0) {
@@ -5701,7 +5760,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 149 /* ParameterDeclaration */:
+      case 151 /* ParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofParameterDeclaration(parent));
         break;
       case 8 /* PackageImport */:
@@ -5710,33 +5769,33 @@ var NodeSemanticInfoService = class {
       case 9 /* PackageName */:
         result = void 0;
         break;
-      case 76 /* MemberAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         result = this.ofMember(analyzer, parent, options7);
         break;
-      case 50 /* MethodDeclaration */:
+      case 52 /* MethodDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofMethodDeclaration(parent));
         break;
-      case 51 /* OperatorDeclaration */:
+      case 53 /* OperatorDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofOperatorDeclaration(parent));
         break;
-      case 52 /* FieldDeclaration */:
+      case 54 /* FieldDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofFieldDeclaration(parent));
         break;
-      case 148 /* TypeParameterDeclaration */:
+      case 150 /* TypeParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeParameterDeclaration(parent));
         break;
-      case 147 /* VariantValueDeclaration */:
+      case 149 /* VariantValueDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofVariantValueDeclaration(parent));
         break;
-      case 34 /* PackageVariableGetterDeclaration */:
-      case 35 /* PackageVariableSetterDeclaration */:
+      case 36 /* PackageVariableGetterDeclaration */:
+      case 37 /* PackageVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedPackageVariableDeclaration(parent));
         break;
-      case 53 /* FieldGetterDeclaration */:
-      case 54 /* FieldSetterDeclaration */:
+      case 55 /* FieldGetterDeclaration */:
+      case 56 /* FieldSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedFieldDeclaration(parent));
         break;
-      case 146 /* TranslationTextTemplateParameter */:
+      case 148 /* TranslationTextTemplateParameter */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTranslationTextTemplateParameter(parent));
         break;
       case 3 /* Keyword */:
@@ -5885,9 +5944,9 @@ var NodeSemanticInfoService = class {
     switch (node.parent.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.ofNamedTypeSpecifierNameQualifier(analyzer, node.parent, qualifier, options7);
-      case 152 /* Tag */:
+      case 154 /* Tag */:
         return this.ofTagNameQualifier(analyzer, node.parent, qualifier, options7);
-      case 40 /* ExtendedTypeClause */:
+      case 42 /* ExtendedTypeClause */:
         return void 0;
       default:
         Debug.never(node.parent);
@@ -6386,7 +6445,7 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 76 /* MemberAccessExpression */) {
+    while (parent.kind === 78 /* MemberAccessExpression */) {
       const meaning = analyzer.resolveMemberAccessExpression(parent);
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
@@ -6431,12 +6490,12 @@ var NodeSemanticInfoService = class {
     const translationDeclaration = typeParameterList.parent.parent;
     let translationTargets;
     switch (translationDeclaration.kind) {
-      case 132 /* PackageFunctionTranslationDeclaration */:
-      case 134 /* FunctionTypeTranslationDeclaration */:
-      case 139 /* TypeTranslationDeclaration */:
+      case 134 /* PackageFunctionTranslationDeclaration */:
+      case 136 /* FunctionTypeTranslationDeclaration */:
+      case 141 /* TypeTranslationDeclaration */:
         translationTargets = translationPackage.getPackageMemberTranslationTargets(translationDeclaration);
         break;
-      case 133 /* MethodTranslation */:
+      case 135 /* MethodTranslation */:
         translationTargets = translationPackage.getTypeMemberTranslationTargets(translationDeclaration);
         break;
       default:
@@ -6476,13 +6535,13 @@ var NodeSemanticInfoService = class {
     const translationDeclaration = parameterList.parent.parent;
     let translationTargets;
     switch (translationDeclaration.kind) {
-      case 132 /* PackageFunctionTranslationDeclaration */:
-      case 134 /* FunctionTypeTranslationDeclaration */:
+      case 134 /* PackageFunctionTranslationDeclaration */:
+      case 136 /* FunctionTypeTranslationDeclaration */:
         translationTargets = translationPackage.getPackageMemberTranslationTargets(translationDeclaration);
         break;
-      case 133 /* MethodTranslation */:
-      case 127 /* ConstructorTranslation */:
-      case 129 /* IndexerTranslation */:
+      case 135 /* MethodTranslation */:
+      case 129 /* ConstructorTranslation */:
+      case 131 /* IndexerTranslation */:
         translationTargets = translationPackage.getTypeMemberTranslationTargets(translationDeclaration);
         break;
       default:
@@ -6761,57 +6820,58 @@ function getEntitySourceLocations(analyzer, entity) {
           range = node.rangeWithoutTrivia;
           break;
         case 20 /* PackageAliasTypeDeclaration */:
-        case 25 /* PackageFunctionDeclaration */:
-        case 26 /* PackageFunctionTypeDeclaration */:
-        case 31 /* PackageStructuredTypeDeclaration */:
-        case 36 /* PackageVariantTypeDeclaration */:
-        case 56 /* NestedFunctionDeclaration */:
-        case 50 /* MethodDeclaration */:
-        case 148 /* TypeParameterDeclaration */:
-        case 51 /* OperatorDeclaration */:
+        case 22 /* PackageReducedTypeDeclaration */:
+        case 27 /* PackageFunctionDeclaration */:
+        case 28 /* PackageFunctionTypeDeclaration */:
+        case 33 /* PackageStructuredTypeDeclaration */:
+        case 38 /* PackageVariantTypeDeclaration */:
+        case 58 /* NestedFunctionDeclaration */:
+        case 52 /* MethodDeclaration */:
+        case 150 /* TypeParameterDeclaration */:
+        case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
-        case 43 /* ConstructorDeclaration */:
+        case 45 /* ConstructorDeclaration */:
           range = node.creationKeyword.rangeWithoutTrivia;
           break;
-        case 44 /* DestructorDeclaration */:
+        case 46 /* DestructorDeclaration */:
           range = node.destructionKeyword.rangeWithoutTrivia;
           break;
         case 8 /* PackageImport */:
           Debug.assertNotNull(node.alias);
           range = node.alias.rangeWithoutTrivia;
           break;
-        case 38 /* TypeExtensionDeclaration */:
+        case 40 /* TypeExtensionDeclaration */:
           range = node.plusEqualsToken.rangeWithoutTrivia;
           break;
-        case 34 /* PackageVariableGetterDeclaration */:
+        case 36 /* PackageVariableGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 35 /* PackageVariableSetterDeclaration */:
+        case 37 /* PackageVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 53 /* FieldGetterDeclaration */:
+        case 55 /* FieldGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 54 /* FieldSetterDeclaration */:
+        case 56 /* FieldSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 45 /* IndexedElementGetterDeclaration */:
+        case 47 /* IndexedElementGetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 46 /* IndexedElementSetterDeclaration */:
+        case 48 /* IndexedElementSetterDeclaration */:
           range = node.parameterClause.rangeWithoutTrivia;
           break;
-        case 48 /* DereferencedVariableGetterDeclaration */:
+        case 50 /* DereferencedVariableGetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
-        case 49 /* DereferencedVariableSetterDeclaration */:
+        case 51 /* DereferencedVariableSetterDeclaration */:
           range = node.caretToken.rangeWithoutTrivia;
           break;
-        case 65 /* FunctionLiteral */:
+        case 67 /* FunctionLiteral */:
           range = node.functionKeyword.rangeWithoutTrivia;
           break;
-        case 66 /* FunctionBlockLiteral */:
+        case 68 /* FunctionBlockLiteral */:
           range = node.block.openBraceToken.rangeWithoutTrivia;
           break;
         default:
@@ -7010,48 +7070,48 @@ var DefinitionService = class {
   getSourceLocationOfSubprogramNode(analyzer, node) {
     let range;
     switch (node.kind) {
-      case 25 /* PackageFunctionDeclaration */:
-      case 34 /* PackageVariableGetterDeclaration */:
-      case 35 /* PackageVariableSetterDeclaration */:
-      case 50 /* MethodDeclaration */:
-      case 53 /* FieldGetterDeclaration */:
-      case 54 /* FieldSetterDeclaration */:
-      case 56 /* NestedFunctionDeclaration */:
+      case 27 /* PackageFunctionDeclaration */:
+      case 36 /* PackageVariableGetterDeclaration */:
+      case 37 /* PackageVariableSetterDeclaration */:
+      case 52 /* MethodDeclaration */:
+      case 55 /* FieldGetterDeclaration */:
+      case 56 /* FieldSetterDeclaration */:
+      case 58 /* NestedFunctionDeclaration */:
         range = node.name.rangeWithoutTrivia;
         break;
-      case 23 /* PackageConstructorDeclaration */:
+      case 25 /* PackageConstructorDeclaration */:
         range = node.creationKeyword.rangeWithoutTrivia;
         break;
-      case 24 /* PackageEntryPointDeclaration */:
+      case 26 /* PackageEntryPointDeclaration */:
         range = node.runKeyword.rangeWithoutTrivia;
         break;
-      case 43 /* ConstructorDeclaration */:
+      case 45 /* ConstructorDeclaration */:
         range = node.creationKeyword.rangeWithoutTrivia;
         break;
-      case 44 /* DestructorDeclaration */:
+      case 46 /* DestructorDeclaration */:
         range = node.destructionKeyword.rangeWithoutTrivia;
         break;
-      case 45 /* IndexedElementGetterDeclaration */:
-      case 46 /* IndexedElementSetterDeclaration */:
+      case 47 /* IndexedElementGetterDeclaration */:
+      case 48 /* IndexedElementSetterDeclaration */:
         range = node.parameterClause.rangeWithoutTrivia;
         break;
-      case 48 /* DereferencedVariableGetterDeclaration */:
-      case 49 /* DereferencedVariableSetterDeclaration */:
+      case 50 /* DereferencedVariableGetterDeclaration */:
+      case 51 /* DereferencedVariableSetterDeclaration */:
         range = node.caretToken.rangeWithoutTrivia;
         break;
-      case 51 /* OperatorDeclaration */:
+      case 53 /* OperatorDeclaration */:
         range = node.name.rangeWithoutTrivia;
         break;
-      case 66 /* FunctionBlockLiteral */:
+      case 68 /* FunctionBlockLiteral */:
         range = node.block.openBraceToken.rangeWithoutTrivia;
         break;
-      case 65 /* FunctionLiteral */: {
+      case 67 /* FunctionLiteral */: {
         const rangeStart = node.functionKeyword.rangeWithoutTrivia.start;
         const rangeEnd = node.parameterClause.rangeWithoutTrivia.end;
         range = new Range(rangeStart, rangeEnd);
         break;
       }
-      case 141 /* TextTranslationFunctionDeclaration */:
+      case 143 /* TextTranslationFunctionDeclaration */:
         range = node.sourceText.rangeWithoutTrivia;
         break;
       default:
@@ -7124,7 +7184,7 @@ var ReferencesService = class {
               }
             }
             if (!options7.onlyNamed) {
-              if (node.kind === 69 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
+              if (node.kind === 71 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
                 const semanticInfo = NodeSemanticInfoService.ofAutotypeCallExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
                   definitions,
@@ -7136,7 +7196,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 75 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 77 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -7152,7 +7212,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 64 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
+              if (node.kind === 66 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofBinaryExpressionOperator(
                   analyzer,
                   node,
@@ -7168,7 +7228,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 48 /* DereferencedVariableGetterDeclaration */ || node.kind === 49 /* DereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
+              if ((node.kind === 50 /* DereferencedVariableGetterDeclaration */ || node.kind === 51 /* DereferencedVariableSetterDeclaration */) && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceOperatorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
                   definitions,
@@ -7180,7 +7240,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 78 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 80 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -7196,7 +7256,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 92 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 94 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -7212,7 +7272,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 43 /* ConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
+              if (node.kind === 45 /* ConstructorDeclaration */ && restrictions.canBeConstructorDeclaration) {
                 const semanticInfo = NodeSemanticInfoService.ofConstructorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
                   definitions,
@@ -7224,7 +7284,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 87 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 89 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
                   definitions,
@@ -7236,7 +7296,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 88 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 90 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
                   definitions,
@@ -7248,7 +7308,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if ((node.kind === 45 /* IndexedElementGetterDeclaration */ || node.kind === 46 /* IndexedElementSetterDeclaration */) && restrictions.canBeIndexer) {
+              if ((node.kind === 47 /* IndexedElementGetterDeclaration */ || node.kind === 48 /* IndexedElementSetterDeclaration */) && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedElementAccessorDeclaration(analyzer, node);
                 const referenceKind = this.ifReferenceToSomeOfDefinitionsThenKind(
                   definitions,
@@ -7260,7 +7320,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 70 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
+              if (node.kind === 72 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedAccessExpressionOperator(
                   analyzer,
                   node,
@@ -7280,7 +7340,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, range, referenceKind));
                 }
               }
-              if (node.kind === 127 /* ConstructorTranslation */ && restrictions.canBeConstructorDeclaration) {
+              if (node.kind === 129 /* ConstructorTranslation */ && restrictions.canBeConstructorDeclaration) {
                 {
                   const semanticInfo = NodeSemanticInfoService.ofConstructorTranslationSourceConstructor(
                     analyzer,
@@ -7318,7 +7378,7 @@ var ReferencesService = class {
                   }
                 }
               }
-              if (node.kind === 129 /* IndexerTranslation */ && restrictions.canBeIndexer) {
+              if (node.kind === 131 /* IndexerTranslation */ && restrictions.canBeIndexer) {
                 {
                   const semanticInfo = NodeSemanticInfoService.ofIndexerTranslationSourceIndexer(
                     analyzer,
@@ -7590,6 +7650,8 @@ var ReferencesService = class {
           }
           case 4 /* Alias */:
             return { name: entity.getName() };
+          case 5 /* Reduced */:
+            return { name: entity.getName() };
           default:
             Debug.never(entity);
         }
@@ -7709,7 +7771,7 @@ var EvaluatableExpressionService = class {
     let result = "";
     if (isIdentifier(node)) {
       let originalName;
-      if (node.parent.kind === 76 /* MemberAccessExpression */) {
+      if (node.parent.kind === 78 /* MemberAccessExpression */) {
         const meaning = analyzer.resolveMemberAccessExpression(node.parent);
         let entity;
         switch (meaning.kind) {
@@ -7727,7 +7789,7 @@ var EvaluatableExpressionService = class {
             break;
         }
         originalName = entity?.getOriginalEntity().getName().keyWithoutBackQuotes;
-      } else if (node.parent.kind === 89 /* IdentifierExpression */) {
+      } else if (node.parent.kind === 91 /* IdentifierExpression */) {
         const meaning = analyzer.resolveIdentifierExpression(node.parent);
         let entity;
         switch (meaning.kind) {
@@ -7755,9 +7817,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 89 /* IdentifierExpression */:
+      case 91 /* IdentifierExpression */:
         return parent;
-      case 76 /* MemberAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7778,9 +7840,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 89 /* IdentifierExpression */:
+      case 91 /* IdentifierExpression */:
         return true;
-      case 76 /* MemberAccessExpression */:
+      case 78 /* MemberAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7788,40 +7850,41 @@ var EvaluatableExpressionService = class {
   }
   ifNamedDeclarationThenName(node) {
     switch (node.kind) {
-      case 58 /* ForStatementVariableDeclaration */:
+      case 60 /* ForStatementVariableDeclaration */:
       case 20 /* PackageAliasTypeDeclaration */:
-      case 25 /* PackageFunctionDeclaration */:
-      case 26 /* PackageFunctionTypeDeclaration */:
-      case 31 /* PackageStructuredTypeDeclaration */:
-      case 33 /* PackageVariableDeclaration */:
-      case 36 /* PackageVariantTypeDeclaration */:
-      case 56 /* NestedFunctionDeclaration */:
-      case 57 /* LocalVariableDeclaration */:
-      case 149 /* ParameterDeclaration */:
-      case 50 /* MethodDeclaration */:
-      case 52 /* FieldDeclaration */:
-      case 148 /* TypeParameterDeclaration */:
-      case 147 /* VariantValueDeclaration */:
-      case 102 /* ErrorVariableDeclaration */:
-      case 34 /* PackageVariableGetterDeclaration */:
-      case 35 /* PackageVariableSetterDeclaration */:
-      case 53 /* FieldGetterDeclaration */:
-      case 54 /* FieldSetterDeclaration */:
-      case 51 /* OperatorDeclaration */:
-      case 146 /* TranslationTextTemplateParameter */:
+      case 22 /* PackageReducedTypeDeclaration */:
+      case 27 /* PackageFunctionDeclaration */:
+      case 28 /* PackageFunctionTypeDeclaration */:
+      case 33 /* PackageStructuredTypeDeclaration */:
+      case 35 /* PackageVariableDeclaration */:
+      case 38 /* PackageVariantTypeDeclaration */:
+      case 58 /* NestedFunctionDeclaration */:
+      case 59 /* LocalVariableDeclaration */:
+      case 151 /* ParameterDeclaration */:
+      case 52 /* MethodDeclaration */:
+      case 54 /* FieldDeclaration */:
+      case 150 /* TypeParameterDeclaration */:
+      case 149 /* VariantValueDeclaration */:
+      case 104 /* ErrorVariableDeclaration */:
+      case 36 /* PackageVariableGetterDeclaration */:
+      case 37 /* PackageVariableSetterDeclaration */:
+      case 55 /* FieldGetterDeclaration */:
+      case 56 /* FieldSetterDeclaration */:
+      case 53 /* OperatorDeclaration */:
+      case 148 /* TranslationTextTemplateParameter */:
         return node.name;
-      case 89 /* IdentifierExpression */:
-      case 76 /* MemberAccessExpression */:
-      case 150 /* Argument */:
-      case 125 /* TranslationParameterList */:
-      case 130 /* TranslationTypeParameterList */:
-      case 132 /* PackageFunctionTranslationDeclaration */:
-      case 134 /* FunctionTypeTranslationDeclaration */:
-      case 136 /* PackageVariableTranslationDeclaration */:
-      case 137 /* FieldOrVariantTranslation */:
-      case 139 /* TypeTranslationDeclaration */:
-      case 135 /* QualifiedName */:
-      case 133 /* MethodTranslation */:
+      case 91 /* IdentifierExpression */:
+      case 78 /* MemberAccessExpression */:
+      case 152 /* Argument */:
+      case 127 /* TranslationParameterList */:
+      case 132 /* TranslationTypeParameterList */:
+      case 134 /* PackageFunctionTranslationDeclaration */:
+      case 136 /* FunctionTypeTranslationDeclaration */:
+      case 138 /* PackageVariableTranslationDeclaration */:
+      case 139 /* FieldOrVariantTranslation */:
+      case 141 /* TypeTranslationDeclaration */:
+      case 137 /* QualifiedName */:
+      case 135 /* MethodTranslation */:
       case 8 /* PackageImport */:
       case 9 /* PackageName */:
       case 3 /* Keyword */:
@@ -7900,12 +7963,7 @@ var HoverService = class {
     if (semanticInfo === void 0) {
       return void 0;
     }
-    this.displayService = new DisplayService(
-      analyzer,
-      sourceFile.package.locale,
-      sourceFile.package.dialect,
-      sourceFile
-    );
+    this.displayService = new DisplayService(analyzer, sourceFile.locale, sourceFile.dialect, sourceFile);
     switch (semanticInfo.kind) {
       case "definition":
         return this.createHoverForEntity(semanticInfo.entity, void 0, tokenOrKeyword.value.rangeWithoutTrivia);
@@ -7974,7 +8032,7 @@ var HoverService = class {
           const typeText = this.displayService.displayType(firstTarget.type);
           return new Hover(`${keywordText}: ${typeText}`, range);
         } else if (firstTarget.typeContextKind === "base") {
-          const keywordText = this.displayService.displayKeyword(56 /* Base */);
+          const keywordText = this.displayService.displayKeyword(57 /* Base */);
           const typeText = this.displayService.displayType(firstTarget.type);
           return new Hover(`${keywordText}: ${typeText}`, range);
         } else {
@@ -8150,7 +8208,7 @@ var ScriptEditingService = class _ScriptEditingService {
       result = new SourceFileEdit(sourceFile, lastAssignmentStatement.right.rangeWithoutTrivia, value);
     } else {
       const assignmentText = `${_ScriptEditingService.elementParameterNameText}.${fieldName} = ${value}`;
-      if (subprogramBlock.expressionOrStatementList.kind === 93 /* StatementList */) {
+      if (subprogramBlock.expressionOrStatementList.kind === 95 /* StatementList */) {
         const lastStatement = subprogramBlock.expressionOrStatementList?.statements.last();
         let editRange;
         let indentationText;
@@ -8188,7 +8246,7 @@ var ScriptEditingService = class _ScriptEditingService {
     }
     let scriptBlockIndentation;
     let editStart;
-    if (subprogramBlock.expressionOrStatementList.kind === 93 /* StatementList */) {
+    if (subprogramBlock.expressionOrStatementList.kind === 95 /* StatementList */) {
       const lastStatement = subprogramBlock.expressionOrStatementList.statements.last();
       if (lastStatement !== void 0) {
         const lastStatementStartCharacter = sourceFile.getPositionAt(lastStatement.rangeWithoutTrivia.start).character;
@@ -8216,7 +8274,7 @@ var ScriptEditingService = class _ScriptEditingService {
   }
   createEditDeletingBlock(sourceFile, scriptDeclaration) {
     let result;
-    if (NodeTypeUtils.isRegularOrBlockFunctionLiteral(scriptDeclaration) && scriptDeclaration.parent.kind === 150 /* Argument */ && scriptDeclaration.parent.parent.parent.kind === 68 /* CallExpression */) {
+    if (NodeTypeUtils.isRegularOrBlockFunctionLiteral(scriptDeclaration) && scriptDeclaration.parent.kind === 152 /* Argument */ && scriptDeclaration.parent.parent.parent.kind === 70 /* CallExpression */) {
       const callExpression = scriptDeclaration.parent.parent.parent;
       let rangeStart = callExpression.rangeWithoutTrivia.start;
       let rangeEnd = callExpression.rangeWithoutTrivia.end;
@@ -8243,20 +8301,20 @@ var ScriptEditingService = class _ScriptEditingService {
     return result;
   }
   findLastAssignmentToField(analyzer, block, fieldNameText) {
-    if (block.expressionOrStatementList.kind !== 93 /* StatementList */) {
+    if (block.expressionOrStatementList.kind !== 95 /* StatementList */) {
       return void 0;
     }
     const fieldName = new Name(fieldNameText);
     const statements = block.expressionOrStatementList.statements.toArray();
     for (let i = statements.length - 1; i >= 0; i--) {
       const statement = statements[i];
-      if (statement.kind === 92 /* AssignmentStatement */) {
+      if (statement.kind === 94 /* AssignmentStatement */) {
         const left = unwrapParenthesizedExpressions(statement.left);
-        if (left.kind === 76 /* MemberAccessExpression */) {
+        if (left.kind === 78 /* MemberAccessExpression */) {
           const memberAccessMeaning = analyzer.resolveMemberAccessExpression(left);
           if (memberAccessMeaning.kind === "instance-field-access" && memberAccessMeaning.field.getName().considerEqual(fieldName)) {
             const receiver = unwrapParenthesizedExpressions(left.expression);
-            if (receiver.kind === 89 /* IdentifierExpression */) {
+            if (receiver.kind === 91 /* IdentifierExpression */) {
               const receiverMeaning = analyzer.resolveIdentifierExpression(receiver);
               if (receiverMeaning.kind === "variable-access" && receiverMeaning.variable.getName().considerEqual(_ScriptEditingService.elementParameterName)) {
                 return statement;
@@ -8345,13 +8403,13 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 161 /* TypeAnnotation */:
-      case 32 /* StructuredTypeDeclarationBody */:
-      case 37 /* VariantTypeDeclarationBody */:
+      case 163 /* TypeAnnotation */:
+      case 34 /* StructuredTypeDeclarationBody */:
+      case 39 /* VariantTypeDeclarationBody */:
       case 21 /* AliasTypeDeclarationBody */:
-      case 27 /* FunctionTypeDeclarationBody */:
-      case 82 /* TextTemplateSpan */:
-      case 81 /* TextTemplateSpanList */:
+      case 29 /* FunctionTypeDeclarationBody */:
+      case 84 /* TextTemplateSpan */:
+      case 83 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8389,7 +8447,7 @@ var SemanticTokensService = class {
             controller.skipChildrenTraverse();
             return;
           }
-          if (node.kind === 89 /* IdentifierExpression */) {
+          if (node.kind === 91 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node);
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.getEntity();
@@ -8443,7 +8501,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 76 /* MemberAccessExpression */) {
+          if (node.kind === 78 /* MemberAccessExpression */) {
             const meaning = analyzer.resolveMemberAccessExpression(node);
             if (meaning.kind === "static-field-access") {
               const entity = meaning.field.getEntity();
@@ -8487,7 +8545,7 @@ var SemanticTokensService = class {
               ));
             }
           }
-          if (node.kind === 147 /* VariantValueDeclaration */) {
+          if (node.kind === 149 /* VariantValueDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8496,7 +8554,7 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 25 /* PackageFunctionDeclaration */) {
+          if (node.kind === 27 /* PackageFunctionDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8505,7 +8563,7 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 56 /* NestedFunctionDeclaration */) {
+          if (node.kind === 58 /* NestedFunctionDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8514,12 +8572,12 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 50 /* MethodDeclaration */) {
+          if (node.kind === 52 /* MethodDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 6 /* Method */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
             );
           }
-          if (node.kind === 51 /* OperatorDeclaration */) {
+          if (node.kind === 53 /* OperatorDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 7 /* Operator */, new SemanticTokenModifiers().makeDeclaration())
             );
@@ -8638,8 +8696,8 @@ var TypeParameterSignatureHelpProvider = class {
   get signatureContext() {
     return this.signatureContext_.getOrInsertWith(() => new SignatureContext(new DisplayService(
       this.analyzer,
-      this.sourceFile.package.locale,
-      this.sourceFile.package.dialect,
+      this.sourceFile.locale,
+      this.sourceFile.dialect,
       this.sourceFile
     )));
   }
@@ -8669,7 +8727,7 @@ var TypeParameterSignatureHelpProvider = class {
     }
     let node = token.parent;
     while (node !== void 0) {
-      if (node.kind === 157 /* TypeArgumentClause */ && this.offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this.offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
+      if (node.kind === 159 /* 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);
@@ -8714,9 +8772,9 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 90 /* GenericSpecializationExpression */:
+      case 92 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
-      case 152 /* Tag */:
+      case 154 /* Tag */:
         return this.getSignaturesForTag(node);
       default:
         Debug.never(node);
@@ -8750,7 +8808,7 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
-    if (expression.kind === 89 /* IdentifierExpression */) {
+    if (expression.kind === 91 /* IdentifierExpression */) {
       const meaning = this.analyzer.resolveIdentifierExpression(expression);
       if (meaning.kind === "function-access") {
         return Query.from(meaning.candidates).mapAndFilter((f) => this.getSignatureForAccessedFunction(f)).toArray();
@@ -8763,7 +8821,7 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 76 /* MemberAccessExpression */) {
+    if (expression.kind === 78 /* MemberAccessExpression */) {
       const meaning = this.analyzer.resolveMemberAccessExpression(expression);
       let accessedFunctions;
       if (meaning.kind === "instance-method-access") {
@@ -8844,6 +8902,11 @@ var TypeParameterSignatureHelpProvider = class {
           result = new AliasTypeSignature(this.signatureContext, type);
         }
         break;
+      case 5 /* Reduced */:
+        if (type.getArity() > 0) {
+          result = new ReducedTypeSignature(this.signatureContext, type);
+        }
+        break;
       case 2 /* Parameter */:
         break;
       default:
@@ -8949,6 +9012,21 @@ var AliasTypeSignature = class {
     return this.ctx.convertNamedTypeDisplayParts(displayParts);
   }
 };
+var ReducedTypeSignature = class {
+  constructor(ctx, type) {
+    this.ctx = ctx;
+    this.type = type;
+    this.kind = "reduced-type";
+  }
+  getArity() {
+    return this.type.getArity();
+  }
+  getDisplayParts() {
+    const type = new NamedType_reduced(this.type);
+    const displayParts = this.ctx.displayService.getNamedTypeDisplayParts(type);
+    return this.ctx.convertNamedTypeDisplayParts(displayParts);
+  }
+};
 var SignatureContext = class {
   constructor(displayService) {
     this.displayService = displayService;
@@ -8974,8 +9052,8 @@ var ParametersSignatureHelpProvider = class {
   get signatureContext() {
     return this.signatureContext_.getOrInsertWith(() => new SignatureContext2(new DisplayService(
       this.analyzer,
-      this.sourceFile.package.locale,
-      this.sourceFile.package.dialect,
+      this.sourceFile.locale,
+      this.sourceFile.dialect,
       this.sourceFile
     )));
   }
@@ -9026,7 +9104,7 @@ var ParametersSignatureHelpProvider = class {
     let node = token.parent;
     while (node !== void 0) {
       switch (node.kind) {
-        case 68 /* CallExpression */: {
+        case 70 /* CallExpression */: {
           if (this.offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this.offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const args = ArgumentFactory.createArgumentsOfCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this.offset);
@@ -9034,7 +9112,7 @@ var ParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 69 /* AutotypeCallExpression */: {
+        case 71 /* AutotypeCallExpression */: {
           if (this.offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this.offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const args = ArgumentFactory.createArgumentsOfAutotypeCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this.offset);
@@ -9042,7 +9120,7 @@ var ParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 70 /* IndexedAccessExpression */: {
+        case 72 /* IndexedAccessExpression */: {
           if (this.offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this.offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const args = ArgumentFactory.createArgumentsOfIndexedAccessExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentList.elements, this.offset);
@@ -9050,7 +9128,7 @@ var ParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 152 /* Tag */: {
+        case 154 /* 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 args = ArgumentFactory.createArgumentsOfTag(node);
@@ -11600,6 +11678,8 @@ var EntityToSyntax = class {
         return this.convertPackageVariantType(entity);
       case 4 /* Alias */:
         return this.convertPackageAliasType(entity);
+      case 5 /* Reduced */:
+        return this.convertPackageReducedType(entity);
       default:
         Debug.never(entity);
     }
@@ -11632,7 +11712,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isConstant()) {
-      modifiers.push(SyntaxFactory.modifier(36 /* Const */));
+      modifiers.push(SyntaxFactory.modifier(37 /* Const */));
     }
     return modifiers;
   }
@@ -11660,7 +11740,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isAsync()) {
-      modifiers.push(SyntaxFactory.modifier(40 /* Async */));
+      modifiers.push(SyntaxFactory.modifier(41 /* Async */));
     }
     return modifiers;
   }
@@ -11679,10 +11759,10 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.markedBasic()) {
-      modifiers.push(SyntaxFactory.modifier(17 /* Basic */));
+      modifiers.push(SyntaxFactory.modifier(18 /* Basic */));
     }
     if (entity.isAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Abstract */));
     }
     return modifiers;
   }
@@ -11702,6 +11782,22 @@ var EntityToSyntax = class {
     }
     return modifiers;
   }
+  convertPackageReducedType(entity) {
+    const tags = this.convertTags(entity.getTags());
+    const modifiers = this.convertPackageReducedTypeModifiers(entity);
+    const name = this.getEntityName(entity);
+    const typeParameters = this.convertTypeParameters(entity.getTypeParameters());
+    const body = this.createReducedTypeDeclarationBody(entity);
+    return SyntaxFactory.packageReducedTypeDeclaration(tags, modifiers, name, typeParameters, body);
+  }
+  convertPackageReducedTypeModifiers(entity) {
+    const modifiers = new Array();
+    const isHidden = entity.isHidden();
+    if (isHidden !== void 0) {
+      modifiers.push(this.createHidingModifier(isHidden));
+    }
+    return modifiers;
+  }
   convertPackageVariantType(entity) {
     const tags = this.convertTags(entity.getTags());
     const modifiers = this.convertPackageVariantTypeModifiers(entity);
@@ -11773,19 +11869,19 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isStatic()) {
-      modifiers.push(SyntaxFactory.modifier(41 /* Static */));
+      modifiers.push(SyntaxFactory.modifier(42 /* Static */));
     }
     if (entity.markedBasic()) {
-      modifiers.push(SyntaxFactory.modifier(17 /* Basic */));
+      modifiers.push(SyntaxFactory.modifier(18 /* Basic */));
     }
     if (entity.markedAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Abstract */));
     }
     if (entity.isOverride()) {
-      modifiers.push(SyntaxFactory.modifier(39 /* Override */));
+      modifiers.push(SyntaxFactory.modifier(40 /* Override */));
     }
     if (entity.isConstant()) {
-      modifiers.push(SyntaxFactory.modifier(36 /* Const */));
+      modifiers.push(SyntaxFactory.modifier(37 /* Const */));
     }
     return modifiers;
   }
@@ -11805,16 +11901,16 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isStatic()) {
-      modifiers.push(SyntaxFactory.modifier(41 /* Static */));
+      modifiers.push(SyntaxFactory.modifier(42 /* Static */));
     }
     if (entity.markedBasic()) {
-      modifiers.push(SyntaxFactory.modifier(17 /* Basic */));
+      modifiers.push(SyntaxFactory.modifier(18 /* Basic */));
     }
     if (entity.markedAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Abstract */));
     }
     if (entity.isOverride()) {
-      modifiers.push(SyntaxFactory.modifier(39 /* Override */));
+      modifiers.push(SyntaxFactory.modifier(40 /* Override */));
     }
     return modifiers;
   }
@@ -11831,7 +11927,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.markedAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Abstract */));
     }
     return modifiers;
   }
@@ -11848,7 +11944,7 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.markedAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Abstract */));
     }
     return modifiers;
   }
@@ -11877,10 +11973,10 @@ var EntityToSyntax = class {
       modifiers.push(this.createHidingModifier(isHidden));
     }
     if (entity.isStatic()) {
-      modifiers.push(SyntaxFactory.modifier(41 /* Static */));
+      modifiers.push(SyntaxFactory.modifier(42 /* Static */));
     }
     if (entity.markedAbstract()) {
-      modifiers.push(SyntaxFactory.modifier(38 /* Abstract */));
+      modifiers.push(SyntaxFactory.modifier(39 /* Abstract */));
     }
     return modifiers;
   }
@@ -11929,6 +12025,27 @@ var EntityToSyntax = class {
     }
     return SyntaxFactory.aliasTypeDeclarationBody(aliasedType, members);
   }
+  createReducedTypeDeclarationBody(entity) {
+    let reductionSource = this.convertType(entity.getReductionSource().declared);
+    if (reductionSource.kind !== 10 /* NamedTypeSpecifier */) {
+      reductionSource = SyntaxFactory.namedTypeSpecifier("\u041E\u0431\u044A\u0435\u043A\u0442");
+    }
+    let preservedTypes;
+    const baseObjectType = entity.getBaseObjectType().declared;
+    const baseAspectTypes = entity.getBaseAspectTypes().declared;
+    if (baseObjectType !== void 0 || baseAspectTypes.length > 0) {
+      preservedTypes = [];
+      if (baseObjectType !== void 0) {
+        const baseObjectTypeSpecifier = this.convertType(baseObjectType);
+        if (baseObjectTypeSpecifier.kind === 10 /* NamedTypeSpecifier */) {
+          preservedTypes.push(baseObjectTypeSpecifier);
+        }
+      }
+      preservedTypes.push(...baseAspectTypes.map((t) => this.convertType(t)).filter((t) => t.kind === 10 /* NamedTypeSpecifier */));
+    }
+    const members = this.convertTypeEntityMembers(entity.getMembers());
+    return SyntaxFactory.reducedTypeDeclarationBody(reductionSource, preservedTypes, members);
+  }
   createVariantTypeDeclarationBody(entity) {
     const members = this.convertTypeEntityMembers(entity.getMembers());
     return SyntaxFactory.variantTypeDeclarationBody(members);
@@ -11978,21 +12095,21 @@ var EntityToSyntax = class {
     let levelKeyword;
     switch (hiding.kind) {
       case "type":
-        levelKeyword = 51 /* InType */;
+        levelKeyword = 52 /* InType */;
         break;
       case "type-hierarchy":
-        levelKeyword = 48 /* InHierarchy */;
+        levelKeyword = 49 /* InHierarchy */;
         break;
       case "file":
-        levelKeyword = 49 /* InFile */;
+        levelKeyword = 50 /* InFile */;
         break;
       case "package":
-        levelKeyword = 50 /* InPackage */;
+        levelKeyword = 51 /* InPackage */;
         break;
       default:
         Debug.never(hiding);
     }
-    return SyntaxFactory.modifier(37 /* Hidden */, levelKeyword);
+    return SyntaxFactory.modifier(38 /* Hidden */, levelKeyword);
   }
   convertTags(entityTags) {
     return [];
@@ -12010,6 +12127,8 @@ var EntityToSyntax = class {
         return this.convertFunctionType(type);
       case "alias":
         return this.convertAliasType(type);
+      case "reduced":
+        return this.convertReducedType(type);
       case "parameter":
         return this.convertParameterType(type);
       case "union":
@@ -12058,6 +12177,10 @@ var EntityToSyntax = class {
     const name = this.getEntityName(type.getEntity());
     return this.createNamedTypeSpecifier(name, type.getSubstitutions());
   }
+  convertReducedType(type) {
+    const name = this.getEntityName(type.getEntity());
+    return this.createNamedTypeSpecifier(name, type.getSubstitutions());
+  }
   convertParameterType(type) {
     const name = this.getEntityName(type.getEntity());
     return this.createNamedTypeSpecifier(name, type.getSubstitutions());
@@ -12298,6 +12421,7 @@ var SourceGenerationService = class extends ObservableObject7 {
             return true;
           }
           case 4 /* Alias */:
+          case 5 /* Reduced */:
             return true;
           case 2 /* Parameter */:
             return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainingEntity());
@@ -12403,6 +12527,8 @@ var EntityFinder = class {
           }
           case 4 /* Alias */:
             return this.findPackageTypeEntityByNameAndArity(this.getEntityName(entity), entity.getArity());
+          case 5 /* Reduced */:
+            return this.findPackageTypeEntityByNameAndArity(this.getEntityName(entity), entity.getArity());
           case 2 /* Parameter */:
             return this.findTypeParameterEntity(entity);
           default:
@@ -12683,10 +12809,10 @@ var SourceFileItemsService = class {
     return this.getChildItems(sourceFile.getSyntaxNode());
   }
   get locale() {
-    return this.sourceFile.package.locale;
+    return this.sourceFile.locale;
   }
   get dialect() {
-    return this.sourceFile.package.dialect;
+    return this.sourceFile.dialect;
   }
   getChildItems(node) {
     const result = new Array();
@@ -12705,7 +12831,7 @@ var SourceFileItemsService = class {
           }
           break;
         }
-        case 33 /* PackageVariableDeclaration */: {
+        case 35 /* PackageVariableDeclaration */: {
           result.push(this.createItem(
             1 /* PackageVariable */,
             node2.name.value,
@@ -12715,7 +12841,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 34 /* PackageVariableGetterDeclaration */: {
+        case 36 /* PackageVariableGetterDeclaration */: {
           result.push(this.createItem(
             2 /* PackageVariableGetter */,
             node2.name.value,
@@ -12725,7 +12851,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 35 /* PackageVariableSetterDeclaration */: {
+        case 37 /* PackageVariableSetterDeclaration */: {
           result.push(this.createItem(
             3 /* PackageVariableSetter */,
             node2.name.value,
@@ -12735,7 +12861,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 25 /* PackageFunctionDeclaration */: {
+        case 27 /* PackageFunctionDeclaration */: {
           result.push(this.createItem(
             4 /* PackageFunction */,
             node2.name.value,
@@ -12745,7 +12871,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 31 /* PackageStructuredTypeDeclaration */: {
+        case 33 /* PackageStructuredTypeDeclaration */: {
           result.push(this.createItem(
             5 /* StructuredType */,
             node2.name.value,
@@ -12755,7 +12881,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 52 /* FieldDeclaration */: {
+        case 54 /* FieldDeclaration */: {
           result.push(this.createItem(
             12 /* Field */,
             node2.name.value,
@@ -12765,7 +12891,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 53 /* FieldGetterDeclaration */: {
+        case 55 /* FieldGetterDeclaration */: {
           result.push(this.createItem(
             13 /* FieldGetter */,
             node2.name.value,
@@ -12775,7 +12901,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 54 /* FieldSetterDeclaration */: {
+        case 56 /* FieldSetterDeclaration */: {
           result.push(this.createItem(
             14 /* FieldSetter */,
             node2.name.value,
@@ -12785,7 +12911,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 50 /* MethodDeclaration */: {
+        case 52 /* MethodDeclaration */: {
           result.push(this.createItem(
             15 /* Method */,
             node2.name.value,
@@ -12795,7 +12921,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 43 /* ConstructorDeclaration */: {
+        case 45 /* ConstructorDeclaration */: {
           result.push(this.createItem(
             10 /* Constructor */,
             void 0,
@@ -12805,7 +12931,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 44 /* DestructorDeclaration */: {
+        case 46 /* DestructorDeclaration */: {
           result.push(this.createItem(
             11 /* Destructor */,
             void 0,
@@ -12815,7 +12941,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 45 /* IndexedElementGetterDeclaration */: {
+        case 47 /* IndexedElementGetterDeclaration */: {
           result.push(this.createItem(
             16 /* IndexedElementGetter */,
             void 0,
@@ -12825,7 +12951,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 46 /* IndexedElementSetterDeclaration */: {
+        case 48 /* IndexedElementSetterDeclaration */: {
           result.push(this.createItem(
             17 /* IndexedElementSetter */,
             void 0,
@@ -12835,7 +12961,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 26 /* PackageFunctionTypeDeclaration */: {
+        case 28 /* PackageFunctionTypeDeclaration */: {
           result.push(this.createItem(
             6 /* FunctionType */,
             node2.name.value,
@@ -12845,7 +12971,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 36 /* PackageVariantTypeDeclaration */: {
+        case 38 /* PackageVariantTypeDeclaration */: {
           result.push(this.createItem(
             7 /* VariantType */,
             node2.name.value,
@@ -12855,7 +12981,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 147 /* VariantValueDeclaration */: {
+        case 149 /* VariantValueDeclaration */: {
           result.push(this.createItem(
             9 /* VariantValue */,
             node2.name.value,
@@ -12865,7 +12991,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 148 /* TypeParameterDeclaration */: {
+        case 150 /* TypeParameterDeclaration */: {
           result.push(this.createItem(
             18 /* TypeParameter */,
             node2.name.value,
@@ -12875,7 +13001,7 @@ var SourceFileItemsService = class {
           ));
           break;
         }
-        case 56 /* NestedFunctionDeclaration */: {
+        case 58 /* NestedFunctionDeclaration */: {
           result.push(this.createItem(
             19 /* NestedFunction */,
             node2.name.value,
@@ -12910,30 +13036,30 @@ var SourceFileItemsService = class {
       case 4 /* PackageFunction */:
       case 15 /* Method */:
       case 19 /* NestedFunction */:
-        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(12 /* Function */, this.locale, this.dialect)}>`;
+        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(13 /* Function */, this.locale, this.dialect)}>`;
       case 5 /* StructuredType */:
       case 6 /* FunctionType */:
       case 7 /* VariantType */:
       case 8 /* InvalidType */:
-        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(16 /* Type */, this.locale, this.dialect)}>`;
+        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(17 /* Type */, this.locale, this.dialect)}>`;
       case 10 /* Constructor */:
-        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(31 /* Creation */, this.locale, this.dialect);
+        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(32 /* Creation */, this.locale, this.dialect);
       case 11 /* Destructor */:
-        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(47 /* Destruction */, this.locale, this.dialect);
+        return name ?? LocalizationHelper.localizeKeywordAndTakeFirst(48 /* Destruction */, this.locale, this.dialect);
       case 9 /* VariantValue */:
-        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(6 /* Variant */, this.locale, this.dialect)}>`;
+        return name ?? `<${LocalizationHelper.localizeKeywordAndTakeFirst(7 /* Variant */, this.locale, this.dialect)}>`;
       case 18 /* TypeParameter */:
         return name ?? `<${LocalizationHelper.localizeHelperPhrase(2 /* TypeParameter */, this.locale)}>`;
       case 2 /* PackageVariableGetter */:
       case 13 /* FieldGetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(58 /* Get */, this.locale, this.dialect)} ${name ?? ""}`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Get */, this.locale, this.dialect)} ${name ?? ""}`;
       case 3 /* PackageVariableSetter */:
       case 14 /* FieldSetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Set */, this.locale, this.dialect)} ${name ?? ""}`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(60 /* Set */, this.locale, this.dialect)} ${name ?? ""}`;
       case 16 /* IndexedElementGetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(58 /* Get */, this.locale, this.dialect)} []`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Get */, this.locale, this.dialect)} []`;
       case 17 /* IndexedElementSetter */:
-        return `${LocalizationHelper.localizeKeywordAndTakeFirst(59 /* Set */, this.locale, this.dialect)} []`;
+        return `${LocalizationHelper.localizeKeywordAndTakeFirst(60 /* Set */, this.locale, this.dialect)} []`;
       default:
         Debug.never(kind);
     }
@@ -13769,7 +13895,7 @@ var _LanguageServer = class _LanguageServer {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
         if (node !== void 0) {
           let nodeForRange = node;
-          if (node.kind === 92 /* AssignmentStatement */) {
+          if (node.kind === 94 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);
@@ -14001,15 +14127,17 @@ ${e}`);
         return ls3.CompletionItemKind.Function;
       case 19 /* AliasType */:
         return ls3.CompletionItemKind.Class;
-      case 20 /* InvalidType */:
+      case 20 /* ReducedType */:
+        return ls3.CompletionItemKind.Class;
+      case 21 /* InvalidType */:
         return ls3.CompletionItemKind.Class;
-      case 21 /* Keyword */:
+      case 22 /* Keyword */:
         return ls3.CompletionItemKind.Keyword;
-      case 22 /* TargetSignatureParameter */:
+      case 23 /* TargetSignatureParameter */:
         return ls3.CompletionItemKind.Variable;
       case 4 /* Operator */:
         return ls3.CompletionItemKind.Operator;
-      case 23 /* OperatorName */:
+      case 24 /* OperatorName */:
         return ls3.CompletionItemKind.Operator;
       default:
         Debug.never(kind);