@teselagen/range-utils 0.3.7 → 0.3.8

package/src/index.js

@@ -1,51 +1,51 @@
-export { default as adjustRangeToDeletionOfAnotherRange } from './adjustRangeToDeletionOfAnotherRange';
-export { default as adjustRangeToInsert } from './adjustRangeToInsert';
-export { default as checkIfNonCircularRangesOverlap } from './checkIfNonCircularRangesOverlap';
-export { default as checkIfPotentiallyCircularRangesOverlap } from './checkIfPotentiallyCircularRangesOverlap';
-export { default as collapseOverlapsGeneratedFromRangeComparisonIfPossible } from './collapseOverlapsGeneratedFromRangeComparisonIfPossible';
-export { default as convertRangeIndices } from './convertRangeIndices';
-export { default as convertRangeTo0Based } from './convertRangeTo0Based';
-export { default as convertRangeTo1Based } from './convertRangeTo1Based';
-export { default as doesRangeSpanEntireSequence } from './doesRangeSpanEntireSequence';
-export { default as isRangeOrPositionWithinRange } from './isRangeOrPositionWithinRange';
-export { default as doesRangeSpanOrigin } from './doesRangeSpanOrigin';
-export { default as expandOrContractCircularRangeToPosition } from './expandOrContractCircularRangeToPosition';
-export { default as expandOrContractNonCircularRangeToPosition } from './expandOrContractNonCircularRangeToPosition';
-export { default as expandOrContractRangeByLength } from './expandOrContractRangeByLength';
-export { default as expandOrContractRangeToPosition } from './expandOrContractRangeToPosition';
-export { default as flipContainedRange } from './flipContainedRange';
-export { default as generateRandomRange } from './generateRandomRange';
-export { default as getAnnotationRangeType } from './getAnnotationRangeType';
-export { default as getEachPositionInRangeAsArray } from './getEachPositionInRangeAsArray';
-export { default as getLengthOfOverlappingRegionsBetweenTwoRanges } from './getLengthOfOverlappingRegionsBetweenTwoRanges';
-export { default as getOverlapOfNonCircularRanges } from './getOverlapOfNonCircularRanges';
-export { default as getOverlapsOfPotentiallyCircularRanges } from './getOverlapsOfPotentiallyCircularRanges';
-export { default as getPositionFromAngle } from './getPositionFromAngle';
-export { default as getRangeAngles } from './getRangeAngles';
-export { default as getRangeLength } from './getRangeLength';
-export { default as getMiddleOfRange } from './getMiddleOfRange';
-export { default as getRangesBetweenTwoRanges } from './getRangesBetweenTwoRanges';
-export { default as getSequenceWithinRange } from './getSequenceWithinRange';
-export { default as getShortestDistanceBetweenTwoPositions } from './getShortestDistanceBetweenTwoPositions';
-export { default as getYOffsetForPotentiallyCircularRange } from './getYOffsetForPotentiallyCircularRange';
-export { default as getYOffsetsForPotentiallyCircularRanges } from './getYOffsetsForPotentiallyCircularRanges';
-export { default as invertRange } from './invertRange';
-export { default as isPositionCloserToRangeStartThanRangeEnd } from './isPositionCloserToRangeStartThanRangeEnd';
-export { default as isPositionWithinRange } from './isPositionWithinRange';
-export { default as isRangeWithinRange } from './isRangeWithinRange';
-export { default as loopEachPositionInRange } from './loopEachPositionInRange';
-export { default as modulatePositionByRange } from './modulatePositionByRange';
-export { default as modulateRangeBySequenceLength } from './modulateRangeBySequenceLength';
-export { default as normalizePositionByRangeLength } from './normalizePositionByRangeLength';
-export { default as normalizePositionByRangeLength1Based } from './normalizePositionByRangeLength1Based';
-export { default as normalizeRange } from './normalizeRange';
-export { default as provideInclusiveOptions } from './provideInclusiveOptions';
-export { default as reversePositionInRange } from './reversePositionInRange';
-export { default as splitRangeIntoTwoPartsIfItIsCircular } from './splitRangeIntoTwoPartsIfItIsCircular';
-export { default as translateRange } from './translateRange';
-export { default as trimNonCicularRangeByAnotherNonCircularRange } from './trimNonCicularRangeByAnotherNonCircularRange';
-export { default as trimNumberToFitWithin0ToAnotherNumber } from './trimNumberToFitWithin0ToAnotherNumber';
-export { default as trimRangeByAnotherRange } from './trimRangeByAnotherRange';
-export { default as zeroSubrangeByContainerRange } from './zeroSubrangeByContainerRange';
-export { default as adjustRangeToRotation } from './adjustRangeToRotation';
-export { default as getZeroedRangeOverlaps } from './getZeroedRangeOverlaps';
+export { default as adjustRangeToDeletionOfAnotherRange } from "./adjustRangeToDeletionOfAnotherRange";
+export { default as adjustRangeToInsert } from "./adjustRangeToInsert";
+export { default as checkIfNonCircularRangesOverlap } from "./checkIfNonCircularRangesOverlap";
+export { default as checkIfPotentiallyCircularRangesOverlap } from "./checkIfPotentiallyCircularRangesOverlap";
+export { default as collapseOverlapsGeneratedFromRangeComparisonIfPossible } from "./collapseOverlapsGeneratedFromRangeComparisonIfPossible";
+export { default as convertRangeIndices } from "./convertRangeIndices";
+export { default as convertRangeTo0Based } from "./convertRangeTo0Based";
+export { default as convertRangeTo1Based } from "./convertRangeTo1Based";
+export { default as doesRangeSpanEntireSequence } from "./doesRangeSpanEntireSequence";
+export { default as isRangeOrPositionWithinRange } from "./isRangeOrPositionWithinRange";
+export { default as doesRangeSpanOrigin } from "./doesRangeSpanOrigin";
+export { default as expandOrContractCircularRangeToPosition } from "./expandOrContractCircularRangeToPosition";
+export { default as expandOrContractNonCircularRangeToPosition } from "./expandOrContractNonCircularRangeToPosition";
+export { default as expandOrContractRangeByLength } from "./expandOrContractRangeByLength";
+export { default as expandOrContractRangeToPosition } from "./expandOrContractRangeToPosition";
+export { default as flipContainedRange } from "./flipContainedRange";
+export { default as generateRandomRange } from "./generateRandomRange";
+export { default as getAnnotationRangeType } from "./getAnnotationRangeType";
+export { default as getEachPositionInRangeAsArray } from "./getEachPositionInRangeAsArray";
+export { default as getLengthOfOverlappingRegionsBetweenTwoRanges } from "./getLengthOfOverlappingRegionsBetweenTwoRanges";
+export { default as getOverlapOfNonCircularRanges } from "./getOverlapOfNonCircularRanges";
+export { default as getOverlapsOfPotentiallyCircularRanges } from "./getOverlapsOfPotentiallyCircularRanges";
+export { default as getPositionFromAngle } from "./getPositionFromAngle";
+export { default as getRangeAngles } from "./getRangeAngles";
+export { default as getRangeLength } from "./getRangeLength";
+export { default as getMiddleOfRange } from "./getMiddleOfRange";
+export { default as getRangesBetweenTwoRanges } from "./getRangesBetweenTwoRanges";
+export { default as getSequenceWithinRange } from "./getSequenceWithinRange";
+export { default as getShortestDistanceBetweenTwoPositions } from "./getShortestDistanceBetweenTwoPositions";
+export { default as getYOffsetForPotentiallyCircularRange } from "./getYOffsetForPotentiallyCircularRange";
+export { default as getYOffsetsForPotentiallyCircularRanges } from "./getYOffsetsForPotentiallyCircularRanges";
+export { default as invertRange } from "./invertRange";
+export { default as isPositionCloserToRangeStartThanRangeEnd } from "./isPositionCloserToRangeStartThanRangeEnd";
+export { default as isPositionWithinRange } from "./isPositionWithinRange";
+export { default as isRangeWithinRange } from "./isRangeWithinRange";
+export { default as loopEachPositionInRange } from "./loopEachPositionInRange";
+export { default as modulatePositionByRange } from "./modulatePositionByRange";
+export { default as modulateRangeBySequenceLength } from "./modulateRangeBySequenceLength";
+export { default as normalizePositionByRangeLength } from "./normalizePositionByRangeLength";
+export { default as normalizePositionByRangeLength1Based } from "./normalizePositionByRangeLength1Based";
+export { default as normalizeRange } from "./normalizeRange";
+export { default as provideInclusiveOptions } from "./provideInclusiveOptions";
+export { default as reversePositionInRange } from "./reversePositionInRange";
+export { default as splitRangeIntoTwoPartsIfItIsCircular } from "./splitRangeIntoTwoPartsIfItIsCircular";
+export { default as translateRange } from "./translateRange";
+export { default as trimNonCicularRangeByAnotherNonCircularRange } from "./trimNonCicularRangeByAnotherNonCircularRange";
+export { default as trimNumberToFitWithin0ToAnotherNumber } from "./trimNumberToFitWithin0ToAnotherNumber";
+export { default as trimRangeByAnotherRange } from "./trimRangeByAnotherRange";
+export { default as zeroSubrangeByContainerRange } from "./zeroSubrangeByContainerRange";
+export { default as adjustRangeToRotation } from "./adjustRangeToRotation";
+export { default as getZeroedRangeOverlaps } from "./getZeroedRangeOverlaps";

