@artel/artc 0.6.25211 → 0.6.25212

package/build/api/ApiServices.js

@@ -7,7 +7,6 @@ import {
   AnonymousTypeSpecifier,
   AnonymousVariantTypeDeclaration,
   BaseTypeList,
-  BinaryOperatorDeclaration_typeMember,
   Cached,
   CallArgumentList,
   CancelledError,
@@ -62,6 +61,7 @@ import {
   NodePath,
   NodeTypeUtils,
   NullableTypeSpecifier,
+  OperatorDeclaration_typeMember,
   PackageAliasTypeDeclaration,
   PackageImport,
   PackageImportDirectiveList,
@@ -144,7 +144,6 @@ import {
   TypeVariableGetterDeclaration,
   TypeVariableOrVariantTranslation,
   TypeVariableSetterDeclaration,
-  UnaryOperatorDeclaration_typeMember,
   UnionTypeSpecifier,
   UnionTypeSpecifierTypeList,
   Uri,
@@ -172,8 +171,10 @@ import {
   isSourceOrConfigurationFileName,
   isTypeEntity,
   isTypeEntityWithMembers,
+  isUnaryOperator,
   kebabCaseToCamelCase,
   localeToString,
+  operatorKinds,
   setUserLocale,
   tokenKindValues,
   traverseTreeWithCancellationToken,
@@ -181,7 +182,7 @@ import {
   unwrapParenthesizedExpressions,
   visitChildren,
   yieldExecution
-} from "../chunk-Y3KGPV3L.js";
+} from "../chunk-DYVLHEXS.js";
 
 // source/services/CustomCommand.ts
 import * as ls from "vscode-languageserver";
@@ -269,7 +270,7 @@ function cast(value) {
 import { atomic as atomic6, atomicRun as atomicRun3 } from "reactronic";
 import * as ls3 from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { URI as URI2, Utils } from "vscode-uri";
+import { URI as URI2 } from "vscode-uri";
 
 // source/services/Types.ts
 import * as ls2 from "vscode-languageserver";
@@ -301,7 +302,7 @@ var AddPropertyAssignmentService = class {
     let result;
     let leftValueText;
     if (propertyName !== void 0) {
-      if (assignmentNode.left.kind !== 79 /* PropertyAccessExpression */) {
+      if (assignmentNode.left.kind !== 80 /* PropertyAccessExpression */) {
         return void 0;
       }
       const propertyReceiver = assignmentNode.left.expression;
@@ -362,22 +363,23 @@ var AddPropertyAssignmentService = class {
       case 50 /* TypeDereferencedVariableGetterDeclaration */:
       case 51 /* TypeDereferencedVariableSetterDeclaration */:
       case 52 /* TypeMethodDeclaration */:
-      case 54 /* TypeVariableGetterDeclaration */:
-      case 55 /* TypeVariableSetterDeclaration */:
-      case 57 /* NestedMethodDeclaration */:
-      case 66 /* MethodBlockLiteral */:
-      case 75 /* MethodLiteral */:
+      case 55 /* TypeVariableGetterDeclaration */:
+      case 56 /* TypeVariableSetterDeclaration */:
+      case 58 /* NestedMethodDeclaration */:
+      case 67 /* MethodBlockLiteral */:
+      case 76 /* MethodLiteral */:
+      case 53 /* OperatorDeclaration */:
         return void 0;
-      case 99 /* RunStatement */:
+      case 100 /* RunStatement */:
         return this.ifShouldBeAssignedAtTheEndOfSubprogramThenBody(parent);
-      case 100 /* OnErrorClause */:
-      case 102 /* FinallyClause */:
-      case 107 /* ForStatement */:
-      case 108 /* IfStatement */:
-      case 110 /* ElseIfClause */:
-      case 114 /* LoopStatement */:
-      case 119 /* SwitchStatementCaseClause */:
-      case 120 /* WhileStatement */:
+      case 101 /* OnErrorClause */:
+      case 103 /* FinallyClause */:
+      case 108 /* ForStatement */:
+      case 109 /* IfStatement */:
+      case 111 /* ElseIfClause */:
+      case 115 /* LoopStatement */:
+      case 120 /* SwitchStatementCaseClause */:
+      case 121 /* WhileStatement */:
         return this.getContainingSubprogram(parent)?.body;
       default:
         Debug.never(parent);
@@ -408,11 +410,11 @@ function isSubprogramDeclaration(node) {
     case 50 /* TypeDereferencedVariableGetterDeclaration */:
     case 51 /* TypeDereferencedVariableSetterDeclaration */:
     case 52 /* TypeMethodDeclaration */:
-    case 54 /* TypeVariableGetterDeclaration */:
-    case 55 /* TypeVariableSetterDeclaration */:
-    case 57 /* NestedMethodDeclaration */:
-    case 66 /* MethodBlockLiteral */:
-    case 75 /* MethodLiteral */:
+    case 55 /* TypeVariableGetterDeclaration */:
+    case 56 /* TypeVariableSetterDeclaration */:
+    case 58 /* NestedMethodDeclaration */:
+    case 67 /* MethodBlockLiteral */:
+    case 76 /* MethodLiteral */:
       return true;
     default:
       Debug.typeIsAssignableTo();
@@ -1034,7 +1036,7 @@ var SyntaxFactory = class {
     return new Token(kind, value ?? "", [], flags, void 0);
   }
   static keyword(kind) {
-    return new Keyword(kind, [], true);
+    return new Keyword([], kind, true);
   }
   static createTypeParameterClause(typeParameters) {
     if (typeParameters === void 0) {
@@ -1383,6 +1385,20 @@ var SyntaxToCode = class _SyntaxToCode {
       this.writeDeclarationBody(node.body);
     }
   }
+  writeOperatorDeclaration(node) {
+    this.writeDeclarationTags(node.tagList);
+    this.writeDeclarationModifiers(node.modifierList);
+    this.writeKeyword(node.functionKeyword);
+    this.writeWhitespace();
+    this.writeToken(node.name);
+    this.writeParameterClause(node.parameterClause);
+    if (node.returnTypeAnnotation !== void 0) {
+      this.writeTypeAnnotation(node.returnTypeAnnotation, true);
+    }
+    if (node.body !== void 0) {
+      this.writeDeclarationBody(node.body);
+    }
+  }
   writeTypeConstructorDeclaration(node) {
     this.writeDeclarationTags(node.tagList);
     this.writeDeclarationModifiers(node.modifierList);
@@ -2012,22 +2028,23 @@ var SyntaxToCode = class _SyntaxToCode {
       [50 /* TypeDereferencedVariableGetterDeclaration */]: this.prototype.writeTypeDereferencedVariableGetterDeclaration,
       [51 /* TypeDereferencedVariableSetterDeclaration */]: this.prototype.writeTypeDereferencedVariableSetterDeclaration,
       [52 /* TypeMethodDeclaration */]: this.prototype.writeTypeMethodDeclaration,
-      [53 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
-      [54 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
-      [55 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
-      [94 /* StatementBlock */]: this.prototype.writeStatementBlock,
-      [133 /* QualifiedName */]: this.prototype.writeQualifiedName,
-      [140 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
-      [141 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
-      [142 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
-      [143 /* CallArgument */]: this.prototype.writeCallArgument,
-      [145 /* Tag */]: this.prototype.writeTag,
-      [147 /* Modifier */]: this.prototype.writeModifier,
-      [148 /* ParameterClause */]: this.prototype.writeParameterClause,
-      [149 /* ParameterList */]: this.prototype.writeParameterList,
-      [150 /* SetterParameterClause */]: this.prototype.writeSetterParameterClause,
-      [152 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
-      [154 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
+      [53 /* OperatorDeclaration */]: this.prototype.writeOperatorDeclaration,
+      [54 /* TypeVariableDeclaration */]: this.prototype.writeTypeVariableDeclaration,
+      [55 /* TypeVariableGetterDeclaration */]: this.prototype.writeTypeVariableGetterDeclaration,
+      [56 /* TypeVariableSetterDeclaration */]: this.prototype.writeTypeVariableSetterDeclaration,
+      [95 /* StatementBlock */]: this.prototype.writeStatementBlock,
+      [134 /* QualifiedName */]: this.prototype.writeQualifiedName,
+      [141 /* VariantDeclaration */]: this.prototype.writeVariantDeclaration,
+      [142 /* TypeParameterDeclaration */]: this.prototype.writeTypeParameterDeclaration,
+      [143 /* ParameterDeclaration */]: this.prototype.writeParameterDeclaration,
+      [144 /* CallArgument */]: this.prototype.writeCallArgument,
+      [146 /* Tag */]: this.prototype.writeTag,
+      [148 /* Modifier */]: this.prototype.writeModifier,
+      [149 /* ParameterClause */]: this.prototype.writeParameterClause,
+      [150 /* ParameterList */]: this.prototype.writeParameterList,
+      [151 /* SetterParameterClause */]: this.prototype.writeSetterParameterClause,
+      [153 /* TypeArgumentClause */]: this.prototype.writeTypeArgumentClause,
+      [155 /* TypeParameterClause */]: this.prototype.writeTypeParameterClause,
       [17 /* AnonymousMethodTypeDeclaration */]: this.prototype.writeAnonymousMethodTypeDeclaration,
       [18 /* AnonymousStructuredTypeDeclaration */]: this.prototype.writeAnonymousStructuredTypeDeclaration,
       [19 /* AnonymousVariantTypeDeclaration */]: this.prototype.writeAnonymousVariantTypeDeclaration,
@@ -2044,94 +2061,94 @@ var SyntaxToCode = class _SyntaxToCode {
       [42 /* ExtendedTypeClause */]: this.prototype.writeNodeDefault,
       [43 /* InvalidPackageMemberDeclaration */]: this.prototype.writeNodeDefault,
       [49 /* TypeIndexerParameterClause */]: this.prototype.writeNodeDefault,
-      [56 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
-      [57 /* NestedMethodDeclaration */]: this.prototype.writeNodeDefault,
-      [58 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [59 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [60 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
-      [61 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
-      [62 /* AssertionExpression */]: this.prototype.writeNodeDefault,
-      [63 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
-      [64 /* AsExpression */]: this.prototype.writeNodeDefault,
-      [65 /* BinaryExpression */]: this.prototype.writeNodeDefault,
-      [66 /* MethodBlockLiteral */]: this.prototype.writeNodeDefault,
-      [67 /* CallArgumentList */]: this.prototype.writeNodeDefault,
-      [68 /* CallExpression */]: this.prototype.writeNodeDefault,
-      [69 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
-      [70 /* IndexedAccessArgumentList */]: this.prototype.writeNodeDefault,
-      [71 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
-      [72 /* InvalidExpression */]: this.prototype.writeNodeDefault,
-      [73 /* IsExpression */]: this.prototype.writeNodeDefault,
-      [74 /* NotExpression */]: this.prototype.writeNodeDefault,
-      [75 /* MethodLiteral */]: this.prototype.writeNodeDefault,
-      [76 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
-      [77 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
-      [78 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
-      [79 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
-      [80 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
-      [81 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
-      [82 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
-      [83 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
-      [84 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
-      [85 /* TokenExpression */]: this.prototype.writeNodeDefault,
-      [86 /* KeywordExpression */]: this.prototype.writeNodeDefault,
-      [87 /* ObjectExpression */]: this.prototype.writeNodeDefault,
-      [88 /* BaseExpression */]: this.prototype.writeNodeDefault,
-      [89 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
-      [90 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
-      [91 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
-      [92 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
-      [93 /* StatementList */]: this.prototype.writeNodeDefault,
-      [95 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
-      [96 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
-      [97 /* DisposeStatement */]: this.prototype.writeNodeDefault,
-      [98 /* RunStatementClauseList */]: this.prototype.writeNodeDefault,
-      [99 /* RunStatement */]: this.prototype.writeNodeDefault,
-      [100 /* OnErrorClause */]: this.prototype.writeNodeDefault,
-      [101 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
-      [102 /* FinallyClause */]: this.prototype.writeNodeDefault,
-      [103 /* EmptyStatement */]: this.prototype.writeNodeDefault,
-      [104 /* ErrorStatement */]: this.prototype.writeNodeDefault,
-      [105 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
-      [106 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
-      [107 /* ForStatement */]: this.prototype.writeNodeDefault,
-      [108 /* IfStatement */]: this.prototype.writeNodeDefault,
-      [109 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
-      [110 /* ElseIfClause */]: this.prototype.writeNodeDefault,
-      [111 /* InvalidStatement */]: this.prototype.writeNodeDefault,
-      [112 /* NestedMethodDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [113 /* LocalVariableDeclarationStatement */]: this.prototype.writeNodeDefault,
-      [114 /* LoopStatement */]: this.prototype.writeNodeDefault,
-      [115 /* ReturnStatement */]: this.prototype.writeNodeDefault,
-      [116 /* CaseClauseList */]: this.prototype.writeNodeDefault,
-      [117 /* SwitchStatement */]: this.prototype.writeNodeDefault,
-      [118 /* MatchExpressionList */]: this.prototype.writeNodeDefault,
-      [119 /* SwitchStatementCaseClause */]: this.prototype.writeNodeDefault,
-      [120 /* WhileStatement */]: this.prototype.writeNodeDefault,
-      [121 /* YieldStatement */]: this.prototype.writeNodeDefault,
-      [122 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
-      [123 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
-      [124 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
-      [125 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
-      [126 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
-      [127 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
-      [128 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
-      [129 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
-      [130 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
-      [131 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
-      [132 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
-      [134 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
-      [135 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
-      [136 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
-      [137 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
-      [138 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [139 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
-      [144 /* TagList */]: this.prototype.writeNodeDefault,
-      [146 /* ModifierList */]: this.prototype.writeNodeDefault,
-      [151 /* SetterParameterDeclaration */]: this.prototype.writeNodeDefault,
-      [153 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
-      [155 /* TypeParameterList */]: this.prototype.writeNodeDefault,
-      [156 /* TypeAnnotation */]: this.prototype.writeNodeDefault
+      [57 /* InvalidTypeMemberDeclaration */]: this.prototype.writeNodeDefault,
+      [58 /* NestedMethodDeclaration */]: this.prototype.writeNodeDefault,
+      [59 /* LocalVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [60 /* EnumerationVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [61 /* ArrayLiteral */]: this.prototype.writeNodeDefault,
+      [62 /* ArrayLiteralElementList */]: this.prototype.writeNodeDefault,
+      [63 /* AssertionExpression */]: this.prototype.writeNodeDefault,
+      [64 /* AssumptionExpression */]: this.prototype.writeNodeDefault,
+      [65 /* AsExpression */]: this.prototype.writeNodeDefault,
+      [66 /* BinaryExpression */]: this.prototype.writeNodeDefault,
+      [67 /* MethodBlockLiteral */]: this.prototype.writeNodeDefault,
+      [68 /* CallArgumentList */]: this.prototype.writeNodeDefault,
+      [69 /* CallExpression */]: this.prototype.writeNodeDefault,
+      [70 /* AutotypeCallExpression */]: this.prototype.writeNodeDefault,
+      [71 /* IndexedAccessArgumentList */]: this.prototype.writeNodeDefault,
+      [72 /* IndexedAccessExpression */]: this.prototype.writeNodeDefault,
+      [73 /* InvalidExpression */]: this.prototype.writeNodeDefault,
+      [74 /* IsExpression */]: this.prototype.writeNodeDefault,
+      [75 /* NotExpression */]: this.prototype.writeNodeDefault,
+      [76 /* MethodLiteral */]: this.prototype.writeNodeDefault,
+      [77 /* ParenthesizedExpression */]: this.prototype.writeNodeDefault,
+      [78 /* WhenTernaryExpression */]: this.prototype.writeNodeDefault,
+      [79 /* PrefixUnaryExpression */]: this.prototype.writeNodeDefault,
+      [80 /* PropertyAccessExpression */]: this.prototype.writeNodeDefault,
+      [81 /* ReferenceExpression */]: this.prototype.writeNodeDefault,
+      [82 /* DereferenceExpression */]: this.prototype.writeNodeDefault,
+      [83 /* TextTemplateLiteral */]: this.prototype.writeNodeDefault,
+      [84 /* TextTemplateSpanList */]: this.prototype.writeNodeDefault,
+      [85 /* TextTemplateSpan */]: this.prototype.writeNodeDefault,
+      [86 /* TokenExpression */]: this.prototype.writeNodeDefault,
+      [87 /* KeywordExpression */]: this.prototype.writeNodeDefault,
+      [88 /* ObjectExpression */]: this.prototype.writeNodeDefault,
+      [89 /* BaseExpression */]: this.prototype.writeNodeDefault,
+      [90 /* IdentifierExpression */]: this.prototype.writeNodeDefault,
+      [91 /* GenericSpecializationExpression */]: this.prototype.writeNodeDefault,
+      [92 /* DefaultMatchExpression */]: this.prototype.writeNodeDefault,
+      [93 /* AssignmentStatement */]: this.prototype.writeNodeDefault,
+      [94 /* StatementList */]: this.prototype.writeNodeDefault,
+      [96 /* BreakLoopStatement */]: this.prototype.writeNodeDefault,
+      [97 /* ContinueLoopStatement */]: this.prototype.writeNodeDefault,
+      [98 /* DisposeStatement */]: this.prototype.writeNodeDefault,
+      [99 /* RunStatementClauseList */]: this.prototype.writeNodeDefault,
+      [100 /* RunStatement */]: this.prototype.writeNodeDefault,
+      [101 /* OnErrorClause */]: this.prototype.writeNodeDefault,
+      [102 /* ErrorVariableDeclaration */]: this.prototype.writeNodeDefault,
+      [103 /* FinallyClause */]: this.prototype.writeNodeDefault,
+      [104 /* EmptyStatement */]: this.prototype.writeNodeDefault,
+      [105 /* ErrorStatement */]: this.prototype.writeNodeDefault,
+      [106 /* ExpressionStatement */]: this.prototype.writeNodeDefault,
+      [107 /* EnumerationVariableList */]: this.prototype.writeNodeDefault,
+      [108 /* ForStatement */]: this.prototype.writeNodeDefault,
+      [109 /* IfStatement */]: this.prototype.writeNodeDefault,
+      [110 /* ElseIfClauseList */]: this.prototype.writeNodeDefault,
+      [111 /* ElseIfClause */]: this.prototype.writeNodeDefault,
+      [112 /* InvalidStatement */]: this.prototype.writeNodeDefault,
+      [113 /* NestedMethodDeclarationStatement */]: 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 /* SwitchStatementCaseClause */]: this.prototype.writeNodeDefault,
+      [121 /* WhileStatement */]: this.prototype.writeNodeDefault,
+      [122 /* YieldStatement */]: this.prototype.writeNodeDefault,
+      [123 /* TranslationParameterList */]: this.prototype.writeNodeDefault,
+      [124 /* TranslationParameterClause */]: this.prototype.writeTranslationParameterClause,
+      [125 /* ConstructorTranslation */]: this.prototype.writeConstructorTranslation,
+      [126 /* IndexerTranslationParameterClause */]: this.prototype.writeIndexerTranslationParameterClause,
+      [127 /* IndexerTranslation */]: this.prototype.writeIndexerTranslation,
+      [128 /* TranslationTypeParameterList */]: this.prototype.writeNodeDefault,
+      [129 /* TranslationTypeParameterClause */]: this.prototype.writeTranslationTypeParameterClause,
+      [130 /* PackageMethodTranslation */]: this.prototype.writePackageMethodTranslation,
+      [131 /* TypeMethodTranslation */]: this.prototype.writeTypeMethodTranslation,
+      [132 /* MethodTypeTranslation */]: this.prototype.writeMethodTypeTranslation,
+      [133 /* PackageImportTranslation */]: this.prototype.writePackageImportTranslation,
+      [135 /* PackageVariableTranslation */]: this.prototype.writePackageVariableTranslation,
+      [136 /* TypeVariableOrVariantTranslation */]: this.prototype.writeTypeVariableOrVariantTranslation,
+      [137 /* TypeMemberTranslationList */]: this.prototype.writeNodeDefault,
+      [138 /* TypeTranslation */]: this.prototype.writeTypeTranslation,
+      [139 /* TextLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [140 /* TextTemplateLiteralTranslation */]: this.prototype.writeNodeDefault,
+      [145 /* TagList */]: this.prototype.writeNodeDefault,
+      [147 /* ModifierList */]: this.prototype.writeNodeDefault,
+      [152 /* SetterParameterDeclaration */]: this.prototype.writeNodeDefault,
+      [154 /* TypeArgumentList */]: this.prototype.writeNodeDefault,
+      [156 /* TypeParameterList */]: this.prototype.writeNodeDefault,
+      [157 /* TypeAnnotation */]: this.prototype.writeNodeDefault
     };
     return writeFunctions;
   }
@@ -2317,7 +2334,7 @@ var TranslationsGenerationService = class {
       return void 0;
     }
     let result;
-    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 137 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
+    if (tokenOrKeyword.isToken(63 /* Identifier */) && tokenOrKeyword.parent.kind === 138 /* TypeTranslation */ && tokenOrKeyword.value === tokenOrKeyword.parent.sourceName) {
       const translationPackage = analyzer.getAnalyzedTranslationPackageIfTargetResolved(sourceFile.package);
       if (translationPackage !== void 0) {
         const generator = new TranslationsGenerator(
@@ -2363,16 +2380,19 @@ var TranslationsGenerationService = class {
       return false;
     }
     const generator = new TranslationsGenerator(analyzer, sourceFile, translationPackage, sourceFile.package.dialect);
-    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 137 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
+    return Query.from(tokenOrKeyword.parent.translationList.translationDeclarations).filter((t) => t.kind === 138 /* TypeTranslation */).mapAndFilter((t) => translationPackage.getTypeTranslationTarget(t).target).any((t) => generator.collectNotTranslatedTypeMembers(t).length > 0);
   }
 };
-var TranslationsGenerator = class {
+var TranslationsGenerator = class _TranslationsGenerator {
   constructor(_analyzer, _sourceFile, _translationPackage, _dialect) {
     this._analyzer = _analyzer;
     this._sourceFile = _sourceFile;
     this._translationPackage = _translationPackage;
     this._dialect = _dialect;
   }
+  static {
+    this._translationArrowRegExp = /-> /g;
+  }
   generateMissingPackageMemberAndTypeMemberTranslations(translationsDeclaration) {
     const result = new Array();
     const memberEntities = this.collectNotTranslatedPackageMembers();
@@ -2382,9 +2402,27 @@ var TranslationsGenerator = class {
         keywordsLocale: this._translationPackage.getTranslatedPackage().getLocale(),
         keywordsDialect: this._dialect,
         initialIndentation: this.detectIndentationForPackageMemberTranslations(translationsDeclaration),
-        indentationStep: this.detectIndentationStepForTypeMemberTranslations(translationsDeclaration)
+        indentationStep: this.detectIndentationStepForTypeMemberTranslations(translationsDeclaration),
+        newLine
       };
-      const memberTranslationsCode = Query.from(memberEntities).mapAndFilter((m) => this.createPackageMemberTranslationNode(m)).uniqueWithComparator(compareNodes).map((n) => new SyntaxToCode(n, syntaxToCodeOptions).convert()).join(`${newLine}${newLine}`);
+      const memberTranslationsCode = Query.from(memberEntities).mapAndFilter((m) => this.createPackageMemberTranslationNode(m)).uniqueWithComparator(compareNodes).map((n) => {
+        const code = new SyntaxToCode(n, syntaxToCodeOptions).convert();
+        if (n.kind === 138 /* TypeTranslation */) {
+          const startOffset = Math.max(code.indexOf(newLine), 0);
+          return this.addNewLineBeforeArrowsInTranslation(
+            code,
+            syntaxToCodeOptions.initialIndentation + syntaxToCodeOptions.indentationStep.repeat(2),
+            newLine,
+            startOffset
+          );
+        } else {
+          return this.addNewLineBeforeArrowsInTranslation(
+            code,
+            syntaxToCodeOptions.initialIndentation + syntaxToCodeOptions.indentationStep,
+            newLine
+          );
+        }
+      }).join(`${newLine}${newLine}`);
       const editRange = Range.empty(translationsDeclaration.openBraceToken.rangeWithoutTrivia.end);
       let editText = newLine + memberTranslationsCode;
       if (translationsDeclaration.translationList.translationDeclarations.count() > 0) {
@@ -2401,7 +2439,7 @@ var TranslationsGenerator = class {
   generateMissingTranslationsForPartiallyTranslatedTypes(translationsDeclaration) {
     const result = new Array();
     for (const translation of translationsDeclaration.translationList.translationDeclarations) {
-      if (translation.kind === 137 /* TypeTranslation */) {
+      if (translation.kind === 138 /* TypeTranslation */) {
         const edits = this.generateMissingTypeMemberTranslations(translation);
         if (edits !== void 0) {
           result.push(...edits);
@@ -2420,13 +2458,21 @@ var TranslationsGenerator = class {
       return void 0;
     }
     const newLine = this.detectNewLine();
-    const membersIndentation = this.detectIndentationForTypeMemberTranslations(typeTranslation);
     const syntaxToCodeOptions = {
       keywordsLocale: this._translationPackage.getTranslatedPackage().getLocale(),
       keywordsDialect: this._dialect,
-      initialIndentation: membersIndentation
+      initialIndentation: this.detectIndentationForTypeMemberTranslations(typeTranslation),
+      indentationStep: this.detectIndentationStepForTypeMemberTranslations(typeTranslation),
+      newLine
     };
-    const memberTranslationsCode = Query.from(memberEntities).mapAndFilter((m) => this.createTypeMemberTranslationNode(m)).uniqueWithComparator(compareNodes).map((n) => new SyntaxToCode(n, syntaxToCodeOptions).convert()).join(`${newLine}${newLine}`);
+    const memberTranslationsCode = Query.from(memberEntities).mapAndFilter((m) => this.createTypeMemberTranslationNode(m)).uniqueWithComparator(compareNodes).map((n) => {
+      const code = new SyntaxToCode(n, syntaxToCodeOptions).convert();
+      return this.addNewLineBeforeArrowsInTranslation(
+        code,
+        syntaxToCodeOptions.initialIndentation + syntaxToCodeOptions.indentationStep,
+        newLine
+      );
+    }).join(`${newLine}${newLine}`);
     let editText;
     let editRange;
     if (typeTranslation.openBraceToken !== void 0) {
@@ -2499,21 +2545,34 @@ var TranslationsGenerator = class {
     }
     return " ".repeat(indentationSize);
   }
-  detectIndentationStepForTypeMemberTranslations(translationsDeclaration) {
+  detectIndentationStepForTypeMemberTranslations(node) {
     let indentationStepSize;
-    for (const member of translationsDeclaration.translationList.translationDeclarations) {
-      if (member.kind === 137 /* TypeTranslation */) {
-        const typeMemberTranslation = member.memberList?.members.first();
-        if (typeMemberTranslation !== void 0) {
-          const typeTranslationIndentation = this._sourceFile.getPositionAt(member.typeKeyword.rangeWithoutTrivia.start).character;
-          const typeMemberTranslationIndentation = this._sourceFile.getPositionAt(typeMemberTranslation.rangeWithoutTrivia.start).character;
-          indentationStepSize = Math.max(typeMemberTranslationIndentation - typeTranslationIndentation, 0);
-          break;
+    if (node.kind === 138 /* TypeTranslation */) {
+      indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(node, this._sourceFile);
+    }
+    if (indentationStepSize === void 0) {
+      const translationsDeclarations = node.kind === 21 /* TranslationsDeclaration */ ? node : node.parent.parent;
+      for (const member of translationsDeclarations.translationList.translationDeclarations) {
+        if (member.kind === 138 /* TypeTranslation */) {
+          indentationStepSize = tryDetectIndentationStepSizeUsingTypeTranslation(member, this._sourceFile);
+          if (indentationStepSize !== void 0) {
+            break;
+          }
         }
       }
     }
     indentationStepSize ??= 2;
     return " ".repeat(indentationStepSize);
+    function tryDetectIndentationStepSizeUsingTypeTranslation(node2, sourceFile) {
+      let result;
+      const member = node2.memberList?.members.first();
+      if (member !== void 0) {
+        const typeTranslationIndentation = sourceFile.getPositionAt(node2.typeKeyword.rangeWithoutTrivia.start).character;
+        const typeMemberTranslationIndentation = sourceFile.getPositionAt(member.rangeWithoutTrivia.start).character;
+        result = Math.max(typeMemberTranslationIndentation - typeTranslationIndentation, 0);
+      }
+      return result;
+    }
   }
   detectIndentationForTypeMemberTranslations(typeTranslation) {
     let indentationSize;
@@ -2553,7 +2612,7 @@ var TranslationsGenerator = class {
         return this.createPackageTypeWithMembersTranslation(entity);
       case 11 /* MethodType */:
         return this.createPackageMethodTypeTranslation(entity);
-      case 19 /* TypeExtension */:
+      case 17 /* TypeExtension */:
         return void 0;
       default:
         Debug.never(entity);
@@ -2595,8 +2654,7 @@ var TranslationsGenerator = class {
         return this.createVariantTranslation(entity);
       case 8 /* DereferenceOperator */:
       case 10 /* Destructor */:
-      case 15 /* UnaryOperator */:
-      case 16 /* BinaryOperator */:
+      case 15 /* Operator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -2625,7 +2683,18 @@ var TranslationsGenerator = class {
     return SyntaxFactory.typeVariableOrVariantTranslation(name, name);
   }
   getNameText(name) {
-    return name.unescapedOriginal;
+    const flags = name.flags & ~16 /* ConflictResolvingParameterName */;
+    return name.getPreferredUnescapedOriginal(flags);
+  }
+  // TODO: Работать с синтаксическим деревом и использовать Trivia для добавления перевода строки. Требуется доработка
+  // SyntaxToCode и возможность добавлять Trivia в узлы, создаваемые через SyntaxFactory.
+  addNewLineBeforeArrowsInTranslation(code, indentationAfterNewLine, newLine, startOffset = 0) {
+    const replacementString = "->" + newLine + indentationAfterNewLine;
+    if (startOffset === 0) {
+      return code.replace(_TranslationsGenerator._translationArrowRegExp, replacementString);
+    } else {
+      return code.substring(0, startOffset) + code.substring(startOffset).replace(_TranslationsGenerator._translationArrowRegExp, replacementString);
+    }
   }
   detectNewLine() {
     return this._sourceFile.getSourceText().includes("\r\n") ? "\r\n" : "\n";
@@ -2672,7 +2741,7 @@ var CodeActionsService = class {
     }
     const result = new Array();
     const diagnosticCodeSet = new Set(diagnosticCodes);
-    if (diagnosticCodeSet.has(135 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(136 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
+    if (diagnosticCodeSet.has(142 /* TheFollowingDeclarationsAreNotTranslated0 */) || diagnosticCodeSet.has(143 /* TheFollowingDeclarationAreNotTranslated0And1More */)) {
       const data = { onlyTypeMembers: false };
       result.push(CodeAction.unresolved(
         "\u0421\u0433\u0435\u043D\u0435\u0440\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0435\u0434\u043E\u0441\u0442\u0430\u044E\u0449\u0438\u0435 \u043F\u0435\u0440\u0435\u0432\u043E\u0434\u044B.",
@@ -2789,13 +2858,13 @@ var ValueArgumentFactory = class _ValueArgumentFactory {
 var SignatureForNode = class _SignatureForNode {
   static getSignaturesForNode(analyzer, node) {
     switch (node.kind) {
-      case 68 /* CallExpression */:
+      case 69 /* CallExpression */:
         return _SignatureForNode.getSignaturesForCallExpression(analyzer, node);
-      case 69 /* AutotypeCallExpression */:
+      case 70 /* AutotypeCallExpression */:
         return _SignatureForNode.getSignaturesForAutotypeCallExpression(analyzer, node);
-      case 71 /* IndexedAccessExpression */:
+      case 72 /* IndexedAccessExpression */:
         return _SignatureForNode.getSignaturesForIndexedAccessExpression(analyzer, node);
-      case 145 /* Tag */:
+      case 146 /* Tag */:
         return _SignatureForNode.getSignaturesForTag(analyzer, node);
       default:
         Debug.never(node);
@@ -2935,7 +3004,7 @@ var SimplifiedOverloadResolver = class _SimplifiedOverloadResolver {
         result = false;
         break;
       }
-      if (argument.expression === void 0 || argument.expression.kind === 72 /* InvalidExpression */) {
+      if (argument.expression === void 0 || argument.expression.kind === 73 /* InvalidExpression */) {
         continue;
       }
       const targetParameterType = targetParameter.getType();
@@ -3149,17 +3218,20 @@ var CompletionService = class {
     );
     completionItemInfos = this.mergeOverloadedMethods(completionItemInfos);
     completionItemInfos = this.removeCompletionItemsWithDuplicateLabels(completionItemInfos);
-    const cacheId = this._cache.add(completionItemInfos);
+    const cacheId = this._cache.add(completionItemInfos, sourceFile).id;
     const result = this.convertCompletionItemInfos(completionItemInfos, cacheId);
     return result;
   }
   resolveCompletionItem(cacheId, indexInCache) {
-    const itemInfos = this._cache.get(cacheId);
-    if (itemInfos === void 0 || indexInCache >= itemInfos.length) {
+    const cacheEntry = this._cache.get(cacheId);
+    if (cacheEntry === void 0 || indexInCache >= cacheEntry.items.length) {
       return new ResolutionResult_notInCache();
     }
-    const completionItemInfo = itemInfos[indexInCache];
-    return new ResolutionResult_item(this.convertCompletionItemInfo(completionItemInfo, cacheId, indexInCache, true));
+    const completionItemInfo = cacheEntry.items[indexInCache];
+    return new ResolutionResult_item(
+      this.convertCompletionItemInfo(completionItemInfo, cacheId, indexInCache, true),
+      cacheEntry.sourceFile
+    );
   }
   createSemanticContextAtPosition(positionDescription) {
     switch (positionDescription.kind) {
@@ -3208,6 +3280,9 @@ var CompletionService = class {
     if (syntaxContext.isInComment || syntaxContext.isInStringOrChar) {
       return { kind: "none" };
     }
+    if (syntaxContext.isInQuotedIdentifier !== void 0 && (syntaxContext.isInQuotedIdentifier.parent.kind === 53 /* OperatorDeclaration */ || syntaxContext.isInQuotedIdentifier.parent.kind === 52 /* TypeMethodDeclaration */)) {
+      return new OperatorNameCompletionContext(syntaxContext.isInQuotedIdentifier);
+    }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
     if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 5 /* SinglePackageImportDirective */) {
       return new PackageImportCompletionContext([], void 0);
@@ -3223,7 +3298,7 @@ var CompletionService = class {
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || this.tokenOrKeywordIsPackageImportListChild(tokenOrKeyword)) {
       return new PackageImportCompletionContext([], void 0);
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 79 /* PropertyAccessExpression */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 80 /* PropertyAccessExpression */) {
       const propertyAccess = tokenOrKeyword.parent;
       {
         const info = this._analyzer.checkExpressionDenotesPackageNameSegment(propertyAccess.expression);
@@ -3264,7 +3339,7 @@ var CompletionService = class {
         typeExtensionLookup
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 133 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 134 /* QualifiedName */ && tokenOrKeyword.parent.parent.kind === 10 /* NamedTypeSpecifier */) {
       const namedTypeSpecifier = tokenOrKeyword.parent.parent;
       const resolutionResult = this._analyzer.resolveNamedTypeSpecifier(namedTypeSpecifier);
       const segmentIndex = Math.floor(
@@ -3272,7 +3347,7 @@ var CompletionService = class {
       );
       if (segmentIndex < resolutionResult.resolvedQualifiers.length) {
         let completionInIsOrAsExpressionInfo;
-        if (namedTypeSpecifier.parent.kind === 73 /* IsExpression */ || namedTypeSpecifier.parent.kind === 64 /* AsExpression */) {
+        if (namedTypeSpecifier.parent.kind === 74 /* IsExpression */ || namedTypeSpecifier.parent.kind === 65 /* AsExpression */) {
           completionInIsOrAsExpressionInfo = {
             expressionType: this._analyzer.type.ofExpression(namedTypeSpecifier.parent.expression)
           };
@@ -3308,7 +3383,7 @@ var CompletionService = class {
     }
     if (syntaxContext.isUnqualifiedTypeContext !== void 0) {
       let completionInIsOrAsExpressionInfo;
-      if (tokenOrKeyword.parent.kind === 73 /* IsExpression */ || tokenOrKeyword.parent.kind === 64 /* AsExpression */) {
+      if (tokenOrKeyword.parent.kind === 74 /* IsExpression */ || tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
         completionInIsOrAsExpressionInfo = {
           expressionType: this._analyzer.type.ofExpression(tokenOrKeyword.parent.expression)
         };
@@ -3358,17 +3433,17 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 132 /* PackageImportTranslation */) {
+    if (tokenOrKeyword.isKeyword(17 /* Import */) && tokenOrKeyword.parent.kind === 133 /* PackageImportTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* PackageImport */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(15 /* Type */) && (tokenOrKeyword.parent.kind === 137 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 131 /* MethodTypeTranslation */)) {
+    if (tokenOrKeyword.isKeyword(15 /* Type */) && (tokenOrKeyword.parent.kind === 138 /* TypeTranslation */ || tokenOrKeyword.parent.kind === 132 /* MethodTypeTranslation */)) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Type */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 129 /* PackageMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 130 /* PackageMethodTranslation */) {
       translationsDeclaration = tokenOrKeyword.parent.parent.parent;
       translationKind = 2 /* Method */;
       hasPrecedingKeyword = true;
@@ -3388,9 +3463,9 @@ var CompletionService = class {
         hasPrecedingKeyword
       );
     }
-    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 133 /* QualifiedName */) {
+    if (tokenOrKeyword.isToken(26 /* Dot */) && tokenOrKeyword.parent.kind === 134 /* QualifiedName */) {
       const qualifiedName = tokenOrKeyword.parent;
-      if (qualifiedName.parent.kind === 132 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
+      if (qualifiedName.parent.kind === 133 /* PackageImportTranslation */ && qualifiedName === qualifiedName.parent.sourceName) {
         const precedingSegmentNames = qualifiedName.qualifiers.takeWhile((s) => s.rangeStart < tokenOrKeyword.value.rangeStart).map((p) => this._analyzer.createNameFromIdentifier(p)).toArray();
         const sourceLocale = translationPackage.getTranslatedPackage().getLocale();
         return new PackageImportCompletionContext(precedingSegmentNames, { sourceLocale });
@@ -3415,12 +3490,12 @@ var CompletionService = class {
       translationKind = 0 /* Any */;
       hasPrecedingKeyword = false;
     }
-    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 130 /* TypeMethodTranslation */) {
+    if (tokenOrKeyword.isKeyword(11 /* Function */) && tokenOrKeyword.parent.kind === 131 /* TypeMethodTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 1 /* Method */;
       hasPrecedingKeyword = true;
     }
-    if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 124 /* ConstructorTranslation */) {
+    if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 125 /* ConstructorTranslation */) {
       typeTranslation = tokenOrKeyword.parent.parent.parent;
       translationKind = 3 /* Constructor */;
       hasPrecedingKeyword = true;
@@ -3450,17 +3525,17 @@ var CompletionService = class {
       let signatures;
       let valueArguments;
       switch (role.argumentList.parent.kind) {
-        case 68 /* CallExpression */:
+        case 69 /* CallExpression */:
           signatures = SignatureForNode.getSignaturesForCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(role.argumentList.parent);
           break;
-        case 69 /* AutotypeCallExpression */:
+        case 70 /* AutotypeCallExpression */:
           signatures = SignatureForNode.getSignaturesForAutotypeCallExpression(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(
             role.argumentList.parent
           );
           break;
-        case 145 /* Tag */:
+        case 146 /* Tag */:
           signatures = SignatureForNode.getSignaturesForTag(this._analyzer, role.argumentList.parent);
           valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(role.argumentList.parent);
           break;
@@ -3574,6 +3649,9 @@ var CompletionService = class {
       case "type-member-translation-list":
         result = this.getTypeAliasMemberListItemInfos(completionContext);
         break;
+      case "operator-name":
+        result = this.getOperatorNameItemInfos(completionContext);
+        break;
       case "none":
         result = [];
         break;
@@ -3647,7 +3725,7 @@ var CompletionService = class {
     if (syntaxContext.isUnqualifiedTypeContext?.allowsAnonymousTypes === true) {
       kinds.add(5 /* PlainObject */).add(4 /* Object */).add(6 /* Variant */).add(3 /* Aspect */).add(11 /* Function */).add(38 /* Async */);
     }
-    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(38 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 57 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 75 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* MethodTypeDeclarationBody */)) {
+    if (positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isKeyword(38 /* Async */) && (positionDescription.tokenOrKeyword.parent.kind === 58 /* NestedMethodDeclaration */ || positionDescription.tokenOrKeyword.parent.kind === 76 /* MethodLiteral */ || positionDescription.tokenOrKeyword.parent.kind === 29 /* MethodTypeDeclarationBody */)) {
       kinds.add(11 /* Function */);
     }
     return Query.from(kinds.values()).map(
@@ -3659,28 +3737,28 @@ var CompletionService = class {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 114 /* LoopStatement */;
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 115 /* LoopStatement */;
   }
   isModifierLevelContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 147 /* Modifier */;
+    return tokenOrKeyword.isToken(44 /* OpenParenthesis */) && tokenOrKeyword.parent.kind === 148 /* Modifier */;
   }
   isElseOrElseIfKeywordContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 108 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.thenBlock || tokenOrKeyword.parent.parent.kind === 110 /* ElseIfClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 109 /* IfStatement */ && tokenOrKeyword.parent === tokenOrKeyword.parent.parent.thenBlock || tokenOrKeyword.parent.parent.kind === 111 /* ElseIfClause */);
   }
   isRunStatementAccessorListContext(positionDescription) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 99 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 100 /* OnErrorClause */ || tokenOrKeyword.parent.parent.kind === 102 /* FinallyClause */);
+    return tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 100 /* RunStatement */ || tokenOrKeyword.parent.parent.kind === 101 /* OnErrorClause */ || tokenOrKeyword.parent.parent.kind === 103 /* FinallyClause */);
   }
   isTypeKindCompletionContext(positionDescription) {
     return positionDescription.kind === "after-token-or-keyword" && positionDescription.tokenOrKeyword.isToken(57 /* Equals */) && NodeTypeUtils.isPackageTypeDeclaration(positionDescription.tokenOrKeyword.parent);
@@ -3690,17 +3768,17 @@ var CompletionService = class {
       return false;
     }
     const token = positionDescription.tokenOrKeyword.value;
-    return token.parent.kind === 59 /* EnumerationVariableDeclaration */ && (token.parent.parent.elements.length > 0 && token.parent.parent.elements[token.parent.parent.elements.length - 1] === token.parent || token.parent.parent.elements.length > 1 && token.parent.parent.elements[token.parent.parent.elements.length - 2] === token.parent);
+    return token.parent.kind === 60 /* EnumerationVariableDeclaration */ && (token.parent.parent.elements.length > 0 && token.parent.parent.elements[token.parent.parent.elements.length - 1] === token.parent || token.parent.parent.elements.length > 1 && token.parent.parent.elements[token.parent.parent.elements.length - 2] === token.parent);
   }
   isCaseKeywordContext(positionDescription, syntaxContext) {
     if (positionDescription.kind !== "after-token-or-keyword") {
       return false;
     }
     const tokenOrKeyword = positionDescription.tokenOrKeyword;
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 119 /* SwitchStatementCaseClause */) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && tokenOrKeyword.parent.parent.kind === 120 /* SwitchStatementCaseClause */) {
       return true;
     }
-    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 117 /* SwitchStatement */) {
+    if (syntaxContext.precedingExpression !== void 0 && syntaxContext.precedingExpression.parent.kind === 118 /* SwitchStatement */) {
       return true;
     }
     return false;
@@ -3818,7 +3896,9 @@ var CompletionService = class {
         default:
           Debug.never(d.value);
       }
-    });
+    }).chain(
+      Query.from(lookup.getOperators()).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization))
+    );
   }
   getTypeCompletionItemInfos(ctx) {
     let result;
@@ -3989,7 +4069,7 @@ var CompletionService = class {
           default:
             Debug.never(m.value);
         }
-      }).toArray();
+      }).chain(Query.from(memberLookup.getOperators(ctx.hidingMatcher, ctx.typeExtensionsLookup)).filter((m) => m.value.isStatic() === ctx.isStaticAccess).map((o) => new OperatorCompletionItemInfo(this.completionItemInfoContext, o.value, o.localization))).toArray();
     }
   }
   getPackageImportCompletionItemInfos(ctx) {
@@ -4181,13 +4261,25 @@ var CompletionService = class {
     }
     return result.toArray();
   }
+  getOperatorNameItemInfos(ctx) {
+    let editRange;
+    const identifierRange = ctx.nameToken.rangeWithoutTrivia;
+    if (identifierRange.length > 2) {
+      editRange = new Range(identifierRange.start + 1, identifierRange.end - 1);
+    }
+    return operatorKinds.map((k) => {
+      const value = LocalizationHelper.localizeSyntacticalOperatorKind(k, this._locale, this._dialect);
+      return new OperatorNameCompletionItemInfo(this.completionItemInfoContext, value, editRange);
+    });
+  }
   mergeOverloadedMethods(completionItemInfos) {
     const result = new Array();
     const methodInfoByLabel = /* @__PURE__ */ new Map();
     for (const itemInfo of completionItemInfos) {
       switch (itemInfo.kind) {
         case "type-method":
-        case "method-entity": {
+        case "method-entity":
+        case "operator": {
           const label = itemInfo.getLabel();
           const methodInfo = methodInfoByLabel.get(label);
           if (methodInfo !== void 0) {
@@ -4241,6 +4333,7 @@ var CompletionService = class {
       info.getCompletionItemKind(),
       isForResolve ? info.getDetails() : void 0,
       info.getInsertText(),
+      info.getEditRange(),
       info.getSortText(),
       cacheId,
       indexInCache
@@ -4248,19 +4341,21 @@ var CompletionService = class {
   }
 };
 var CompletionItem = class {
-  constructor(label, kind, details, insertText, sortText, cacheId, indexInCache) {
+  constructor(label, kind, details, insertText, editRange, sortText, cacheId, indexInCache) {
     this.label = label;
     this.kind = kind;
     this.details = details;
     this.insertText = insertText;
+    this.editRange = editRange;
     this.sortText = sortText;
     this.cacheId = cacheId;
     this.indexInCache = indexInCache;
   }
 };
 var ResolutionResult_item = class {
-  constructor(value) {
+  constructor(value, sourceFile) {
     this.value = value;
+    this.sourceFile = sourceFile;
     this.kind = "item";
   }
 };
@@ -4317,10 +4412,10 @@ function getRightmostChildExcludingValidEmptyNodes(node) {
 }
 function isInvalidNode(node) {
   switch (node.kind) {
-    case 72 /* InvalidExpression */:
+    case 73 /* InvalidExpression */:
     case 43 /* InvalidPackageMemberDeclaration */:
-    case 111 /* InvalidStatement */:
-    case 56 /* InvalidTypeMemberDeclaration */:
+    case 112 /* InvalidStatement */:
+    case 57 /* InvalidTypeMemberDeclaration */:
     case 16 /* InvalidTypeSpecifier */:
       return true;
     case 0 /* Token */:
@@ -4370,6 +4465,12 @@ var TypeCompletionContext = class {
     this.kind = "type";
   }
 };
+var OperatorNameCompletionContext = class {
+  constructor(nameToken) {
+    this.nameToken = nameToken;
+    this.kind = "operator-name";
+  }
+};
 var ScopeTypeSearchLocation = class {
   constructor(lookup) {
     this.lookup = lookup;
@@ -4466,6 +4567,9 @@ var PackageNameSegmentCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var PackageAliasEntityCompletionItemInfo = class {
   constructor(ctx, packageAlias) {
@@ -4488,6 +4592,9 @@ var PackageAliasEntityCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var TypeVariableCompletionItemInfo = class {
   constructor(ctx, variable, name, isNameExplicitlyOriginal) {
@@ -4514,6 +4621,9 @@ var TypeVariableCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var TypeMethodCompletionItemInfo = class {
   constructor(ctx, method, name, isNameExplicitlyOriginal) {
@@ -4540,6 +4650,37 @@ var TypeMethodCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
+};
+var OperatorCompletionItemInfo = class {
+  constructor(ctx, operator, localization) {
+    this.ctx = ctx;
+    this.operator = operator;
+    this.localization = localization;
+    this.kind = "operator";
+  }
+  getLabel() {
+    return `'${this.ctx.displayService.displayOperatorKind(this.operator.getOperatorKind(), this.localization.locale)}'`;
+  }
+  getCompletionItemKind() {
+    return 4 /* Operator */;
+  }
+  getDetails() {
+    return this.ctx.displayService.displayOperatorDeclaration(
+      new OperatorDeclaration_typeMember(this.operator, this.localization)
+    );
+  }
+  getInsertText() {
+    return void 0;
+  }
+  getSortText() {
+    return void 0;
+  }
+  getEditRange() {
+    return void 0;
+  }
 };
 var VariantCompletionItemInfo = class {
   constructor(ctx, variant, name, isNameExplicitlyOriginal) {
@@ -4553,7 +4694,7 @@ var VariantCompletionItemInfo = class {
     return `${this.isNameExplicitlyOriginal ? "~" : ""}${this.ctx.getInsertTextForName(this.name.value)}`;
   }
   getCompletionItemKind() {
-    return 11 /* Variant */;
+    return 12 /* Variant */;
   }
   getDetails() {
     return this.ctx.displayService.displayVariantEntity(this.variant, this.name.localization);
@@ -4564,6 +4705,9 @@ var VariantCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var VariableEntityCompletionItemInfo = class {
   constructor(ctx, entity, name, isNameExplicitlyOriginal) {
@@ -4579,13 +4723,13 @@ var VariableEntityCompletionItemInfo = class {
   getCompletionItemKind() {
     switch (this.entity.subkind) {
       case "package":
-        return 6 /* PackageVariable */;
+        return 7 /* PackageVariable */;
       case "type":
         return 2 /* TypeVariable */;
       case "parameter":
-        return 9 /* ParameterVariable */;
+        return 10 /* ParameterVariable */;
       case "local":
-        return 8 /* LocalVariable */;
+        return 9 /* LocalVariable */;
       default:
         Debug.never(this.entity);
     }
@@ -4601,6 +4745,9 @@ var VariableEntityCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var MethodEntityCompletionItemInfo = class {
   constructor(ctx, entity, name, isNameExplicitlyOriginal) {
@@ -4616,11 +4763,11 @@ var MethodEntityCompletionItemInfo = class {
   getCompletionItemKind() {
     switch (this.entity.subkind) {
       case "package":
-        return 7 /* PackageMethod */;
+        return 8 /* PackageMethod */;
       case "type":
         return 3 /* TypeMethod */;
       case "nested":
-        return 10 /* NestedMethod */;
+        return 11 /* NestedMethod */;
       default:
         Debug.never(this.entity);
     }
@@ -4636,6 +4783,9 @@ var MethodEntityCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var NamedTypeCompletionItemInfo = class {
   constructor(ctx, entity, name, isNameExplicitlyOriginal, prefix = "", sortText) {
@@ -4653,23 +4803,23 @@ var NamedTypeCompletionItemInfo = class {
   getCompletionItemKind() {
     switch (this.entity.kind) {
       case 2 /* VariantType */:
-        return 15 /* VariantType */;
+        return 16 /* VariantType */;
       case 6 /* TypeParameter */:
-        return 16 /* TypeParameter */;
+        return 17 /* TypeParameter */;
       case 11 /* MethodType */:
-        return 17 /* MethodType */;
+        return 18 /* MethodType */;
       case 12 /* StructuredType */:
         if (this.entity.isRefObject()) {
-          return 12 /* RefObjectType */;
+          return 13 /* RefObjectType */;
         } else if (this.entity.isPlainObject()) {
-          return 13 /* PlainObjectType */;
+          return 14 /* PlainObjectType */;
         } else if (this.entity.isAspect()) {
-          return 14 /* AspectType */;
+          return 15 /* AspectType */;
         } else {
-          return 19 /* InvalidType */;
+          return 20 /* InvalidType */;
         }
       case 14 /* AliasType */:
-        return 18 /* AliasType */;
+        return 19 /* AliasType */;
       default:
         Debug.never(this.entity);
     }
@@ -4683,6 +4833,9 @@ var NamedTypeCompletionItemInfo = class {
   getSortText() {
     return this.sortText;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var KeywordCompletionItemInfo = class {
   constructor(ctx, keywordKind, value) {
@@ -4695,7 +4848,7 @@ var KeywordCompletionItemInfo = class {
     return this.value;
   }
   getCompletionItemKind() {
-    return 20 /* Keyword */;
+    return 21 /* Keyword */;
   }
   getDetails() {
     return void 0;
@@ -4706,6 +4859,9 @@ var KeywordCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var MergedOverloadedMethodCompletionItemInfo = class {
   constructor(ctx, firstOverloadInfo, overloadCount) {
@@ -4732,6 +4888,9 @@ var MergedOverloadedMethodCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var TargetSignatureValueParameterCompletionItemInfo = class {
   constructor(ctx, parameter) {
@@ -4743,7 +4902,7 @@ var TargetSignatureValueParameterCompletionItemInfo = class {
     return `${this.ctx.getInsertTextForName(this.parameter.getName())} =`;
   }
   getCompletionItemKind() {
-    return 21 /* TargetSignatureParameter */;
+    return 22 /* TargetSignatureParameter */;
   }
   getDetails() {
     return this.ctx.displayService.displayValueParameterDeclaration(
@@ -4760,6 +4919,9 @@ var TargetSignatureValueParameterCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var AliasesSourceVariableCompletionItemInfo = class {
   constructor(ctx, variable, displayService) {
@@ -4774,13 +4936,13 @@ var AliasesSourceVariableCompletionItemInfo = class {
   getCompletionItemKind() {
     switch (this.variable.subkind) {
       case "package":
-        return 6 /* PackageVariable */;
+        return 7 /* PackageVariable */;
       case "type":
         return 2 /* TypeVariable */;
       case "parameter":
-        return 6 /* PackageVariable */;
+        return 7 /* PackageVariable */;
       case "local":
-        return 8 /* LocalVariable */;
+        return 9 /* LocalVariable */;
       default:
         Debug.never(this.variable);
     }
@@ -4796,6 +4958,9 @@ var AliasesSourceVariableCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var AliasesSourceMethodCompletionItemInfo = class {
   constructor(ctx, method, includeMethodKeyword, displayService) {
@@ -4811,11 +4976,11 @@ var AliasesSourceMethodCompletionItemInfo = class {
   getCompletionItemKind() {
     switch (this.method.subkind) {
       case "package":
-        return 7 /* PackageMethod */;
+        return 8 /* PackageMethod */;
       case "type":
         return 3 /* TypeMethod */;
       case "nested":
-        return 10 /* NestedMethod */;
+        return 11 /* NestedMethod */;
       default:
         Debug.never(this.method);
     }
@@ -4836,6 +5001,9 @@ var AliasesSourceMethodCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var AliasesSourcePackageTypeCompletionItemInfo = class {
   constructor(ctx, typeEntity, includeTypeKeyword, displayService) {
@@ -4851,21 +5019,21 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
   getCompletionItemKind() {
     switch (this.typeEntity.kind) {
       case 2 /* VariantType */:
-        return 15 /* VariantType */;
+        return 16 /* VariantType */;
       case 11 /* MethodType */:
-        return 17 /* MethodType */;
+        return 18 /* MethodType */;
       case 12 /* StructuredType */: {
         if (this.typeEntity.isRefObject()) {
-          return 12 /* RefObjectType */;
+          return 13 /* RefObjectType */;
         } else if (this.typeEntity.isPlainObject()) {
-          return 13 /* PlainObjectType */;
+          return 14 /* PlainObjectType */;
         } else if (this.typeEntity.isAspect()) {
-          return 14 /* AspectType */;
+          return 15 /* AspectType */;
         }
-        return 19 /* InvalidType */;
+        return 20 /* InvalidType */;
       }
       case 14 /* AliasType */:
-        return 18 /* AliasType */;
+        return 19 /* AliasType */;
     }
   }
   getDetails() {
@@ -4904,6 +5072,9 @@ var AliasesSourcePackageTypeCompletionItemInfo = class {
         Debug.never(this.typeEntity);
     }
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var AliasesSourceTypeIndexerCompletionItemInfo = class {
   constructor(ctx, indexer, displayService) {
@@ -4924,7 +5095,7 @@ var AliasesSourceTypeIndexerCompletionItemInfo = class {
     return this.label;
   }
   getCompletionItemKind() {
-    return 4 /* TypeIndexer */;
+    return 5 /* TypeIndexer */;
   }
   getDetails() {
     return this.label;
@@ -4936,6 +5107,9 @@ var AliasesSourceTypeIndexerCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
 };
 var AliasesSourceTypeConstructorCompletionItemInfo = class {
   constructor(ctx, constructor_, includeOnCreateKeyword, displayService) {
@@ -4961,7 +5135,7 @@ var AliasesSourceTypeConstructorCompletionItemInfo = class {
     return this.label;
   }
   getCompletionItemKind() {
-    return 5 /* TypeConstructor */;
+    return 6 /* TypeConstructor */;
   }
   getDetails() {
     return this.label;
@@ -4974,11 +5148,41 @@ var AliasesSourceTypeConstructorCompletionItemInfo = class {
   getSortText() {
     return void 0;
   }
+  getEditRange() {
+    return void 0;
+  }
+};
+var OperatorNameCompletionItemInfo = class {
+  constructor(ctx, value, editRange) {
+    this.ctx = ctx;
+    this.value = value;
+    this.editRange = editRange;
+    this.kind = "operator-name";
+  }
+  getLabel() {
+    return this.value;
+  }
+  getCompletionItemKind() {
+    return 23 /* OperatorName */;
+  }
+  getDetails() {
+    return void 0;
+  }
+  getInsertText() {
+    return void 0;
+  }
+  getSortText() {
+    return void 0;
+  }
+  getEditRange() {
+    return this.editRange;
+  }
 };
 var SyntaxContext = class {
-  constructor(isInComment, isInStringOrChar, isPackageMemberDeclarationListContext, isTypeMemberDeclarationListContext, isStatementContext, isExpressionContext, precedingExpression, isUnqualifiedTypeContext, isTopLevelTranslationListContext, isTypeMemberTranslationListContext) {
+  constructor(isInComment, isInStringOrChar, isInQuotedIdentifier, isPackageMemberDeclarationListContext, isTypeMemberDeclarationListContext, isStatementContext, isExpressionContext, precedingExpression, isUnqualifiedTypeContext, isTopLevelTranslationListContext, isTypeMemberTranslationListContext) {
     this.isInComment = isInComment;
     this.isInStringOrChar = isInStringOrChar;
+    this.isInQuotedIdentifier = isInQuotedIdentifier;
     this.isPackageMemberDeclarationListContext = isPackageMemberDeclarationListContext;
     this.isTypeMemberDeclarationListContext = isTypeMemberDeclarationListContext;
     this.isStatementContext = isStatementContext;
@@ -5031,6 +5235,7 @@ var SyntaxContextFactory = class {
   static fromPositionDescription(sourceFile, positionDescription) {
     const isInComment = this.isInComment(sourceFile, positionDescription.getOffset());
     const isInStringOrChar = this.isInStringOrChar(sourceFile, positionDescription.getOffset());
+    const isInQuotedIdentifier = this.isInQuotedIdentifier(sourceFile, positionDescription.getOffset());
     let isPackageMemberDeclarationListContext = false;
     if (positionDescription.kind === "at-file-start") {
       isPackageMemberDeclarationListContext = true;
@@ -5067,6 +5272,7 @@ var SyntaxContextFactory = class {
     return new SyntaxContext(
       isInComment,
       isInStringOrChar,
+      isInQuotedIdentifier,
       isPackageMemberDeclarationListContext,
       isTypeMemberDeclarationListContext,
       isStatementContext,
@@ -5079,11 +5285,11 @@ var SyntaxContextFactory = class {
   }
   static isExpressionOrStatementContext(tokenOrKeyword) {
     if (tokenOrKeyword.isToken(57 /* Equals */)) {
-      if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+      if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 58 /* LocalVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 59 /* LocalVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
@@ -5091,40 +5297,40 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 53 /* TypeVariableDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 54 /* TypeVariableDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.initializer);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 142 /* ParameterDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 143 /* ParameterDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.defaultValue);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 143 /* CallArgument */) {
+      if (tokenOrKeyword.parent.kind === 144 /* CallArgument */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 140 /* VariantDeclaration */) {
+      if (tokenOrKeyword.parent.kind === 141 /* VariantDeclaration */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.value);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 78 /* PrefixUnaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 79 /* PrefixUnaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.operand);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.parent.kind === 65 /* BinaryExpression */) {
+    if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.right);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 82 /* TextTemplateLiteral */) {
+    if (tokenOrKeyword.isToken(7 /* TextTemplateHead */) && tokenOrKeyword.parent.kind === 83 /* TextTemplateLiteral */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.spanList.spans.at(0)?.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 84 /* TextTemplateSpan */) {
+    if (tokenOrKeyword.isToken(8 /* TextTemplatePart */) && tokenOrKeyword.parent.kind === 85 /* TextTemplateSpan */) {
       let expressionForTargetType;
       const spanList = tokenOrKeyword.parent.parent;
       const spanIndex = spanList.spans.indexOf(tokenOrKeyword.parent);
@@ -5136,34 +5342,34 @@ var SyntaxContextFactory = class {
         isStatementContext: false
       };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 94 /* StatementBlock */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 95 /* StatementBlock */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 93 /* StatementList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 94 /* StatementList */) {
       return { isExpressionContext: { expressionRole: new ExpressionRole_other(void 0) }, isStatementContext: true };
     }
     if (tokenOrKeyword.isToken(44 /* OpenParenthesis */)) {
-      if (tokenOrKeyword.parent.kind === 76 /* ParenthesizedExpression */) {
+      if (tokenOrKeyword.parent.kind === 77 /* ParenthesizedExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 74 /* NotExpression */) {
+      if (tokenOrKeyword.parent.kind === 75 /* NotExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 80 /* ReferenceExpression */) {
+      if (tokenOrKeyword.parent.kind === 81 /* ReferenceExpression */) {
         const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 68 /* CallExpression */) {
+      if (tokenOrKeyword.parent.kind === 69 /* CallExpression */) {
         const expressionRole = new ExpressionRole_callArgument(tokenOrKeyword.parent.callArgumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 69 /* AutotypeCallExpression */) {
+      if (tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
         const expressionRole = new ExpressionRole_callArgument(tokenOrKeyword.parent.callArgumentList, 0);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 145 /* Tag */) {
+      if (tokenOrKeyword.parent.kind === 146 /* Tag */) {
         const callArgumentList = tokenOrKeyword.parent.callArgumentList;
         if (callArgumentList !== void 0) {
           const expressionRole = new ExpressionRole_callArgument(callArgumentList, 0);
@@ -5171,16 +5377,16 @@ var SyntaxContextFactory = class {
         }
       }
     }
-    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 72 /* IndexedAccessExpression */) {
       const expressionRole = new ExpressionRole_indexedAccessArgument(tokenOrKeyword.parent.argumentsList, 0);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 60 /* ArrayLiteral */) {
+    if (tokenOrKeyword.isToken(45 /* OpenSquareBracket */) && tokenOrKeyword.parent.kind === 61 /* ArrayLiteral */) {
       const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
     if (tokenOrKeyword.isToken(24 /* Comma */)) {
-      if (tokenOrKeyword.parent.kind === 67 /* CallArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 68 /* CallArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5194,7 +5400,7 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_callArgument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 70 /* IndexedAccessArgumentList */) {
+      if (tokenOrKeyword.parent.kind === 71 /* IndexedAccessArgumentList */) {
         const argumentList = tokenOrKeyword.parent;
         let index = 0;
         for (const element of argumentList.elements) {
@@ -5208,56 +5414,56 @@ var SyntaxContextFactory = class {
         const expressionRole = new ExpressionRole_indexedAccessArgument(argumentList, index);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 118 /* MatchExpressionList */) {
+      if (tokenOrKeyword.parent.kind === 119 /* MatchExpressionList */) {
         const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
-      if (tokenOrKeyword.parent.kind === 61 /* ArrayLiteralElementList */) {
+      if (tokenOrKeyword.parent.kind === 62 /* ArrayLiteralElementList */) {
         const expressionRole = new ExpressionRole_arrayElement(tokenOrKeyword.parent.parent);
         return { isExpressionContext: { expressionRole }, isStatementContext: false };
       }
     }
-    if (tokenOrKeyword.isKeyword(43 /* Case */) && tokenOrKeyword.parent.kind === 119 /* SwitchStatementCaseClause */) {
+    if (tokenOrKeyword.isKeyword(43 /* Case */) && tokenOrKeyword.parent.kind === 120 /* SwitchStatementCaseClause */) {
       const expressionRole = new ExpressionRole_matchListElement(tokenOrKeyword.parent.parent.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(14 /* Return */) && tokenOrKeyword.parent.kind === 115 /* ReturnStatement */) {
+    if (tokenOrKeyword.isKeyword(14 /* Return */) && tokenOrKeyword.parent.kind === 116 /* ReturnStatement */) {
       const expressionRole = new ExpressionRole_returnedValue(tokenOrKeyword.parent);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(42 /* Switch */) && tokenOrKeyword.parent.kind === 117 /* SwitchStatement */) {
+    if (tokenOrKeyword.isKeyword(42 /* Switch */) && tokenOrKeyword.parent.kind === 118 /* SwitchStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(12 /* If */) && tokenOrKeyword.parent.kind === 108 /* IfStatement */) {
+    if (tokenOrKeyword.isKeyword(12 /* If */) && tokenOrKeyword.parent.kind === 109 /* IfStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(10 /* ElseIf */) && tokenOrKeyword.parent.kind === 110 /* ElseIfClause */) {
+    if (tokenOrKeyword.isKeyword(10 /* ElseIf */) && tokenOrKeyword.parent.kind === 111 /* ElseIfClause */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(8 /* From */) && tokenOrKeyword.parent.kind === 107 /* ForStatement */) {
+    if (tokenOrKeyword.isKeyword(8 /* From */) && tokenOrKeyword.parent.kind === 108 /* ForStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.enumeratedExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(23 /* While */) && tokenOrKeyword.parent.kind === 120 /* WhileStatement */) {
+    if (tokenOrKeyword.isKeyword(23 /* While */) && tokenOrKeyword.parent.kind === 121 /* WhileStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(25 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 114 /* LoopStatement */) {
+    if (tokenOrKeyword.isKeyword(25 /* RepeatWhile */) && tokenOrKeyword.parent.kind === 115 /* LoopStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(26 /* Yield */) && tokenOrKeyword.parent.kind === 121 /* YieldStatement */) {
+    if (tokenOrKeyword.isKeyword(26 /* Yield */) && tokenOrKeyword.parent.kind === 122 /* YieldStatement */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.expression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isKeyword(27 /* When */) && tokenOrKeyword.parent.kind === 77 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isKeyword(27 /* When */) && tokenOrKeyword.parent.kind === 78 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.condition);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 77 /* WhenTernaryExpression */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 78 /* WhenTernaryExpression */) {
       const expressionRole = new ExpressionRole_other(tokenOrKeyword.parent.secondExpression);
       return { isExpressionContext: { expressionRole }, isStatementContext: false };
     }
@@ -5279,7 +5485,7 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 32 /* TypeMemberDeclarationBlock */ && (tokenOrKeyword.parent.parent.kind === 40 /* TypeExtensionDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 33 /* PackageStructuredTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 38 /* PackageVariantTypeDeclaration */ || tokenOrKeyword.parent.parent.parent.kind === 22 /* PackageAliasTypeDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 94 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageMethodDeclaration */))) {
+    if (tokenOrKeyword.isToken(20 /* CloseBrace */) && (tokenOrKeyword.parent.kind === 21 /* TranslationsDeclaration */ || tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */ || tokenOrKeyword.parent.kind === 6 /* PackageGroupImportDirective */ || tokenOrKeyword.parent.kind === 95 /* StatementBlock */ && (tokenOrKeyword.parent.parent.kind === 25 /* PackageConstructorDeclaration */ || tokenOrKeyword.parent.parent.kind === 26 /* PackageEntryPointDeclaration */ || tokenOrKeyword.parent.parent.kind === 27 /* PackageMethodDeclaration */))) {
       return true;
     }
     if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 24 /* PackageMemberGroupDeclaration */) {
@@ -5291,10 +5497,10 @@ var SyntaxContextFactory = class {
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 37 /* PackageVariableSetterDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 147 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 148 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 147 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 148 /* Modifier */ && NodeTypeUtils.isPackageMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5309,19 +5515,19 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isToken(20 /* CloseBrace */) && tokenOrKeyword.parent.kind === 44 /* TypeMemberGroupDeclaration */) {
       return true;
     }
-    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* TypeVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* TypeVariableGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* TypeVariableSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 47 /* TypeIndexedGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 48 /* TypeIndexedSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
+    if (SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 54 /* TypeVariableDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 55 /* TypeVariableGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 56 /* TypeVariableSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 47 /* TypeIndexedGetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 48 /* TypeIndexedSetterDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
       50 /* TypeDereferencedVariableGetterDeclaration */
     ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(
       tokenOrKeyword,
       51 /* TypeDereferencedVariableSetterDeclaration */
-    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 140 /* VariantDeclaration */)) {
+    ) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 52 /* TypeMethodDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 53 /* OperatorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 45 /* TypeConstructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 46 /* TypeDestructorDeclaration */) || SyntaxContextUtils.tokenOrKeywordIsValidEndOfNode(tokenOrKeyword, 141 /* VariantDeclaration */)) {
       return true;
     }
-    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 147 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isKeyword() && tokenOrKeyword.parent.kind === 148 /* Modifier */ && tokenOrKeyword.value === tokenOrKeyword.parent.value && tokenOrKeyword.parent.openParenthesisToken === void 0 && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
-    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 147 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
+    if (tokenOrKeyword.isToken(21 /* CloseParenthesis */) && tokenOrKeyword.parent.kind === 148 /* Modifier */ && NodeTypeUtils.isTypeMemberDeclaration(tokenOrKeyword.parent.parent.parent)) {
       return true;
     }
     return false;
@@ -5346,8 +5552,19 @@ var SyntaxContextFactory = class {
     }
     return token !== void 0 && offset > token.rangeWithoutTrivia.start && (token.tokenKind === 6 /* TextLiteral */ || token.tokenKind === 5 /* CharLiteral */ || token.tokenKind === 7 /* TextTemplateHead */ || token.tokenKind === 8 /* TextTemplatePart */ || token.tokenKind === 9 /* TextTemplateTail */);
   }
+  static isInQuotedIdentifier(sourceFile, offset) {
+    let result;
+    const tokenArOffset = getTokenAtOffset(sourceFile.getSyntaxNode(), offset, false);
+    if (tokenArOffset !== void 0 && isIdentifier(tokenArOffset)) {
+      const range = tokenArOffset.rangeWithoutTrivia;
+      if (offset >= range.start + 1 && offset < range.end) {
+        result = tokenArOffset;
+      }
+    }
+    return result;
+  }
   static isUnqualifiedTypeContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 156 /* TypeAnnotation */) {
+    if (tokenOrKeyword.isToken(23 /* Colon */) && tokenOrKeyword.parent.kind === 157 /* TypeAnnotation */) {
       return { allowsAnonymousTypes: true };
     }
     if ((tokenOrKeyword.isKeyword(4 /* Object */) || tokenOrKeyword.isKeyword(5 /* PlainObject */) || tokenOrKeyword.isKeyword(3 /* Aspect */)) && tokenOrKeyword.parent.kind === 34 /* StructuredTypeDeclarationBody */) {
@@ -5356,25 +5573,25 @@ var SyntaxContextFactory = class {
     if (tokenOrKeyword.isKeyword(15 /* Type */) && (NodeTypeUtils.isPackageTypeDeclaration(tokenOrKeyword.parent) || tokenOrKeyword.parent.kind === 40 /* TypeExtensionDeclaration */)) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 152 /* TypeArgumentClause */) {
+    if (tokenOrKeyword.isToken(36 /* LessThan */) && tokenOrKeyword.parent.kind === 153 /* TypeArgumentClause */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */)) {
-      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 153 /* TypeArgumentList */ };
+    if (tokenOrKeyword.isToken(24 /* Comma */) && (tokenOrKeyword.parent.kind === 30 /* BaseTypeList */ || tokenOrKeyword.parent.kind === 154 /* TypeArgumentList */)) {
+      return { allowsAnonymousTypes: tokenOrKeyword.parent.kind === 154 /* TypeArgumentList */ };
     }
-    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 145 /* Tag */) {
+    if (tokenOrKeyword.isToken(35 /* HashSign */) && tokenOrKeyword.parent.kind === 146 /* Tag */) {
       return { allowsAnonymousTypes: false };
     }
-    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 141 /* TypeParameterDeclaration */) {
+    if ((tokenOrKeyword.isToken(23 /* Colon */) || tokenOrKeyword.isToken(57 /* Equals */)) && tokenOrKeyword.parent.kind === 142 /* TypeParameterDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
     if (tokenOrKeyword.isToken(57 /* Equals */) && tokenOrKeyword.parent.kind === 22 /* PackageAliasTypeDeclaration */) {
       return { allowsAnonymousTypes: false };
     }
-    if (tokenOrKeyword.isKeyword(13 /* Is */) && tokenOrKeyword.parent.kind === 73 /* IsExpression */) {
+    if (tokenOrKeyword.isKeyword(13 /* Is */) && tokenOrKeyword.parent.kind === 74 /* IsExpression */) {
       return { allowsAnonymousTypes: true };
     }
-    if (tokenOrKeyword.isKeyword(40 /* As */) && tokenOrKeyword.parent.kind === 64 /* AsExpression */) {
+    if (tokenOrKeyword.isKeyword(40 /* As */) && tokenOrKeyword.parent.kind === 65 /* AsExpression */) {
       return { allowsAnonymousTypes: true };
     }
     if (tokenOrKeyword.isToken(17 /* Bar */) && tokenOrKeyword.parent.kind === 12 /* UnionTypeSpecifierTypeList */) {
@@ -5391,32 +5608,32 @@ var SyntaxContextFactory = class {
     }
     const packageImport = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      132 /* PackageImportTranslation */
+      133 /* PackageImportTranslation */
     );
     if (packageImport !== void 0) {
       return { translationsDeclaration: packageImport.parent.parent };
     }
-    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 137 /* TypeTranslation */);
+    const type = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 138 /* TypeTranslation */);
     if (type !== void 0) {
       return { translationsDeclaration: type.parent.parent };
     }
     const methodType = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      131 /* MethodTypeTranslation */
+      132 /* MethodTypeTranslation */
     );
     if (methodType !== void 0) {
       return { translationsDeclaration: methodType.parent.parent };
     }
     const variable = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      134 /* PackageVariableTranslation */
+      135 /* PackageVariableTranslation */
     );
     if (variable !== void 0) {
       return { translationsDeclaration: variable.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      129 /* PackageMethodTranslation */
+      130 /* PackageMethodTranslation */
     );
     if (method !== void 0) {
       return { translationsDeclaration: method.parent.parent };
@@ -5424,33 +5641,33 @@ var SyntaxContextFactory = class {
     return void 0;
   }
   static isTypeMemberTranslationListContext(tokenOrKeyword) {
-    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 136 /* TypeMemberTranslationList */) {
+    if (tokenOrKeyword.isToken(51 /* Semicolon */) && tokenOrKeyword.parent.kind === 137 /* TypeMemberTranslationList */) {
       return { typeTranslation: tokenOrKeyword.parent.parent };
     }
-    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 137 /* TypeTranslation */) {
+    if (tokenOrKeyword.isToken(43 /* OpenBrace */) && tokenOrKeyword.parent.kind === 138 /* TypeTranslation */) {
       return { typeTranslation: tokenOrKeyword.parent };
     }
-    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 126 /* IndexerTranslation */);
+    const indexer = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(tokenOrKeyword, 127 /* IndexerTranslation */);
     if (indexer !== void 0) {
       return { typeTranslation: indexer.parent.parent };
     }
     const constructor = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      124 /* ConstructorTranslation */
+      125 /* ConstructorTranslation */
     );
     if (constructor !== void 0) {
       return { typeTranslation: constructor.parent.parent };
     }
     const variableOrVariant = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      135 /* TypeVariableOrVariantTranslation */
+      136 /* TypeVariableOrVariantTranslation */
     );
     if (variableOrVariant !== void 0) {
       return { typeTranslation: variableOrVariant.parent.parent };
     }
     const method = SyntaxContextUtils.ifTokenIsValidEndOfNodeThenNode(
       tokenOrKeyword,
-      130 /* TypeMethodTranslation */
+      131 /* TypeMethodTranslation */
     );
     if (method !== void 0) {
       return { typeTranslation: method.parent.parent };
@@ -5543,13 +5760,13 @@ var CompletionItemInfoCache = class {
   constructor() {
     this._id = 0;
   }
-  add(list) {
-    this._entry = { cacheId: this.getNextId(), value: list };
-    return this._entry.cacheId;
+  add(list, sourceFile) {
+    this._entry = { id: this.getNextId(), items: list, sourceFile };
+    return this._entry;
   }
   get(id) {
-    if (id === this._entry?.cacheId) {
-      return this._entry.value;
+    if (id === this._entry?.id) {
+      return this._entry;
     }
     return void 0;
   }
@@ -5563,31 +5780,31 @@ var NodeSemanticInfoService = class {
   static ofTokenOrKeyword(analyzer, tokenOrKeyword, options6) {
     if (isIdentifier(tokenOrKeyword.value)) {
       return this.ofNonKeywordIdentifier(analyzer, tokenOrKeyword.value, options6);
-    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 69 /* AutotypeCallExpression */) {
+    } else if (tokenOrKeyword.isKeyword(2 /* Autotype */) && tokenOrKeyword.parent.kind === 70 /* AutotypeCallExpression */) {
       return this.ofAutotypeCallExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 78 /* PrefixUnaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 79 /* PrefixUnaryExpression */) {
       return this.ofPrefixUnaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(41 /* Not */) && tokenOrKeyword.parent.kind === 74 /* NotExpression */) {
+    } else if (tokenOrKeyword.isKeyword(41 /* Not */) && tokenOrKeyword.parent.kind === 75 /* NotExpression */) {
       return this.ofNotExpressionNotKeyword(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 65 /* BinaryExpression */) {
+    } else if (tokenOrKeyword.parent.kind === 66 /* BinaryExpression */) {
       return this.ofBinaryExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.isToken(19 /* Caret */) && (tokenOrKeyword.parent.kind === 50 /* TypeDereferencedVariableGetterDeclaration */ || tokenOrKeyword.parent.kind === 51 /* TypeDereferencedVariableSetterDeclaration */)) {
       return this.ofDereferenceOperatorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 81 /* DereferenceExpression */) {
+    } else if (tokenOrKeyword.isToken(19 /* Caret */) && tokenOrKeyword.parent.kind === 82 /* DereferenceExpression */) {
       return this.ofDereferenceExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.parent.kind === 92 /* AssignmentStatement */) {
+    } else if (tokenOrKeyword.parent.kind === 93 /* AssignmentStatement */) {
       return this.ofAssignmentStatementOperator(analyzer, tokenOrKeyword.parent, options6);
     } else if (tokenOrKeyword.isKeyword(28 /* Creation */) && tokenOrKeyword.parent.kind === 45 /* TypeConstructorDeclaration */) {
       return this.ofTypeConstructorDeclaration(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 91 /* DefaultMatchExpression */) {
+    } else if (tokenOrKeyword.isToken(13 /* Asterisk */) && tokenOrKeyword.parent.kind === 92 /* DefaultMatchExpression */) {
       return this.ofDefaultMatchExpression(analyzer, tokenOrKeyword.parent);
-    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 87 /* ObjectExpression */) {
+    } else if (tokenOrKeyword.isKeyword(4 /* Object */) && tokenOrKeyword.parent.kind === 88 /* ObjectExpression */) {
       return this.ofObjectExpression(analyzer, tokenOrKeyword.parent, options6);
-    } else if (tokenOrKeyword.isKeyword(55 /* Base */) && tokenOrKeyword.parent.kind === 88 /* BaseExpression */) {
+    } else if (tokenOrKeyword.isKeyword(55 /* Base */) && tokenOrKeyword.parent.kind === 89 /* BaseExpression */) {
       return this.ofBaseExpression(analyzer, tokenOrKeyword.parent, options6);
     } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 49 /* TypeIndexerParameterClause */) {
       return this.ofTypeIndexerDeclaration(analyzer, tokenOrKeyword.parent.parent);
-    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 71 /* IndexedAccessExpression */) {
+    } else if ((tokenOrKeyword.isToken(45 /* OpenSquareBracket */) || tokenOrKeyword.isToken(22 /* CloseSquareBracket */)) && tokenOrKeyword.parent.kind === 72 /* IndexedAccessExpression */) {
       return this.ofIndexedAccessExpressionOperator(analyzer, tokenOrKeyword.parent, options6);
     }
     return void 0;
@@ -5600,11 +5817,11 @@ var NodeSemanticInfoService = class {
     let result;
     const parent = node.parent;
     switch (parent.kind) {
-      case 127 /* TranslationTypeParameterList */:
+      case 128 /* TranslationTypeParameterList */:
         break;
-      case 122 /* TranslationParameterList */:
+      case 123 /* TranslationParameterList */:
         break;
-      case 143 /* CallArgument */: {
+      case 144 /* CallArgument */: {
         const respectiveParameter = analyzer.getRespectiveParameter(parent);
         if (respectiveParameter !== void 0) {
           const target = new SimpleWithLocalization(
@@ -5618,10 +5835,10 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 59 /* EnumerationVariableDeclaration */:
+      case 60 /* EnumerationVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofEnumerationVariableDeclaration(parent));
         break;
-      case 101 /* ErrorVariableDeclaration */:
+      case 102 /* ErrorVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofErrorVariableDeclaration(parent));
         break;
       case 22 /* PackageAliasTypeDeclaration */:
@@ -5642,19 +5859,19 @@ var NodeSemanticInfoService = class {
       case 38 /* PackageVariantTypeDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofPackageVariantTypeDeclaration(parent));
         break;
-      case 89 /* IdentifierExpression */:
+      case 90 /* IdentifierExpression */:
         result = this.ofIdentifierExpression(analyzer, parent, options6);
         break;
-      case 57 /* NestedMethodDeclaration */:
+      case 58 /* NestedMethodDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofNestedMethodDeclaration(parent));
         break;
-      case 58 /* LocalVariableDeclaration */:
+      case 59 /* LocalVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofLocalVariableDeclaration(parent));
         break;
-      case 133 /* QualifiedName */:
+      case 134 /* QualifiedName */:
         result = this.ofQualifiedNameQualifier(analyzer, parent, node, options6);
         break;
-      case 134 /* PackageVariableTranslation */: {
+      case 135 /* PackageVariableTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getPackageVariableTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5674,7 +5891,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 135 /* TypeVariableOrVariantTranslation */: {
+      case 136 /* TypeVariableOrVariantTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getTypeVariableOrVariantTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5698,7 +5915,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 129 /* PackageMethodTranslation */: {
+      case 130 /* PackageMethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getPackageMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5722,7 +5939,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 130 /* TypeMethodTranslation */: {
+      case 131 /* TypeMethodTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetsResult = translationPackage?.getTypeMethodTranslationTargets(parent);
         if (translationPackage !== void 0 && isNonEmptyArray(getTargetsResult?.targets)) {
@@ -5746,7 +5963,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 137 /* TypeTranslation */: {
+      case 138 /* TypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5766,7 +5983,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 131 /* MethodTypeTranslation */: {
+      case 132 /* MethodTypeTranslation */: {
         const translationPackage = this.getContainingTranslationPackage(analyzer, node);
         const getTargetResult = translationPackage?.getMethodTypeTranslationTarget(parent);
         if (translationPackage !== void 0 && getTargetResult?.target !== void 0) {
@@ -5786,7 +6003,7 @@ var NodeSemanticInfoService = class {
         }
         break;
       }
-      case 142 /* ParameterDeclaration */:
+      case 143 /* ParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofParameterDeclaration(parent));
         break;
       case 8 /* PackageImport */:
@@ -5795,30 +6012,33 @@ var NodeSemanticInfoService = class {
       case 9 /* PackagePath */:
         result = void 0;
         break;
-      case 79 /* PropertyAccessExpression */:
+      case 80 /* PropertyAccessExpression */:
         result = this.ofProperty(analyzer, parent, options6);
         break;
       case 52 /* TypeMethodDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeMethodDeclaration(parent));
         break;
-      case 53 /* TypeVariableDeclaration */:
+      case 53 /* OperatorDeclaration */:
+        result = new DefinitionNodeSemanticInfo(analyzer.entity.ofOperatorDeclaration(parent));
+        break;
+      case 54 /* TypeVariableDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeVariableDeclaration(parent));
         break;
-      case 141 /* TypeParameterDeclaration */:
+      case 142 /* TypeParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofTypeParameterDeclaration(parent));
         break;
-      case 140 /* VariantDeclaration */:
+      case 141 /* VariantDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofVariantDeclaration(parent));
         break;
       case 36 /* PackageVariableGetterDeclaration */:
       case 37 /* PackageVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedPackageVariableDeclaration(parent));
         break;
-      case 54 /* TypeVariableGetterDeclaration */:
-      case 55 /* TypeVariableSetterDeclaration */:
+      case 55 /* TypeVariableGetterDeclaration */:
+      case 56 /* TypeVariableSetterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofComputedTypeVariableDeclaration(parent));
         break;
-      case 151 /* SetterParameterDeclaration */:
+      case 152 /* SetterParameterDeclaration */:
         result = new DefinitionNodeSemanticInfo(analyzer.entity.ofSetterParameterDeclaration(parent));
         break;
       case 3 /* Keyword */:
@@ -5879,6 +6099,14 @@ var NodeSemanticInfoService = class {
           result = createAccessedMethodsReference(meaning.candidates, true);
         }
         break;
+      case "operator-access": {
+        if (isNonEmptyArray(meaning.suitableOperators)) {
+          result = createOperatorsReference(meaning.suitableOperators, meaning.suitableOperators.length > 1);
+        } else if (isNonEmptyArray(meaning.candidates)) {
+          result = createOperatorsReference(meaning.candidates, true);
+        }
+        break;
+      }
       case "package-method-access":
         if (isNonEmptyArray(meaning.suitableMethods)) {
           result = createAccessedMethodsReference(meaning.suitableMethods, meaning.suitableMethods.length > 1);
@@ -5909,9 +6137,11 @@ var NodeSemanticInfoService = class {
     }
     return result;
     function createAccessedMethodsReference(methods, isAmbiguous) {
-      const targets = methods.map(
-        (o) => new SimpleWithLocalization(new AccessedMethodReferenceTarget(o.value), o.localization)
-      );
+      const targets = methods.map((o) => new SimpleWithLocalization(new AccessedMethodReferenceTarget(o.value), o.localization));
+      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
+    }
+    function createOperatorsReference(operators, isAmbiguous) {
+      const targets = operators.map((o) => new SimpleWithLocalization(new OperatorReferenceTarget(o.value), o.localization));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
   }
@@ -5962,7 +6192,7 @@ var NodeSemanticInfoService = class {
         return result;
       }
       case 42 /* ExtendedTypeClause */:
-      case 132 /* PackageImportTranslation */:
+      case 133 /* PackageImportTranslation */:
         return void 0;
       default:
         Debug.never(node.parent);
@@ -5995,6 +6225,14 @@ var NodeSemanticInfoService = class {
           result = createAccessedMethodsReference(meaning.candidates, true);
         }
         break;
+      case "operator-access": {
+        if (isNonEmptyArray(meaning.suitableOperators)) {
+          result = createOperatorsReference(meaning.suitableOperators, meaning.suitableOperators.length > 1);
+        } else if (isNonEmptyArray(meaning.candidates)) {
+          result = createOperatorsReference(meaning.candidates, true);
+        }
+        break;
+      }
       case "variable-access": {
         const variable = meaning.variable;
         if (variable.value.kind === "entity") {
@@ -6064,9 +6302,11 @@ var NodeSemanticInfoService = class {
     }
     return result;
     function createAccessedMethodsReference(methods, isAmbiguous) {
-      const targets = methods.map(
-        (o) => new SimpleWithLocalization(new AccessedMethodReferenceTarget(o.value), o.localization)
-      );
+      const targets = methods.map((o) => new SimpleWithLocalization(new AccessedMethodReferenceTarget(o.value), o.localization));
+      return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
+    }
+    function createOperatorsReference(operators, isAmbiguous) {
+      const targets = operators.map((o) => new SimpleWithLocalization(new OperatorReferenceTarget(o.value), o.localization));
       return new ReferenceNodeSemanticInfo(createNonEmptyArray(targets), isAmbiguous);
     }
   }
@@ -6099,7 +6339,7 @@ var NodeSemanticInfoService = class {
       const operator = analyzer.resolveCompoundAssignmentStatementOperator(node, operatorKind);
       if (operator.kind === "ok") {
         const target = new SimpleWithLocalization(
-          new TypeBinaryOperatorReferenceTarget(operator.value.value),
+          new OperatorReferenceTarget(operator.value.value),
           operator.value.localization
         );
         let result = new ReferenceNodeSemanticInfo([target], false);
@@ -6117,7 +6357,7 @@ var NodeSemanticInfoService = class {
       const operator = analyzer.resolveBinaryExpressionUserDefinableOperator(node, classificationResult.operatorKind);
       if (operator.kind === "ok") {
         const target = new SimpleWithLocalization(
-          new TypeBinaryOperatorReferenceTarget(operator.value.value),
+          new OperatorReferenceTarget(operator.value.value),
           operator.value.localization
         );
         let result = new ReferenceNodeSemanticInfo([target], false);
@@ -6133,7 +6373,7 @@ var NodeSemanticInfoService = class {
     const operator = analyzer.resolveNotExpressionOperator(node);
     if (operator.kind === "ok") {
       const target = new SimpleWithLocalization(
-        new TypeUnaryOperatorReferenceTarget(operator.value.value),
+        new OperatorReferenceTarget(operator.value.value),
         operator.value.localization
       );
       let result = new ReferenceNodeSemanticInfo([target], false);
@@ -6148,7 +6388,7 @@ var NodeSemanticInfoService = class {
     const operator = analyzer.resolvePrefixUnaryExpressionOperator(node);
     if (operator.kind === "ok") {
       const target = new SimpleWithLocalization(
-        new TypeUnaryOperatorReferenceTarget(operator.value.value),
+        new OperatorReferenceTarget(operator.value.value),
         operator.value.localization
       );
       let result = new ReferenceNodeSemanticInfo([target], false);
@@ -6260,6 +6500,15 @@ var NodeSemanticInfoService = class {
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
+      case "overridden-operator-access": {
+        const locale = TreeQuery.fromNode(node).packageEntity(analyzer).getLocale();
+        const target = new SimpleWithLocalization(
+          new OperatorReferenceTarget(meaning.operator),
+          new Localization.Original(locale)
+        );
+        result = new ReferenceNodeSemanticInfo([target], false);
+        break;
+      }
       case "unresolved":
         break;
       default:
@@ -6272,7 +6521,7 @@ var NodeSemanticInfoService = class {
   }
   static ofPackageNameSegmentAccess(analyzer, packageTreeNode, node) {
     let parent = getParentSkippingParenthesizedExpressions(node);
-    while (parent.kind === 79 /* PropertyAccessExpression */) {
+    while (parent.kind === 80 /* PropertyAccessExpression */) {
       const meaning = analyzer.resolvePropertyAccessExpression(parent).meaning;
       if (meaning.kind === "package-name-segment-access") {
         packageTreeNode = meaning.packageTreeNode;
@@ -6311,11 +6560,11 @@ var NodeSemanticInfoService = class {
     }
     const parent = getParentSkippingParenthesizedExpressions(typeAccessExpression);
     let parentCallExpression;
-    if (parent.kind === 68 /* CallExpression */) {
+    if (parent.kind === 69 /* CallExpression */) {
       parentCallExpression = parent;
-    } else if (parent.kind === 90 /* GenericSpecializationExpression */) {
+    } else if (parent.kind === 91 /* GenericSpecializationExpression */) {
       const grandParent = getParentSkippingParenthesizedExpressions(parent);
-      if (grandParent.kind === 68 /* CallExpression */) {
+      if (grandParent.kind === 69 /* CallExpression */) {
         parentCallExpression = grandParent;
       }
     }
@@ -6444,18 +6693,6 @@ var TypeConstructorReferenceTarget = class {
     this.kind = "type-constructor";
   }
 };
-var TypeUnaryOperatorReferenceTarget = class {
-  constructor(operator) {
-    this.operator = operator;
-    this.kind = "type-unary-operator";
-  }
-};
-var TypeBinaryOperatorReferenceTarget = class {
-  constructor(operator) {
-    this.operator = operator;
-    this.kind = "type-binary-operator";
-  }
-};
 var TypeDereferenceOperatorReferenceTarget = class {
   constructor(operator, accessKind) {
     this.operator = operator;
@@ -6469,6 +6706,12 @@ var AccessedMethodReferenceTarget = class {
     this.kind = "accessed-method";
   }
 };
+var OperatorReferenceTarget = class {
+  constructor(operator) {
+    this.operator = operator;
+    this.kind = "operator";
+  }
+};
 var MatchResultValueParameterReferenceTarget = class {
   constructor(parameter, accessKind) {
     this.parameter = parameter;
@@ -6522,7 +6765,7 @@ var SimpleWithLocalization = class {
 
 // source/services/Utils.ts
 function getEntitySourceLocations(analyzer, entity) {
-  if (entity.kind === 18 /* Package */) {
+  if (entity.kind === 16 /* Package */) {
     return void 0;
   }
   let result;
@@ -6570,8 +6813,8 @@ function getEntitySourceLocations(analyzer, entity) {
         case 17 /* AnonymousMethodTypeDeclaration */:
         case 18 /* AnonymousStructuredTypeDeclaration */:
         case 19 /* AnonymousVariantTypeDeclaration */:
-        case 66 /* MethodBlockLiteral */:
-        case 75 /* MethodLiteral */:
+        case 67 /* MethodBlockLiteral */:
+        case 76 /* MethodLiteral */:
           range = node.rangeWithoutTrivia;
           break;
         case 22 /* PackageAliasTypeDeclaration */:
@@ -6579,10 +6822,11 @@ function getEntitySourceLocations(analyzer, entity) {
         case 28 /* PackageMethodTypeDeclaration */:
         case 33 /* PackageStructuredTypeDeclaration */:
         case 38 /* PackageVariantTypeDeclaration */:
-        case 57 /* NestedMethodDeclaration */:
+        case 58 /* NestedMethodDeclaration */:
         case 52 /* TypeMethodDeclaration */:
-        case 141 /* TypeParameterDeclaration */:
-        case 140 /* VariantDeclaration */:
+        case 142 /* TypeParameterDeclaration */:
+        case 141 /* VariantDeclaration */:
+        case 53 /* OperatorDeclaration */:
           range = node.name.rangeWithoutTrivia;
           break;
         case 45 /* TypeConstructorDeclaration */:
@@ -6604,10 +6848,10 @@ function getEntitySourceLocations(analyzer, entity) {
         case 37 /* PackageVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
-        case 54 /* TypeVariableGetterDeclaration */:
+        case 55 /* TypeVariableGetterDeclaration */:
           range = node.getKeyword.rangeWithoutTrivia;
           break;
-        case 55 /* TypeVariableSetterDeclaration */:
+        case 56 /* TypeVariableSetterDeclaration */:
           range = node.setKeyword.rangeWithoutTrivia;
           break;
         case 47 /* TypeIndexedGetterDeclaration */:
@@ -6733,9 +6977,7 @@ var DefinitionService = class {
         return getEntitySourceLocations(analyzer, target.constructor_.getEntity());
       case "accessed-method":
         return getEntitySourceLocations(analyzer, target.method.getEntity());
-      case "type-unary-operator":
-        return getEntitySourceLocations(analyzer, target.operator.getEntity());
-      case "type-binary-operator":
+      case "operator":
         return getEntitySourceLocations(analyzer, target.operator.getEntity());
       case "type-dereference-operator":
         return getEntitySourceLocations(analyzer, target.operator.getEntity());
@@ -6769,9 +7011,7 @@ var DefinitionService = class {
         return target.parameter.getEntity();
       case "type-constructor":
         return target.constructor_.getEntity();
-      case "type-unary-operator":
-        return target.operator.getEntity();
-      case "type-binary-operator":
+      case "operator":
         return target.operator.getEntity();
       case "type-dereference-operator":
         return target.operator.getEntity();
@@ -6862,7 +7102,7 @@ var ReferencesService = class {
               }
             }
             if (!options6.onlyNamed) {
-              if (node.kind === 69 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
+              if (node.kind === 70 /* AutotypeCallExpression */ && restrictions.canBeAutotypeCall) {
                 const semanticInfo = NodeSemanticInfoService.ofAutotypeCallExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -6874,7 +7114,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.autotypeKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 78 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
+              if (node.kind === 79 /* PrefixUnaryExpression */ && restrictions.canBePrefixUnaryOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofPrefixUnaryExpressionOperator(
                   analyzer,
                   node,
@@ -6890,7 +7130,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.operator.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 74 /* NotExpression */ && restrictions.canBeNotExpression) {
+              if (node.kind === 75 /* NotExpression */ && restrictions.canBeNotExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofNotExpressionNotKeyword(
                   analyzer,
                   node,
@@ -6906,7 +7146,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.notKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 65 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
+              if (node.kind === 66 /* BinaryExpression */ && restrictions.canBeBinaryExpressionOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofBinaryExpressionOperator(
                   analyzer,
                   node,
@@ -6934,7 +7174,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 81 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
+              if (node.kind === 82 /* DereferenceExpression */ && restrictions.canBeDereferenceOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofDereferenceExpressionOperator(
                   analyzer,
                   node,
@@ -6950,7 +7190,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.caretToken.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 92 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
+              if (node.kind === 93 /* AssignmentStatement */ && restrictions.canBeAssignmentStatementOperator) {
                 const semanticInfo = NodeSemanticInfoService.ofAssignmentStatementOperator(
                   analyzer,
                   node,
@@ -6978,7 +7218,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.creationKeyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 87 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
+              if (node.kind === 88 /* ObjectExpression */ && restrictions.canBeObjectExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofObjectExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -6990,7 +7230,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.keyword.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 88 /* BaseExpression */ && restrictions.canBeBaseExpression) {
+              if (node.kind === 89 /* BaseExpression */ && restrictions.canBeBaseExpression) {
                 const semanticInfo = NodeSemanticInfoService.ofBaseExpression(analyzer, node, semanticInfoOptions);
                 const referenceKind = this.ifReferenceToDefinitionThenKind(
                   definition,
@@ -7014,7 +7254,7 @@ var ReferencesService = class {
                   result.push(new Reference(sourceFile2, node.parameterClause.rangeWithoutTrivia, referenceKind));
                 }
               }
-              if (node.kind === 71 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
+              if (node.kind === 72 /* IndexedAccessExpression */ && restrictions.canBeIndexer) {
                 const semanticInfo = NodeSemanticInfoService.ofIndexedAccessExpressionOperator(
                   analyzer,
                   node,
@@ -7133,9 +7373,7 @@ var ReferencesService = class {
           );
         case "type-constructor":
           return new DefinitionInfo(target.value.constructor_.getEntity(), target.localization, 0 /* Read */);
-        case "type-unary-operator":
-          return new DefinitionInfo(target.value.operator.getEntity(), target.localization, 0 /* Read */);
-        case "type-binary-operator":
+        case "operator":
           return new DefinitionInfo(target.value.operator.getEntity(), target.localization, 0 /* Read */);
         case "type-dereference-operator":
           return new DefinitionInfo(
@@ -7185,13 +7423,15 @@ var ReferencesService = class {
       result.canBeAutotypeCall = true;
       result.canBeConstructorDeclaration = true;
     }
-    if (definition.value.kind === 15 /* UnaryOperator */) {
-      result.canBePrefixUnaryOperator = true;
-      result.canBeNotExpression = true;
-    }
-    if (definition.value.kind === 16 /* BinaryOperator */) {
-      result.canBeBinaryExpressionOperator = true;
-      result.canBeAssignmentStatementOperator = true;
+    if (definition.value.kind === 15 /* Operator */) {
+      const operatorKind = definition.value.getOperatorKind();
+      if (isUnaryOperator(operatorKind)) {
+        result.canBePrefixUnaryOperator = true;
+        result.canBeNotExpression = true;
+      } else {
+        result.canBeBinaryExpressionOperator = true;
+        result.canBeAssignmentStatementOperator = true;
+      }
     }
     if (definition.value.kind === 8 /* DereferenceOperator */) {
       result.canBeDereferenceOperator = true;
@@ -7274,10 +7514,9 @@ var ReferencesService = class {
       case 10 /* Destructor */:
       case 7 /* Indexer */:
       case 8 /* DereferenceOperator */:
-      case 15 /* UnaryOperator */:
-      case 16 /* BinaryOperator */:
-      case 18 /* Package */:
-      case 19 /* TypeExtension */:
+      case 16 /* Package */:
+      case 17 /* TypeExtension */:
+      case 15 /* Operator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -7390,9 +7629,9 @@ var EvaluatableExpressionService = class {
   getEvaluatableExpressionForIdentifier(node) {
     const parent = node.parent;
     switch (parent.kind) {
-      case 89 /* IdentifierExpression */:
+      case 90 /* IdentifierExpression */:
         return parent;
-      case 79 /* PropertyAccessExpression */:
+      case 80 /* PropertyAccessExpression */:
         if (this.isEvaluatableReceiver(parent.expression)) {
           return parent;
         }
@@ -7413,9 +7652,9 @@ var EvaluatableExpressionService = class {
   }
   isEvaluatableReceiver(expression) {
     switch (expression.kind) {
-      case 89 /* IdentifierExpression */:
+      case 90 /* IdentifierExpression */:
         return true;
-      case 79 /* PropertyAccessExpression */:
+      case 80 /* PropertyAccessExpression */:
         return this.isEvaluatableReceiver(expression.expression);
       default:
         return false;
@@ -7423,7 +7662,7 @@ var EvaluatableExpressionService = class {
   }
   isNamedDeclaration(node) {
     switch (node.kind) {
-      case 59 /* EnumerationVariableDeclaration */:
+      case 60 /* EnumerationVariableDeclaration */:
         return { nameIdentifier: node.name };
       case 22 /* PackageAliasTypeDeclaration */:
         return { nameIdentifier: node.name };
@@ -7437,21 +7676,21 @@ var EvaluatableExpressionService = class {
         return { nameIdentifier: node.name };
       case 38 /* PackageVariantTypeDeclaration */:
         return { nameIdentifier: node.name };
-      case 57 /* NestedMethodDeclaration */:
+      case 58 /* NestedMethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 58 /* LocalVariableDeclaration */:
+      case 59 /* LocalVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 142 /* ParameterDeclaration */:
+      case 143 /* ParameterDeclaration */:
         return { nameIdentifier: node.name };
       case 52 /* TypeMethodDeclaration */:
         return { nameIdentifier: node.name };
-      case 53 /* TypeVariableDeclaration */:
+      case 54 /* TypeVariableDeclaration */:
         return { nameIdentifier: node.name };
-      case 141 /* TypeParameterDeclaration */:
+      case 142 /* TypeParameterDeclaration */:
         return { nameIdentifier: node.name };
-      case 140 /* VariantDeclaration */:
+      case 141 /* VariantDeclaration */:
         return { nameIdentifier: node.name };
-      case 101 /* ErrorVariableDeclaration */:
+      case 102 /* ErrorVariableDeclaration */:
         return { nameIdentifier: node.name };
       default:
         return void 0;
@@ -7572,13 +7811,12 @@ var HoverService = class {
         );
         return new Hover(this._displayService.displayConstructorDeclaration(declaration), range);
       }
-      case "type-unary-operator": {
-        const operator = new UnaryOperatorDeclaration_typeMember(firstTarget.value.operator);
-        return new Hover(this._displayService.displayUnaryOperatorDeclaration(operator), range);
-      }
-      case "type-binary-operator": {
-        const operator = new BinaryOperatorDeclaration_typeMember(firstTarget.value.operator);
-        return new Hover(this._displayService.displayBinaryOperatorDeclaration(operator), range);
+      case "operator": {
+        const operator = new OperatorDeclaration_typeMember(
+          firstTarget.value.operator,
+          firstTarget.localization
+        );
+        return new Hover(this._displayService.displayOperatorDeclaration(operator), range);
       }
       case "type-dereference-operator": {
         const operator = new DereferenceOperatorDeclaration_typeMember(firstTarget.value.operator);
@@ -7747,7 +7985,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 53 /* TypeVariableDeclaration */: {
+        case 54 /* TypeVariableDeclaration */: {
           result.push(
             this.createItem(
               12 /* TypeVariable */,
@@ -7759,7 +7997,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 54 /* TypeVariableGetterDeclaration */: {
+        case 55 /* TypeVariableGetterDeclaration */: {
           result.push(
             this.createItem(
               13 /* TypeVariableGetter */,
@@ -7771,7 +8009,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 55 /* TypeVariableSetterDeclaration */: {
+        case 56 /* TypeVariableSetterDeclaration */: {
           result.push(
             this.createItem(
               14 /* TypeVariableSetter */,
@@ -7865,7 +8103,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 140 /* VariantDeclaration */: {
+        case 141 /* VariantDeclaration */: {
           result.push(
             this.createItem(
               9 /* Variant */,
@@ -7877,7 +8115,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 141 /* TypeParameterDeclaration */: {
+        case 142 /* TypeParameterDeclaration */: {
           result.push(
             this.createItem(
               18 /* TypeParameter */,
@@ -7889,7 +8127,7 @@ var SourceFileItemsService = class {
           );
           break;
         }
-        case 57 /* NestedMethodDeclaration */: {
+        case 58 /* NestedMethodDeclaration */: {
           result.push(
             this.createItem(
               19 /* NestedMethod */,
@@ -8056,9 +8294,10 @@ var RenameService = class {
           case "match-result-value-parameter":
             canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.parameter.entity);
             break;
+          case "operator":
+            canBeRenamed = this.entityCanBeRenamed(analyzer, target.value.operator.getEntity());
+            break;
           case "type-constructor":
-          case "type-unary-operator":
-          case "type-binary-operator":
           case "type-dereference-operator":
           case "package":
           case "type-context":
@@ -8108,7 +8347,7 @@ var SelectionRangeService = class {
       if (!this.nodeShouldBeSkipped(child) && !child.rangeWithoutTrivia.equals(result.range)) {
         result = new SelectionRange(child.rangeWithoutTrivia, result);
       }
-      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 82 /* TextTemplateLiteral */) {
+      if (child.kind === 0 /* Token */ && (child.tokenKind === 6 /* TextLiteral */ || child.tokenKind === 7 /* TextTemplateHead */ || child.tokenKind === 8 /* TextTemplatePart */ || child.tokenKind === 9 /* TextTemplateTail */ || child.tokenKind === 5 /* CharLiteral */) || child.kind === 83 /* TextTemplateLiteral */) {
         const textContentStart = child.rangeWithoutTrivia.start + 1;
         const textContentEnd = child.rangeWithoutTrivia.end - 1;
         if (offset >= textContentStart && offset < textContentEnd) {
@@ -8139,13 +8378,13 @@ var SelectionRangeService = class {
       }
     }
     switch (node.kind) {
-      case 156 /* TypeAnnotation */:
+      case 157 /* TypeAnnotation */:
       case 34 /* StructuredTypeDeclarationBody */:
       case 39 /* VariantTypeDeclarationBody */:
       case 23 /* AliasTypeDeclarationBody */:
       case 29 /* MethodTypeDeclarationBody */:
-      case 84 /* TextTemplateSpan */:
-      case 83 /* TextTemplateSpanList */:
+      case 85 /* TextTemplateSpan */:
+      case 84 /* TextTemplateSpanList */:
         return true;
       default:
         return false;
@@ -8183,7 +8422,7 @@ var SemanticTokensService = class {
             controller.stopChildrenTraverse();
             return;
           }
-          if (node.kind === 89 /* IdentifierExpression */) {
+          if (node.kind === 90 /* IdentifierExpression */) {
             const meaning = analyzer.resolveIdentifierExpression(node).meaning;
             if (meaning.kind === "variable-access") {
               const variable = meaning.variable.value.getEntity();
@@ -8233,7 +8472,7 @@ var SemanticTokensService = class {
               );
             }
           }
-          if (node.kind === 79 /* PropertyAccessExpression */) {
+          if (node.kind === 80 /* PropertyAccessExpression */) {
             const meaning = analyzer.resolvePropertyAccessExpression(node).meaning;
             if (meaning.kind === "variant-access") {
               result.push(
@@ -8267,7 +8506,7 @@ var SemanticTokensService = class {
               );
             }
           }
-          if (node.kind === 140 /* VariantDeclaration */) {
+          if (node.kind === 141 /* VariantDeclaration */) {
             result.push(
               new SemanticToken(
                 node.name.rangeWithoutTrivia,
@@ -8285,7 +8524,7 @@ var SemanticTokensService = class {
               )
             );
           }
-          if (node.kind === 57 /* NestedMethodDeclaration */) {
+          if (node.kind === 58 /* NestedMethodDeclaration */) {
             result.push(
               new SemanticToken(node.name.rangeWithoutTrivia, 5 /* NestedMethod */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
             );
@@ -8295,6 +8534,11 @@ var SemanticTokensService = class {
               new SemanticToken(node.name.rangeWithoutTrivia, 6 /* TypeMethod */, new SemanticTokenModifiers().makeDeclaration().setCapitalized(this.isCapitalizedName(node.name.value)))
             );
           }
+          if (node.kind === 53 /* OperatorDeclaration */) {
+            result.push(
+              new SemanticToken(node.name.rangeWithoutTrivia, 7 /* Operator */, new SemanticTokenModifiers().makeDeclaration())
+            );
+          }
         }
       );
       return result.sort((t1, t2) => t1.range.start - t2.range.end);
@@ -8371,7 +8615,8 @@ var supportedSemanticTokens = [
   3 /* Variant */,
   4 /* PackageMethod */,
   5 /* NestedMethod */,
-  6 /* TypeMethod */
+  6 /* TypeMethod */,
+  7 /* Operator */
 ];
 var supportedSemanticTokenModifiers = [
   1 /* Const */,
@@ -8445,7 +8690,7 @@ var TypeParameterSignatureHelpProvider = class {
     }
     let node = token.parent;
     while (node !== void 0) {
-      if (node.kind === 152 /* TypeArgumentClause */ && this._offset >= node.lessThanToken.rangeWithoutTrivia.end && (node.greaterThanToken.rangeWithoutTrivia.isEmpty || this._offset <= node.greaterThanToken.rangeWithoutTrivia.start)) {
+      if (node.kind === 153 /* 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);
@@ -8490,7 +8735,7 @@ var TypeParameterSignatureHelpProvider = class {
     switch (node.kind) {
       case 10 /* NamedTypeSpecifier */:
         return this.getSignaturesForNamedTypeSpecifier(node);
-      case 90 /* GenericSpecializationExpression */:
+      case 91 /* GenericSpecializationExpression */:
         return this.getSignaturesForGenericSpecializationExpression(node);
       default:
         Debug.never(node);
@@ -8508,7 +8753,7 @@ var TypeParameterSignatureHelpProvider = class {
   }
   getSignaturesForGenericSpecializationExpression(node) {
     const expression = unwrapParenthesizedExpressions(node.expression);
-    if (expression.kind === 89 /* IdentifierExpression */) {
+    if (expression.kind === 90 /* IdentifierExpression */) {
       const meaning = this._analyzer.resolveIdentifierExpression(expression).meaning;
       if (meaning.kind === "method-access") {
         return Query.from(meaning.candidates).mapAndFilter((o) => {
@@ -8523,7 +8768,7 @@ var TypeParameterSignatureHelpProvider = class {
       }
       return void 0;
     }
-    if (expression.kind === 79 /* PropertyAccessExpression */) {
+    if (expression.kind === 80 /* PropertyAccessExpression */) {
       const meaning = this._analyzer.resolvePropertyAccessExpression(expression).meaning;
       let accessedMethods;
       if (meaning.kind === "instance-method-access") {
@@ -8776,7 +9021,7 @@ var ValueParametersSignatureHelpProvider = class {
     let node = token.parent;
     while (node !== void 0) {
       switch (node.kind) {
-        case 68 /* CallExpression */: {
+        case 69 /* CallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.callArgumentList.elements, this._offset);
@@ -8784,7 +9029,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 69 /* AutotypeCallExpression */: {
+        case 70 /* AutotypeCallExpression */: {
           if (this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && (node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfAutotypeCallExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.callArgumentList.elements, this._offset);
@@ -8792,7 +9037,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 71 /* IndexedAccessExpression */: {
+        case 72 /* IndexedAccessExpression */: {
           if (this._offset >= node.openSquareBracketToken.rangeWithoutTrivia.end && (node.closeSquareBracketToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeSquareBracketToken.rangeWithoutTrivia.start)) {
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfIndexedAccessExpression(node);
             const argumentIndex = this.getArgumentIndexInList(node.argumentsList.elements, this._offset);
@@ -8800,7 +9045,7 @@ var ValueParametersSignatureHelpProvider = class {
           }
           break;
         }
-        case 145 /* Tag */: {
+        case 146 /* Tag */: {
           if (node.openParenthesisToken !== void 0 && this._offset >= node.openParenthesisToken.rangeWithoutTrivia.end && node.callArgumentList !== void 0 && (node.closeParenthesisToken === void 0 || node.closeParenthesisToken.rangeWithoutTrivia.isEmpty || this._offset <= node.closeParenthesisToken.rangeWithoutTrivia.start)) {
             const argumentIndex = this.getArgumentIndexInList(node.callArgumentList.elements, this._offset);
             const valueArguments = ValueArgumentFactory.createValueArgumentsOfTag(node);
@@ -11796,7 +12041,7 @@ var SourceGenerationService = class extends ObservableObject7 {
       if (result === void 0) {
         const node = new EntityToSyntax(analyzer, packageEntity, localizationContext).convert();
         const code = new SyntaxToCode(node, { keywordsLocale: packageLocale }).convert();
-        const generatedPackageUri = new Uri(GeneratedSourceFileScheme, [key]);
+        const generatedPackageUri = new Uri(GeneratedSourceFileScheme, "", [key]);
         const generatedFileUri = generatedPackageUri.append(`${packageEntity.getName().toString()}.art`);
         const fileSystemTree = atomicRun2(() => new FileSystemTree());
         const packageDirectory = fileSystemTree.addDirectory(generatedPackageUri);
@@ -11893,14 +12138,13 @@ var SourceGenerationService = class extends ObservableObject7 {
       case 8 /* DereferenceOperator */:
       case 9 /* Constructor */:
       case 10 /* Destructor */:
-      case 15 /* UnaryOperator */:
-      case 16 /* BinaryOperator */:
+      case 15 /* Operator */:
         return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainer().getEntity());
       case 13 /* PackageAlias */:
         return false;
-      case 18 /* Package */:
+      case 16 /* Package */:
         return false;
-      case 19 /* TypeExtension */:
+      case 17 /* TypeExtension */:
         return true;
       default:
         Debug.never(entity);
@@ -11959,6 +12203,8 @@ var EntityFinder = class {
         return this.findConstructorEntity(entity);
       case 10 /* Destructor */:
         return this.findDestructorEntity(entity);
+      case 15 /* Operator */:
+        return this.findOperatorEntity(entity);
       case 7 /* Indexer */:
         return this.findIndexerEntity(entity);
       case 8 /* DereferenceOperator */:
@@ -11970,10 +12216,8 @@ var EntityFinder = class {
       case 13 /* PackageAlias */:
       case 3 /* Getter */:
       case 4 /* Setter */:
-      case 15 /* UnaryOperator */:
-      case 16 /* BinaryOperator */:
-      case 18 /* Package */:
-      case 19 /* TypeExtension */:
+      case 16 /* Package */:
+      case 17 /* TypeExtension */:
         return void 0;
       default:
         Debug.never(entity);
@@ -12077,6 +12321,23 @@ var EntityFinder = class {
       return index >= 0 ? members[index] : void 0;
     }
   }
+  findOperatorEntity(entity) {
+    const containingType = this.findEntity(entity.getContainer().getEntity());
+    if (!(containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType))) {
+      return void 0;
+    }
+    const members = containingType.getMembers().getOperators();
+    if (members.length === 0) {
+      return void 0;
+    } else if (members.length === 1) {
+      return members[0];
+    } else {
+      const referenceData = new DataForFindingOverloadedMember([], entity.getValueParameters());
+      const membersData = members.map((m) => new DataForFindingOverloadedMember([], m.getValueParameters()));
+      const index = this.findOverloadedMemberIndex(referenceData, membersData);
+      return index >= 0 ? members[index] : void 0;
+    }
+  }
   findIndexerEntity(entity) {
     const containingType = this.findEntity(entity.getContainer().getEntity());
     if (!(containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType))) {
@@ -12139,6 +12400,8 @@ var EntityFinder = class {
         return entity.getValueParameters();
       case 11 /* MethodType */:
         return entity.getValueParameters();
+      case 15 /* Operator */:
+        return entity.getValueParameters();
       case 0 /* Variable */:
       case 1 /* Variant */:
       case 2 /* VariantType */:
@@ -12148,10 +12411,8 @@ var EntityFinder = class {
       case 12 /* StructuredType */:
       case 13 /* PackageAlias */:
       case 14 /* AliasType */:
-      case 15 /* UnaryOperator */:
-      case 16 /* BinaryOperator */:
-      case 18 /* Package */:
-      case 19 /* TypeExtension */:
+      case 16 /* Package */:
+      case 17 /* TypeExtension */:
       case 8 /* DereferenceOperator */:
         return void 0;
       default:
@@ -12180,10 +12441,9 @@ var EntityFinder = class {
       case 4 /* Setter */:
       case 6 /* TypeParameter */:
       case 13 /* PackageAlias */:
-      case 15 /* UnaryOperator */:
-      case 16 /* BinaryOperator */:
-      case 18 /* Package */:
-      case 19 /* TypeExtension */:
+      case 16 /* Package */:
+      case 17 /* TypeExtension */:
+      case 15 /* Operator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -12867,7 +13127,7 @@ var LanguageServer = class {
       const sourceFileContext = yield this.getSourceFileContext(uri, token);
       if (sourceFileContext !== void 0) {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
-        if (node?.kind === 92 /* AssignmentStatement */) {
+        if (node?.kind === 93 /* AssignmentStatement */) {
           const sourceFileEdit = this._addPropertyAssignmentService.createEditWithAssignment(
             sourceFileContext.sourceFile,
             node,
@@ -12904,7 +13164,7 @@ var LanguageServer = class {
         const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
         if (node !== void 0) {
           let nodeForRange = node;
-          if (node.kind === 92 /* AssignmentStatement */) {
+          if (node.kind === 93 /* AssignmentStatement */) {
             nodeForRange = node.right;
           }
           result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);
@@ -13051,7 +13311,7 @@ ${e}`);
         const position = new Position(params.position.line, params.position.character);
         const offset = sourceFile.getOffsetAtPosition(position);
         const completions = this._completionService.getCompletions(analyzer, sourceFile, offset);
-        result = completions.map((c) => this.convertCompletionItem(c));
+        result = completions.map((c) => this.convertCompletionItem(c, sourceFile));
       }
       return result;
     });
@@ -13064,22 +13324,31 @@ ${e}`);
     const resolutionResult = this._completionService.resolveCompletionItem(cacheId, indexInCache);
     let result;
     if (resolutionResult.kind === "item") {
-      result = this.convertCompletionItem(resolutionResult.value);
+      result = this.convertCompletionItem(resolutionResult.value, resolutionResult.sourceFile);
+      result.textEdit = item.textEdit;
     } else {
       result = item;
     }
     return result;
   }
-  convertCompletionItem(item) {
+  convertCompletionItem(item, sourceFile) {
     const data = {
       cacheId: item.cacheId,
       indexInCache: item.indexInCache
     };
+    let textEdit;
+    if (item.editRange !== void 0) {
+      textEdit = ls3.TextEdit.replace(
+        this.convertSourceFileRange(sourceFile, item.editRange),
+        item.insertText ?? item.label
+      );
+    }
     return {
       label: item.label,
       kind: this.convertCompletionItemKind(item.kind),
       detail: item.details,
       insertText: item.insertText,
+      textEdit,
       sortText: item.sortText,
       data
     };
@@ -13094,42 +13363,46 @@ ${e}`);
         return ls3.CompletionItemKind.Property;
       case 3 /* TypeMethod */:
         return ls3.CompletionItemKind.Method;
-      case 4 /* TypeIndexer */:
+      case 5 /* TypeIndexer */:
         return ls3.CompletionItemKind.Property;
-      case 5 /* TypeConstructor */:
+      case 6 /* TypeConstructor */:
         return ls3.CompletionItemKind.Constructor;
-      case 11 /* Variant */:
+      case 12 /* Variant */:
         return ls3.CompletionItemKind.EnumMember;
-      case 6 /* PackageVariable */:
+      case 7 /* PackageVariable */:
         return ls3.CompletionItemKind.Variable;
-      case 7 /* PackageMethod */:
+      case 8 /* PackageMethod */:
         return ls3.CompletionItemKind.Function;
-      case 8 /* LocalVariable */:
+      case 9 /* LocalVariable */:
         return ls3.CompletionItemKind.Variable;
-      case 9 /* ParameterVariable */:
+      case 10 /* ParameterVariable */:
         return ls3.CompletionItemKind.Variable;
-      case 10 /* NestedMethod */:
+      case 11 /* NestedMethod */:
         return ls3.CompletionItemKind.Function;
-      case 12 /* RefObjectType */:
+      case 13 /* RefObjectType */:
         return ls3.CompletionItemKind.Class;
-      case 13 /* PlainObjectType */:
+      case 14 /* PlainObjectType */:
         return ls3.CompletionItemKind.Struct;
-      case 14 /* AspectType */:
+      case 15 /* AspectType */:
         return ls3.CompletionItemKind.Interface;
-      case 15 /* VariantType */:
+      case 16 /* VariantType */:
         return ls3.CompletionItemKind.Enum;
-      case 16 /* TypeParameter */:
+      case 17 /* TypeParameter */:
         return ls3.CompletionItemKind.TypeParameter;
-      case 17 /* MethodType */:
+      case 18 /* MethodType */:
         return ls3.CompletionItemKind.Function;
-      case 18 /* AliasType */:
+      case 19 /* AliasType */:
         return ls3.CompletionItemKind.Class;
-      case 19 /* InvalidType */:
+      case 20 /* InvalidType */:
         return ls3.CompletionItemKind.Class;
-      case 20 /* Keyword */:
+      case 21 /* Keyword */:
         return ls3.CompletionItemKind.Keyword;
-      case 21 /* TargetSignatureParameter */:
+      case 22 /* TargetSignatureParameter */:
         return ls3.CompletionItemKind.Variable;
+      case 4 /* Operator */:
+        return ls3.CompletionItemKind.Operator;
+      case 23 /* OperatorName */:
+        return ls3.CompletionItemKind.Operator;
       default:
         Debug.never(kind);
     }
@@ -13216,6 +13489,8 @@ ${e}`);
         return ls3.SemanticTokenTypes.function;
       case 6 /* TypeMethod */:
         return ls3.SemanticTokenTypes.method;
+      case 7 /* Operator */:
+        return ls3.SemanticTokenTypes.operator;
       default:
         Debug.never(kind);
     }
@@ -13409,22 +13684,10 @@ ${e}`);
     });
   }
   convertUriToVscodeUri(uri) {
-    return URI2.from({ scheme: uri.scheme, path: `/${uri.segments.join("/")}` });
+    return URI2.from({ scheme: uri.scheme, authority: uri.authority, path: uri.path });
   }
   convertVscodeUriToUri(uri) {
-    uri = Utils.resolvePath(uri);
-    const scheme = uri.scheme;
-    let path = uri.path;
-    if (path.startsWith("/")) {
-      path = path.slice(1);
-    }
-    let segments;
-    if (path === "") {
-      segments = [];
-    } else {
-      segments = path.split("/");
-    }
-    return new Uri(scheme, segments);
+    return Uri.from(uri.scheme, uri.authority, uri.path);
   }
   createCancellationToken(cancellationToken) {
     if (!this._enableRequestCancellation) {