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

package/index.js

@@ -1564,9 +1564,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
@@ -1597,8 +1598,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;
 }
@@ -1671,10 +1675,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) {
@@ -1717,6 +1718,7 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
       end: outputTrimmedRange.end
     });
   }
+  return void 0;
 }
 __name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
 function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, maxLength) {
@@ -1863,11 +1865,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)
@@ -1890,25 +1891,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;
   };
@@ -1929,9 +1937,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) {
@@ -1965,6 +1974,9 @@ function isRangeOrPositionWithinRange(rangeOrPositionToCheck, containingRange, m
     return false;
   }
   if (isObject(rangeOrPositionToCheck)) {
+    if (typeof rangeOrPositionToCheck.start !== "number") {
+      return false;
+    }
     return isRangeWithinRange(
       rangeOrPositionToCheck,
       containingRange,
@@ -1985,7 +1997,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;
@@ -2077,10 +2089,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");
@@ -2338,15 +2347,19 @@ 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) {
+    if (typeof sequence === "string") return "";
+    return [];
+  }
   if (range.start > range.end) {
-    let subSequence = sequence.slice(range.start, sequence.length);
+    const subSequence = sequence.slice(range.start, sequence.length);
     if (typeof subSequence === "string") {
-      subSequence += sequence.slice(0, range.end + 1);
+      return subSequence + sequence.slice(0, range.end + 1);
     } else {
-      subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
+      return subSequence.concat(
+        sequence.slice(0, range.end + 1)
+      );
     }
-    return subSequence;
   } else {
     return sequence.slice(range.start, range.end + 1);
   }
@@ -2364,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(
@@ -2414,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) {
@@ -2496,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;
   }
@@ -2509,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.umd.cjs

@@ -1568,9 +1568,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       }
     }
+    return null;
   }
   __name(getOverlapOfNonCircularRanges, "getOverlapOfNonCircularRanges");
-  function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible) {
+  function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible = false) {
     const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
       rangeA,
       maxRangeLength
@@ -1601,8 +1602,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           joinedOverlap.start = o.start;
           return [];
         }
+        return [o];
       });
-      overlaps.push(joinedOverlap);
+      if (Object.keys(joinedOverlap).length > 0) {
+        overlaps.push(joinedOverlap);
+      }
     }
     return overlaps;
   }
@@ -1675,10 +1679,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     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) {
@@ -1721,6 +1722,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         end: outputTrimmedRange.end
       });
     }
+    return void 0;
   }
   __name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
   function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, maxLength) {
@@ -1867,11 +1869,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       }
     }
+    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)
@@ -1894,25 +1895,32 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __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;
     };
@@ -1933,9 +1941,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __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) {
@@ -1969,6 +1978,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       return false;
     }
     if (isObject(rangeOrPositionToCheck)) {
+      if (typeof rangeOrPositionToCheck.start !== "number") {
+        return false;
+      }
       return isRangeWithinRange(
         rangeOrPositionToCheck,
         containingRange,
@@ -1989,7 +2001,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     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;
@@ -2081,10 +2093,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     if (range.start > range.end) {
       return expandOrContractCircularRangeToPosition(range, position, maxLength);
     } else {
-      return expandOrContractNonCircularRangeToPosition(
-        range,
-        position
-      );
+      return expandOrContractNonCircularRangeToPosition(range, position);
     }
   }
   __name(expandOrContractRangeToPosition, "expandOrContractRangeToPosition");
@@ -2342,15 +2351,19 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(getRangesBetweenTwoRanges, "getRangesBetweenTwoRanges");
   function getSequenceWithinRange(range, sequence) {
-    if (range.start < 0 || range.end < 0) return "";
+    if (range.start < 0 || range.end < 0) {
+      if (typeof sequence === "string") return "";
+      return [];
+    }
     if (range.start > range.end) {
-      let subSequence = sequence.slice(range.start, sequence.length);
+      const subSequence = sequence.slice(range.start, sequence.length);
       if (typeof subSequence === "string") {
-        subSequence += sequence.slice(0, range.end + 1);
+        return subSequence + sequence.slice(0, range.end + 1);
       } else {
-        subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
+        return subSequence.concat(
+          sequence.slice(0, range.end + 1)
+        );
       }
-      return subSequence;
     } else {
       return sequence.slice(range.start, range.end + 1);
     }
@@ -2368,7 +2381,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
   function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
-    let yOffset = [];
+    let yOffset = 0;
     const openYOffsetFound = YOffsetLevelsWithRanges.some(
       function(rangesAlreadyAddedToYOffset, index) {
         const rangeBlocked = rangesAlreadyAddedToYOffset.some(
@@ -2418,21 +2431,20 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __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) {
@@ -2500,9 +2512,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         "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;
     }
@@ -2513,10 +2526,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __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/invertRange.d.ts

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

package/isPositionCloserToRangeStartThanRangeEnd.d.ts

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

package/isPositionWithinRange.d.ts

@@ -1,4 +1,4 @@
-export default isPositionWithinRange;
+import { Range } from './types';
 /**
  *
  * @param {*} position //assumed to be a 0 based "caretPosition"
@@ -6,4 +6,5 @@ export default isPositionWithinRange;
  * @param {*} sequenceLength
  * @param {*} includeEdges - (default false) whether or not to say
  */
-declare function isPositionWithinRange(position: any, range: any, sequenceLength: any, includeStartEdge: any, includeEndEdge: any): boolean;
+declare function isPositionWithinRange(position: number, range: Range, sequenceLength: number, includeStartEdge?: boolean, includeEndEdge?: boolean): boolean;
+export default isPositionWithinRange;

package/isRangeOrPositionWithinRange.d.ts

@@ -1 +1,2 @@
-export default function isRangeOrPositionWithinRange(rangeOrPositionToCheck: any, containingRange: any, maxLength: any, includeStartEdge: any, includeEndEdge: any): boolean;
+import { Range } from './types';
+export default function isRangeOrPositionWithinRange(rangeOrPositionToCheck: Range | number, containingRange: Range, maxLength: number, includeStartEdge?: boolean, includeEndEdge?: boolean): boolean;

package/isRangeWithinRange.d.ts

@@ -1 +1,2 @@
-export default function isRangeWithinRange(rangeToCheck: any, containingRange: any, maxLength: any): boolean;
+import { Range } from './types';
+export default function isRangeWithinRange(rangeToCheck: Range, containingRange: Range, maxLength: number): boolean;

package/loopEachPositionInRange.d.ts

@@ -1 +1,2 @@
-export default function loopEachPositionInRange(range: any, rangeMax: any, func: any): void;
+import { Range } from './types';
+export default function loopEachPositionInRange(range: Range, rangeMax: number, func: (pos: number) => void): void;

package/modulatePositionByRange.d.ts

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

package/modulateRangeBySequenceLength.d.ts

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

package/normalizePositionByRangeLength.d.ts

@@ -1 +1 @@
-export default function normalizePositionByRangeLength(pPosition: any, sequenceLength: any, isInBetweenPositions: any): any;
+export default function normalizePositionByRangeLength(pPosition: number, sequenceLength: number, isInBetweenPositions?: boolean): number;

package/normalizePositionByRangeLength1Based.d.ts

@@ -1 +1 @@
-export default function normalizePositionByRangeLength1Based(position: any, sequenceLength: any): any;
+export default function normalizePositionByRangeLength1Based(position: number, sequenceLength: number): number;

package/normalizeRange.d.ts

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

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@teselagen/range-utils",
-  "version": "0.3.18",
+  "version": "0.3.20-beta.1",
   "type": "module",
   "repository": "https://github.com/TeselaGen/tg-oss",
   "dependencies": {
     "lodash-es": "^4.17.21"
-  }
+  },
+  "main": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "require": "./src/index.ts"
+    }
+  },
+  "types": "./src/index.ts"
 }