package/src/index.test.js

@@ -3,15 +3,11 @@ import fs from "fs";
 
 describe("index.js", () => {
   it(`should export all functions defined`, () => {
-    return new Promise((resolve) => {
-
+    return new Promise(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("index.js") > -1) {
             return;
           }
           const funcOrObj = src[file.replace(".js", "")];
@@ -24,10 +20,12 @@ describe("index.js", () => {
           }
         });
         if (!passes) {
-          throw new Error("Please make sure to export (or ignore) each file! Update index.js to export the file");
+          throw new Error(
+            "Please make sure to export (or ignore) each file! Update index.js to export the file"
+          );
         }
         resolve();
       });
-    })
+    });
   });
 });

package/src/invertRange.test.js

@@ -1,96 +1,106 @@
-
-import invertRange from './invertRange';
-import chai from 'chai';
+import invertRange from "./invertRange";
+import chai from "chai";
 chai.should();
-describe('invertRange', function () {
-	it('should invert a non-circular range', function () {
-		const invertedRange = invertRange({start: 2, end:2}, 10);
-		invertedRange.start.should.equal(3)
-		invertedRange.end.should.equal(1)
-	});
-	it('should invert a non-circular range', function () {
-		const invertedRange = invertRange({start: 0, end:2}, 10);
-		invertedRange.start.should.equal(3)
-		invertedRange.end.should.equal(9)
-	});
-	it('should invert a non-circular range', function () {
-		const invertedRange = invertRange({start: 0, end:9}, 10);
-		invertedRange.start.should.equal(0)
-		invertedRange.end.should.equal(9)
-	});
-	it('should invert a non-circular range', function () {
-		const invertedRange = invertRange({start: 4, end:9}, 10);
-		invertedRange.start.should.equal(0)
-		invertedRange.end.should.equal(3)
-	});
-	it('should invert a circular range', function () {
-		const invertedRange = invertRange({start: 3, end:1}, 10);
-		invertedRange.start.should.equal(2)
-		invertedRange.end.should.equal(2)
-	});
-	it('should invert a circular range', function () {
-		const invertedRange = invertRange({start: 9, end:1}, 10);
-		invertedRange.start.should.equal(2)
-		invertedRange.end.should.equal(8)
-	});
-	it('should invert a circular range', function () {
-		const invertedRange = invertRange({start: 3, end:0}, 10);
-		invertedRange.start.should.equal(1)
-		invertedRange.end.should.equal(2)
-	});
-	it('should handle inverting a whole range by returning the original range', function () {
-		const invertedRange = invertRange({start: 4, end:3}, 10);
-		invertedRange.start.should.equal(4)
-		invertedRange.end.should.equal(3)
-	});
-	it('should handle inverting a caret position', function () {
-		const invertedRange = invertRange(1, 10);
-		invertedRange.start.should.equal(1)
-		invertedRange.end.should.equal(0)
-	});
-	it('should handle inverting a caret position', function () {
-		const invertedRange = invertRange(0, 10);
-		invertedRange.start.should.equal(0)
-		invertedRange.end.should.equal(9)
-	});
-	//tnrtodo: maybe one day we'll want to handle the "entire range" case in a special way, but for now we'll just return the original range
-	// it('should handle inverting a whole range by setting the start and end to -1', function () {
-	// 	var invertedRange = invertRange({start: 4, end:3}, 10);
-	// 	invertedRange.start.should.equal(-1)
-	// 	invertedRange.end.should.equal(-1)
-	// });
+describe("invertRange", function () {
+  it("should invert a non-circular range", function () {
+    const invertedRange = invertRange({ start: 2, end: 2 }, 10);
+    invertedRange.start.should.equal(3);
+    invertedRange.end.should.equal(1);
+  });
+  it("should invert a non-circular range", function () {
+    const invertedRange = invertRange({ start: 0, end: 2 }, 10);
+    invertedRange.start.should.equal(3);
+    invertedRange.end.should.equal(9);
+  });
+  it("should invert a non-circular range", function () {
+    const invertedRange = invertRange({ start: 0, end: 9 }, 10);
+    invertedRange.start.should.equal(0);
+    invertedRange.end.should.equal(9);
+  });
+  it("should invert a non-circular range", function () {
+    const invertedRange = invertRange({ start: 4, end: 9 }, 10);
+    invertedRange.start.should.equal(0);
+    invertedRange.end.should.equal(3);
+  });
+  it("should invert a circular range", function () {
+    const invertedRange = invertRange({ start: 3, end: 1 }, 10);
+    invertedRange.start.should.equal(2);
+    invertedRange.end.should.equal(2);
+  });
+  it("should invert a circular range", function () {
+    const invertedRange = invertRange({ start: 9, end: 1 }, 10);
+    invertedRange.start.should.equal(2);
+    invertedRange.end.should.equal(8);
+  });
+  it("should invert a circular range", function () {
+    const invertedRange = invertRange({ start: 3, end: 0 }, 10);
+    invertedRange.start.should.equal(1);
+    invertedRange.end.should.equal(2);
+  });
+  it("should handle inverting a whole range by returning the original range", function () {
+    const invertedRange = invertRange({ start: 4, end: 3 }, 10);
+    invertedRange.start.should.equal(4);
+    invertedRange.end.should.equal(3);
+  });
+  it("should handle inverting a caret position", function () {
+    const invertedRange = invertRange(1, 10);
+    invertedRange.start.should.equal(1);
+    invertedRange.end.should.equal(0);
+  });
+  it("should handle inverting a caret position", function () {
+    const invertedRange = invertRange(0, 10);
+    invertedRange.start.should.equal(0);
+    invertedRange.end.should.equal(9);
+  });
+  //tnrtodo: maybe one day we'll want to handle the "entire range" case in a special way, but for now we'll just return the original range
+  // it('should handle inverting a whole range by setting the start and end to -1', function () {
+  // 	var invertedRange = invertRange({start: 4, end:3}, 10);
+  // 	invertedRange.start.should.equal(-1)
+  // 	invertedRange.end.should.equal(-1)
+  // });
 });
-describe('invertRange should handle options inclusive1BasedEnd or inclusive1BasedStart', function () {
-	it('should handle inverting a whole range by returning the original range', function () {
-		const options = {inclusive1BasedEnd: true};
-		const invertedRange = invertRange({start: 2, end:2}, 10, options);
-		invertedRange.start.should.equal(2)
-		invertedRange.end.should.equal(2)
-	});
-	it('should invert a non-circular range', function () {
-		const options = {inclusive1BasedEnd: true};
-		const invertedRange = invertRange({start: 0, end:2}, 10, options);
-		invertedRange.start.should.equal(2)
-		invertedRange.end.should.equal(10)
-	});
-	it('should invert non-circular range 1', function () {
-		const invertedRange = invertRange({start: 0, end:9}, 10,{inclusive1BasedEnd: true});
-		invertedRange.start.should.equal(9)
-		invertedRange.end.should.equal(10)
-	});
-	it('should invert a non-circular range 2', function () {
-		const invertedRange = invertRange({start: 1, end:9}, 10,{inclusive1BasedEnd: true,inclusive1BasedStart: true});
-		invertedRange.start.should.equal(10)
-		invertedRange.end.should.equal(10)
-	});
-	it('should invert a non-circular range 3', function () {
-		const invertedRange = invertRange({start: 3, end:6}, 10,{inclusive1BasedEnd: true,inclusive1BasedStart: true});
-		invertedRange.start.should.equal(7)
-		invertedRange.end.should.equal(2)
-	});
-	it('should invert a circular range 4', function () {
-		const invertedRange = invertRange({start: 6, end:3}, 10,{inclusive1BasedEnd: true,inclusive1BasedStart: true});
-		invertedRange.start.should.equal(4)
-		invertedRange.end.should.equal(5)
-	});
+describe("invertRange should handle options inclusive1BasedEnd or inclusive1BasedStart", function () {
+  it("should handle inverting a whole range by returning the original range", function () {
+    const options = { inclusive1BasedEnd: true };
+    const invertedRange = invertRange({ start: 2, end: 2 }, 10, options);
+    invertedRange.start.should.equal(2);
+    invertedRange.end.should.equal(2);
+  });
+  it("should invert a non-circular range", function () {
+    const options = { inclusive1BasedEnd: true };
+    const invertedRange = invertRange({ start: 0, end: 2 }, 10, options);
+    invertedRange.start.should.equal(2);
+    invertedRange.end.should.equal(10);
+  });
+  it("should invert non-circular range 1", function () {
+    const invertedRange = invertRange({ start: 0, end: 9 }, 10, {
+      inclusive1BasedEnd: true
+    });
+    invertedRange.start.should.equal(9);
+    invertedRange.end.should.equal(10);
+  });
+  it("should invert a non-circular range 2", function () {
+    const invertedRange = invertRange({ start: 1, end: 9 }, 10, {
+      inclusive1BasedEnd: true,
+      inclusive1BasedStart: true
+    });
+    invertedRange.start.should.equal(10);
+    invertedRange.end.should.equal(10);
+  });
+  it("should invert a non-circular range 3", function () {
+    const invertedRange = invertRange({ start: 3, end: 6 }, 10, {
+      inclusive1BasedEnd: true,
+      inclusive1BasedStart: true
+    });
+    invertedRange.start.should.equal(7);
+    invertedRange.end.should.equal(2);
+  });
+  it("should invert a circular range 4", function () {
+    const invertedRange = invertRange({ start: 6, end: 3 }, 10, {
+      inclusive1BasedEnd: true,
+      inclusive1BasedStart: true
+    });
+    invertedRange.start.should.equal(4);
+    invertedRange.end.should.equal(5);
+  });
 });

package/src/isPositionCloserToRangeStartThanRangeEnd.js

@@ -1,8 +1,20 @@
 //function to calculate whether a position is closer to the range start than the range end
-import getShortestDistanceBetweenTwoPositions from './getShortestDistanceBetweenTwoPositions';
+import getShortestDistanceBetweenTwoPositions from "./getShortestDistanceBetweenTwoPositions";
 
-export default function isPositionCloserToRangeStartThanRangeEnd(position, range, maxLength) {
-    const distanceFromStart = getShortestDistanceBetweenTwoPositions(range.start, position, maxLength);
-    const distanceFromEnd = getShortestDistanceBetweenTwoPositions(range.end, position, maxLength);
-    return distanceFromStart <= distanceFromEnd
-};
+export default function isPositionCloserToRangeStartThanRangeEnd(
+  position,
+  range,
+  maxLength
+) {
+  const distanceFromStart = getShortestDistanceBetweenTwoPositions(
+    range.start,
+    position,
+    maxLength
+  );
+  const distanceFromEnd = getShortestDistanceBetweenTwoPositions(
+    range.end,
+    position,
+    maxLength
+  );
+  return distanceFromStart <= distanceFromEnd;
+}

package/src/isPositionCloserToRangeStartThanRangeEnd.test.js

@@ -1,17 +1,37 @@
-import isPositionCloserToRangeStartThanRangeEnd from './isPositionCloserToRangeStartThanRangeEnd';
-import {expect} from 'chai';
+import isPositionCloserToRangeStartThanRangeEnd from "./isPositionCloserToRangeStartThanRangeEnd";
+import { expect } from "chai";
 
-describe('isPositionCloserToRangeStartThanRangeEnd', function() {
-    it('should correctly determine whether a position is closer to the start of a range than the end', function() {
-        expect(isPositionCloserToRangeStartThanRangeEnd(0,{start: 1, end: 10}, 100)).to.equal(true)
-        expect(isPositionCloserToRangeStartThanRangeEnd(1,{start: 0, end: 10}, 100)).to.equal(true)
-        expect(isPositionCloserToRangeStartThanRangeEnd(11,{start: 1, end: 10}, 100)).to.equal(false)
-        expect(isPositionCloserToRangeStartThanRangeEnd(0,{start: 0, end: 10}, 100)).to.equal(true)
-        expect(isPositionCloserToRangeStartThanRangeEnd(10,{start: 0, end: 10}, 100)).to.equal(false)
-        expect(isPositionCloserToRangeStartThanRangeEnd(10,{start: 10, end: 5}, 100)).to.equal(true)
-        expect(isPositionCloserToRangeStartThanRangeEnd(11,{start: 10, end: 5}, 100)).to.equal(true)
-        expect(isPositionCloserToRangeStartThanRangeEnd(4,{start: 10, end: 5}, 100)).to.equal(false)
-        expect(isPositionCloserToRangeStartThanRangeEnd(5,{start: 10, end: 5}, 100)).to.equal(false)
-        expect(isPositionCloserToRangeStartThanRangeEnd(6,{start: 10, end: 5}, 100)).to.equal(false)
-    })
-})
+describe("isPositionCloserToRangeStartThanRangeEnd", function () {
+  it("should correctly determine whether a position is closer to the start of a range than the end", function () {
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(0, { start: 1, end: 10 }, 100)
+    ).to.equal(true);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(1, { start: 0, end: 10 }, 100)
+    ).to.equal(true);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(11, { start: 1, end: 10 }, 100)
+    ).to.equal(false);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(0, { start: 0, end: 10 }, 100)
+    ).to.equal(true);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(10, { start: 0, end: 10 }, 100)
+    ).to.equal(false);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(10, { start: 10, end: 5 }, 100)
+    ).to.equal(true);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(11, { start: 10, end: 5 }, 100)
+    ).to.equal(true);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(4, { start: 10, end: 5 }, 100)
+    ).to.equal(false);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(5, { start: 10, end: 5 }, 100)
+    ).to.equal(false);
+    expect(
+      isPositionCloserToRangeStartThanRangeEnd(6, { start: 10, end: 5 }, 100)
+    ).to.equal(false);
+  });
+});

