@teselagen/range-utils 0.1.21 → 0.1.23

package/src/getSequenceWithinRange.test.js

@@ -0,0 +1,49 @@
+
+
+import getSequenceWithinRange from './getSequenceWithinRange.js';
+
+import assert from 'assert';
+let subseq;
+
+describe('getSequenceWithinRange', function() {
+    it('works with an array (translation amino acids for example) as well', function() {
+        subseq = getSequenceWithinRange({start: 0,end:0},['a','t','g','c']);
+        assert.deepEqual(subseq, ['a']);
+        subseq = getSequenceWithinRange({start: 1,end:1},['a','t','g','c']);
+        assert.deepEqual(subseq, ['t']);
+        subseq = getSequenceWithinRange({start: 1,end:0},['a','t','g','c']);
+        assert.deepEqual(subseq, ['t','g','c','a']);
+    });
+    it('gets a non circular range', function() {
+        subseq = getSequenceWithinRange({start: 0,end:0},'atgc');
+        assert.equal(subseq, 'a');
+        subseq = getSequenceWithinRange({start: 1,end:1},'atgc');
+        assert.equal(subseq, 't');
+        subseq = getSequenceWithinRange({start: 0,end:3},'atgc');
+        assert.equal(subseq, 'atgc');
+    });
+    it('gets a circular range', function() {
+        subseq = getSequenceWithinRange({start: 1,end:0},'atgc');
+        assert.deepEqual(subseq, 'tgca');
+        subseq = getSequenceWithinRange({start: 2,end:1},'atgc');
+        assert.deepEqual(subseq, 'gcat');
+        subseq = getSequenceWithinRange({start: 3,end:0},'atgc');
+        assert.deepEqual(subseq, 'ca');
+    });
+    it('gets a circular range', function() {
+        subseq = getSequenceWithinRange({start: 1,end:0},'atgc');
+        assert.deepEqual(subseq, 'tgca');
+        subseq = getSequenceWithinRange({start: 2,end:1},'atgc');
+        assert.deepEqual(subseq, 'gcat');
+        subseq = getSequenceWithinRange({start: 3,end:0},'atgc');
+        assert.deepEqual(subseq, 'ca');
+    });
+    it('returns an empty string if the range is invalid', function() {
+        subseq = getSequenceWithinRange({start: -1,end:0},'atgc');
+        assert.deepEqual(subseq, '');
+        subseq = getSequenceWithinRange({start: -1,end:-1},'atgc');
+        assert.deepEqual(subseq, '');
+        subseq = getSequenceWithinRange({start: 3,end:-1},'atgc');
+        assert.deepEqual(subseq, '');
+    });
+});

package/src/getShortestDistanceBetweenTwoPositions.js

@@ -0,0 +1,12 @@
+export default function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLength) {
+  if (position1 < position2) {
+	const position1Holder = position1;
+  	position1 = position2
+	position2 = position1Holder
+  }
+  //position 1 is now always >= position 2
+
+  const d1 = position1 - position2;
+  const d2 = sequenceLength - position1 + position2;
+  return Math.min(d1,d2)
+};

package/src/getShortestDistanceBetweenTwoPositions.test.js

@@ -0,0 +1,14 @@
+import assert from 'assert';
+import getShortestDistanceBetweenTwoPositions from './getShortestDistanceBetweenTwoPositions';
+describe('getShortestDistanceBetweenTwoPositions', function () {
+	it('should return the correct length for positions that cross the origin', function () {
+		const length = getShortestDistanceBetweenTwoPositions(9,0,10);
+		assert(length === 1)
+
+	});
+	it('should return the correct length for ranges that do not cross the origin', function () {
+		const length = getShortestDistanceBetweenTwoPositions(4,6,10);
+		assert(length === 2)
+
+	});
+});

package/src/getYOffsetForPotentiallyCircularRange.js

