@teselagen/range-utils 0.3.7 → 0.3.8

package/src/modulateRangeBySequenceLength.test.js

@@ -1,16 +1,39 @@
-import {expect} from 'chai';
-import modulateRangeBySequenceLength from './modulateRangeBySequenceLength';
-describe('modulateRangeBySequenceLength', function() {
-    it('should modulate ranges that are outside of the sequence length', function() {
-        //agtc
-        //0123
-        expect(modulateRangeBySequenceLength({start: 2, end: 5},4)).to.deep.equal({start: 2, end:1})
-        expect(modulateRangeBySequenceLength({start: 2, end: 4},4)).to.deep.equal({start: 2, end:0})
-        //agtc
-        //12345
-        expect(modulateRangeBySequenceLength({start: 2, end: 4},4,{inclusive1BasedEnd: true})).to.deep.equal({start: 2, end:4})
-        expect(modulateRangeBySequenceLength({start: 2, end: 4},4,{inclusive1BasedEnd: true,inclusive1BasedStart: true})).to.deep.equal({start: 2, end:4})
-        expect(modulateRangeBySequenceLength({start: 5, end: 4},4,{inclusive1BasedEnd: true,inclusive1BasedStart: true})).to.deep.equal({start: 1, end:4})
-        expect(modulateRangeBySequenceLength({start: 5, end: 5},4,{inclusive1BasedEnd: true,inclusive1BasedStart: true})).to.deep.equal({start: 1, end:1})
-    })
-})
+import { expect } from "chai";
+import modulateRangeBySequenceLength from "./modulateRangeBySequenceLength";
+describe("modulateRangeBySequenceLength", function () {
+  it("should modulate ranges that are outside of the sequence length", function () {
+    //agtc
+    //0123
+    expect(
+      modulateRangeBySequenceLength({ start: 2, end: 5 }, 4)
+    ).to.deep.equal({ start: 2, end: 1 });
+    expect(
+      modulateRangeBySequenceLength({ start: 2, end: 4 }, 4)
+    ).to.deep.equal({ start: 2, end: 0 });
+    //agtc
+    //12345
+    expect(
+      modulateRangeBySequenceLength({ start: 2, end: 4 }, 4, {
+        inclusive1BasedEnd: true
+      })
+    ).to.deep.equal({ start: 2, end: 4 });
+    expect(
+      modulateRangeBySequenceLength({ start: 2, end: 4 }, 4, {
+        inclusive1BasedEnd: true,
+        inclusive1BasedStart: true
+      })
+    ).to.deep.equal({ start: 2, end: 4 });
+    expect(
+      modulateRangeBySequenceLength({ start: 5, end: 4 }, 4, {
+        inclusive1BasedEnd: true,
+        inclusive1BasedStart: true
+      })
+    ).to.deep.equal({ start: 1, end: 4 });
+    expect(
+      modulateRangeBySequenceLength({ start: 5, end: 5 }, 4, {
+        inclusive1BasedEnd: true,
+        inclusive1BasedStart: true
+      })
+    ).to.deep.equal({ start: 1, end: 1 });
+  });
+});

package/src/normalizePositionByRangeLength.js

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

package/src/normalizePositionByRangeLength.test.js

