Added support to exclude start or end token in ranges

src/Types.ts

@@ -117,6 +117,8 @@ export interface PartialRangeTarget {
   type: "range";
   start: PartialPrimitiveTarget;
   end: PartialPrimitiveTarget;
+  excludeStart?: boolean;
+  excludeEnd?: boolean;
 }
 
 export interface PartialListTarget {
@@ -142,6 +144,8 @@ export interface RangeTarget {
   type: "range";
   start: PrimitiveTarget;
   end: PrimitiveTarget;
+  excludeStart: boolean;
+  excludeEnd: boolean;
 }
 
 export interface ListTarget {

src/inferFullTargets.ts

@@ -269,6 +269,8 @@ export function inferSingleNonListTarget(
       );
       return {
         type: "range",
+        excludeStart: target.excludeStart ?? false,
+        excludeEnd: target.excludeEnd ?? false,
         start,
         end: inferRangeEndTarget(
           context,

src/processTargets.ts

@@ -69,22 +69,44 @@ function processSingleRangeTarget(
       endSelection.start
     );
 
-    const anchor = isStartBeforeEnd ? startSelection.start : startSelection.end;
-    const active = isStartBeforeEnd ? endSelection.end : endSelection.start;
+    const anchor = getRangePosition(
+      startTarget!,
+      isStartBeforeEnd,
+      target.excludeStart
+    );
+    const active = getRangePosition(
+      endTarget!,
+      !isStartBeforeEnd,
+      target.excludeEnd
+    );
+
+    const outerAnchor = target.excludeStart
+      ? null
+      : isStartBeforeEnd
+      ? startTarget!.selectionContext.outerSelection?.start
+      : startTarget!.selectionContext.outerSelection?.end;
+    const outerActive = target.excludeEnd
+      ? null
+      : isStartBeforeEnd
+      ? endTarget!.selectionContext.outerSelection?.end
+      : endTarget!.selectionContext.outerSelection?.start;
+    const outerSelection =
+      outerAnchor != null || outerActive != null
+        ? new Selection(outerAnchor ?? anchor, outerActive ?? active)
+        : null;
+
+    const startSelectionContext = target.excludeStart
+      ? null
+      : startTarget!.selectionContext;
+    const endSelectionContext = target.excludeEnd
+      ? null
+      : endTarget!.selectionContext;
     const leadingDelimiterRange = isStartBeforeEnd
-      ? startTarget!.selectionContext.leadingDelimiterRange
-      : endTarget!.selectionContext.leadingDelimiterRange;
+      ? startSelectionContext?.leadingDelimiterRange
+      : endSelectionContext?.leadingDelimiterRange;
     const trailingDelimiterRange = isStartBeforeEnd
-      ? endTarget!.selectionContext.trailingDelimiterRange
-      : startTarget!.selectionContext.trailingDelimiterRange;
-
-    const startOuterSelection =
-      startTarget!.selectionContext.outerSelection ?? startSelection;
-    const endOuterSelection =
-      endTarget!.selectionContext.outerSelection ?? endSelection;
-    const outerSelection = isStartBeforeEnd
-      ? new Selection(startOuterSelection.start, endOuterSelection.end)
-      : new Selection(endOuterSelection.start, startOuterSelection.end);
+      ? endSelectionContext?.trailingDelimiterRange
+      : startSelectionContext?.trailingDelimiterRange;
 
     return {
       selection: {
@@ -106,6 +128,33 @@ function processSingleRangeTarget(
   });
 }
 
+/**
+* @param target The target to get position from
+* @param isStart If true disposition is the start of the range
+* @param exclude If true the content of this position should be excluded
+*/
+function getRangePosition(
+  target: TypedSelection,
+  isStart: boolean,
+  exclude: boolean
+) {
+  const selection = target.selection.selection;
+  if (exclude) {
+    const outerSelection = target!.selectionContext.outerSelection;
+    const delimiterPosition = isStart
+      ? target.selectionContext.trailingDelimiterRange?.end
+      : target.selectionContext.leadingDelimiterRange?.start;
+    if (outerSelection != null) {
+      if (delimiterPosition != null) {
+        return delimiterPosition;
+      }
+      return isStart ? outerSelection.end : outerSelection.start;
+    }
+    return isStart ? selection.end : selection.start;
+  }
+  return isStart ? selection.start : selection.end;
+}
+
 function processSinglePrimitiveTarget(
   context: ProcessedTargetsContext,
   target: PrimitiveTarget