@teselagen/range-utils 0.3.13 → 0.3.14-beta.2

package/RangeAngles.d.ts

@@ -0,0 +1,7 @@
+export interface RangeAngles {
+    startAngle: number;
+    totalAngle: number;
+    endAngle: number;
+    centerAngle: number;
+    locationAngles?: RangeAngles[];
+}

package/adjustRangeToDeletionOfAnotherRange.d.ts

@@ -1 +1,2 @@
-export default function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted: any, anotherRange: any, maxLength: any): object;
+import { Range } from './types';
+export default function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted: Range, anotherRange: Range, maxLength: number): Range | null;

package/adjustRangeToInsert.d.ts

@@ -1 +1,2 @@
-export default function adjustRangeToInsert(rangeToBeAdjusted: any, insertStart: any, insertLength: any): any;
+import { Range } from './types';
+export default function adjustRangeToInsert(rangeToBeAdjusted: Range, insertStart: number, insertLength: number): Range;

package/adjustRangeToRotation.d.ts

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

package/checkIfNonCircularRangesOverlap.d.ts

@@ -1 +1,2 @@
-export default function checkIfNonCircularRangesOverlap(range: any, comparisonRange: any): boolean;
+import { Range } from './types';
+export default function checkIfNonCircularRangesOverlap(range: Range, comparisonRange: Range): boolean;

package/checkIfPotentiallyCircularRangesOverlap.d.ts

@@ -1 +1,2 @@
-export default function checkIfPotentiallyCircularRangesOverlap(range: any, comparisonRange: any): boolean;
+import { Range } from './types';
+export default function checkIfPotentiallyCircularRangesOverlap(range: Range, comparisonRange: Range): boolean;

package/collapseOverlapsGeneratedFromRangeComparisonIfPossible.d.ts

@@ -1 +1,2 @@
-export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps: any, sequenceLength: any, optionalOriginalRange: any): any;
+import { Range } from './types';
+export default function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps: Range[], sequenceLength: number, optionalOriginalRange?: Range): Range[];

package/convertRangeIndices.d.ts

@@ -1 +1,10 @@
-export default function convertRangeIndices(range: any, inputType: any, outputType: any): any;
+import { Range } from './types';
+interface RangeIndicesOptions {
+    inclusive1BasedStart?: boolean;
+    inclusive1BasedEnd?: boolean;
+}
+export default function convertRangeIndices(range: Range, inputType?: RangeIndicesOptions, outputType?: RangeIndicesOptions): Range & {
+    start: number;
+    end: number;
+};
+export {};

package/convertRangeTo0Based.d.ts

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

package/convertRangeTo1Based.d.ts

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

package/doesRangeSpanEntireSequence.d.ts

@@ -1 +1,2 @@
-export default function doesRangeSpanEntireSequence(range: any, sequenceLength: any): true | undefined;
+import { Range } from './types';
+export default function doesRangeSpanEntireSequence(range: Range, sequenceLength: number): boolean;

package/doesRangeSpanOrigin.d.ts

@@ -1 +1,2 @@
-export default function doesRangeSpanOrigin(range: any): boolean;
+import { Range } from './types';
+export default function doesRangeSpanOrigin(range: Range): boolean;

package/expandOrContractCircularRangeToPosition.d.ts