@@ -0,0 +1,24 @@
+import checkIfPotentiallyCircularRangesOverlap from './checkIfPotentiallyCircularRangesOverlap';
+
+export default function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
+    //adjust the yOffset of the range being pushed in by checking its range against other range already in the row
+    let yOffset = [];
+    //YOffsetLevelsWithRanges is an array of arrays (array of yOffset levels holding arrays of range)
+    //loop through y offset levels starting with the 0 level until an empty one is found and push the range into it. If none are found, add another level. 
+    const openYOffsetFound = YOffsetLevelsWithRanges.some(function(rangesAlreadyAddedToYOffset, index) {
+        const rangeBlocked = rangesAlreadyAddedToYOffset.some(function(comparisonRange) {
+            return checkIfPotentiallyCircularRangesOverlap(range, comparisonRange)
+        })
+        if (!rangeBlocked) {
+            yOffset = index
+            if (assignYOffsetToRange) range.yOffset = index
+            rangesAlreadyAddedToYOffset.push(range)
+            return true
+        }
+    });
+    if (!openYOffsetFound) {
+        yOffset = YOffsetLevelsWithRanges.length
+        if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length
+    }
+    return yOffset
+};

package/src/getYOffsetsForPotentiallyCircularRanges.js

@@ -0,0 +1,20 @@
+import getYOffsetForPotentiallyCircularRange from './getYOffsetForPotentiallyCircularRange';
+
+export default function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
+    //adjust the yOffset of the range being pushed in by checking its range against other ranges already in the row
+    const yOffsets = [];
+    let maxYOffset = 0;
+    const yOffsetLevels = [] //yOffsetLevels is an array of arrays (array of yOffset levels holding arrays of ranges)
+    ranges.forEach(function(range){
+        //loop through y offset levels starting with the 0 level until an empty one is found and push the range into it. If none are found, add another level.
+        const yOffset = getYOffsetForPotentiallyCircularRange(range, yOffsetLevels, assignYOffsetToRange)
+        yOffsets.push(yOffset)
+        if (yOffset>maxYOffset) {
+            maxYOffset = yOffset;
+        }
+        range.yOffset = yOffset;
+        if (!yOffsetLevels[yOffset]) yOffsetLevels[yOffset] = [];
+        yOffsetLevels[yOffset].push(range);
+    });
+    return {yOffsets:yOffsets, maxYOffset: maxYOffset};
+};

package/src/getYOffsetsForPotentiallyCircularRanges.test.js

@@ -0,0 +1,29 @@
+import {expect} from 'chai';
+import getYOffsetsForPotentiallyCircularRanges from './getYOffsetsForPotentiallyCircularRanges.js';
+describe('getYOffsetsForPotentiallyCircularRanges', function() {
+    it('returns correct yOffset for overlapping ranges', function() {
+        expect(getYOffsetsForPotentiallyCircularRanges([{
+            start: 5,
+            end: 100
+        }, {
+            start: 50,
+            end: 50
+        }])).to.deep.equal({yOffsets: [0,1], maxYOffset: 1});
+        expect(getYOffsetsForPotentiallyCircularRanges([{
+            start: 5,
+            end: 100
+        }, {
+            start: 50,
+            end: 50
+        },{
+            start: 50,
+            end: 50
+        },{
+            start: 150,
+            end: 4
+        },{
+            start: 150,
+            end: 150
+        }])).to.deep.equal({yOffsets: [0,1,2,0,1], maxYOffset: 2});
+    });
+});

package/src/getZeroedRangeOverlaps.js

@@ -0,0 +1,17 @@
+
+import getOverlapsOfPotentiallyCircularRanges from './getOverlapsOfPotentiallyCircularRanges';
+import collapseOverlapsGeneratedFromRangeComparisonIfPossible from './collapseOverlapsGeneratedFromRangeComparisonIfPossible';
+import zeroSubrangeByContainerRange from './zeroSubrangeByContainerRange';
+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)  {
+  const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(getOverlapsOfPotentiallyCircularRanges(annotation, selection, sequenceLength), sequenceLength, annotation)
+  const zeroedOverlaps = overlaps.map((overlap) => {
+    return zeroSubrangeByContainerRange(overlap, {
+      start: selection.start,
+      end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
+    }, sequenceLength)
+  })
+  return zeroedOverlaps
+};

