@artel/artc 0.6.26025 → 0.6.26027

package/build/api/ApiServices.js

@@ -1,7 +1,8 @@
 import {
   AccessedFunction_entity,
   AccessedFunction_typeMember,
-  Analyzer2 as Analyzer,
+  AccessorEntity,
+  Analyzer3 as Analyzer,
   Cached,
   CancelledError,
   CompilationLoader,
@@ -19,7 +20,6 @@ import {
   FileSystemTree,
   FunctionDeclaration_accessedFunction,
   FunctionDeclaration_entity,
-  FunctionDeclaration_substitutedFunction,
   FunctionDeclaration_typeMember,
   GeneratedSourceFileScheme,
   GenericCancellationToken,
@@ -39,7 +39,6 @@ import {
   NamedType_structured,
   NamedType_variant,
   NodeModulesDirectoryName,
-  NodePath,
   Option,
   PackageMemberLookup,
   ParameterDeclaration_matchResultParameter,
@@ -64,6 +63,7 @@ import {
   TypeMemberLookupA,
   TypeWithMembersOrExtensionEntity,
   Uri,
+  UrisRelativityKind,
   VariableDeclaration_entity,
   VariableDeclaration_typeMember,
   WellKnownDeclarationsLoadError,
@@ -78,7 +78,6 @@ import {
   getOrCreateKeywordDictionary,
   ifTypeEntityIsFunctionTypeAliasThenFunctionType,
   isAnonymousStructuredTypeDeclaration,
-  isComputedVariableEntity,
   isEntityWithParameters,
   isEntityWithTypeParameters,
   isExpression,
@@ -92,15 +91,14 @@ import {
   isPackageStructuredTypeDeclaration,
   isPackageTypeDeclaration,
   isPackageTypeEntity,
-  isRegularOrBlockFunctionLiteral,
   isSourceOrConfigurationFileName,
   isStatement,
-  isSubprogramDeclarationOrLiteral,
   isTypeEntity,
   isTypeEntityWithMembers,
   isTypeMemberDeclaration,
   isTypeSpecifier,
   isUnaryOperator,
+  isVariableEntityWithExplicitAccessors,
   kebabCaseToCamelCase,
   localeToString,
   modifierKindsInSortOrder,
@@ -109,11 +107,41 @@ import {
   sortModifiers,
   traverseTreeAsync,
   yieldTask
-} from "../chunk-OTHSFQXT.js";
+} from "../chunk-IJGHVDYP.js";
 
-// source/services/CustomRequests.ts
+// source/services/common/Types.ts
 import * as ls from "vscode-languageserver";
-var CustomRequestType = class extends ls.RequestType {
+var SourceLocation = class {
+  constructor(sourceFile, range) {
+    this.sourceFile = sourceFile;
+    this.range = range;
+  }
+};
+function isCompletionItemData(value) {
+  Debug.cast(value);
+  return value instanceof Object && typeof value.cacheId === "number" && typeof value.indexInCache === "number";
+}
+function isCodeActionData(value) {
+  Debug.cast(value);
+  return value instanceof Object && typeof value.name === "string" && value.location instanceof Object && ls.DocumentUri.is(value.location.uri) && ls.Position.is(value.location.position) && "data" in value;
+}
+var SourceFileEdit = class {
+  constructor(sourceFile, range, text) {
+    this.sourceFile = sourceFile;
+    this.range = range;
+    this.text = text;
+  }
+};
+var NodeLocation = class {
+  constructor(sourceFile, path) {
+    this.sourceFile = sourceFile;
+    this.path = path;
+  }
+};
+
+// source/services/CustomRequests.ts
+import * as ls2 from "vscode-languageserver";
+var CustomRequestType = class extends ls2.RequestType {
 };
 var customRequests = {
   getLocalesAvailableForTranslation: new CustomRequestType("artel/getLocalesAvailableForTranslation"),
@@ -123,12 +151,7 @@ var customRequests = {
   emitCodeToString: new CustomRequestType("artel/emitCodeToString"),
   displayFileSystemTree: new CustomRequestType("artel/displayFileSystemTree"),
   createOrUpdateSourceFile: new CustomRequestType("artel/fs.createOrUpdateSourceFile"),
-  deleteSourceFile: new CustomRequestType("artel/fs.deleteSourceFile"),
-  getNodeRange: new CustomRequestType("artel/getNodeRange"),
-  assignField: new CustomRequestType("artel/assignField"),
-  addBlocksToScript: new CustomRequestType("artel/addBlocksToScript"),
-  canDeleteBlocksFromScript: new CustomRequestType("artel/canDeleteBlocksFromScript"),
-  deleteBlocksFromScript: new CustomRequestType("artel/deleteBlocksFromScript")
+  deleteSourceFile: new CustomRequestType("artel/fs.deleteSourceFile")
 };
 
 // source/services/LanguageServer.ts
@@ -158,36 +181,6 @@ function isGenerateMissingTranslationsCodeActionData(value) {
   return value instanceof Object && typeof value.onlyTypeMembers === "boolean";
 }
 
-// source/services/common/Types.ts
-import * as ls2 from "vscode-languageserver";
-var SourceLocation = class {
-  constructor(sourceFile, range) {
-    this.sourceFile = sourceFile;
-    this.range = range;
-  }
-};
-function isCompletionItemData(value) {
-  Debug.cast(value);
-  return value instanceof Object && typeof value.cacheId === "number" && typeof value.indexInCache === "number";
-}
-function isCodeActionData(value) {
-  Debug.cast(value);
-  return value instanceof Object && typeof value.name === "string" && value.location instanceof Object && ls2.DocumentUri.is(value.location.uri) && ls2.Position.is(value.location.position) && "data" in value;
-}
-var SourceFileEdit = class {
-  constructor(sourceFile, range, text) {
-    this.sourceFile = sourceFile;
-    this.range = range;
-    this.text = text;
-  }
-};
-var NodeLocation = class {
-  constructor(sourceFile, path) {
-    this.sourceFile = sourceFile;
-    this.path = path;
-  }
-};
-
 // source/services/a/TreeUtils.ts
 function getPrecedingToken(sourceFile, offset) {
   let token = getTokenAtOffset(sourceFile, offset, true);
@@ -566,8 +559,8 @@ var TranslationsGenerator = class _TranslationsGenerator {
         }
         return this.createPackageTypeWithMembersTranslation(entity);
       }
-      case 8 /* TypeExtension */:
-      case 10 /* TextTranslation */:
+      case 6 /* TypeExtension */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -601,9 +594,9 @@ var TranslationsGenerator = class _TranslationsGenerator {
         return this.createFieldTranslation(entity);
       case 1 /* Function */:
         return this.createMethodTranslation(entity);
-      case 5 /* Indexer */:
+      case 3 /* Indexer */:
         return this.createIndexerTranslation(entity);
-      case 6 /* DereferenceOperator */:
+      case 4 /* DereferenceOperator */:
         return void 0;
       default:
         Debug.never(entity);
@@ -640,6 +633,7 @@ var TranslationsGenerator = class _TranslationsGenerator {
         return SyntaxFactory.constructorTranslation(parameters, parameters);
       }
       case 2 /* Destructor */:
+      case 4 /* Accessor */:
         return void 0;
       default:
         Debug.never(entity.methodKind);
@@ -3872,7 +3866,7 @@ var NodeSemanticInfoServiceA = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new FieldReferenceTarget(meaning.field, meaning.accessKind, narrowedType);
+        const target = new FieldReferenceTarget(meaning.field, meaning.access.kind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -3881,7 +3875,7 @@ var NodeSemanticInfoServiceA = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new FieldReferenceTarget(meaning.field, meaning.accessKind, narrowedType);
+        const target = new FieldReferenceTarget(meaning.field, meaning.access.kind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -3890,7 +3884,7 @@ var NodeSemanticInfoServiceA = class {
         if (isNarrowableReferenceExpression(node)) {
           narrowedType = analyzer.type.ofExpression(node);
         }
-        const target = new EntityReferenceTarget(meaning.variable, meaning.accessKind, narrowedType);
+        const target = new EntityReferenceTarget(meaning.variable, meaning.access.kind, narrowedType);
         result = new ReferenceNodeSemanticInfo([target], false);
         break;
       }
@@ -4176,10 +4170,10 @@ var NodeSemanticInfoServiceA = class {
         }
         const variable = meaning.variable;
         if (variable.kind === "entity") {
-          const target = new EntityReferenceTarget(variable.value, meaning.accessKind, narrowedType);
+          const target = new EntityReferenceTarget(variable.value, meaning.access.kind, narrowedType);
           result = new ReferenceNodeSemanticInfo([target], false);
         } else if (variable.kind === "type-member") {
-          const target = new FieldReferenceTarget(variable.value, meaning.accessKind, narrowedType);
+          const target = new FieldReferenceTarget(variable.value, meaning.access.kind, narrowedType);
           result = new ReferenceNodeSemanticInfo([target], false);
         } else {
           Debug.never(variable);
@@ -4242,11 +4236,11 @@ var NodeSemanticInfoServiceA = class {
       if (isNonEmptyArray(meaning.suitableIndexers)) {
         result = createIndexersReference(
           meaning.suitableIndexers,
-          meaning.accessKind,
+          meaning.access.kind,
           meaning.suitableIndexers.length > 1
         );
       } else if (isNonEmptyArray(meaning.candidates)) {
-        result = createIndexersReference(meaning.candidates, meaning.accessKind, true);
+        result = createIndexersReference(meaning.candidates, meaning.access.kind, true);
       }
       if (result !== void 0 && options7.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -4308,7 +4302,7 @@ var NodeSemanticInfoServiceA = class {
   static ofDereferenceExpressionOperator(analyzer, node, options7) {
     const meaning = analyzer.resolveDereferenceExpression(node);
     if (meaning.kind === "resolved") {
-      const target = new DereferenceOperatorReferenceTarget(meaning.operator, meaning.accessKind);
+      const target = new DereferenceOperatorReferenceTarget(meaning.operator, meaning.access.kind);
       let result = new ReferenceNodeSemanticInfo([target], false);
       if (options7.includeBetterReferenceTargets) {
         result = this.getBetterReferenceTargetsOrPreserve(result);
@@ -4616,45 +4610,79 @@ var NodeSemanticInfoServiceA = class {
   }
   static getBetterReferenceTargetsOrPreserve(info) {
     const currentTargets = info.betterTargets ?? info.targets;
-    const betterTargets = Query.from(currentTargets).mapAndFilter((t) => this.getBetterReferenceTarget(t)).toArray();
+    const betterTargets = currentTargets.map((t) => this.getBetterReferenceTargets(t)).filter((t) => t !== void 0).flat();
     if (isNonEmptyArray(betterTargets)) {
       return new ReferenceNodeSemanticInfo(info.targets, info.isAmbiguous, betterTargets);
     }
     return info;
   }
-  static getBetterReferenceTarget(original) {
+  static getBetterReferenceTargets(original) {
     let result;
-    let currentTarget = original;
-    let betterTarget;
+    let currentTargets = [original];
+    let betterTargets;
+    let foundBetterTarget;
     do {
-      betterTarget = void 0;
-      if (currentTarget.kind === "entity" && currentTarget.entity.kind === 0 /* Variable */) {
-        {
-          if (currentTarget.entity.subkind === "parameter") {
-            const specialVariableInfo = currentTarget.entity.isSpecial();
-            if (specialVariableInfo?.kind === "implicit-function-block-parameter") {
-              betterTarget = new TypeParameterReferenceTarget(
-                specialVariableInfo.targetTypeParameter,
-                currentTarget.accessKind
-              );
+      betterTargets = [];
+      foundBetterTarget = false;
+      for (const currentTarget of currentTargets) {
+        let foundBetterCurrentTarget = false;
+        if (currentTarget.kind === "entity" && currentTarget.entity.kind === 0 /* Variable */) {
+          {
+            if (currentTarget.entity.subkind === "parameter") {
+              const specialVariableInfo = currentTarget.entity.isSpecial();
+              if (specialVariableInfo?.kind === "implicit-function-block-parameter") {
+                const target = new TypeParameterReferenceTarget(
+                  specialVariableInfo.targetTypeParameter,
+                  currentTarget.accessKind
+                );
+                betterTargets.push(target);
+                foundBetterCurrentTarget = true;
+              }
             }
           }
-        }
-      } else if (currentTarget.kind === "accessed-function") {
-        const entity = currentTarget.func.getEntity();
-        if (entity.subkind === "method" && TypeMemberEntity.isConstructor(entity) && entity.getDefinition().kind === 1 /* Intrinsic */) {
-          const containingEntity = entity.getContainingEntity();
-          if (containingEntity.kind === 2 /* Type */ && containingEntity.getDefinition().kind === 0 /* Source */) {
-            betterTarget = new EntityReferenceTarget(containingEntity, 0 /* Get */);
+        } else if (currentTarget.kind === "accessed-function") {
+          const entity = currentTarget.func.getEntity();
+          if (TypeMemberEntity.isConstructor(entity) && entity.getDefinition().kind === 1 /* Intrinsic */) {
+            const containingEntity = entity.getContainingEntity();
+            if (containingEntity.kind === 2 /* Type */ && containingEntity.getDefinition().kind === 0 /* Source */) {
+              const target = new EntityReferenceTarget(containingEntity, 0 /* Get */);
+              betterTargets.push(target);
+              foundBetterCurrentTarget = true;
+            }
           }
+        } else if (currentTarget.kind === "entity" && currentTarget.entity.kind === 1 /* Function */) {
+        } else if (currentTarget.kind === "match-result-value-parameter") {
+          const containingEntity = currentTarget.parameter.entity.getContainingEntity();
+          if (containingEntity.kind === 3 /* Indexer */ && containingEntity.getDefinition().kind === 0 /* Source */) {
+            const indexerParameters = containingEntity.getParameters();
+            const parameterIndex = indexerParameters.indexOf(currentTarget.parameter.entity);
+            if (parameterIndex >= 0) {
+              const getterParameter = containingEntity.getGetter()?.getParameters()[parameterIndex];
+              const setterParameter = containingEntity.getSetter()?.getParameters()[parameterIndex];
+              if (getterParameter !== void 0) {
+                const target = new EntityReferenceTarget(getterParameter, currentTarget.accessKind);
+                betterTargets.push(target);
+                foundBetterCurrentTarget = true;
+              }
+              if (setterParameter !== void 0) {
+                const target = new EntityReferenceTarget(setterParameter, currentTarget.accessKind);
+                betterTargets.push(target);
+                foundBetterCurrentTarget = true;
+              }
+            }
+          }
+        }
+        if (foundBetterCurrentTarget) {
+          foundBetterTarget ||= true;
+        } else {
+          betterTargets.push(currentTarget);
         }
-      } else if (currentTarget.kind === "entity" && currentTarget.entity.kind === 1 /* Function */) {
       }
-      if (betterTarget !== void 0) {
-        result = betterTarget;
-        currentTarget = betterTarget;
+      if (foundBetterTarget) {
+        result = betterTargets;
+        currentTargets = betterTargets;
       }
-    } while (betterTarget !== void 0);
+    } while (foundBetterTarget);
     return result;
   }
   static getResolvedContainingTranslationPackage(analyzer, node) {
@@ -4703,7 +4731,7 @@ var NodeSemanticInfoServiceA = class {
 
 // source/services/common/Utils.ts
 function getEntitySourceLocations(analyzer, entity) {
-  if (entity.kind === 9 /* Package */) {
+  if (entity.kind === 7 /* Package */) {
     return void 0;
   }
   let result;
@@ -4724,7 +4752,7 @@ function getEntitySourceLocations(analyzer, entity) {
         Debug.never(definition.value);
       }
     }
-  } else if (entity.kind === 5 /* Indexer */) {
+  } else if (entity.kind === 3 /* Indexer */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       result = definition.nodes.map((d) => {
@@ -4733,7 +4761,7 @@ function getEntitySourceLocations(analyzer, entity) {
         return new SourceLocation(sourceFile, range);
       });
     }
-  } else if (entity.kind === 6 /* DereferenceOperator */) {
+  } else if (entity.kind === 4 /* DereferenceOperator */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       result = definition.nodes.map((d) => {
@@ -4742,7 +4770,7 @@ function getEntitySourceLocations(analyzer, entity) {
         return new SourceLocation(sourceFile, range);
       });
     }
-  } else if (entity.kind === 10 /* TextTranslation */) {
+  } else if (entity.kind === 8 /* TextTranslation */) {
     const definition = entity.getDefinition();
     if (definition.kind === 0 /* Source */) {
       const range = definition.node.rangeWithoutTrivia;
@@ -5385,22 +5413,8 @@ var HoverService = class {
     }
   }
   createHoverAtAccessedFunction(func, range) {
-    switch (func.kind) {
-      case "entity": {
-        const declaration = new FunctionDeclaration_entity(func.value);
-        return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
-      }
-      case "type-member": {
-        const declaration = new FunctionDeclaration_typeMember(func.value);
-        return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
-      }
-      case "substituted-function": {
-        const declaration = new FunctionDeclaration_substitutedFunction(func.value);
-        return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
-      }
-      default:
-        Debug.never(func);
-    }
+    const declaration = new FunctionDeclaration_accessedFunction(func);
+    return new Hover(this.displayService.displayFunctionDeclaration(declaration), range);
   }
 };
 
@@ -5609,7 +5623,7 @@ var ReferencesFinder = class {
         return void 0;
       }
     } else if (this.definitions.length > 1 && potentialReferenceDefinitions.length > 1) {
-      if (this.definitions.length === potentialReferenceDefinitions.length && this.definitions.every((d) => potentialReferenceDefinitions.some((rd) => this.areEntitiesWithSameDefinition(rd.value, d.value)))) {
+      if (potentialReferenceDefinitions.some((r) => this.definitions.some((d) => this.areEntitiesWithSameDefinition(r.value, d.value)))) {
         return potentialReferenceDefinitions[0].referenceKind;
       } else {
         return void 0;
@@ -5639,7 +5653,7 @@ var ReferencesFinderA = class extends ReferencesFinder {
     return __async(this, null, function* () {
       let semanticInfoOptions;
       const firstDefinition = this.definitions[0].value;
-      if (firstDefinition.kind === 1 /* Function */ && firstDefinition.subkind === "method" && TypeMemberEntity.isConstructor(firstDefinition)) {
+      if (TypeMemberEntity.isConstructor(firstDefinition)) {
         semanticInfoOptions = {
           preferredTargetOfExplicitConstructorCall: "constructor-declaration",
           includeBetterReferenceTargets: true
@@ -5889,6 +5903,7 @@ var ReferencesService = class {
       if (definitions.length === 0) {
         return [];
       }
+      this.expandDefinitionsArray(definitions);
       const result = [];
       const firstDefinition = definitions[0];
       const restrictions = this.getReferenceRestrictions(firstDefinition, options7);
@@ -5907,6 +5922,46 @@ var ReferencesService = class {
       return result;
     });
   }
+  expandDefinitionsArray(definitions) {
+    const length = definitions.length;
+    for (let i = 0; i < length; i++) {
+      const definition = definitions[i];
+      if (definition.value.kind === 0 /* Variable */ && definition.value.subkind === "parameter") {
+        const containingEntity = definition.value.getContainingEntity();
+        if (containingEntity.kind === 3 /* Indexer */) {
+          const parameterIndex = containingEntity.getParameters().indexOf(definition.value);
+          if (parameterIndex >= 0) {
+            const getterParameter = containingEntity.getGetter()?.getParameters()[parameterIndex];
+            if (getterParameter !== void 0 && !definitions.some((d) => d.value === getterParameter)) {
+              definitions.push(new DefinitionInfo(getterParameter, definition.referenceKind));
+            }
+            const setterParameter = containingEntity.getSetter()?.getParameters()[parameterIndex];
+            if (setterParameter !== void 0 && !definitions.some((d) => d.value === setterParameter)) {
+              definitions.push(new DefinitionInfo(setterParameter, definition.referenceKind));
+            }
+          }
+        } else if (TypeMemberEntity.isAccessor(containingEntity)) {
+          const accessorOwner = containingEntity.getAccessorOwner();
+          if (accessorOwner?.kind === 3 /* Indexer */) {
+            const parameterIndex = containingEntity.getParameters().indexOf(definition.value);
+            if (parameterIndex >= 0) {
+              const indexerParameter = accessorOwner.getParameters()[parameterIndex];
+              if (indexerParameter !== void 0 && !definitions.some((d) => d.value === indexerParameter)) {
+                definitions.push(new DefinitionInfo(indexerParameter, definition.referenceKind));
+              }
+            }
+            const otherAccessor = AccessorEntity.isGetter(containingEntity) ? accessorOwner.getSetter() : accessorOwner.getGetter();
+            if (otherAccessor !== void 0) {
+              const otherAccessorParameter = otherAccessor.getParameters()[parameterIndex];
+              if (otherAccessorParameter !== void 0 && !definitions.some((d) => d.value === otherAccessorParameter)) {
+                definitions.push(new DefinitionInfo(otherAccessorParameter, definition.referenceKind));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
   getReferencedDefinitionInfosAtOffset(analyzer, sourceFile, offset, options7) {
     switch (sourceFile.dialect) {
       case 0 /* ArtelA */:
@@ -5920,7 +5975,7 @@ var ReferencesService = class {
   getReferenceRestrictions(definition, _options) {
     const result = new ReferenceRestrictions();
     let namedDefinitionInfo;
-    if (definition.value.kind === 1 /* Function */ && definition.value.subkind === "method" && TypeMemberEntity.isConstructor(definition.value)) {
+    if (TypeMemberEntity.isConstructor(definition.value)) {
       const type = TypeWithMembersOrExtensionEntity.getContextualTypeEntity(definition.value.getContainingEntity());
       if (type !== void 0) {
         namedDefinitionInfo = this.isEntityWithRegularName(type);
@@ -5931,12 +5986,12 @@ var ReferencesService = class {
     if (namedDefinitionInfo !== void 0) {
       result.canBeIdentifier = true;
     }
-    const isConstructor = definition.value.kind === 1 /* Function */ && definition.value.subkind === "method" && TypeMemberEntity.isConstructor(definition.value);
+    const isConstructor = TypeMemberEntity.isConstructor(definition.value);
     if (isConstructor) {
       result.canBeAutotypeCall = true;
       result.canBeConstructorDeclaration = true;
     }
-    if (definition.value.kind === 6 /* DereferenceOperator */) {
+    if (definition.value.kind === 4 /* DereferenceOperator */) {
       result.canBeDereferenceOperator = true;
     }
     if (isTypeEntity(definition.value) || isConstructor) {
@@ -5945,7 +6000,7 @@ var ReferencesService = class {
     if (definition.value.kind === 1 /* Function */) {
       result.canBeBaseExpression = true;
     }
-    if (definition.value.kind === 5 /* Indexer */) {
+    if (definition.value.kind === 3 /* Indexer */) {
       result.canBeIndexer = true;
     }
     if (definition.value.kind === 0 /* Variable */ && definition.value.subkind === "parameter" && definition.value.isObjectParameter()) {
@@ -6010,15 +6065,13 @@ var ReferencesService = class {
         }
         return void 0;
       }
-      case 7 /* PackageAlias */:
+      case 5 /* PackageAlias */:
         return { name: entity.getName() };
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 5 /* Indexer */:
-      case 6 /* DereferenceOperator */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
-      case 10 /* TextTranslation */:
+      case 3 /* Indexer */:
+      case 4 /* DereferenceOperator */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -6164,155 +6217,6 @@ var RenameServiceA = class extends RenameService {
   }
 };
 
-// source/services/common/script-editing/ScriptEditingService.ts
-var ScriptEditingService = class _ScriptEditingService {
-  static {
-    this.indentationStep = "  ";
-  }
-  static {
-    this.elementParameterNameText = "o";
-  }
-  static {
-    this.elementParameterName = new Name(_ScriptEditingService.elementParameterNameText);
-  }
-  createScriptBlockText(blockInfo, indentation, newLine) {
-    const i = indentation;
-    const s = _ScriptEditingService.indentationStep;
-    const nl = newLine;
-    const el = _ScriptEditingService.elementParameterNameText;
-    let result = `${i}${blockInfo.name}(${nl}${i}${s}key = ${blockInfo.key},${nl}`;
-    if (blockInfo.areaIndex !== void 0) {
-      result += `${i}${s}areaIndex = ${blockInfo.areaIndex},${nl}`;
-    }
-    result += `${i}${s}body =${nl}${i}${s}{${nl}` + Object.entries(blockInfo.elementProperties).map(([p, v]) => `${i}${s}${s}${el}.${p} = ${v}${nl}`).join("");
-    if (blockInfo.nestedBlocks.length > 0) {
-      result += blockInfo.nestedBlocks.map((b) => this.createScriptBlockText(b, `${i}${s}${s}`, nl) + nl).join("");
-    }
-    result += `${i}${s}})`;
-    return result;
-  }
-  detectNewLine(text) {
-    return text.includes("\r\n") ? "\r\n" : "\n";
-  }
-};
-
-// source/services/a/ScriptEditingService.ts
-var ScriptEditingServiceA = class _ScriptEditingServiceA extends ScriptEditingService {
-  createEditWithFieldAssignment(analyzer, sourceFile, scriptDeclaration, fieldName, value) {
-    const subprogramBlock = scriptDeclaration.block;
-    if (subprogramBlock === void 0) {
-      return void 0;
-    }
-    const lastAssignmentStatement = this.findLastAssignmentToField(analyzer, subprogramBlock, fieldName);
-    let result;
-    if (lastAssignmentStatement !== void 0) {
-      result = new SourceFileEdit(sourceFile, lastAssignmentStatement.right.rangeWithoutTrivia, value);
-    } else {
-      const assignmentText = `${_ScriptEditingServiceA.elementParameterNameText}.${fieldName} = ${value}`;
-      const lastStatement = subprogramBlock.statementList?.statements.last();
-      let editRange;
-      let indentationText;
-      if (lastStatement !== void 0) {
-        editRange = Range.empty(lastStatement.rangeWithoutTrivia.end);
-        const statementStartCharacter = sourceFile.getPositionAt(lastStatement.rangeWithoutTrivia.start).character;
-        indentationText = `${this.detectNewLine(sourceFile.getSourceText())}${" ".repeat(statementStartCharacter)}`;
-      } else {
-        const openBraceRange = subprogramBlock.openBraceToken.rangeWithoutTrivia;
-        const closeBraceRange = subprogramBlock.closeBraceToken.rangeWithoutTrivia;
-        const openBracePosition = sourceFile.getPositionAt(openBraceRange.start);
-        const closeBracePosition = sourceFile.getPositionAt(closeBraceRange.start);
-        if (openBracePosition.line !== closeBracePosition.line) {
-          editRange = Range.empty(openBraceRange.end);
-          indentationText = `${this.detectNewLine(sourceFile.getSourceText())}${" ".repeat(closeBracePosition.character + 2)}`;
-        } else {
-          editRange = Range.empty(openBraceRange.end);
-          indentationText = " ";
-        }
-      }
-      result = new SourceFileEdit(sourceFile, editRange, `${indentationText}${assignmentText}`);
-    }
-    return result;
-  }
-  createEditAddingBlocks(sourceFile, scriptDeclaration, addedBlockInfos) {
-    const subprogramBlock = scriptDeclaration.block;
-    if (subprogramBlock === void 0) {
-      return void 0;
-    }
-    let scriptBlockIndentation;
-    let editStart;
-    const lastStatement = subprogramBlock.statementList.statements.last();
-    if (lastStatement !== void 0) {
-      const lastStatementStartCharacter = sourceFile.getPositionAt(lastStatement.rangeWithoutTrivia.start).character;
-      scriptBlockIndentation = " ".repeat(lastStatementStartCharacter);
-      editStart = lastStatement.rangeWithoutTrivia.end;
-    } else {
-      const openBraceStartCharacter = sourceFile.getPositionAt(subprogramBlock.openBraceToken.rangeWithoutTrivia.start).character;
-      scriptBlockIndentation = " ".repeat(openBraceStartCharacter) + _ScriptEditingServiceA.indentationStep;
-      editStart = subprogramBlock.openBraceToken.rangeWithoutTrivia.end;
-    }
-    const newLine = this.detectNewLine(sourceFile.getSourceText());
-    const scriptBlocksText = addedBlockInfos.map((i) => this.createScriptBlockText(i, scriptBlockIndentation, newLine)).join(newLine);
-    const editText = `${newLine}${scriptBlocksText}`;
-    const result = new SourceFileEdit(sourceFile, Range.empty(editStart), editText);
-    return result;
-  }
-  canDeleteBlocks(outerScriptFunctionLocation, scriptFunctionLocations) {
-    const outerScriptPathText = outerScriptFunctionLocation.path.toString();
-    return scriptFunctionLocations.every((l) => l.sourceFile === outerScriptFunctionLocation.sourceFile && l.path.toString().startsWith(outerScriptPathText));
-  }
-  createEditDeletingBlock(sourceFile, scriptDeclaration) {
-    let result;
-    if (isRegularOrBlockFunctionLiteral(scriptDeclaration) && scriptDeclaration.parent.kind === 148 /* Argument */ && scriptDeclaration.parent.parent.parent.kind === 65 /* CallExpression */) {
-      const callExpression = scriptDeclaration.parent.parent.parent;
-      let rangeStart = callExpression.rangeWithoutTrivia.start;
-      let rangeEnd = callExpression.rangeWithoutTrivia.end;
-      const leadingTrivia = callExpression.findLeftmostToken()?.selectLeadingTrivia(() => true);
-      const lastLeadingTrivia = leadingTrivia !== void 0 && leadingTrivia.length > 0 ? leadingTrivia[leadingTrivia.length - 1] : void 0;
-      if (lastLeadingTrivia?.kind === 0 /* Whitespace */) {
-        rangeStart = lastLeadingTrivia.range.start;
-      }
-      const trailingTrivia = callExpression.findRightmostToken()?.selectTrailingTrivia(() => true);
-      if (trailingTrivia !== void 0) {
-        let trailingTriviaIndex = -1;
-        if (trailingTrivia.length > trailingTriviaIndex + 1 && trailingTrivia[trailingTriviaIndex + 1].kind === 0 /* Whitespace */) {
-          trailingTriviaIndex++;
-        }
-        if (trailingTrivia.length > trailingTriviaIndex + 1 && trailingTrivia[trailingTriviaIndex + 1].kind === 1 /* NewLine */) {
-          trailingTriviaIndex++;
-        }
-        if (trailingTriviaIndex >= 0) {
-          rangeEnd = trailingTrivia[trailingTriviaIndex].range.end;
-        }
-      }
-      result = new SourceFileEdit(sourceFile, new Range(rangeStart, rangeEnd), "");
-    }
-    return result;
-  }
-  findLastAssignmentToField(analyzer, block, fieldNameText) {
-    const fieldName = new Name(fieldNameText);
-    const statements = block.statementList.statements.toArray();
-    for (let i = statements.length - 1; i >= 0; i--) {
-      const statement = statements[i];
-      if (statement.kind === 90 /* AssignmentStatement */) {
-        const left = statement.left.unwrapParenthesizedExpressions();
-        if (left.kind === 73 /* MemberAccessExpression */) {
-          const memberAccessMeaning = analyzer.resolveMemberAccessExpression(left);
-          if (memberAccessMeaning.kind === "instance-field-access" && memberAccessMeaning.field.getName().considerEqual(fieldName)) {
-            const receiver = left.expression.unwrapParenthesizedExpressions();
-            if (receiver.kind === 86 /* IdentifierExpression */) {
-              const receiverMeaning = analyzer.resolveIdentifierExpression(receiver);
-              if (receiverMeaning.kind === "variable-access" && receiverMeaning.variable.getName().considerEqual(_ScriptEditingServiceA.elementParameterName)) {
-                return statement;
-              }
-            }
-          }
-        }
-      }
-    }
-    return void 0;
-  }
-};
-
 // source/services/common/selection-rage/Types.ts
 var SelectionRange = class {
   constructor(range, parent) {
@@ -9798,7 +9702,7 @@ var EntityToSyntax = class {
     const tags = this.convertTags(entity.getTags());
     const modifiers = this.convertPackageVariableModifiers(entity);
     let result;
-    if (isComputedVariableEntity(entity)) {
+    if (isVariableEntityWithExplicitAccessors(entity)) {
       result = [];
       const getterEntity = entity.getGetter();
       if (getterEntity !== void 0) {
@@ -9806,7 +9710,7 @@ var EntityToSyntax = class {
       }
       const setterEntity = entity.getSetter();
       if (setterEntity !== void 0) {
-        result.push(SyntaxFactory.packageVariableSetterDeclaration(tags, modifiers, name, void 0));
+        result.push(SyntaxFactory.packageVariableSetterDeclaration(tags, modifiers, name, type, void 0));
       }
     } else {
       result = SyntaxFactory.packageVariableDeclaration(tags, modifiers, name, type);
@@ -9967,9 +9871,9 @@ var EntityToSyntax = class {
     return sortModifiers(modifiers);
   }
   convertTypeEntityMembers(members) {
-    const variables = members.getNamedMembers(127 /* All */).filter((m) => m.kind === 0 /* Variable */).flatMap((m) => this.convertField(m));
+    const variables = members.getNamedMembers(255 /* All */).filter((m) => m.kind === 0 /* Variable */).flatMap((m) => this.convertField(m));
     const groupedVariables = this.groupTypeMemberDeclarations(variables);
-    const ordinaryMethods = members.getNamedMembers(127 /* All */).filter((m) => TypeMemberEntity.isOrdinaryMethod(m)).map((m) => this.convertMethod(m));
+    const ordinaryMethods = members.getNamedMembers(255 /* All */).filter((m) => TypeMemberEntity.isOrdinaryMethod(m)).map((m) => this.convertMethod(m));
     const groupedOrdinaryMethods = this.groupTypeMemberDeclarations(ordinaryMethods);
     const operators = members.getOperators().map((m) => this.convertMethod(m));
     const groupedOperators = this.groupTypeMemberDeclarations(operators);
@@ -9979,11 +9883,14 @@ var EntityToSyntax = class {
     const groupedDestructors = this.groupTypeMemberDeclarations(destructors);
     const indexers = members.getIndexers().flatMap((i) => this.convertIndexer(i));
     const groupedIndexers = this.groupTypeMemberDeclarations(indexers);
+    const dereferenceOperators = members.getDereferenceOperators().flatMap((i) => this.convertDereferenceOperator(i));
+    const groupedDereferenceOperators = this.groupTypeMemberDeclarations(dereferenceOperators);
     return groupedVariables.concat(
       groupedIndexers,
       groupedConstructors,
       groupedOrdinaryMethods,
       groupedOperators,
+      groupedDereferenceOperators,
       groupedDestructors
     );
   }
@@ -9991,22 +9898,22 @@ var EntityToSyntax = class {
     if (entity.isVariant()) {
       return this.convertVariant(entity);
     }
-    const name = this.getEntityName(entity);
-    const type = this.convertType(entity.getType());
-    const tags = this.convertTags(entity.getTags());
-    const modifiers = this.convertFieldModifiers(entity);
     let result;
-    if (isComputedVariableEntity(entity)) {
+    if (isVariableEntityWithExplicitAccessors(entity)) {
       result = [];
       const getterEntity = entity.getGetter();
       if (getterEntity !== void 0) {
-        result.push(SyntaxFactory.fieldGetterDeclaration(tags, modifiers, name, type, void 0));
+        result.push(this.convertTypeMemberAccessor(getterEntity));
       }
       const setterEntity = entity.getSetter();
       if (setterEntity !== void 0) {
-        result.push(SyntaxFactory.fieldSetterDeclaration(tags, modifiers, name, void 0));
+        result.push(this.convertTypeMemberAccessor(setterEntity));
       }
     } else {
+      const name = this.getEntityName(entity);
+      const type = this.convertType(entity.getType());
+      const tags = this.convertTags(entity.getTags());
+      const modifiers = this.convertFieldModifiers(entity);
       result = SyntaxFactory.fieldDeclaration(tags, modifiers, name, type);
     }
     return result;
@@ -10058,6 +9965,8 @@ var EntityToSyntax = class {
         const parameters = this.convertParameters(entity.getParameters());
         return SyntaxFactory.destructorDeclaration(tags, modifiers, parameters, void 0);
       }
+      case 4 /* Accessor */:
+        return this.convertTypeMemberAccessor(entity);
       default:
         Debug.never(entity.methodKind);
     }
@@ -10104,25 +10013,64 @@ var EntityToSyntax = class {
     }
     return sortModifiers(modifiers);
   }
-  convertIndexer(entity) {
-    const tags = this.convertTags(entity.getTags());
-    const modifiers = this.convertIndexerModifiers(entity);
-    const parameters = this.convertParameters(entity.getParameters());
-    const result = new Array();
-    const getterEntity = entity.getGetter();
-    if (getterEntity !== void 0) {
-      const type = this.convertType(entity.getType());
-      const declaration = SyntaxFactory.indexedElementGetterDeclaration(tags, modifiers, parameters, type, void 0);
-      result.push(declaration);
+  convertTypeMemberAccessor(entity) {
+    const accessorKind = entity.accessorKind;
+    if (accessorKind === void 0) {
+      return SyntaxFactory.missingTypeMemberDeclaration([], []);
     }
-    const setterEntity = entity.getSetter();
-    if (setterEntity !== void 0) {
-      const declaration = SyntaxFactory.indexedElementSetterDeclaration(tags, modifiers, parameters, void 0);
-      result.push(declaration);
+    const tags = this.convertTags(entity.getTags());
+    const modifiers = this.convertAccessorModifiers(entity);
+    switch (accessorKind) {
+      case 2 /* FieldGetter */: {
+        const owningEntity = entity.getAccessorOwner();
+        if (owningEntity?.kind !== 0 /* Variable */) {
+          return SyntaxFactory.missingTypeMemberDeclaration([], []);
+        }
+        const name = this.getEntityName(owningEntity);
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.fieldGetterDeclaration(tags, modifiers, name, type, void 0);
+      }
+      case 3 /* FieldSetter */: {
+        const owningEntity = entity.getAccessorOwner();
+        if (owningEntity?.kind !== 0 /* Variable */) {
+          return SyntaxFactory.missingTypeMemberDeclaration([], []);
+        }
+        const type = this.convertType(owningEntity.getType());
+        const name = this.getEntityName(owningEntity);
+        return SyntaxFactory.fieldSetterDeclaration(tags, modifiers, name, type, void 0);
+      }
+      case 4 /* IndexedElementGetter */: {
+        const parameters = this.convertParameters(entity.getParameters());
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.indexedElementGetterDeclaration(tags, modifiers, parameters, type, void 0);
+      }
+      case 5 /* IndexedElementSetter */: {
+        const owningEntity = entity.getAccessorOwner();
+        if (owningEntity?.kind !== 3 /* Indexer */) {
+          return SyntaxFactory.missingTypeMemberDeclaration([], []);
+        }
+        const parameterEntities = entity.getParameters();
+        const parameters = this.convertParameters(parameterEntities.slice(0, parameterEntities.length - 1));
+        const type = this.convertType(owningEntity.getType());
+        return SyntaxFactory.indexedElementSetterDeclaration(tags, modifiers, parameters, type, void 0);
+      }
+      case 6 /* DereferencedVariableGetter */: {
+        const type = this.convertType(entity.getReturnType());
+        return SyntaxFactory.dereferencedVariableGetterDeclaration(tags, modifiers, type, void 0);
+      }
+      case 7 /* DereferencedVariableSetter */: {
+        const owningEntity = entity.getAccessorOwner();
+        if (owningEntity?.kind !== 4 /* DereferenceOperator */) {
+          return SyntaxFactory.missingTypeMemberDeclaration([], []);
+        }
+        const type = this.convertType(owningEntity.getType());
+        return SyntaxFactory.dereferencedVariableSetterDeclaration(tags, modifiers, type, void 0);
+      }
+      default:
+        Debug.never(accessorKind);
     }
-    return result;
   }
-  convertIndexerModifiers(entity) {
+  convertAccessorModifiers(entity) {
     const modifiers = new Array();
     const isHidden = entity.isHidden();
     if (isHidden !== void 0) {
@@ -10131,11 +10079,41 @@ var EntityToSyntax = class {
     if (entity.isStatic()) {
       modifiers.push(SyntaxFactory.modifier(45 /* Static */));
     }
+    if (entity.markedBasic()) {
+      modifiers.push(SyntaxFactory.modifier(21 /* Basic */));
+    }
     if (entity.markedAbstract()) {
       modifiers.push(SyntaxFactory.modifier(42 /* Abstract */));
     }
+    if (entity.isOverride()) {
+      modifiers.push(SyntaxFactory.modifier(43 /* Override */));
+    }
     return sortModifiers(modifiers);
   }
+  convertIndexer(entity) {
+    const result = new Array();
+    const getterEntity = entity.getGetter();
+    if (getterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(getterEntity));
+    }
+    const setterEntity = entity.getSetter();
+    if (setterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(setterEntity));
+    }
+    return result;
+  }
+  convertDereferenceOperator(entity) {
+    const result = new Array();
+    const getterEntity = entity.getGetter();
+    if (getterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(getterEntity));
+    }
+    const setterEntity = entity.getSetter();
+    if (setterEntity !== void 0) {
+      result.push(this.convertTypeMemberAccessor(setterEntity));
+    }
+    return result;
+  }
   convertVariant(entity) {
     const tags = this.convertTags(entity.getTags());
     const name = this.getEntityName(entity);
@@ -10616,19 +10594,16 @@ var SourceGenerationService = class extends RxObject7 {
           default:
             Debug.never(entity);
         }
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-        return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getOwningEntity());
-      case 5 /* Indexer */:
-      case 6 /* DereferenceOperator */:
+      case 3 /* Indexer */:
+      case 4 /* DereferenceOperator */:
         return this.checkIfEntityOfKindIsPresentInGeneratedCode(entity.getContainingEntity());
-      case 7 /* PackageAlias */:
+      case 5 /* PackageAlias */:
         return false;
-      case 9 /* Package */:
+      case 7 /* Package */:
         return false;
-      case 8 /* TypeExtension */:
+      case 6 /* TypeExtension */:
         return true;
-      case 10 /* TextTranslation */:
+      case 8 /* TextTranslation */:
         return true;
       default:
         Debug.never(entity);
@@ -10719,17 +10694,15 @@ var EntityFinder = class {
           default:
             Debug.never(entity);
         }
-      case 5 /* Indexer */:
+      case 3 /* Indexer */:
         return this.findIndexerEntity(entity);
-      case 6 /* DereferenceOperator */:
+      case 4 /* DereferenceOperator */:
         return this.findDereferenceOperatorEntity(entity);
-      case 7 /* PackageAlias */:
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
+      case 5 /* PackageAlias */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
         return void 0;
-      case 10 /* TextTranslation */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -10741,7 +10714,7 @@ var EntityFinder = class {
     } else if (entity.subkind === "field") {
       const containingType = this.findEntity(entity.getContainingEntity());
       if (containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType)) {
-        return containingType.getMembers().getNamedMembersByName(entity.getName(), 127 /* All */)[0];
+        return containingType.getMembers().getNamedMembersByName(entity.getName(), 255 /* All */)[0];
       }
     } else if (entity.subkind === "parameter") {
       const originalContainingEntity = entity.getContainingEntity();
@@ -10776,7 +10749,7 @@ var EntityFinder = class {
         if (!(containingType !== void 0 && isTypeEntity(containingType) && isTypeEntityWithMembers(containingType))) {
           return void 0;
         }
-        const members = containingType.getMembers().getNamedMembersByName(entity.getSpecialNameOrName(), 127 /* All */).filter((m) => m.kind === 1 /* Function */);
+        const members = containingType.getMembers().getNamedMembersByName(entity.getSpecialNameOrName(), 255 /* All */).filter((m) => m.kind === 1 /* Function */);
         if (members.length === 0) {
           return void 0;
         } else if (members.length === 1) {
@@ -10845,7 +10818,7 @@ var EntityFinder = class {
     switch (entity.kind) {
       case 1 /* Function */:
         return entity.getParameters();
-      case 5 /* Indexer */:
+      case 3 /* Indexer */:
         return entity.getParameters();
       case 2 /* Type */: {
         if (entity.typeEntityKind === 0 /* Function */) {
@@ -10854,14 +10827,12 @@ var EntityFinder = class {
         return void 0;
       }
       case 0 /* Variable */:
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 7 /* PackageAlias */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
-      case 6 /* DereferenceOperator */:
+      case 5 /* PackageAlias */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
+      case 4 /* DereferenceOperator */:
         return void 0;
-      case 10 /* TextTranslation */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -10877,15 +10848,13 @@ var EntityFinder = class {
         }
         return void 0;
       }
-      case 5 /* Indexer */:
-      case 6 /* DereferenceOperator */:
+      case 3 /* Indexer */:
+      case 4 /* DereferenceOperator */:
       case 0 /* Variable */:
-      case 3 /* Getter */:
-      case 4 /* Setter */:
-      case 7 /* PackageAlias */:
-      case 9 /* Package */:
-      case 8 /* TypeExtension */:
-      case 10 /* TextTranslation */:
+      case 5 /* PackageAlias */:
+      case 7 /* Package */:
+      case 6 /* TypeExtension */:
+      case 8 /* TextTranslation */:
         return void 0;
       default:
         Debug.never(entity);
@@ -10965,7 +10934,6 @@ var _LanguageServer = class _LanguageServer {
     this.signatureHelpServiceA = new SignatureHelpServiceA();
     this.fileSystemTreeDisplayService = new FileSystemTreeDisplayService();
     this.selectionRangeServiceA = new SelectionRangeServiceA();
-    this.scriptEditingServiceA = new ScriptEditingServiceA();
     this.codeActionsServiceA = new CodeActionsServiceA();
     this.connection = config.connection;
     this.config = config;
@@ -10984,6 +10952,22 @@ var _LanguageServer = class _LanguageServer {
   static {
     this.DefaultCancellationTokenThrottleTime = 50;
   }
+  registerMessageHandler(handler) {
+    switch (handler.kind) {
+      case "request": {
+        const disposable = this.connection.onRequest(handler.requestType, (params, token) => this.withTaskController(token, (taskController) => handler.onRequest(params, this.getOrCreateMessageHandlerContext(), taskController)));
+        this.disposables.push(disposable);
+        break;
+      }
+      case "notification": {
+        const disposable = this.connection.onNotification(handler.notificationType, (params) => this.withTaskController(void 0, (taskController) => handler.onNotification(params, this.getOrCreateMessageHandlerContext(), taskController)));
+        this.disposables.push(disposable);
+        break;
+      }
+      default:
+        Debug.never(handler);
+    }
+  }
   start() {
     let disposable;
     disposable = this.connection.onInitialize((params) => this.onInitialize(params));
@@ -11060,16 +11044,6 @@ var _LanguageServer = class _LanguageServer {
       (params) => this.onDeleteSourceFile(params)
     );
     this.disposables.push(disposable);
-    disposable = this.connection.onRequest(customRequests.getNodeRange, (params, token) => this.withTaskController(token, (taskController) => this.onGetNodeRange(params, taskController)));
-    this.disposables.push(disposable);
-    disposable = this.connection.onRequest(customRequests.assignField, (params, token) => this.withTaskController(token, (taskController) => this.onAssignField(params, taskController)));
-    this.disposables.push(disposable);
-    disposable = this.connection.onRequest(customRequests.addBlocksToScript, (params, token) => this.withTaskController(token, (taskController) => this.onAddBlocksToScript(params, taskController)));
-    this.disposables.push(disposable);
-    disposable = this.connection.onRequest(customRequests.canDeleteBlocksFromScript, (params, token) => this.withTaskController(token, (taskController) => this.onCanDeleteBlocksFromScript(params, taskController)));
-    this.disposables.push(disposable);
-    disposable = this.connection.onRequest(customRequests.deleteBlocksFromScript, (params, token) => this.withTaskController(token, (taskController) => this.onDeleteBlocksFromScript(params, taskController)));
-    this.disposables.push(disposable);
     this.connection.listen();
   }
   dispose() {
@@ -11714,143 +11688,6 @@ var _LanguageServer = class _LanguageServer {
     const code = diagnostic.data.code;
     return { message, range, severity, tags, code };
   }
-  onAssignField(params, taskController) {
-    return __async(this, null, function* () {
-      const scriptFunctionUri = URI.parse(params.scriptFunctionUri);
-      const sourceFileContext = yield this.getSourceFileContext(scriptFunctionUri, taskController);
-      if (sourceFileContext !== void 0) {
-        const { analyzer, sourceFile } = sourceFileContext;
-        let sourceFileEdit;
-        switch (sourceFile.dialect) {
-          case 0 /* ArtelA */: {
-            const scriptDeclaration = NodePath.parse(scriptFunctionUri.fragment).getNode(sourceFile.getSyntaxNode());
-            if (scriptDeclaration !== void 0 && isSubprogramDeclarationOrLiteral(scriptDeclaration)) {
-              sourceFileEdit = this.scriptEditingServiceA.createEditWithFieldAssignment(
-                analyzer.dialectA,
-                sourceFile,
-                scriptDeclaration,
-                params.fieldName,
-                params.value
-              );
-            }
-            break;
-          }
-          case 1 /* ArtelM */:
-            break;
-          default:
-            Debug.never(sourceFile);
-        }
-        if (sourceFileEdit !== void 0) {
-          const textDocumentEdit = this.convertSourceFileEdit(sourceFileEdit);
-          const workspaceEdit = { documentChanges: [textDocumentEdit] };
-          yield this.connection.workspace.applyEdit(workspaceEdit);
-        }
-      }
-    });
-  }
-  onAddBlocksToScript(params, taskController) {
-    return __async(this, null, function* () {
-      const sourceFileEdits = new Array();
-      const convertAddedScriptBlock = (block) => {
-        return {
-          name: block.name,
-          key: block.key,
-          areaIndex: block.areaIndex,
-          elementProperties: block.elementProperties ?? {},
-          nestedBlocks: block.nestedBlocks?.map(convertAddedScriptBlock) ?? []
-        };
-      };
-      for (const scriptBlockAddedToOuterScript of params) {
-        const scriptFunctionUri = URI.parse(scriptBlockAddedToOuterScript.outerScriptFunctionUri);
-        const sourceFileContext = yield this.getSourceFileContext(scriptFunctionUri, taskController);
-        if (sourceFileContext !== void 0) {
-          const { sourceFile } = sourceFileContext;
-          let sourceFileEdit;
-          switch (sourceFile.dialect) {
-            case 0 /* ArtelA */: {
-              const scriptDeclaration = NodePath.parse(scriptFunctionUri.fragment).getNode(sourceFile.getSyntaxNode());
-              if (scriptDeclaration !== void 0 && isSubprogramDeclarationOrLiteral(scriptDeclaration)) {
-                const addedBlockInfos = scriptBlockAddedToOuterScript.values.map(convertAddedScriptBlock);
-                sourceFileEdit = this.scriptEditingServiceA.createEditAddingBlocks(
-                  sourceFile,
-                  scriptDeclaration,
-                  addedBlockInfos
-                );
-              }
-              break;
-            }
-            case 1 /* ArtelM */:
-              break;
-            default:
-              Debug.never(sourceFile);
-          }
-          if (sourceFileEdit !== void 0) {
-            sourceFileEdits.push(sourceFileEdit);
-          }
-        }
-      }
-      if (sourceFileEdits.length > 0) {
-        const workspaceEdit = this.convertSourceFileEditsToWorkspaceEdit(sourceFileEdits);
-        yield this.connection.workspace.applyEdit(workspaceEdit);
-      }
-    });
-  }
-  onCanDeleteBlocksFromScript(params, taskController) {
-    return __async(this, null, function* () {
-      let result = false;
-      const outerScriptFunctionUri = URI.parse(params.outerScriptFunctionUri);
-      const sourceFileContext = yield this.getSourceFileContext(outerScriptFunctionUri, taskController);
-      if (sourceFileContext !== void 0) {
-        const outerScriptFunctionLocation = new NodeLocation(
-          sourceFileContext.sourceFile,
-          NodePath.parse(outerScriptFunctionUri.fragment)
-        );
-        const scriptFunctionLocations = Query.from(params.scriptFunctionUris).map((u) => {
-          const parsedVscodeUri = URI.parse(u);
-          const uri = this.convertVscodeUriToUri(parsedVscodeUri);
-          const sourceFile = sourceFileContext.analyzer.compilation.getSourceFileByUri(uri);
-          return sourceFile !== void 0 ? new NodeLocation(sourceFile, NodePath.parse(parsedVscodeUri.fragment)) : void 0;
-        }).toNullable();
-        if (scriptFunctionLocations !== void 0) {
-          result = this.scriptEditingServiceA.canDeleteBlocks(outerScriptFunctionLocation, scriptFunctionLocations);
-        }
-      }
-      return result;
-    });
-  }
-  onDeleteBlocksFromScript(params, taskController) {
-    return __async(this, null, function* () {
-      const sourceFileEdits = new Array();
-      for (const scriptFunctionUri of params.scriptFunctionUris) {
-        const parsedScriptFunctionUri = URI.parse(scriptFunctionUri);
-        const sourceFileContext = yield this.getSourceFileContext(parsedScriptFunctionUri, taskController);
-        if (sourceFileContext !== void 0) {
-          const { sourceFile } = sourceFileContext;
-          let sourceFileEdit;
-          switch (sourceFile.dialect) {
-            case 0 /* ArtelA */: {
-              const scriptDeclaration = NodePath.parse(parsedScriptFunctionUri.fragment).getNode(sourceFile.getSyntaxNode());
-              if (scriptDeclaration !== void 0 && isSubprogramDeclarationOrLiteral(scriptDeclaration)) {
-                sourceFileEdit = this.scriptEditingServiceA.createEditDeletingBlock(sourceFile, scriptDeclaration);
-              }
-              break;
-            }
-            case 1 /* ArtelM */:
-              break;
-            default:
-              Debug.never(sourceFile);
-          }
-          if (sourceFileEdit !== void 0) {
-            sourceFileEdits.push(sourceFileEdit);
-          }
-        }
-      }
-      if (sourceFileEdits.length > 0) {
-        const workspaceEdit = this.convertSourceFileEditsToWorkspaceEdit(sourceFileEdits);
-        yield this.connection.workspace.applyEdit(workspaceEdit);
-      }
-    });
-  }
   convertSourceFileEdit(edit) {
     const range = this.convertSourceFileRange(edit.sourceFile, edit.range);
     const textDocument = ls3.OptionalVersionedTextDocumentIdentifier.create(
@@ -11863,24 +11700,6 @@ var _LanguageServer = class _LanguageServer {
     const convertedEdits = edits.map((e) => this.convertSourceFileEdit(e));
     return { documentChanges: convertedEdits };
   }
-  onGetNodeRange(params, taskController) {
-    return __async(this, null, function* () {
-      const uri = URI.parse(params.uri);
-      const sourceFileContext = yield this.getSourceFileContext(uri, taskController);
-      let result;
-      if (sourceFileContext !== void 0) {
-        const node = NodePath.parse(uri.fragment).getNode(sourceFileContext.sourceFile.getSyntaxNode());
-        if (node !== void 0) {
-          let nodeForRange = node;
-          if (node.kind === 90 /* AssignmentStatement */) {
-            nodeForRange = node.right;
-          }
-          result = this.convertSourceFileRange(sourceFileContext.sourceFile, nodeForRange.rangeWithoutTrivia);
-        }
-      }
-      return result;
-    });
-  }
   onCreateOrUpdateSourceFile(params) {
     return __async(this, null, function* () {
       const uri = this.convertVscodeUriToUri(URI.parse(params.uri));
@@ -12471,6 +12290,21 @@ ${e}`);
   convertVscodeUriToUri(uri) {
     return Uri.from(uri.scheme, uri.authority, uri.path);
   }
+  getOrCreateMessageHandlerContext() {
+    if (this.messageHandlerContext === void 0) {
+      this.messageHandlerContext = {
+        connection: this.connection,
+        workspace: this.workspace,
+        convertSourceFileEdit: this.convertSourceFileEdit.bind(this),
+        convertSourceFileEditsToWorkspaceEdit: this.convertSourceFileEditsToWorkspaceEdit.bind(this),
+        convertSourceFileRange: this.convertSourceFileRange.bind(this),
+        convertUriToVscodeUri: this.convertUriToVscodeUri.bind(this),
+        convertVscodeUriToUri: this.convertVscodeUriToUri.bind(this),
+        getSourceFileContext: this.getSourceFileContext.bind(this)
+      };
+    }
+    return this.messageHandlerContext;
+  }
   createCancellationToken(cancellationToken) {
     if (!this.enableRequestCancellation) {
       return new StubCancellationToken();
@@ -12479,9 +12313,10 @@ ${e}`);
   }
   withTaskController(token, handler) {
     return __async(this, null, function* () {
+      const cancellationToken = token !== void 0 ? this.createCancellationToken(token) : void 0;
       const taskController = new TaskController(
         _LanguageServer.DefaultCancellationTokenThrottleTime,
-        this.createCancellationToken(token)
+        cancellationToken
       );
       try {
         return yield handler(taskController);
@@ -12546,5 +12381,16 @@ export {
   ClientCancellationToken,
   FileSystemSynchronizationMode,
   LanguageServer,
-  customRequests
+  NodeLocation,
+  Range,
+  SourceFileContext,
+  SourceFileEdit,
+  SourceLocation,
+  TaskController,
+  Uri,
+  UrisRelativityKind,
+  Workspace,
+  customRequests,
+  isCodeActionData,
+  isCompletionItemData
 };