@@ -1,4 +1,5 @@
-export default function expandOrContractCircularRangeToPosition(range: any, position: any, maxLength: any): {
-    newRange: any;
+import { Range } from './types';
+export default function expandOrContractCircularRangeToPosition(range: Range, position: number, maxLength: number): {
+    newRange: Range;
     endMoved: boolean;
 };

package/expandOrContractNonCircularRangeToPosition.d.ts

@@ -1,4 +1,5 @@
-export default function expandOrContractNonCircularRangeToPosition(range: any, position: any): {
-    newRange: any;
+import { Range } from './types';
+export default function expandOrContractNonCircularRangeToPosition(range: Range, position: number): {
+    newRange: Range;
     endMoved: boolean;
 };

package/expandOrContractRangeByLength.d.ts

@@ -1 +1,5 @@
-export default function expandOrContractRangeByLength(range: any, shiftBy: any, shiftStart: any, sequenceLength: any): any;
+import { Range } from './types';
+export default function expandOrContractRangeByLength(range: Range, shiftBy: number, shiftStart: boolean, sequenceLength: number): Range & {
+    start: number;
+    end: number;
+};

package/expandOrContractRangeToPosition.d.ts

@@ -1,4 +1,5 @@
-export default function expandOrContractRangeToPosition(range: any, position: any, maxLength: any): {
-    newRange: any;
+import { Range } from './types';
+export default function expandOrContractRangeToPosition(range: Range, position: number, maxLength: number): {
+    newRange: Range;
     endMoved: boolean;
 };

package/flipContainedRange.d.ts

@@ -1 +1,5 @@
-export default function flipRelativeRange(innerRange: any, outerRange: any, sequenceLength: any): any;
+import { Range } from './types';
+export default function flipRelativeRange(innerRange: Range, outerRange: Range, sequenceLength: number): Range & {
+    start: number;
+    end: number;
+};

package/generateRandomRange.d.ts

@@ -1,4 +1,4 @@
-export default function generateRandomRange(minStart: any, maxEnd: any, maxLength: any): {
-    start: any;
-    end: any;
+export default function generateRandomRange(minStart: number, maxEnd: number, maxLength: number): {
+    start: number;
+    end: number;
 };

package/getAnnotationRangeType.d.ts

@@ -1 +1,2 @@
-export default function getAnnotationRangeType(annotationRange: any, enclosingRangeType: any, forward: any): "end" | "beginningAndEnd" | "start" | "middle";
+import { Range } from './types';
+export default function getAnnotationRangeType(annotationRange: Range, enclosingRangeType: Range, forward: boolean): "end" | "beginningAndEnd" | "start" | "middle";

package/getEachPositionInRangeAsArray.d.ts

@@ -1 +1,2 @@
-export default function getEachPositionInRangeAsArray(range: any, rangeMax: any): any[];
+import { Range } from './types';
+export default function getEachPositionInRangeAsArray(range: Range, rangeMax: number): number[];

package/getLengthOfOverlappingRegionsBetweenTwoRanges.d.ts

@@ -1 +1,2 @@
-export default function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA: any, rangeB: any, maxLength: any): any;
+import { Range } from './types';
+export default function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA: Range, rangeB: Range, maxLength: number): number;

package/getMiddleOfRange.d.ts

@@ -1 +1,2 @@
-export default function getMiddleOfRange(range: any, rangeMax: any): any;
+import { Range } from './types';
+export default function getMiddleOfRange(range: Range, rangeMax: number): number;

package/getOverlapOfNonCircularRanges.d.ts

@@ -1,4 +1,5 @@
-export default function getOverlapOfNonCircularRanges(rangeA: any, rangeB: any): {
-    start: any;
-    end: any;
-} | undefined;
+import { Range } from './types';
+export default function getOverlapOfNonCircularRanges(rangeA: Range, rangeB: Range): {
+    start: number;
+    end: number;
+} | null;

package/getOverlapsOfPotentiallyCircularRanges.d.ts

@@ -1 +1,2 @@
-export default function getOverlapsOfPotentiallyCircularRanges(rangeA: any, rangeB: any, maxRangeLength: any, joinIfPossible: any): any[];
+import { Range } from './types';
+export default function getOverlapsOfPotentiallyCircularRanges(rangeA: Range, rangeB: Range, maxRangeLength: number, joinIfPossible?: boolean): Range[];

package/getPositionFromAngle.d.ts

@@ -1 +1 @@
-export default function getPositionFromAngle(angle: any, rangeMax: any, isInBetweenPositions: any): number;
+export default function getPositionFromAngle(angle: number, rangeMax: number, isInBetweenPositions?: boolean): number;

package/getRangeAngles.d.ts

@@ -1,7 +1,3 @@
-export default function getRangeAngles(range: any, rangeMax: any): {
-    startAngle: number;
-    totalAngle: number;
-    endAngle: number;
-    centerAngle: number;
-    locationAngles: any;
-};
+import { Range } from './types';
+import { RangeAngles } from './RangeAngles';
+export default function getRangeAngles(range: Range, rangeMax: number): RangeAngles;

package/getRangeLength.d.ts

@@ -1,2 +1,6 @@
-declare const _default: (...args: any[]) => any;
+import { Range } from './types';
+declare const _default: (range: Range, rangeMax: number, options?: {
+    inclusive1BasedEnd?: boolean;
+    inclusive1BasedStart?: boolean;
+} | undefined) => number;
 export default _default;

package/getRangesBetweenTwoRanges.d.ts

@@ -1 +1,2 @@
-export default function getRangesBetweenTwoRanges(range1: any, range2: any): any[];
+import { Range } from './types';
+export default function getRangesBetweenTwoRanges(range1: Range, range2: Range): Range[];

package/getSequenceWithinRange.d.ts

@@ -1 +1,2 @@
-export default function getSequenceWithinRange(range: any, sequence: any): any;
+import { Range } from './types';
+export default function getSequenceWithinRange<T>(range: Range, sequence: string | T[]): string | T[];

package/getShortestDistanceBetweenTwoPositions.d.ts

@@ -1 +1 @@
-export default function getShortestDistanceBetweenTwoPositions(position1: any, position2: any, sequenceLength: any): number;
+export default function getShortestDistanceBetweenTwoPositions(position1: number, position2: number, sequenceLength: number): number;

package/getYOffsetForPotentiallyCircularRange.d.ts

@@ -1 +1,2 @@
-export default function getYOffsetForPotentiallyCircularRange(range: any, YOffsetLevelsWithRanges: any, assignYOffsetToRange: any): any;
+import { Range } from './types';
+export default function getYOffsetForPotentiallyCircularRange(range: Range, YOffsetLevelsWithRanges: Range[][], assignYOffsetToRange: boolean): number;

package/getYOffsetsForPotentiallyCircularRanges.d.ts

@@ -1,4 +1,5 @@
-export default function getYOffsetsForPotentiallyCircularRanges(ranges: any, assignYOffsetToRange: any): {
-    yOffsets: any[];
+import { Range } from './types';
+export default function getYOffsetsForPotentiallyCircularRanges(ranges: Range[], assignYOffsetToRange: boolean): {
+    yOffsets: number[];
     maxYOffset: number;
 };

package/getZeroedRangeOverlaps.d.ts

@@ -1 +1,2 @@
-export default function getZeroedRangeOverlaps(annotation: any, selection: any, sequenceLength: any): any;
+import { Range } from './types';
+export default function getZeroedRangeOverlaps(annotation: Range, selection: Range, sequenceLength: number): Range[];

package/index.cjs

@@ -87,7 +87,6 @@ function arrayMap(array, iteratee) {
 }
 __name(arrayMap, "arrayMap");
 var isArray = Array.isArray;
-var INFINITY$1 = 1 / 0;
 var symbolProto$2 = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto$2 ? symbolProto$2.toString : void 0;
 function baseToString(value) {
   if (typeof value == "string") {
@@ -100,7 +99,7 @@ function baseToString(value) {
     return symbolToString ? symbolToString.call(value) : "";
   }
   var result = value + "";
-  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
 }
 __name(baseToString, "baseToString");
 function isObject(value) {
@@ -773,13 +772,12 @@ function castPath(value, object) {
   return isKey(value, object) ? [value] : stringToPath(toString(value));
 }
 __name(castPath, "castPath");
-var INFINITY = 1 / 0;
 function toKey(value) {
   if (typeof value == "string" || isSymbol(value)) {
     return value;
   }
   var result = value + "";
-  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
 }
 __name(toKey, "toKey");
 function baseGet(object, path) {
@@ -1538,8 +1536,7 @@ function flatMap(collection, iteratee) {
 __name(flatMap, "flatMap");
 function getOverlapOfNonCircularRanges(rangeA, rangeB) {
   if (rangeA.start < rangeB.start) {
-    if (rangeA.end < rangeB.start)
-      ;
+    if (rangeA.end < rangeB.start) ;
     else {
       if (rangeA.end < rangeB.end) {
         return {
@@ -1554,8 +1551,7 @@ function getOverlapOfNonCircularRanges(rangeA, rangeB) {
       }
     }
   } else {
-    if (rangeA.start > rangeB.end)
-      ;
+    if (rangeA.start > rangeB.end) ;
     else {
       if (rangeA.end < rangeB.end) {
         return {
@@ -1570,9 +1566,10 @@ function getOverlapOfNonCircularRanges(rangeA, rangeB) {
       }
     }
   }
+  return null;
 }
 __name(getOverlapOfNonCircularRanges, "getOverlapOfNonCircularRanges");
-function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible) {
+function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible = false) {
   const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
     rangeA,
     maxRangeLength
@@ -1603,8 +1600,11 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
         joinedOverlap.start = o.start;
         return [];
       }
+      return [o];
     });
-    overlaps.push(joinedOverlap);
+    if (Object.keys(joinedOverlap).length > 0) {
+      overlaps.push(joinedOverlap);
+    }
   }
   return overlaps;
 }
@@ -1634,8 +1634,7 @@ function trimNonCicularRangeByAnotherNonCircularRange(rangeToBeTrimmed, trimming
       }
     }
   } else {
-    if (rangeToBeTrimmed.end <= trimmingRange.end)
-      ;
+    if (rangeToBeTrimmed.end <= trimmingRange.end) ;
     else {
       if (rangeToBeTrimmed.start > trimmingRange.end) {
         outputTrimmedRange = {
@@ -1678,10 +1677,7 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
   if (!overlaps.length) {
     return rangeToBeTrimmed;
   }
-  const splitRangesToBeTrimmed = splitRangeIntoTwoPartsIfItIsCircular(
-    rangeToBeTrimmed,
-    sequenceLength
-  );
+  const splitRangesToBeTrimmed = splitRangeIntoTwoPartsIfItIsCircular(rangeToBeTrimmed, sequenceLength);
   splitRangesToBeTrimmed.forEach(function(nonCircularRangeToBeTrimmed, index) {
     overlaps.forEach(function(overlap) {
       if (nonCircularRangeToBeTrimmed) {
@@ -1702,8 +1698,7 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
     }
   );
   let outputTrimmedRange;
-  if (outputSplitRanges.length < 0)
-    ;
+  if (outputSplitRanges.length < 0) ;
   else if (outputSplitRanges.length === 1) {
     outputTrimmedRange = outputSplitRanges[0];
   } else if (outputSplitRanges.length === 2) {
@@ -1725,6 +1720,7 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
       end: outputTrimmedRange.end
     });
   }
+  return void 0;
 }
 __name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
 function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, maxLength) {
@@ -1733,32 +1729,31 @@ function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, ma
     anotherRange,
     maxLength
   );
-  if (trimmedRange) {
-    const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
-      anotherRange,
-      maxLength
-    );
-    nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
-      const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
-      if (trimmedRange.start > trimmedRange.end) {
-        if (nonCircularDeletionRange.start < trimmedRange.end) {
-          trimmedRange.start -= deletionLength;
-          trimmedRange.end -= deletionLength;
-        } else if (nonCircularDeletionRange.start < trimmedRange.start) {
-          trimmedRange.start -= deletionLength;
-        } else
-          ;
-      } else {
-        if (nonCircularDeletionRange.start < trimmedRange.start) {
-          trimmedRange.start -= deletionLength;
-          trimmedRange.end -= deletionLength;
-        } else if (nonCircularDeletionRange.start < trimmedRange.end) {
-          trimmedRange.end -= deletionLength;
-        } else
-          ;
-      }
-    });
+  if (!trimmedRange) {
+    return null;
   }
+  const nonCircularDeletionRanges = splitRangeIntoTwoPartsIfItIsCircular(
+    anotherRange,
+    maxLength
+  );
+  nonCircularDeletionRanges.forEach(function(nonCircularDeletionRange) {
+    const deletionLength = nonCircularDeletionRange.end - nonCircularDeletionRange.start + 1;
+    if (trimmedRange.start > trimmedRange.end) {
+      if (nonCircularDeletionRange.start < trimmedRange.end) {
+        trimmedRange.start -= deletionLength;
+        trimmedRange.end -= deletionLength;
+      } else if (nonCircularDeletionRange.start < trimmedRange.start) {
+        trimmedRange.start -= deletionLength;
+      } else ;
+    } else {
+      if (nonCircularDeletionRange.start < trimmedRange.start) {
+        trimmedRange.start -= deletionLength;
+        trimmedRange.end -= deletionLength;
+      } else if (nonCircularDeletionRange.start < trimmedRange.end) {
+        trimmedRange.end -= deletionLength;
+      } else ;
+    }
+  });
   return trimmedRange;
 }
 __name(adjustRangeToDeletionOfAnotherRange, "adjustRangeToDeletionOfAnotherRange");
@@ -1872,11 +1867,10 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
       }
     }
   }
+  return overlaps;
 }
 __name(collapseOverlapsGeneratedFromRangeComparisonIfPossible, "collapseOverlapsGeneratedFromRangeComparisonIfPossible");