package/src/getZeroedRangeOverlaps.test.js

@@ -0,0 +1,36 @@
+import assert from 'assert';
+import getZeroedRangeOverlaps from './getZeroedRangeOverlaps';
+describe('getZeroedRangeOverlaps', function() {
+    it('annotation non-circular, selection non circular ', function() {
+        const res = getZeroedRangeOverlaps({start: 0, end: 3}, {start: 2, end: 3}, 4, true, true) 
+        assert.deepEqual(res, [{start: 0, end:1}])
+    })
+    it('annotation non circular, selection circular', function() {
+      //01234
+      //aaaa 
+      //s sss
+        const res = getZeroedRangeOverlaps({start: 0, end: 3}, {start: 2, end: 0}, 5, true, true) 
+        assert.deepEqual(res, [ {start: 3,end: 3}, {start: 0, end:1}])
+    })
+    it('annotation non circular, selection circular 2', function() {
+      //0123
+      //aaaa
+      //ssss 
+        const res = getZeroedRangeOverlaps({start: 0, end: 3}, {start: 2, end: 1}, 4, true, true) 
+        assert.deepEqual(res, [ {start: 2,end: 3}, {start: 0, end:1},])
+    })
+    it('annotation circular, selection fully containing', function() {
+      //01234
+      //aa aa
+      //sssss 
+        const res = getZeroedRangeOverlaps({start: 3, end: 1}, {start: 0, end: 4}, 5, true, true) 
+        assert.deepEqual(res, [{start: 3, end: 1}])
+    })
+    it('annotation circular, selection fully containing 2', function() {
+      //01234
+      //aa aa
+      //sssss 
+        const res = getZeroedRangeOverlaps({start: 3, end: 1}, {start: 1, end: 0}, 5, true, true) 
+        assert.deepEqual(res, [{start: 2, end: 4}, {start: 0, end: 0}])
+    })
+})

package/src/index.js

@@ -0,0 +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';

package/src/index.test.js

@@ -0,0 +1,33 @@
+import * as src from "./index";
+import fs from "fs";
+
+describe("index.js", () => {
+  it(`should export all functions defined`, () => {
+    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
+          ) {
+            return;
+          }
+          const funcOrObj = src[file.replace(".js", "")];
+          if (!funcOrObj) {
+            console.info(
+              `Uh oh, it looks like you forgot to export (or explicitly ignore) this file:`,
+              file
+            );
+            passes = false;
+          }
+        });
+        if (!passes) {
+          throw new Error("Please make sure to export (or ignore) each file! Update index.js to export the file");
+        }
+        resolve();
+      });
+    })
+  });
+});

package/src/invertRange.js

@@ -0,0 +1,21 @@
+import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
+import provideInclusiveOptions from "./provideInclusiveOptions";
+export default provideInclusiveOptions(invertRange);
+
+function invertRange(rangeOrCaret, rangeMax) {
+  if (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)
+      };
+    }
+  }
+}

package/src/invertRange.test.js

@@ -0,0 +1,96 @@
+
+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 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

@@ -0,0 +1,8 @@
+//function to calculate whether a position is closer to the range start than the range end
+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
+};

package/src/isPositionCloserToRangeStartThanRangeEnd.test.js

@@ -0,0 +1,17 @@
+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)
+    })
+})

package/src/isPositionWithinRange.js

@@ -0,0 +1,31 @@
+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 
+ */
+function isPositionWithinRange(
+  position,
+  range,
+  sequenceLength,
+  includeStartEdge,
+  includeEndEdge
+) {
+  const ranges = splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength);
+  const positionFits = ranges.some(function(range) {
+    if (includeStartEdge ? position < range.start : position <= range.start) {
+      return false;
+    } else {
+      if (includeEndEdge ? position <= range.end + 1 : position <= range.end) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  });
+  return positionFits;
+}
+
+export default isPositionWithinRange;

