@teselagen/range-utils 0.3.18 → 0.3.20-beta.1

package/src/{getZeroedRangeOverlaps.js → getZeroedRangeOverlaps.ts}

@@ -1,3 +1,4 @@
+import { Range } from "./types";
 import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCircularRanges";
 import collapseOverlapsGeneratedFromRangeComparisonIfPossible from "./collapseOverlapsGeneratedFromRangeComparisonIfPossible";
 import zeroSubrangeByContainerRange from "./zeroSubrangeByContainerRange";
@@ -5,9 +6,9 @@ import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 
 //gets the overlapping sections of two ranges and zeroes them to their first point of intersection!
 export default function getZeroedRangeOverlaps(
-  annotation,
-  selection,
-  sequenceLength
+  annotation: Range,
+  selection: Range,
+  sequenceLength: number
 ) {
   const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
     getOverlapsOfPotentiallyCircularRanges(

package/src/{index.test.js → index.test.ts}

@@ -3,14 +3,22 @@ import fs from "fs";
 
 describe("index.js", () => {
   it(`should export all functions defined`, () => {
-    return new Promise(resolve => {
+    return new Promise<void>(resolve => {
       fs.readdir(__dirname, (err, files) => {
         let passes = true;
         files.forEach(file => {
-          if (file.indexOf(".test.js") > -1 || file.indexOf("index.js") > -1) {
+          if (
+            file.indexOf(".test.js") > -1 ||
+            file.indexOf(".test.ts") > -1 ||
+            file.indexOf("index.js") > -1 ||
+            file.indexOf("types.ts") > -1 ||
+            file.indexOf("RangeAngles.ts") > -1 ||
+            file.indexOf("index.ts") > -1
+          ) {
             return;
           }
-          const funcOrObj = src[file.replace(".js", "")];
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const funcOrObj = (src as any)[file.replace(/\.(ts|js)$/, "")];
           if (!funcOrObj) {
             console.info(
               `Uh oh, it looks like you forgot to export (or explicitly ignore) this file:`,

package/src/{index.js → index.ts}

@@ -50,3 +50,4 @@ export { default as zeroSubrangeByContainerRange } from "./zeroSubrangeByContain
 export { default as adjustRangeToRotation } from "./adjustRangeToRotation";
 export { default as getZeroedRangeOverlaps } from "./getZeroedRangeOverlaps";
 export { default as trimAnnStartEndToFitSeqLength } from "./trimAnnStartEndToFitSeqLength";
+export * from "./types";

package/src/invertRange.ts

@@ -0,0 +1,25 @@
+import { Range } from "./types";
+
+import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
+import provideInclusiveOptions from "./provideInclusiveOptions";
+export default provideInclusiveOptions(invertRange);
+
+function invertRange(
+  rangeOrCaret: Range | number,
+  rangeMax: number
+): Range | undefined {
+  if (typeof rangeOrCaret !== "number" && rangeOrCaret.start > -1) {
+    const start = rangeOrCaret.end + 1;
+    const end = rangeOrCaret.start - 1;
+    return {
+      start: normalizePositionByRangeLength(start, rangeMax, false),
+      end: normalizePositionByRangeLength(end, rangeMax, false)
+    };
+  } else if (typeof rangeOrCaret === "number" && rangeOrCaret > -1) {
+    return {
+      start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
+      end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
+    };
+  }
+  return undefined;
+}

package/src/{isPositionCloserToRangeStartThanRangeEnd.js → isPositionCloserToRangeStartThanRangeEnd.ts}

@@ -1,10 +1,12 @@
 //function to calculate whether a position is closer to the range start than the range end
 import getShortestDistanceBetweenTwoPositions from "./getShortestDistanceBetweenTwoPositions";
 
+import { Range } from "./types";
+
 export default function isPositionCloserToRangeStartThanRangeEnd(
-  position,
-  range,
-  maxLength
+  position: number,
+  range: Range,
+  maxLength: number
 ) {
   const distanceFromStart = getShortestDistanceBetweenTwoPositions(
     range.start,

package/src/{isPositionWithinRange.js → isPositionWithinRange.ts}

@@ -1,4 +1,13 @@
 import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
+/**
+ *
+ * @param {*} position //assumed to be a 0 based "caretPosition"
+ * @param {*} range //0 based inclusive range
+ * @param {*} sequenceLength
+ * @param {*} includeEdges - (default false) whether or not to say
+ */
+import { Range } from "./types";
+
 /**
  *
  * @param {*} position //assumed to be a 0 based "caretPosition"
@@ -7,11 +16,11 @@ import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIs
  * @param {*} includeEdges - (default false) whether or not to say
  */
 function isPositionWithinRange(
-  position,
-  range,
-  sequenceLength,
-  includeStartEdge,
-  includeEndEdge
+  position: number,
+  range: Range,
+  sequenceLength: number,
+  includeStartEdge?: boolean,
+  includeEndEdge?: boolean
 ) {
   const ranges = splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength);
   const positionFits = ranges.some(function (range) {

package/src/{isRangeOrPositionWithinRange.js → isRangeOrPositionWithinRange.ts}

@@ -2,12 +2,14 @@ import { isObject } from "lodash-es";
 import isRangeWithinRange from "./isRangeWithinRange";
 import isPositionWithinRange from "./isPositionWithinRange";
 
+import { Range } from "./types";
+
 export default function isRangeOrPositionWithinRange(
-  rangeOrPositionToCheck,
-  containingRange,
-  maxLength,
-  includeStartEdge,
-  includeEndEdge
+  rangeOrPositionToCheck: Range | number,
+  containingRange: Range,
+  maxLength: number,
+  includeStartEdge?: boolean,
+  includeEndEdge?: boolean
 ) {
   if (
     rangeOrPositionToCheck === undefined ||
@@ -18,8 +20,11 @@ export default function isRangeOrPositionWithinRange(
     return false;
   }
   if (isObject(rangeOrPositionToCheck)) {
+    if (typeof (rangeOrPositionToCheck as Range).start !== "number") {
+      return false;
+    }
     return isRangeWithinRange(
-      rangeOrPositionToCheck,
+      rangeOrPositionToCheck as Range,
       containingRange,
       maxLength
     );

package/src/{isRangeWithinRange.js → isRangeWithinRange.ts}

@@ -1,10 +1,12 @@
 //TNR: THIS METHOD ONLY WORKS FOR COMPARING 0-BASED RANGES!!!!!!
 import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
 
+import { Range } from "./types";
+
 export default function isRangeWithinRange(
-  rangeToCheck,
-  containingRange,
-  maxLength
+  rangeToCheck: Range,
+  containingRange: Range,
+  maxLength: number
 ) {
   const ranges = trimRangeByAnotherRange(
     rangeToCheck,

package/src/loopEachPositionInRange.ts

@@ -0,0 +1,11 @@
+import { Range } from "./types";
+
+import getEachPositionInRangeAsArray from "./getEachPositionInRangeAsArray";
+
+export default function loopEachPositionInRange(
+  range: Range,
+  rangeMax: number,
+  func: (pos: number) => void
+) {
+  getEachPositionInRangeAsArray(range, rangeMax).map(func);
+}

package/src/{modulatePositionByRange.js → modulatePositionByRange.ts}

@@ -1,5 +1,10 @@
+import { Range } from "./types";
+
 //this function takes a position that might not fit in a given range and puts it into that range
-export default function modulatePositionByRange(position, range) {
+export default function modulatePositionByRange(
+  position: number,
+  range: Range
+) {
   let returnVal = position;
   if (position < range.start) {
     returnVal = range.end - (range.start - (position + 1));

package/src/{modulateRangeBySequenceLength.js → modulateRangeBySequenceLength.ts}

@@ -1,9 +1,11 @@
+import { Range } from "./types";
+
 import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 import provideInclusiveOptions from "./provideInclusiveOptions";
 import { assign } from "lodash-es";
 export default provideInclusiveOptions(modulateRangeBySequenceLength);
 
-function modulateRangeBySequenceLength(range, seqLen) {
+function modulateRangeBySequenceLength(range: Range, seqLen: number) {
   return assign(range, {
     start: normalizePositionByRangeLength(range.start, seqLen),
     end: normalizePositionByRangeLength(range.end, seqLen)

package/src/{normalizePositionByRangeLength.js → normalizePositionByRangeLength.ts}

@@ -1,15 +1,15 @@
 //
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+
 export default function normalizePositionByRangeLength(
-  pPosition,
-  sequenceLength,
-  isInBetweenPositions
+  pPosition: number,
+  sequenceLength: number,
+  isInBetweenPositions = false
 ) {
   //isInBetweenPositions refers to:
   // A T G C
   // 0 1 2 3    <--  isInBetweenPositions = false is counting the positions themselves
   //0 1 2 3 4   <--  isInBetweenPositions = true is counting the spaces between positions
-  // ac.throw([ac.number, ac.posInt, ac.bool], arguments);
+
   let position = pPosition;
   if (position < 0) {
     position += sequenceLength;
@@ -19,6 +19,6 @@ export default function normalizePositionByRangeLength(
   return position < 0
     ? 0
     : position > sequenceLength - (isInBetweenPositions ? 0 : 1)
-    ? sequenceLength - (isInBetweenPositions ? 0 : 1)
-    : position;
+      ? sequenceLength - (isInBetweenPositions ? 0 : 1)
+      : position;
 }

package/src/{normalizePositionByRangeLength1Based.js → normalizePositionByRangeLength1Based.ts}

@@ -1,8 +1,9 @@
+//
 import modulatePositionByRange from "./modulatePositionByRange";
 
 export default function normalizePositionByRangeLength1Based(
-  position,
-  sequenceLength
+  position: number,
+  sequenceLength: number
 ) {
   return modulatePositionByRange(position, { start: 1, end: sequenceLength });
 }

package/src/{normalizeRange.js → normalizeRange.ts}

@@ -2,8 +2,9 @@
 import { assign } from "lodash-es";
 
 import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
+import { Range } from "./types";
 
-export default function normalizeRange(range, sequenceLength) {
+export default function normalizeRange(range: Range, sequenceLength: number) {
   return assign({}, range, {
     start: normalizePositionByRangeLength(range.start, sequenceLength),
     end: normalizePositionByRangeLength(range.end, sequenceLength)

package/src/provideInclusiveOptions.ts

@@ -0,0 +1,79 @@
+import { assign } from "lodash-es";
+
+type Options = {
+  inclusive1BasedEnd?: boolean;
+  inclusive1BasedStart?: boolean;
+};
+
+export default function provideInclusiveOptions<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  T extends (...args: any[]) => any
+>(
+  funToWrap: T
+): (
+  ...args: [...Parameters<T>, options?: Options]
+) => ReturnType<T> {
+  return function (
+    this: unknown,
+    ...args: [...Parameters<T>, options?: Options]
+  ): ReturnType<T> {
+    const options = args[args.length - 1] as Options | undefined;
+    if (
+      options &&
+      (options.inclusive1BasedEnd || options.inclusive1BasedStart)
+    ) {
+      args.forEach(function (arg, index) {
+        // cast arg to check for start/end
+        const potentialRange = arg as { start?: number; end?: number } | null;
+        if (
+          potentialRange &&
+          typeof potentialRange.start === "number" &&
+          potentialRange.start > -1 &&
+          options.inclusive1BasedStart
+        ) {
+          args[index] = assign(potentialRange, {
+            start: potentialRange.start - 1
+          });
+        }
+        if (
+          potentialRange &&
+          typeof potentialRange.end === "number" &&
+          potentialRange.end > -1 &&
+          options.inclusive1BasedEnd
+        ) {
+          args[index] = assign(potentialRange, {
+            end: potentialRange.end - 1
+          });
+        }
+      });
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    let returnVal = (funToWrap as Function).apply(this, args);
+    const potentialReturn = returnVal as {
+      start?: number;
+      end?: number;
+    } | null;
+
+    if (
+      potentialReturn &&
+      typeof potentialReturn.start === "number" &&
+      potentialReturn.start > -1 &&
+      options &&
+      options.inclusive1BasedStart
+    ) {
+      returnVal = assign(potentialReturn, {
+        start: potentialReturn.start + 1
+      });
+    }
+    if (
+      potentialReturn &&
+      typeof potentialReturn.end === "number" &&
+      potentialReturn.end > -1 &&
+      options &&
+      options.inclusive1BasedEnd
+    ) {
+      returnVal = assign(potentialReturn, { end: potentialReturn.end + 1 });
+    }
+    return returnVal as ReturnType<T>;
+  };
+}

package/src/{reversePositionInRange.js → reversePositionInRange.ts}

@@ -1,14 +1,14 @@
 //
 export default function reversePositionInRange(
-  position,
-  rangeLength,
-  isInBetweenPositions
+  position: number,
+  rangeLength: number,
+  isInBetweenPositions: boolean
 ) {
   //isInBetweenPositions refers to:
   // A T G C
   // 0 1 2 3    <--  isInBetweenPositions = false is counting the positions themselves
   //0 1 2 3 4   <--  isInBetweenPositions = true is counting the spaces between positions
-  // ac.throw([
+
   //     ac.posInt,
   //     ac.posInt,
   //     ac.bool

package/src/{splitRangeIntoTwoPartsIfItIsCircular.js → splitRangeIntoTwoPartsIfItIsCircular.ts}

@@ -1,11 +1,12 @@
+import { Range } from "./types";
+
 //
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+
 //takes a potentially circular range and returns an array containing the range split on the origin
 export default function splitRangeIntoTwoPartsIfItIsCircular(
-  range,
-  sequenceLength
+  range: Range,
+  sequenceLength: number
 ) {
-  // ac.throw([ac.range, ac.number], arguments);
   if (sequenceLength !== 0) {
     sequenceLength = sequenceLength || Infinity;
   }

package/src/{translateRange.js → translateRange.ts}

@@ -1,10 +1,12 @@
+import { Range } from "./types";
+
 import { assign } from "lodash-es";
 import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 
 export default function translateRange(
-  rangeToBeAdjusted,
-  translateBy,
-  rangeLength
+  rangeToBeAdjusted: Range,
+  translateBy: number,
+  rangeLength: number
 ) {
   return assign({}, rangeToBeAdjusted, {
     start: normalizePositionByRangeLength(

package/src/{trimAnnStartEndToFitSeqLength.js → trimAnnStartEndToFitSeqLength.ts}

@@ -1,6 +1,6 @@
 export default function trimAnnStartEndToFitSeqLength(
-  annStartOrEnd,
-  sequenceLength
+  annStartOrEnd: number,
+  sequenceLength: number
 ) {
   return Math.max(
     0,

package/src/{trimNonCicularRangeByAnotherNonCircularRange.js → trimNonCicularRangeByAnotherNonCircularRange.ts}

@@ -1,9 +1,11 @@
+//
+import { Range } from "./types";
+
 //
 export default function trimNonCicularRangeByAnotherNonCircularRange(
-  rangeToBeTrimmed,
-  trimmingRange
-) {
-  // ac.throw([ac.range, ac.range], arguments);
+  rangeToBeTrimmed: Range,
+  trimmingRange: Range
+): Range | undefined {
   let outputTrimmedRange;
   if (!rangeToBeTrimmed) {
     return outputTrimmedRange;

package/src/{trimNumberToFitWithin0ToAnotherNumber.js → trimNumberToFitWithin0ToAnotherNumber.ts}

@@ -1,10 +1,9 @@
 //
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+
 export default function trimNumberToFitWithin0ToAnotherNumber(
-  numberToBeTrimmed,
-  max
+  numberToBeTrimmed: number,
+  max: number
 ) {
-  // ac.throw([ac.number, ac.number], arguments);
   if (numberToBeTrimmed < 0) {
     numberToBeTrimmed = 0;
   }

package/src/{trimRangeByAnotherRange.js → trimRangeByAnotherRange.ts}

@@ -2,6 +2,7 @@ import getOverlapsOfPotentiallyCircularRanges from "./getOverlapsOfPotentiallyCi
 import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
 import trimNonCicularRangeByAnotherNonCircularRange from "./trimNonCicularRangeByAnotherNonCircularRange";
 import { extend } from "lodash-es";
+import { Range } from "./types";
 
 /**
  * trims range, but does *not* adjust it
@@ -18,10 +19,10 @@ import { extend } from "lodash-es";
  *                                  }
  */
 export default function trimRangeByAnotherRange(
-  rangeToBeTrimmed,
-  trimmingRange,
-  sequenceLength
-) {
+  rangeToBeTrimmed: Range,
+  trimmingRange: Range,
+  sequenceLength: number
+): Range | undefined | null {
   if (!rangeToBeTrimmed || !trimmingRange) {
     console.warn("invalid range input");
     return null; //a null return val means something went wrong with this function
@@ -50,10 +51,8 @@ export default function trimRangeByAnotherRange(
     return rangeToBeTrimmed;
   }
   //and trim both pieces by the already calculated overlaps
-  const splitRangesToBeTrimmed = splitRangeIntoTwoPartsIfItIsCircular(
-    rangeToBeTrimmed,
-    sequenceLength
-  );
+  const splitRangesToBeTrimmed: (Range | undefined | null)[] =
+    splitRangeIntoTwoPartsIfItIsCircular(rangeToBeTrimmed, sequenceLength);
   splitRangesToBeTrimmed.forEach(function (nonCircularRangeToBeTrimmed, index) {
     overlaps.forEach(function (overlap) {
       if (nonCircularRangeToBeTrimmed) {
@@ -68,7 +67,7 @@ export default function trimRangeByAnotherRange(
   });
   //filter out any of the split ranges that have been fully deleted!
   const outputSplitRanges = splitRangesToBeTrimmed.filter(
-    function (trimmedRange) {
+    function (trimmedRange): trimmedRange is Range {
       if (trimmedRange) {
         return true;
       }
@@ -100,4 +99,5 @@ export default function trimRangeByAnotherRange(
       end: outputTrimmedRange.end
     });
   }
+  return undefined;
 }

package/src/types.ts

@@ -0,0 +1,12 @@
+export interface Range {
+  start: number;
+  end: number;
+  type?: string;
+  locations?: Range[];
+  overlapsSelf?: boolean;
+  yOffset?: number;
+  aminoAcids?: unknown[];
+  forward?: boolean;
+  notes?: Record<string, unknown> | string;
+  [key: string]: unknown;
+}

package/src/{zeroSubrangeByContainerRange.js → zeroSubrangeByContainerRange.ts}

@@ -1,7 +1,9 @@
 //
-// ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
+
 import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
 
+import { Range } from "./types";
+
 /**
  * "zeroes" a subrange of a container range by
  * adjusting subRange start and end such that it is as if the container range start = 0.
@@ -17,11 +19,10 @@ import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
  *                                     }
  */
 export default function zeroSubrangeByContainerRange(
-  subRange,
-  containerRange,
-  sequenceLength
+  subRange: Range,
+  containerRange: Range,
+  sequenceLength: number
 ) {
-  // ac.throw([ac.range, ac.range, ac.posInt], arguments);
   //first check to make sure the container range fully contains the subRange
   const trimmedSubRange = trimRangeByAnotherRange(
     subRange,
@@ -33,9 +34,10 @@ export default function zeroSubrangeByContainerRange(
       "subRange must be fully contained by containerRange! Otherwise this function does not make sense"
     );
   }
-  const newSubrange = {};
-  newSubrange.start = subRange.start - containerRange.start;
-  newSubrange.end = subRange.end - containerRange.start;
+  const newSubrange: Range = {
+    start: subRange.start - containerRange.start,
+    end: subRange.end - containerRange.start
+  };
   if (newSubrange.start < 0) {
     newSubrange.start += sequenceLength;
   }

package/translateRange.d.ts

@@ -1 +1,5 @@
-export default function translateRange(rangeToBeAdjusted: any, translateBy: any, rangeLength: any): any;
+import { Range } from './types';
+export default function translateRange(rangeToBeAdjusted: Range, translateBy: number, rangeLength: number): Range & {
+    start: number;
+    end: number;
+};

package/trimAnnStartEndToFitSeqLength.d.ts

@@ -1 +1 @@
-export default function trimAnnStartEndToFitSeqLength(annStartOrEnd: any, sequenceLength: any): number;
+export default function trimAnnStartEndToFitSeqLength(annStartOrEnd: number, sequenceLength: number): number;

package/trimNonCicularRangeByAnotherNonCircularRange.d.ts

@@ -1,4 +1,2 @@
-export default function trimNonCicularRangeByAnotherNonCircularRange(rangeToBeTrimmed: any, trimmingRange: any): {
-    start: any;
-    end: any;
-} | undefined;
+import { Range } from './types';
+export default function trimNonCicularRangeByAnotherNonCircularRange(rangeToBeTrimmed: Range, trimmingRange: Range): Range | undefined;

package/trimNumberToFitWithin0ToAnotherNumber.d.ts

@@ -1 +1 @@
-export default function trimNumberToFitWithin0ToAnotherNumber(numberToBeTrimmed: any, max: any): any;
+export default function trimNumberToFitWithin0ToAnotherNumber(numberToBeTrimmed: number, max: number): number;

package/trimRangeByAnotherRange.d.ts

@@ -1,3 +1,4 @@
+import { Range } from './types';
 /**
  * trims range, but does *not* adjust it
  * returns a new range if there is one, or null, if it is trimmed completely
@@ -12,4 +13,4 @@
  *                                  end:
  *                                  }
  */
-export default function trimRangeByAnotherRange(rangeToBeTrimmed: any, trimmingRange: any, sequenceLength: int): object;
+export default function trimRangeByAnotherRange(rangeToBeTrimmed: Range, trimmingRange: Range, sequenceLength: number): Range | undefined | null;

package/types.d.ts

@@ -0,0 +1,12 @@
+export interface Range {
+    start: number;
+    end: number;
+    type?: string;
+    locations?: Range[];
+    overlapsSelf?: boolean;
+    yOffset?: number;
+    aminoAcids?: unknown[];
+    forward?: boolean;
+    notes?: Record<string, unknown> | string;
+    [key: string]: unknown;
+}

package/zeroSubrangeByContainerRange.d.ts

@@ -1,3 +1,4 @@
+import { Range } from './types';
 /**
  * "zeroes" a subrange of a container range by
  * adjusting subRange start and end such that it is as if the container range start = 0.
@@ -12,4 +13,4 @@
  *                                     end:
  *                                     }
  */
-export default function zeroSubrangeByContainerRange(subRange: object, containerRange: object, sequenceLength: int): object;
+export default function zeroSubrangeByContainerRange(subRange: Range, containerRange: Range, sequenceLength: number): Range;

package/adjustRangeToDeletionOfAnotherRange.test.d.ts

@@ -1 +0,0 @@
-export {};

package/adjustRangeToInsert.test.d.ts

@@ -1 +0,0 @@
-export {};

package/adjustRangeToRotation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/checkIfNonCircularRangesOverlap.test.d.ts

@@ -1 +0,0 @@
-export {};

package/checkIfPotentiallyCircularRangesOverlap.test.d.ts

@@ -1 +0,0 @@
-export {};

package/collapseOverlapsGeneratedFromRangeComparisonIfPossible.test.d.ts

@@ -1 +0,0 @@
-export {};

package/convertRangeIndices.test.d.ts

@@ -1 +0,0 @@
-export {};

package/expandOrContractRangeByLength.test.d.ts

@@ -1 +0,0 @@
-export {};

package/flipContainedRange.test.d.ts

@@ -1 +0,0 @@
-export {};

package/generateRandomRange.test.d.ts

@@ -1 +0,0 @@
-export {};

package/getAnnotationRangeType.test.d.ts

@@ -1 +0,0 @@
-export {};