-function convertRangeIndices(range, inputType, outputType) {
-  inputType = inputType || {};
-  outputType = outputType || {};
+function convertRangeIndices(range, inputType = {}, outputType = {}) {
   return assign({}, range, {
     start: Number(range.start) + (inputType.inclusive1BasedStart ? outputType.inclusive1BasedStart ? 0 : -1 : outputType.inclusive1BasedStart ? 1 : 0),
     end: Number(range.end) + (inputType.inclusive1BasedEnd ? outputType.inclusive1BasedEnd ? 0 : -1 : outputType.inclusive1BasedEnd ? 1 : 0)
@@ -1899,25 +1893,32 @@ function convertRangeTo1Based(range) {
 }
 __name(convertRangeTo1Based, "convertRangeTo1Based");
 function provideInclusiveOptions(funToWrap) {
-  return function() {
-    const args = Array.prototype.slice.call(arguments);
+  return function(...args) {
     const options = args[args.length - 1];
     if (options && (options.inclusive1BasedEnd || options.inclusive1BasedStart)) {
       args.forEach(function(arg, index) {
-        if (arg && arg.start > -1 && options.inclusive1BasedStart) {
-          args[index] = assign(arg, { start: arg.start - 1 });
+        const potentialRange = arg;
+        if (potentialRange && typeof potentialRange.start === "number" && potentialRange.start > -1 && options.inclusive1BasedStart) {
+          args[index] = assign(potentialRange, {
+            start: potentialRange.start - 1
+          });
         }
-        if (arg && arg.end > -1 && options.inclusive1BasedEnd) {
-          args[index] = assign(arg, { end: arg.end - 1 });
+        if (potentialRange && typeof potentialRange.end === "number" && potentialRange.end > -1 && options.inclusive1BasedEnd) {
+          args[index] = assign(potentialRange, {
+            end: potentialRange.end - 1
+          });
         }
       });
     }
     let returnVal = funToWrap.apply(this, args);
-    if (returnVal && returnVal.start > -1 && options && options.inclusive1BasedStart) {
-      returnVal = assign(returnVal, { start: returnVal.start + 1 });
+    const potentialReturn = returnVal;
+    if (potentialReturn && typeof potentialReturn.start === "number" && potentialReturn.start > -1 && options && options.inclusive1BasedStart) {
+      returnVal = assign(potentialReturn, {
+        start: potentialReturn.start + 1
+      });
     }
-    if (returnVal && returnVal.end > -1 && options && options.inclusive1BasedEnd) {
-      returnVal = assign(returnVal, { end: returnVal.end + 1 });
+    if (potentialReturn && typeof potentialReturn.end === "number" && potentialReturn.end > -1 && options && options.inclusive1BasedEnd) {
+      returnVal = assign(potentialReturn, { end: potentialReturn.end + 1 });
     }
     return returnVal;
   };
@@ -1938,9 +1939,10 @@ function getRangeLength$1(range, rangeMax) {
 }
 __name(getRangeLength$1, "getRangeLength$1");
 function doesRangeSpanEntireSequence(range, sequenceLength) {
-  if (getRangeLength(range) === sequenceLength) {
+  if (getRangeLength(range, sequenceLength) === sequenceLength) {
     return true;
   }
+  return false;
 }
 __name(doesRangeSpanEntireSequence, "doesRangeSpanEntireSequence");
 function isRangeWithinRange(rangeToCheck, containingRange, maxLength) {
@@ -1949,8 +1951,7 @@ function isRangeWithinRange(rangeToCheck, containingRange, maxLength) {
     containingRange,
     maxLength
   );
-  if (ranges === null)
-    return false;
+  if (ranges === null) return false;
   return !ranges;
 }
 __name(isRangeWithinRange, "isRangeWithinRange");
@@ -1975,6 +1976,9 @@ function isRangeOrPositionWithinRange(rangeOrPositionToCheck, containingRange, m
     return false;
   }
   if (isObject(rangeOrPositionToCheck)) {
+    if (typeof rangeOrPositionToCheck.start !== "number") {
+      return false;
+    }
     return isRangeWithinRange(
       rangeOrPositionToCheck,
       containingRange,
@@ -1995,7 +1999,7 @@ function doesRangeSpanOrigin(range) {
   return range.start > range.end;
 }
 __name(doesRangeSpanOrigin, "doesRangeSpanOrigin");
-function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions) {
+function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions = false) {
   let position = pPosition;
   if (position < 0) {
     position += sequenceLength;
@@ -2087,10 +2091,7 @@ function expandOrContractRangeToPosition(range, position, maxLength) {
   if (range.start > range.end) {
     return expandOrContractCircularRangeToPosition(range, position, maxLength);
   } else {
-    return expandOrContractNonCircularRangeToPosition(
-      range,
-      position
-    );
+    return expandOrContractNonCircularRangeToPosition(range, position);
   }
 }
 __name(expandOrContractRangeToPosition, "expandOrContractRangeToPosition");
@@ -2348,14 +2349,15 @@ function getRangesBetweenTwoRanges(range1, range2) {
 }
 __name(getRangesBetweenTwoRanges, "getRangesBetweenTwoRanges");
 function getSequenceWithinRange(range, sequence) {
-  if (range.start < 0 || range.end < 0)
-    return "";
+  if (range.start < 0 || range.end < 0) return "";
   if (range.start > range.end) {
     let subSequence = sequence.slice(range.start, sequence.length);
     if (typeof subSequence === "string") {
       subSequence += sequence.slice(0, range.end + 1);
     } else {
-      subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
+      subSequence = subSequence.concat(
+        sequence.slice(0, range.end + 1)
+      );
     }
     return subSequence;
   } else {
@@ -2375,7 +2377,7 @@ function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLe
 }
 __name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
 function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
-  let yOffset = [];
+  let yOffset = 0;
   const openYOffsetFound = YOffsetLevelsWithRanges.some(
     function(rangesAlreadyAddedToYOffset, index) {
       const rangeBlocked = rangesAlreadyAddedToYOffset.some(
@@ -2388,8 +2390,7 @@ function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, a
       );
       if (!rangeBlocked) {
         yOffset = index;
-        if (assignYOffsetToRange)
-          range.yOffset = index;
+        if (assignYOffsetToRange) range.yOffset = index;
         rangesAlreadyAddedToYOffset.push(range);
         return true;
       }
@@ -2398,8 +2399,7 @@ function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, a
   );
   if (!openYOffsetFound) {
     yOffset = YOffsetLevelsWithRanges.length;
-    if (assignYOffsetToRange)
-      range.yOffset = YOffsetLevelsWithRanges.length;
+    if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length;
   }
   return yOffset;
 }
@@ -2419,8 +2419,7 @@ function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
       maxYOffset = yOffset;
     }
     range.yOffset = yOffset;
-    if (!yOffsetLevels[yOffset])
-      yOffsetLevels[yOffset] = [];
+    if (!yOffsetLevels[yOffset]) yOffsetLevels[yOffset] = [];
     yOffsetLevels[yOffset].push(range);
   });
   return { yOffsets, maxYOffset };
@@ -2428,21 +2427,20 @@ function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
 __name(getYOffsetsForPotentiallyCircularRanges, "getYOffsetsForPotentiallyCircularRanges");
 const invertRange = provideInclusiveOptions(invertRange$1);
 function invertRange$1(rangeOrCaret, rangeMax) {
-  if (rangeOrCaret.start > -1) {
+  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 (rangeOrCaret > -1) {
-      return {
-        start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
-        end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
-      };
-    }
+  } else if (typeof rangeOrCaret === "number" && rangeOrCaret > -1) {
+    return {
+      start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
+      end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
+    };
   }
+  return void 0;
 }
 __name(invertRange$1, "invertRange$1");
 function isPositionCloserToRangeStartThanRangeEnd(position, range, maxLength) {
@@ -2510,9 +2508,10 @@ function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength)
       "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 = {
+    start: subRange.start - containerRange.start,
+    end: subRange.end - containerRange.start
+  };
   if (newSubrange.start < 0) {
     newSubrange.start += sequenceLength;
   }
@@ -2523,10 +2522,10 @@ function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength)
 }
 __name(zeroSubrangeByContainerRange, "zeroSubrangeByContainerRange");
 function adjustRangeToRotation(rangeToBeAdjusted, rotateTo = 0, rangeLength) {
-  const mod = rangeLength ? modulo : identity;
+  const mod = /* @__PURE__ */ __name((n) => rangeLength ? modulo(n, rangeLength) : n, "mod");
   const newRange = assign({}, rangeToBeAdjusted, {
-    start: mod(rangeToBeAdjusted.start - (rotateTo || 0), rangeLength),
-    end: mod(rangeToBeAdjusted.end - (rotateTo || 0), rangeLength)
+    start: mod(rangeToBeAdjusted.start - (rotateTo || 0)),
+    end: mod(rangeToBeAdjusted.end - (rotateTo || 0))
   });
   return newRange;
 }

package/index.d.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';