package/src/isRangeOrPositionWithinRange.js

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

package/src/isRangeOrPositionWithinRange.test.js

@@ -0,0 +1,150 @@
+import isRangeOrPositionWithinRange from "./isRangeOrPositionWithinRange";
+import {expect} from "chai";
+
+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
+    );
+    expect(isRangeOrPositionWithinRange(0, { start: 1, end: 10 })).to.equal(
+      false
+    );
+    expect(isRangeOrPositionWithinRange(1, { start: 0, end: 10 })).to.equal(
+      true
+    );
+    expect(isRangeOrPositionWithinRange(11, { start: 1, end: 10 })).to.equal(
+      false
+    );
+    expect(isRangeOrPositionWithinRange(0, { start: 0, end: 10 })).to.equal(
+      false
+    );
+    expect(isRangeOrPositionWithinRange(10, { start: 0, end: 10 })).to.equal(
+      true
+    );
+    expect(isRangeOrPositionWithinRange(10, { start: 10, end: 5 })).to.equal(
+      false
+    );
+    expect(isRangeOrPositionWithinRange(11, { start: 10, end: 5 })).to.equal(
+      true
+    );
+    expect(isRangeOrPositionWithinRange(4, { start: 10, end: 5 })).to.equal(
+      true
+    );
+    expect(isRangeOrPositionWithinRange(5, { start: 10, end: 5 })).to.equal(
+      true
+    );
+    expect(isRangeOrPositionWithinRange(6, { start: 10, end: 5 })).to.equal(
+      false
+    );
+  });
+
+  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);
+    expect(
+      isRangeOrPositionWithinRange(0, { start: 0, end: 10 }, 11, true, true)
+    ).to.equal(true);
+  });
+
+  it("should work for angle values w/ long decimal places", function() {
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 5.669848916850995, end: 5.815135586893387 },
+        { start: 4.71238898038469, end: 1.5707963267948966 },
+        Math.PI * 2 + 1 //need the +1
+      )
+    ).to.equal(true);
+  });
+  it("should correctly determine whether a position is within a range", function() {
+    expect(
+      isRangeOrPositionWithinRange(null, { start: 1, end: 10 }, 100)
+    ).to.equal(false);
+    expect(
+      isRangeOrPositionWithinRange({}, { start: 1, end: 10 }, 100)
+    ).to.equal(false);
+    expect(
+      isRangeOrPositionWithinRange({ start: 5, end: 10 }, undefined, 100)
+    ).to.equal(false);
+    expect(isRangeOrPositionWithinRange(undefined, undefined, 100)).to.equal(
+      false
+    );
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 5, end: 10 },
+        { start: 1, end: 10 },
+        100
+      )
+    ).to.equal(true);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 5, end: 10 },
+        { start: -1, end: 10 },
+        100
+      )
+    ).to.equal(false);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 0, end: 10 },
+        { start: 0, end: 10 },
+        100
+      )
+    ).to.equal(true);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 10, end: 10 },
+        { start: 1, end: 10 },
+        100
+      )
+    ).to.equal(true);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 11, end: 10 },
+        { start: 0, end: 10 },
+        100
+      )
+    ).to.equal(false);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 12, end: 16 },
+        { start: 0, end: 10 },
+        100
+      )
+    ).to.equal(false);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 10, end: 5 },
+        { start: 10, end: 5 },
+        100
+      )
+    ).to.equal(true);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 10, end: 5 },
+        { start: 10, end: 5 },
+        100
+      )
+    ).to.equal(true);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 10, end: 5 },
+        { start: 10, end: 5 },
+        100
+      )
+    ).to.equal(true);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 0, end: 6 },
+        { start: 10, end: 5 },
+        100
+      )
+    ).to.equal(false);
+    expect(
+      isRangeOrPositionWithinRange(
+        { start: 10, end: 6 },
+        { start: 10, end: 5 },
+        100
+      )
+    ).to.equal(false);
+  });
+});