@@ -1,23 +1,23 @@
-import {expect} from 'chai';
-import normalizePositionByRangeLength from './normalizePositionByRangeLength';
-describe('normalizePositionByRangeLength', function() {
-    it('should normalize positions by their max length, assuming 0-based inclusive indices', function() {
-        expect(normalizePositionByRangeLength(10,9)).to.equal(1)
-        expect(normalizePositionByRangeLength(9,9)).to.equal(0)
-        expect(normalizePositionByRangeLength(3572,2000)).to.equal(1572)
-    })
-    it('should set something more than twice outside the sequence length to either 0 or sequenceLength-1', function () {
-        expect(normalizePositionByRangeLength(-3572,2000)).to.equal(0)
-        expect(normalizePositionByRangeLength(33572,2000)).to.equal(1999)
-    })
-    it('should handle isInBetweenPositions === true being passed in ', function() {
-      expect(normalizePositionByRangeLength(9,9,true)).to.equal(9)
-    })
-    it('should set something more than twice outside the sequence length to either 0 or sequenceLength when isInBetweenPositions is true', function () {
-        expect(normalizePositionByRangeLength(-3572,2000, true)).to.equal(0)
-        expect(normalizePositionByRangeLength(33572,2000, true)).to.equal(2000)
-    })
-    it('should not do anything if it does not have to', function() {
-        expect(normalizePositionByRangeLength(10,99)).to.equal(10)
-    })
-})
+import { expect } from "chai";
+import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
+describe("normalizePositionByRangeLength", function () {
+  it("should normalize positions by their max length, assuming 0-based inclusive indices", function () {
+    expect(normalizePositionByRangeLength(10, 9)).to.equal(1);
+    expect(normalizePositionByRangeLength(9, 9)).to.equal(0);
+    expect(normalizePositionByRangeLength(3572, 2000)).to.equal(1572);
+  });
+  it("should set something more than twice outside the sequence length to either 0 or sequenceLength-1", function () {
+    expect(normalizePositionByRangeLength(-3572, 2000)).to.equal(0);
+    expect(normalizePositionByRangeLength(33572, 2000)).to.equal(1999);
+  });
+  it("should handle isInBetweenPositions === true being passed in ", function () {
+    expect(normalizePositionByRangeLength(9, 9, true)).to.equal(9);
+  });
+  it("should set something more than twice outside the sequence length to either 0 or sequenceLength when isInBetweenPositions is true", function () {
+    expect(normalizePositionByRangeLength(-3572, 2000, true)).to.equal(0);
+    expect(normalizePositionByRangeLength(33572, 2000, true)).to.equal(2000);
+  });
+  it("should not do anything if it does not have to", function () {
+    expect(normalizePositionByRangeLength(10, 99)).to.equal(10);
+  });
+});

package/src/normalizePositionByRangeLength1Based.js

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

package/src/normalizePositionByRangeLength1Based.test.js

@@ -1,9 +1,9 @@
-import normalizePositionByRangeLength1Based from './normalizePositionByRangeLength1Based';
-import {expect} from 'chai';
-describe('normalizePositionByRangeLength1Based', function () {
-	it('should normalize a 1 based position by a 1 based range length', function() {
-		expect(normalizePositionByRangeLength1Based(0,10)).to.equal(10)
-		expect(normalizePositionByRangeLength1Based(-1,10)).to.equal(9)
-		expect(normalizePositionByRangeLength1Based(11,10)).to.equal(1)
-	})
-});
+import normalizePositionByRangeLength1Based from "./normalizePositionByRangeLength1Based";
+import { expect } from "chai";
+describe("normalizePositionByRangeLength1Based", function () {
+  it("should normalize a 1 based position by a 1 based range length", function () {
+    expect(normalizePositionByRangeLength1Based(0, 10)).to.equal(10);
+    expect(normalizePositionByRangeLength1Based(-1, 10)).to.equal(9);
+    expect(normalizePositionByRangeLength1Based(11, 10)).to.equal(1);
+  });
+});

package/src/normalizeRange.js

@@ -1,11 +1,11 @@
 //normalize range takes in a range that might be slightly outside of the rangeMax and wraps the start/end as necessary to fit
-import {assign} from "lodash";
+import { assign } from "lodash";
 
-import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 
 export default function normalizeRange(range, sequenceLength) {
-    return assign({}, range, {
-        start: normalizePositionByRangeLength(range.start, sequenceLength),
-        end: normalizePositionByRangeLength(range.end, sequenceLength),
-    })
-};
+  return assign({}, range, {
+    start: normalizePositionByRangeLength(range.start, sequenceLength),
+    end: normalizePositionByRangeLength(range.end, sequenceLength)
+  });
+}

package/src/normalizeRange.test.js