package/src/isPositionWithinRange.js

@@ -1,10 +1,10 @@
 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 
+ * @param {*} sequenceLength
+ * @param {*} includeEdges - (default false) whether or not to say
  */
 function isPositionWithinRange(
   position,
@@ -14,7 +14,7 @@ function isPositionWithinRange(
   includeEndEdge
 ) {
   const ranges = splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength);
-  const positionFits = ranges.some(function(range) {
+  const positionFits = ranges.some(function (range) {
     if (includeStartEdge ? position < range.start : position <= range.start) {
       return false;
     } else {

package/src/isRangeOrPositionWithinRange.js

@@ -1,4 +1,4 @@
-import {isObject} from "lodash";
+import { isObject } from "lodash";
 import isRangeWithinRange from "./isRangeWithinRange";
 import isPositionWithinRange from "./isPositionWithinRange";
 
@@ -9,21 +9,27 @@ export default function isRangeOrPositionWithinRange(
   includeStartEdge,
   includeEndEdge
 ) {
-
-  if (rangeOrPositionToCheck === undefined || rangeOrPositionToCheck === null || 
-    containingRange === undefined || containingRange === null ) {
-    return false
+  if (
+    rangeOrPositionToCheck === undefined ||
+    rangeOrPositionToCheck === null ||
+    containingRange === undefined ||
+    containingRange === null
+  ) {
+    return false;
   }
-  if (isObject(rangeOrPositionToCheck))    {
-    return isRangeWithinRange(rangeOrPositionToCheck,
+  if (isObject(rangeOrPositionToCheck)) {
+    return isRangeWithinRange(
+      rangeOrPositionToCheck,
       containingRange,
-      maxLength)
+      maxLength
+    );
   } else {
-    return isPositionWithinRange( rangeOrPositionToCheck,
+    return isPositionWithinRange(
+      rangeOrPositionToCheck,
       containingRange,
       maxLength,
       includeStartEdge,
-      includeEndEdge)
+      includeEndEdge
+    );
   }
-
-};
+}

package/src/isRangeOrPositionWithinRange.test.js

@@ -1,8 +1,8 @@
 import isRangeOrPositionWithinRange from "./isRangeOrPositionWithinRange";
-import {expect} from "chai";
+import { expect } from "chai";
 
-describe("isRangeOrPositionWithinRange", function() {
-  it("should correctly determine whether a position is within a range", function() {
+describe("isRangeOrPositionWithinRange", function () {
+  it("should correctly determine whether a position is within a range", function () {
     expect(isRangeOrPositionWithinRange(1, { start: 1, end: 1 })).to.equal(
       false
     );
@@ -38,7 +38,7 @@ describe("isRangeOrPositionWithinRange", function() {
     );
   });
 
-  it("should correctly determine whether a position is within a range when includeStartEdge/includeEndEdge is set to true", function() {
+  it("should correctly determine whether a position is within a range when includeStartEdge/includeEndEdge is set to true", function () {
     expect(
       isRangeOrPositionWithinRange(1, { start: 1, end: 1 }, 11, true, true)
     ).to.equal(true);
@@ -47,7 +47,7 @@ describe("isRangeOrPositionWithinRange", function() {
     ).to.equal(true);
   });
 
-  it("should work for angle values w/ long decimal places", function() {
+  it("should work for angle values w/ long decimal places", function () {
     expect(
       isRangeOrPositionWithinRange(
         { start: 5.669848916850995, end: 5.815135586893387 },
@@ -56,7 +56,7 @@ describe("isRangeOrPositionWithinRange", function() {
       )
     ).to.equal(true);
   });
-  it("should correctly determine whether a position is within a range", function() {
+  it("should correctly determine whether a position is within a range", function () {
     expect(
       isRangeOrPositionWithinRange(null, { start: 1, end: 10 }, 100)
     ).to.equal(false);

package/src/isRangeWithinRange.js

@@ -6,12 +6,11 @@ export default function isRangeWithinRange(
   containingRange,
   maxLength
 ) {
-    
   const ranges = trimRangeByAnotherRange(
     rangeToCheck,
     containingRange,
     maxLength
   );
-  if (ranges === null) return false
+  if (ranges === null) return false;
   return !ranges;
-};
+}

package/src/loopEachPositionInRange.js

@@ -1,5 +1,5 @@
-import getEachPositionInRangeAsArray from './getEachPositionInRangeAsArray';
+import getEachPositionInRangeAsArray from "./getEachPositionInRangeAsArray";
 
 export default function loopEachPositionInRange(range, rangeMax, func) {
-    getEachPositionInRangeAsArray(range,rangeMax).map(func)
-};
+  getEachPositionInRangeAsArray(range, rangeMax).map(func);
+}

package/src/modulatePositionByRange.js

@@ -1,10 +1,10 @@
 //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) {
-    let returnVal = position;
-    if (position < range.start) {
-      returnVal = range.end - (range.start - (position + 1))
-    } else if (position > range.end) {
-      returnVal = range.start + (position - range.end - 1)
-    }
-    return returnVal
-};
+  let returnVal = position;
+  if (position < range.start) {
+    returnVal = range.end - (range.start - (position + 1));
+  } else if (position > range.end) {
+    returnVal = range.start + (position - range.end - 1);
+  }
+  return returnVal;
+}

package/src/modulatePositionByRange.test.js

@@ -1,12 +1,11 @@
-import modulatePositionByRange from './modulatePositionByRange';
-import {expect} from 'chai';
+import modulatePositionByRange from "./modulatePositionByRange";
+import { expect } from "chai";
 
-describe('modulatePositionByRange', function() {
-    it('should modulate positions by their min and max', function() {
-        expect(modulatePositionByRange(0,{start: 1, end: 10})).to.equal(10)
-        expect(modulatePositionByRange(11,{start: 1, end: 10})).to.equal(1)
-        expect(modulatePositionByRange(0,{start: 0, end: 10})).to.equal(0)
-        expect(modulatePositionByRange(10,{start: 0, end: 10})).to.equal(10)
-    })
-  
-})
+describe("modulatePositionByRange", function () {
+  it("should modulate positions by their min and max", function () {
+    expect(modulatePositionByRange(0, { start: 1, end: 10 })).to.equal(10);
+    expect(modulatePositionByRange(11, { start: 1, end: 10 })).to.equal(1);
+    expect(modulatePositionByRange(0, { start: 0, end: 10 })).to.equal(0);
+    expect(modulatePositionByRange(10, { start: 0, end: 10 })).to.equal(10);
+  });
+});

package/src/modulateRangeBySequenceLength.js

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