package/provideInclusiveOptions.d.ts

@@ -1 +1,6 @@
-export default function provideInclusiveOptions(funToWrap: any): (...args: any[]) => any;
+type Options = {
+    inclusive1BasedEnd?: boolean;
+    inclusive1BasedStart?: boolean;
+};
+export default function provideInclusiveOptions<T extends (...args: any[]) => any>(funToWrap: T): (...args: [...Parameters<T>, options?: Options]) => ReturnType<T>;
+export {};

package/reversePositionInRange.d.ts

@@ -1 +1 @@
-export default function reversePositionInRange(position: any, rangeLength: any, isInBetweenPositions: any): number;
+export default function reversePositionInRange(position: number, rangeLength: number, isInBetweenPositions: boolean): number;

package/splitRangeIntoTwoPartsIfItIsCircular.d.ts

@@ -1,5 +1,6 @@
-export default function splitRangeIntoTwoPartsIfItIsCircular(range: any, sequenceLength: any): {
-    start: any;
-    end: any;
+import { Range } from './types';
+export default function splitRangeIntoTwoPartsIfItIsCircular(range: Range, sequenceLength: number): {
+    start: number;
+    end: number;
     type: string;
 }[];

package/src/RangeAngles.ts

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

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

@@ -1,17 +1,14 @@
+import { Range } from "./types";
 import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular";
 import trimRangeByAnotherRange from "./trimRangeByAnotherRange";
 
 //takes in two potentially circular ranges and returns the first one trimmed by the second one
 //returns null if no range is left after the trimming
 export default function adjustRangeToDeletionOfAnotherRange(
-  rangeToBeAdjusted,
-  anotherRange,
-  maxLength
+  rangeToBeAdjusted: Range,
+  anotherRange: Range,
+  maxLength: number
 ) {
-  // ac.throw(ac.range, rangeToBeAdjusted)
-  // ac.throw(ac.range, anotherRange)
-  // ac.throw(ac.posInt, maxLength)
-
   const trimmedRange = trimRangeByAnotherRange(
     rangeToBeAdjusted,
     anotherRange,

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

@@ -1,11 +1,11 @@
 import { assign } from "lodash-es";
+import { Range } from "./types";
 
 export default function adjustRangeToInsert(
-  rangeToBeAdjusted,
-  insertStart,
-  insertLength
+  rangeToBeAdjusted: Range,
+  insertStart: number,
+  insertLength: number
 ) {
-  // ac.throw([ac.range, ac.posInt, ac.posInt], arguments);
   const newRange = assign({}, rangeToBeAdjusted);
   if (rangeToBeAdjusted.start > rangeToBeAdjusted.end) {
     //circular range