@@ -1,9 +1,9 @@
-import normalizeRange from './normalizeRange';
-import {expect} from 'chai';
-describe('normalizeRange', function () {
-    it('should normalize range correctly', function() {
-        const normalizedRange = normalizeRange({start: 0, end: -1},10)
-        expect(normalizedRange.start).to.equal(0)
-        expect(normalizedRange.end).to.equal(9)
-    })
-});
+import normalizeRange from "./normalizeRange";
+import { expect } from "chai";
+describe("normalizeRange", function () {
+  it("should normalize range correctly", function () {
+    const normalizedRange = normalizeRange({ start: 0, end: -1 }, 10);
+    expect(normalizedRange.start).to.equal(0);
+    expect(normalizedRange.end).to.equal(9);
+  });
+});

package/src/provideInclusiveOptions.js

@@ -1,26 +1,39 @@
-import {assign} from "lodash";
+import { assign } from "lodash";
 
-export default function provideInclusiveOptions (funToWrap) {
-    return function () {
-        const args = Array.prototype.slice.call(arguments);
-        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})
-                }
-                if (arg && arg.end > -1 && options.inclusive1BasedEnd) {
-                    args[index] = assign(arg, {end: arg.end-1})
-                }
-            })
+export default function provideInclusiveOptions(funToWrap) {
+  return function () {
+    const args = Array.prototype.slice.call(arguments);
+    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 });
         }
-        let returnVal = funToWrap.apply(this,args);
-        if (returnVal && returnVal.start > -1 && options && options.inclusive1BasedStart) {
-            returnVal = assign(returnVal, {start: returnVal.start+1})
+        if (arg && arg.end > -1 && options.inclusive1BasedEnd) {
+          args[index] = assign(arg, { end: arg.end - 1 });
         }
-        if (returnVal && returnVal.end > -1 && options && options.inclusive1BasedEnd) {
-            returnVal = assign(returnVal, {end: returnVal.end+1})
-        }
-        return returnVal
-    };
-};
+      });
+    }
+    let returnVal = funToWrap.apply(this, args);
+    if (
+      returnVal &&
+      returnVal.start > -1 &&
+      options &&
+      options.inclusive1BasedStart
+    ) {
+      returnVal = assign(returnVal, { start: returnVal.start + 1 });
+    }
+    if (
+      returnVal &&
+      returnVal.end > -1 &&
+      options &&
+      options.inclusive1BasedEnd
+    ) {
+      returnVal = assign(returnVal, { end: returnVal.end + 1 });
+    }
+    return returnVal;
+  };
+}

package/src/reversePositionInRange.js

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

package/src/splitRangeIntoTwoPartsIfItIsCircular.js

@@ -1,31 +1,34 @@
 //
 // ac.throw([ac.posInt, ac.posInt, ac.bool], arguments);
 //takes a potentially circular range and returns an array containing the range split on the origin
-export default function splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength) {
-    // ac.throw([ac.range, ac.number], arguments);
-    if (sequenceLength !== 0) {
-      sequenceLength = sequenceLength || Infinity
-    }
-    const ranges = [];
-    if (range.start > range.end) {
-        //the range is cicular, so we return an array of two ranges
-        ranges.push({
-            start: 0,
-            end: range.end,
-            type: "end",
-        });
-        ranges.push({
-            start: range.start,
-            end: sequenceLength - 1,
-            type: "beginning",
-        });
-    } else {
-        //the range isn't circular, so we just return the range
-        ranges.push({
-            start: range.start,
-            end: range.end,
-            type: "beginningAndEnd",
-        });
-    }
-    return ranges;
-};
+export default function splitRangeIntoTwoPartsIfItIsCircular(
+  range,
+  sequenceLength
+) {
+  // ac.throw([ac.range, ac.number], arguments);
+  if (sequenceLength !== 0) {
+    sequenceLength = sequenceLength || Infinity;
+  }
+  const ranges = [];
+  if (range.start > range.end) {
+    //the range is cicular, so we return an array of two ranges
+    ranges.push({
+      start: 0,
+      end: range.end,
+      type: "end"
+    });
+    ranges.push({
+      start: range.start,
+      end: sequenceLength - 1,
+      type: "beginning"
+    });
+  } else {
+    //the range isn't circular, so we just return the range
+    ranges.push({
+      start: range.start,
+      end: range.end,
+      type: "beginningAndEnd"
+    });
+  }
+  return ranges;
+}

package/src/splitRangeIntoTwoPartsIfItIsCircular.test.js

@@ -18,16 +18,27 @@
 //   }
 // };
 
+import splitRangeIntoTwoPartsIfItIsCircular from "./splitRangeIntoTwoPartsIfItIsCircular.js";
 
-import splitRangeIntoTwoPartsIfItIsCircular from './splitRangeIntoTwoPartsIfItIsCircular.js';
-
-import assert from 'assert';
-describe('splitRangeIntoTwoPartsIfItIsCircular', function() {
-    it('returns an array with one range in it if the array is non-circular', function() {
-        assert.deepEqual(splitRangeIntoTwoPartsIfItIsCircular({start: 0, end: 100}, 1000), [{start: 0, end: 100, type: 'beginningAndEnd'}]);
-        assert.deepEqual(splitRangeIntoTwoPartsIfItIsCircular({start: 10, end: 909}, 1000), [{start: 10, end: 909, type: 'beginningAndEnd'}]);
-    });
-    it('returns an array with two ranges in it if the array is circular', function() {
-        assert.deepEqual(splitRangeIntoTwoPartsIfItIsCircular({start: 110, end: 100},1000), [{start: 0, end: 100, type: 'end'},{start: 110, end: 999, type: 'beginning'}]);
-    });
+import assert from "assert";
+describe("splitRangeIntoTwoPartsIfItIsCircular", function () {
+  it("returns an array with one range in it if the array is non-circular", function () {
+    assert.deepEqual(
+      splitRangeIntoTwoPartsIfItIsCircular({ start: 0, end: 100 }, 1000),
+      [{ start: 0, end: 100, type: "beginningAndEnd" }]
+    );
+    assert.deepEqual(
+      splitRangeIntoTwoPartsIfItIsCircular({ start: 10, end: 909 }, 1000),
+      [{ start: 10, end: 909, type: "beginningAndEnd" }]
+    );
+  });
+  it("returns an array with two ranges in it if the array is circular", function () {
+    assert.deepEqual(
+      splitRangeIntoTwoPartsIfItIsCircular({ start: 110, end: 100 }, 1000),
+      [
+        { start: 0, end: 100, type: "end" },
+        { start: 110, end: 999, type: "beginning" }
+      ]
+    );
+  });
 });

package/src/translateRange.js

@@ -1,9 +1,19 @@
-import {assign} from "lodash";
-import normalizePositionByRangeLength from './normalizePositionByRangeLength';
+import { assign } from "lodash";
+import normalizePositionByRangeLength from "./normalizePositionByRangeLength";
 
-export default function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
-    return assign({}, rangeToBeAdjusted, {
-        start: normalizePositionByRangeLength(rangeToBeAdjusted.start + translateBy, rangeLength),
-        end: normalizePositionByRangeLength(rangeToBeAdjusted.end + translateBy, rangeLength)
-    });
-};
+export default function translateRange(
+  rangeToBeAdjusted,
+  translateBy,
+  rangeLength
+) {
+  return assign({}, rangeToBeAdjusted, {
+    start: normalizePositionByRangeLength(
+      rangeToBeAdjusted.start + translateBy,
+      rangeLength
+    ),
+    end: normalizePositionByRangeLength(
+      rangeToBeAdjusted.end + translateBy,
+      rangeLength
+    )
+  });
+}

package/src/translateRange.test.js

@@ -1,20 +1,19 @@
-import translateRange from './translateRange';
-import {expect} from 'chai';
+import translateRange from "./translateRange";
+import { expect } from "chai";
 
-describe('translateRange', function() {
-    it('should correctly translate a range', function() {
-        expect(translateRange({start: 0, end: 10}, 10, 30)).to.deep.equal({
-            start: 10,
-            end: 20,
-        })
-        expect(translateRange({start: 0, end: 10}, 10, 15)).to.deep.equal({
-            start: 10,
-            end: 5,
-        })
-        expect(translateRange({start: 9, end: 10}, 10, 15)).to.deep.equal({
-            start: 4,
-            end: 5,
-        })
-      
-    })
-})
+describe("translateRange", function () {
+  it("should correctly translate a range", function () {
+    expect(translateRange({ start: 0, end: 10 }, 10, 30)).to.deep.equal({
+      start: 10,
+      end: 20
+    });
+    expect(translateRange({ start: 0, end: 10 }, 10, 15)).to.deep.equal({
+      start: 10,
+      end: 5
+    });
+    expect(translateRange({ start: 9, end: 10 }, 10, 15)).to.deep.equal({
+      start: 4,
+      end: 5
+    });
+  });
+});

package/src/trimNonCicularRangeByAnotherNonCircularRange.js

@@ -1,57 +1,60 @@
 //
-export default function trimNonCicularRangeByAnotherNonCircularRange(rangeToBeTrimmed, trimmingRange) {
-    // ac.throw([ac.range, ac.range], arguments);
-    let outputTrimmedRange;
-    if (!rangeToBeTrimmed) {
-        return outputTrimmedRange;
-    }
-    if (rangeToBeTrimmed.start < trimmingRange.start) {
-        if (rangeToBeTrimmed.end < trimmingRange.start) {
+export default function trimNonCicularRangeByAnotherNonCircularRange(
+  rangeToBeTrimmed,
+  trimmingRange
+) {
+  // ac.throw([ac.range, ac.range], arguments);
+  let outputTrimmedRange;
+  if (!rangeToBeTrimmed) {
+    return outputTrimmedRange;
+  }
+  if (rangeToBeTrimmed.start < trimmingRange.start) {
+    if (rangeToBeTrimmed.end < trimmingRange.start) {
       // rrr   <range to be trimmed
       //    ttt  <trimming range
-            outputTrimmedRange = {
-                start: rangeToBeTrimmed.start,
-                end: rangeToBeTrimmed.end
-            };
-        } else {
-            if (rangeToBeTrimmed.end > trimmingRange.end) {
+      outputTrimmedRange = {
+        start: rangeToBeTrimmed.start,
+        end: rangeToBeTrimmed.end
+      };
+    } else {
+      if (rangeToBeTrimmed.end > trimmingRange.end) {
         // rrrrrr   <range to be trimmed
         //   ttt  <trimming range
-                outputTrimmedRange = {
-                    start: rangeToBeTrimmed.start,
-                    end: rangeToBeTrimmed.end
-                };
-            } else {
+        outputTrimmedRange = {
+          start: rangeToBeTrimmed.start,
+          end: rangeToBeTrimmed.end
+        };
+      } else {
         // rrrrrr   <range to be trimmed
         //   ttt  <trimming range
-                outputTrimmedRange = {
-                    start: rangeToBeTrimmed.start,
-                    end: trimmingRange.start - 1
-                };
-            }
-        }
-    } else {
-        if (rangeToBeTrimmed.end <= trimmingRange.end) {
+        outputTrimmedRange = {
+          start: rangeToBeTrimmed.start,
+          end: trimmingRange.start - 1
+        };
+      }
+    }
+  } else {
+    if (rangeToBeTrimmed.end <= trimmingRange.end) {
       //   rrr   <range to be trimmed
       //  ttttt  <trimming range
       //fully deleting the range, so do nothing
-        } else {
-            if (rangeToBeTrimmed.start > trimmingRange.end) {
+    } else {
+      if (rangeToBeTrimmed.start > trimmingRange.end) {
         //     rrrrrr   <range to be trimmed
         //  ttt  <trimming range
-                outputTrimmedRange = {
-                    end: rangeToBeTrimmed.end,
-                    start: rangeToBeTrimmed.start
-                };
-            } else {
+        outputTrimmedRange = {
+          end: rangeToBeTrimmed.end,
+          start: rangeToBeTrimmed.start
+        };
+      } else {
         //    rrrrrr   <range to be trimmed
         //  ttt  <trimming range
-                outputTrimmedRange = {
-                    end: rangeToBeTrimmed.end,
-                    start: trimmingRange.end + 1
-                };
-            }
-        }
+        outputTrimmedRange = {
+          end: rangeToBeTrimmed.end,
+          start: trimmingRange.end + 1
+        };
+      }
     }
-    return outputTrimmedRange;
-};
+  }
+  return outputTrimmedRange;
+}

package/src/trimNumberToFitWithin0ToAnotherNumber.js

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