@teselagen/range-utils 0.3.7 → 0.3.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (89) hide show
  1. package/README.md +94 -0
  2. package/flipContainedRange.d.ts +1 -1
  3. package/index.js +233 -85
  4. package/index.mjs +233 -85
  5. package/index.umd.js +233 -85
  6. package/package.json +1 -2
  7. package/src/adjustRangeToDeletionOfAnotherRange.test.js +166 -105
  8. package/src/adjustRangeToInsert.js +29 -26
  9. package/src/adjustRangeToInsert.test.js +197 -109
  10. package/src/adjustRangeToRotation.js +4 -5
  11. package/src/adjustRangeToRotation.test.js +203 -119
  12. package/src/checkIfNonCircularRangesOverlap.js +18 -15
  13. package/src/checkIfNonCircularRangesOverlap.test.js +67 -42
  14. package/src/checkIfPotentiallyCircularRangesOverlap.js +22 -12
  15. package/src/checkIfPotentiallyCircularRangesOverlap.test.js +115 -70
  16. package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.js +72 -41
  17. package/src/collapseOverlapsGeneratedFromRangeComparisonIfPossible.test.js +183 -84
  18. package/src/convertRangeIndices.js +24 -20
  19. package/src/convertRangeIndices.test.js +40 -21
  20. package/src/convertRangeTo0Based.js +7 -4
  21. package/src/convertRangeTo1Based.js +8 -4
  22. package/src/doesRangeSpanEntireSequence.js +4 -4
  23. package/src/doesRangeSpanOrigin.js +3 -3
  24. package/src/expandOrContractCircularRangeToPosition.js +45 -38
  25. package/src/expandOrContractNonCircularRangeToPosition.js +24 -21
  26. package/src/expandOrContractRangeByLength.js +16 -11
  27. package/src/expandOrContractRangeByLength.test.js +109 -71
  28. package/src/expandOrContractRangeToPosition.js +17 -9
  29. package/src/flipContainedRange.js +133 -72
  30. package/src/flipContainedRange.test.js +143 -117
  31. package/src/generateRandomRange.js +17 -15
  32. package/src/generateRandomRange.test.js +21 -21
  33. package/src/getAnnotationRangeType.js +25 -21
  34. package/src/getAnnotationRangeType.test.js +56 -57
  35. package/src/getEachPositionInRangeAsArray.js +13 -13
  36. package/src/getEachPositionInRangeAsArray.test.js +12 -8
  37. package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.js +16 -8
  38. package/src/getLengthOfOverlappingRegionsBetweenTwoRanges.test.js +32 -24
  39. package/src/getMiddleOfRange.js +1 -1
  40. package/src/getMiddleOfRange.test.js +5 -13
  41. package/src/getOverlapOfNonCircularRanges.js +30 -30
  42. package/src/getOverlapsOfPotentiallyCircularRanges.js +5 -5
  43. package/src/getOverlapsOfPotentiallyCircularRanges.test.js +3 -23
  44. package/src/getPositionFromAngle.js +12 -7
  45. package/src/getRangeAngles.js +1 -1
  46. package/src/getRangeAngles.test.js +10 -11
  47. package/src/getRangeLength.test.js +5 -5
  48. package/src/getRangesBetweenTwoRanges.js +31 -22
  49. package/src/getSequenceWithinRange.js +13 -13
  50. package/src/getSequenceWithinRange.test.js +43 -45
  51. package/src/getShortestDistanceBetweenTwoPositions.js +10 -6
  52. package/src/getShortestDistanceBetweenTwoPositions.test.js +11 -13
  53. package/src/getYOffsetForPotentiallyCircularRange.js +33 -21
  54. package/src/getYOffsetsForPotentiallyCircularRanges.js +26 -19
  55. package/src/getYOffsetsForPotentiallyCircularRanges.test.js +42 -29
  56. package/src/getZeroedRangeOverlaps.js +30 -15
  57. package/src/getZeroedRangeOverlaps.test.js +75 -36
  58. package/src/index.js +51 -51
  59. package/src/index.test.js +6 -8
  60. package/src/invertRange.test.js +103 -93
  61. package/src/isPositionCloserToRangeStartThanRangeEnd.js +18 -6
  62. package/src/isPositionCloserToRangeStartThanRangeEnd.test.js +36 -16
  63. package/src/isPositionWithinRange.js +4 -4
  64. package/src/isRangeOrPositionWithinRange.js +18 -12
  65. package/src/isRangeOrPositionWithinRange.test.js +6 -6
  66. package/src/isRangeWithinRange.js +2 -3
  67. package/src/loopEachPositionInRange.js +3 -3
  68. package/src/modulatePositionByRange.js +8 -8
  69. package/src/modulatePositionByRange.test.js +10 -11
  70. package/src/modulateRangeBySequenceLength.js +7 -7
  71. package/src/modulateRangeBySequenceLength.test.js +39 -16
  72. package/src/normalizePositionByRangeLength.js +22 -18
  73. package/src/normalizePositionByRangeLength.test.js +23 -23
  74. package/src/normalizePositionByRangeLength1Based.js +7 -4
  75. package/src/normalizePositionByRangeLength1Based.test.js +9 -9
  76. package/src/normalizeRange.js +7 -7
  77. package/src/normalizeRange.test.js +9 -9
  78. package/src/provideInclusiveOptions.js +36 -23
  79. package/src/reversePositionInRange.js +16 -12
  80. package/src/splitRangeIntoTwoPartsIfItIsCircular.js +31 -28
  81. package/src/splitRangeIntoTwoPartsIfItIsCircular.test.js +22 -11
  82. package/src/translateRange.js +18 -8
  83. package/src/translateRange.test.js +18 -19
  84. package/src/trimNonCicularRangeByAnotherNonCircularRange.js +45 -42
  85. package/src/trimNumberToFitWithin0ToAnotherNumber.js +13 -10
  86. package/src/trimRangeByAnotherRange.js +20 -19
  87. package/src/trimRangeByAnotherRange.test.js +6 -6
  88. package/src/zeroSubrangeByContainerRange.js +29 -19
  89. package/src/zeroSubrangeByContainerRange.test.js +57 -47
package/index.mjs CHANGED
@@ -6045,8 +6045,8 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
6045
6045
  maxRangeLength
6046
6046
  );
6047
6047
  let overlaps = [];
6048
- normalizedRangeA.forEach(function(nonCircularRangeA, iA) {
6049
- normalizedRangeB.forEach(function(nonCircularRangeB, iB) {
6048
+ normalizedRangeA.forEach(function(nonCircularRangeA) {
6049
+ normalizedRangeB.forEach(function(nonCircularRangeB) {
6050
6050
  const overlap = getOverlapOfNonCircularRanges(
6051
6051
  nonCircularRangeA,
6052
6052
  nonCircularRangeB
@@ -6058,7 +6058,7 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
6058
6058
  });
6059
6059
  if (joinIfPossible && normalizedRangeA.length === 2 && normalizedRangeB.length === 2 && maxRangeLength) {
6060
6060
  const joinedOverlap = {};
6061
- overlaps = lodashExports.flatMap(overlaps, (o, i) => {
6061
+ overlaps = lodashExports.flatMap(overlaps, (o) => {
6062
6062
  if (o.start === 0) {
6063
6063
  joinedOverlap.end = o.end;
6064
6064
  return [];
@@ -6156,12 +6156,14 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
6156
6156
  });
6157
6157
  splitRangesToBeTrimmed[index] = nonCircularRangeToBeTrimmed;
6158
6158
  });
6159
- const outputSplitRanges = splitRangesToBeTrimmed.filter(function(trimmedRange) {
6160
- if (trimmedRange) {
6161
- return true;
6159
+ const outputSplitRanges = splitRangesToBeTrimmed.filter(
6160
+ function(trimmedRange) {
6161
+ if (trimmedRange) {
6162
+ return true;
6163
+ }
6164
+ return false;
6162
6165
  }
6163
- return false;
6164
- });
6166
+ );
6165
6167
  let outputTrimmedRange;
6166
6168
  if (outputSplitRanges.length < 0)
6167
6169
  ;
@@ -6260,11 +6262,19 @@ function checkIfNonCircularRangesOverlap(range, comparisonRange) {
6260
6262
  }
6261
6263
  __name(checkIfNonCircularRangesOverlap, "checkIfNonCircularRangesOverlap");
6262
6264
  function checkIfPotentiallyCircularRangesOverlap(range, comparisonRange) {
6263
- return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(function(splitRange) {
6264
- return splitRangeIntoTwoPartsIfItIsCircular(comparisonRange, Infinity).some(function(splitComparisonRange) {
6265
- return checkIfNonCircularRangesOverlap(splitRange, splitComparisonRange);
6266
- });
6267
- });
6265
+ return splitRangeIntoTwoPartsIfItIsCircular(range, Infinity).some(
6266
+ function(splitRange) {
6267
+ return splitRangeIntoTwoPartsIfItIsCircular(
6268
+ comparisonRange,
6269
+ Infinity
6270
+ ).some(function(splitComparisonRange) {
6271
+ return checkIfNonCircularRangesOverlap(
6272
+ splitRange,
6273
+ splitComparisonRange
6274
+ );
6275
+ });
6276
+ }
6277
+ );
6268
6278
  }
6269
6279
  __name(checkIfPotentiallyCircularRangesOverlap, "checkIfPotentiallyCircularRangesOverlap");
6270
6280
  function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequenceLength, optionalOriginalRange) {
@@ -6273,15 +6283,19 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
6273
6283
  return overlaps;
6274
6284
  } else if (overlaps.length === 2) {
6275
6285
  if (overlaps[0].start === 0 && overlaps[1].end + 1 === sequenceLength && !originalRangeLinear) {
6276
- return [{
6277
- start: overlaps[1].start,
6278
- end: overlaps[0].end
6279
- }];
6286
+ return [
6287
+ {
6288
+ start: overlaps[1].start,
6289
+ end: overlaps[0].end
6290
+ }
6291
+ ];
6280
6292
  } else if (overlaps[1].start === 0 && overlaps[0].end + 1 === sequenceLength && !originalRangeLinear) {
6281
- return [{
6282
- start: overlaps[0].start,
6283
- end: overlaps[1].end
6284
- }];
6293
+ return [
6294
+ {
6295
+ start: overlaps[0].start,
6296
+ end: overlaps[1].end
6297
+ }
6298
+ ];
6285
6299
  } else {
6286
6300
  return overlaps;
6287
6301
  }
@@ -6289,17 +6303,29 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
6289
6303
  const firstOverlap = overlaps[0];
6290
6304
  const secondOverlap = overlaps[1];
6291
6305
  const thirdOverlap = overlaps[2];
6292
- let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, secondOverlap], sequenceLength, optionalOriginalRange);
6306
+ let collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
6307
+ [firstOverlap, secondOverlap],
6308
+ sequenceLength,
6309
+ optionalOriginalRange
6310
+ );
6293
6311
  if (collapsedOverlaps.length === 1) {
6294
6312
  collapsedOverlaps.push(thirdOverlap);
6295
6313
  return collapsedOverlaps;
6296
6314
  } else {
6297
- collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([firstOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
6315
+ collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
6316
+ [firstOverlap, thirdOverlap],
6317
+ sequenceLength,
6318
+ optionalOriginalRange
6319
+ );
6298
6320
  if (collapsedOverlaps.length === 1) {
6299
6321
  collapsedOverlaps.push(secondOverlap);
6300
6322
  return collapsedOverlaps;
6301
6323
  } else {
6302
- collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible([secondOverlap, thirdOverlap], sequenceLength, optionalOriginalRange);
6324
+ collapsedOverlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
6325
+ [secondOverlap, thirdOverlap],
6326
+ sequenceLength,
6327
+ optionalOriginalRange
6328
+ );
6303
6329
  if (collapsedOverlaps.length === 1) {
6304
6330
  collapsedOverlaps.push(firstOverlap);
6305
6331
  return collapsedOverlaps;
@@ -6321,11 +6347,18 @@ function convertRangeIndices(range, inputType, outputType) {
6321
6347
  }
6322
6348
  __name(convertRangeIndices, "convertRangeIndices");
6323
6349
  function convertRangeTo0Based(range) {
6324
- return convertRangeIndices(range, { inclusive1BasedStart: true, inclusive1BasedEnd: true });
6350
+ return convertRangeIndices(range, {
6351
+ inclusive1BasedStart: true,
6352
+ inclusive1BasedEnd: true
6353
+ });
6325
6354
  }
6326
6355
  __name(convertRangeTo0Based, "convertRangeTo0Based");
6327
6356
  function convertRangeTo1Based(range) {
6328
- return convertRangeIndices(range, {}, { inclusive1BasedStart: true, inclusive1BasedEnd: true });
6357
+ return convertRangeIndices(
6358
+ range,
6359
+ {},
6360
+ { inclusive1BasedStart: true, inclusive1BasedEnd: true }
6361
+ );
6329
6362
  }
6330
6363
  __name(convertRangeTo1Based, "convertRangeTo1Based");
6331
6364
  function provideInclusiveOptions(funToWrap) {
@@ -6440,7 +6473,11 @@ function expandOrContractCircularRangeToPosition(range, position, maxLength) {
6440
6473
  let endMoved = true;
6441
6474
  if (range.end >= position) {
6442
6475
  if (position + maxLength - range.start > range.end - position) {
6443
- newRange.end = normalizePositionByRangeLength(position - 1, maxLength, false);
6476
+ newRange.end = normalizePositionByRangeLength(
6477
+ position - 1,
6478
+ maxLength,
6479
+ false
6480
+ );
6444
6481
  } else {
6445
6482
  newRange.start = position;
6446
6483
  endMoved = false;
@@ -6513,19 +6550,32 @@ function expandOrContractRangeToPosition(range, position, maxLength) {
6513
6550
  if (range.start > range.end) {
6514
6551
  return expandOrContractCircularRangeToPosition(range, position, maxLength);
6515
6552
  } else {
6516
- return expandOrContractNonCircularRangeToPosition(range, position);
6553
+ return expandOrContractNonCircularRangeToPosition(
6554
+ range,
6555
+ position
6556
+ );
6517
6557
  }
6518
6558
  }
6519
6559
  __name(expandOrContractRangeToPosition, "expandOrContractRangeToPosition");
6520
6560
  function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
6521
6561
  return lodashExports.assign({}, rangeToBeAdjusted, {
6522
- start: normalizePositionByRangeLength(rangeToBeAdjusted.start + translateBy, rangeLength),
6523
- end: normalizePositionByRangeLength(rangeToBeAdjusted.end + translateBy, rangeLength)
6562
+ start: normalizePositionByRangeLength(
6563
+ rangeToBeAdjusted.start + translateBy,
6564
+ rangeLength
6565
+ ),
6566
+ end: normalizePositionByRangeLength(
6567
+ rangeToBeAdjusted.end + translateBy,
6568
+ rangeLength
6569
+ )
6524
6570
  });
6525
6571
  }
6526
6572
  __name(translateRange, "translateRange");
6527
- function flipRelativeRange(innerRange, outerRange, sequenceLength, options) {
6528
- const isFullyContained = isRangeWithinRange(innerRange, outerRange, sequenceLength);
6573
+ function flipRelativeRange(innerRange, outerRange, sequenceLength) {
6574
+ const isFullyContained = isRangeWithinRange(
6575
+ innerRange,
6576
+ outerRange,
6577
+ sequenceLength
6578
+ );
6529
6579
  if (isFullyContained) {
6530
6580
  return flipFullyContainedRange(innerRange, outerRange, sequenceLength);
6531
6581
  } else {
@@ -6533,42 +6583,92 @@ function flipRelativeRange(innerRange, outerRange, sequenceLength, options) {
6533
6583
  }
6534
6584
  }
6535
6585
  __name(flipRelativeRange, "flipRelativeRange");
6536
- function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength, options) {
6537
- const outerFullyContained = isRangeWithinRange(outerRange, innerRange, sequenceLength);
6586
+ function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength) {
6587
+ const outerFullyContained = isRangeWithinRange(
6588
+ outerRange,
6589
+ innerRange,
6590
+ sequenceLength
6591
+ );
6538
6592
  let flippedInnerRange;
6539
6593
  if (outerFullyContained) {
6540
- const expandBy1 = getRangeLength({
6541
- start: innerRange.start,
6542
- end: outerRange.start
6543
- }, sequenceLength) - 1;
6544
- flippedInnerRange = expandOrContractRangeByLength(outerRange, expandBy1, false, sequenceLength);
6545
- const expandBy2 = getRangeLength({
6546
- end: innerRange.end,
6547
- start: outerRange.end
6548
- }, sequenceLength) - 1;
6549
- flippedInnerRange = expandOrContractRangeByLength(flippedInnerRange, expandBy2, true, sequenceLength);
6594
+ const expandBy1 = getRangeLength(
6595
+ {
6596
+ start: innerRange.start,
6597
+ end: outerRange.start
6598
+ },
6599
+ sequenceLength
6600
+ ) - 1;
6601
+ flippedInnerRange = expandOrContractRangeByLength(
6602
+ outerRange,
6603
+ expandBy1,
6604
+ false,
6605
+ sequenceLength
6606
+ );
6607
+ const expandBy2 = getRangeLength(
6608
+ {
6609
+ end: innerRange.end,
6610
+ start: outerRange.end
6611
+ },
6612
+ sequenceLength
6613
+ ) - 1;
6614
+ flippedInnerRange = expandOrContractRangeByLength(
6615
+ flippedInnerRange,
6616
+ expandBy2,
6617
+ true,
6618
+ sequenceLength
6619
+ );
6550
6620
  } else {
6551
- const overlaps = getOverlapsOfPotentiallyCircularRanges(innerRange, outerRange, sequenceLength);
6621
+ const overlaps = getOverlapsOfPotentiallyCircularRanges(
6622
+ innerRange,
6623
+ outerRange,
6624
+ sequenceLength
6625
+ );
6552
6626
  if (overlaps.length >= 1) {
6553
- let overlapExtendsForward;
6554
6627
  const firstOverlap = overlaps[0];
6555
- overlapExtendsForward = firstOverlap.start !== outerRange.start;
6556
- const flippedTruncatedInner = flipFullyContainedRange(firstOverlap, outerRange, sequenceLength);
6628
+ const overlapExtendsForward = firstOverlap.start !== outerRange.start;
6629
+ const flippedTruncatedInner = flipFullyContainedRange(
6630
+ firstOverlap,
6631
+ outerRange,
6632
+ sequenceLength
6633
+ );
6557
6634
  const lengthToExtend = getRangeLength(innerRange, sequenceLength) - getRangeLength(flippedTruncatedInner, sequenceLength);
6558
- flippedInnerRange = expandOrContractRangeByLength(flippedTruncatedInner, lengthToExtend, overlapExtendsForward, sequenceLength);
6635
+ flippedInnerRange = expandOrContractRangeByLength(
6636
+ flippedTruncatedInner,
6637
+ lengthToExtend,
6638
+ overlapExtendsForward,
6639
+ sequenceLength
6640
+ );
6559
6641
  } else {
6560
- throw new Error("This case (relative ranges that do not overlap) is unsupported! ");
6642
+ throw new Error(
6643
+ "This case (relative ranges that do not overlap) is unsupported! "
6644
+ );
6561
6645
  }
6562
6646
  }
6563
6647
  return flippedInnerRange;
6564
6648
  }
6565
6649
  __name(flipNonFullyContainedRange, "flipNonFullyContainedRange");
6566
- function flipFullyContainedRange(innerRange, outerRange, sequenceLength, options) {
6650
+ function flipFullyContainedRange(innerRange, outerRange, sequenceLength) {
6567
6651
  const translateBy = -outerRange.start;
6568
- const translatedOuterRange = translateRange(outerRange, translateBy, sequenceLength);
6569
- const translatedInnerRange = translateRange(innerRange, translateBy, sequenceLength);
6570
- const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(translatedInnerRange, translatedOuterRange, sequenceLength);
6571
- const flippedInnerRange = translateRange(translatedFlippedInnerRange, -translateBy, sequenceLength);
6652
+ const translatedOuterRange = translateRange(
6653
+ outerRange,
6654
+ translateBy,
6655
+ sequenceLength
6656
+ );
6657
+ const translatedInnerRange = translateRange(
6658
+ innerRange,
6659
+ translateBy,
6660
+ sequenceLength
6661
+ );
6662
+ const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(
6663
+ translatedInnerRange,
6664
+ translatedOuterRange,
6665
+ sequenceLength
6666
+ );
6667
+ const flippedInnerRange = translateRange(
6668
+ translatedFlippedInnerRange,
6669
+ -translateBy,
6670
+ sequenceLength
6671
+ );
6572
6672
  return flippedInnerRange;
6573
6673
  }
6574
6674
  __name(flipFullyContainedRange, "flipFullyContainedRange");
@@ -6586,7 +6686,10 @@ function generateRandomRange(minStart, maxEnd, maxLength) {
6586
6686
  const start = getRandomInt(minStart, maxEnd);
6587
6687
  let end;
6588
6688
  if (maxLength) {
6589
- end = normalizePositionByRangeLength(getRandomInt(start, start + maxLength), maxEnd);
6689
+ end = normalizePositionByRangeLength(
6690
+ getRandomInt(start, start + maxLength),
6691
+ maxEnd
6692
+ );
6590
6693
  } else {
6591
6694
  end = getRandomInt(minStart, maxEnd);
6592
6695
  }
@@ -6638,7 +6741,11 @@ function getEachPositionInRangeAsArray(range, rangeMax) {
6638
6741
  }
6639
6742
  __name(getEachPositionInRangeAsArray, "getEachPositionInRangeAsArray");
6640
6743
  function getLengthOfOverlappingRegionsBetweenTwoRanges(rangeA, rangeB, maxLength) {
6641
- const overlaps = getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxLength);
6744
+ const overlaps = getOverlapsOfPotentiallyCircularRanges(
6745
+ rangeA,
6746
+ rangeB,
6747
+ maxLength
6748
+ );
6642
6749
  return overlaps.reduce(function(counter, overlap) {
6643
6750
  return counter + getRangeLength(overlap, maxLength);
6644
6751
  }, 0);
@@ -6691,13 +6798,16 @@ function getRangesBetweenTwoRanges(range1, range2) {
6691
6798
  if (!(range1.start > -1 && range1.end > -1 && range2.start > -1 && range2.end > -1)) {
6692
6799
  return newRanges;
6693
6800
  }
6694
- return [{
6695
- start: range1.start,
6696
- end: range2.end
6697
- }, {
6698
- start: range2.start,
6699
- end: range1.end
6700
- }];
6801
+ return [
6802
+ {
6803
+ start: range1.start,
6804
+ end: range2.end
6805
+ },
6806
+ {
6807
+ start: range2.start,
6808
+ end: range1.end
6809
+ }
6810
+ ];
6701
6811
  }
6702
6812
  __name(getRangesBetweenTwoRanges, "getRangesBetweenTwoRanges");
6703
6813
  function getSequenceWithinRange(range, sequence) {
@@ -6729,18 +6839,26 @@ function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLe
6729
6839
  __name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
6730
6840
  function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
6731
6841
  let yOffset = [];
6732
- const openYOffsetFound = YOffsetLevelsWithRanges.some(function(rangesAlreadyAddedToYOffset, index) {
6733
- const rangeBlocked = rangesAlreadyAddedToYOffset.some(function(comparisonRange) {
6734
- return checkIfPotentiallyCircularRangesOverlap(range, comparisonRange);
6735
- });
6736
- if (!rangeBlocked) {
6737
- yOffset = index;
6738
- if (assignYOffsetToRange)
6739
- range.yOffset = index;
6740
- rangesAlreadyAddedToYOffset.push(range);
6741
- return true;
6842
+ const openYOffsetFound = YOffsetLevelsWithRanges.some(
6843
+ function(rangesAlreadyAddedToYOffset, index) {
6844
+ const rangeBlocked = rangesAlreadyAddedToYOffset.some(
6845
+ function(comparisonRange) {
6846
+ return checkIfPotentiallyCircularRangesOverlap(
6847
+ range,
6848
+ comparisonRange
6849
+ );
6850
+ }
6851
+ );
6852
+ if (!rangeBlocked) {
6853
+ yOffset = index;
6854
+ if (assignYOffsetToRange)
6855
+ range.yOffset = index;
6856
+ rangesAlreadyAddedToYOffset.push(range);
6857
+ return true;
6858
+ }
6859
+ return false;
6742
6860
  }
6743
- });
6861
+ );
6744
6862
  if (!openYOffsetFound) {
6745
6863
  yOffset = YOffsetLevelsWithRanges.length;
6746
6864
  if (assignYOffsetToRange)
@@ -6754,7 +6872,11 @@ function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
6754
6872
  let maxYOffset = 0;
6755
6873
  const yOffsetLevels = [];
6756
6874
  ranges.forEach(function(range) {
6757
- const yOffset = getYOffsetForPotentiallyCircularRange(range, yOffsetLevels, assignYOffsetToRange);
6875
+ const yOffset = getYOffsetForPotentiallyCircularRange(
6876
+ range,
6877
+ yOffsetLevels,
6878
+ assignYOffsetToRange
6879
+ );
6758
6880
  yOffsets.push(yOffset);
6759
6881
  if (yOffset > maxYOffset) {
6760
6882
  maxYOffset = yOffset;
@@ -6787,8 +6909,16 @@ function invertRange$1(rangeOrCaret, rangeMax) {
6787
6909
  }
6788
6910
  __name(invertRange$1, "invertRange$1");
6789
6911
  function isPositionCloserToRangeStartThanRangeEnd(position, range, maxLength) {
6790
- const distanceFromStart = getShortestDistanceBetweenTwoPositions(range.start, position, maxLength);
6791
- const distanceFromEnd = getShortestDistanceBetweenTwoPositions(range.end, position, maxLength);
6912
+ const distanceFromStart = getShortestDistanceBetweenTwoPositions(
6913
+ range.start,
6914
+ position,
6915
+ maxLength
6916
+ );
6917
+ const distanceFromEnd = getShortestDistanceBetweenTwoPositions(
6918
+ range.end,
6919
+ position,
6920
+ maxLength
6921
+ );
6792
6922
  return distanceFromStart <= distanceFromEnd;
6793
6923
  }
6794
6924
  __name(isPositionCloserToRangeStartThanRangeEnd, "isPositionCloserToRangeStartThanRangeEnd");
@@ -6833,9 +6963,15 @@ function trimNumberToFitWithin0ToAnotherNumber(numberToBeTrimmed, max) {
6833
6963
  }
6834
6964
  __name(trimNumberToFitWithin0ToAnotherNumber, "trimNumberToFitWithin0ToAnotherNumber");
6835
6965
  function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength) {
6836
- const trimmedSubRange = trimRangeByAnotherRange(subRange, containerRange, sequenceLength);
6966
+ const trimmedSubRange = trimRangeByAnotherRange(
6967
+ subRange,
6968
+ containerRange,
6969
+ sequenceLength
6970
+ );
6837
6971
  if (trimmedSubRange) {
6838
- throw new Error("subRange must be fully contained by containerRange! Otherwise this function does not make sense");
6972
+ throw new Error(
6973
+ "subRange must be fully contained by containerRange! Otherwise this function does not make sense"
6974
+ );
6839
6975
  }
6840
6976
  const newSubrange = {};
6841
6977
  newSubrange.start = subRange.start - containerRange.start;
@@ -6863,12 +6999,24 @@ function modulo(n, m) {
6863
6999
  }
6864
7000
  __name(modulo, "modulo");
6865
7001
  function getZeroedRangeOverlaps(annotation, selection, sequenceLength) {
6866
- const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(getOverlapsOfPotentiallyCircularRanges(annotation, selection, sequenceLength), sequenceLength, annotation);
7002
+ const overlaps = collapseOverlapsGeneratedFromRangeComparisonIfPossible(
7003
+ getOverlapsOfPotentiallyCircularRanges(
7004
+ annotation,
7005
+ selection,
7006
+ sequenceLength
7007
+ ),
7008
+ sequenceLength,
7009
+ annotation
7010
+ );
6867
7011
  const zeroedOverlaps = overlaps.map((overlap) => {
6868
- return zeroSubrangeByContainerRange(overlap, {
6869
- start: selection.start,
6870
- end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
6871
- }, sequenceLength);
7012
+ return zeroSubrangeByContainerRange(
7013
+ overlap,
7014
+ {
7015
+ start: selection.start,
7016
+ end: normalizePositionByRangeLength(selection.start - 1, sequenceLength)
7017
+ },
7018
+ sequenceLength
7019
+ );
6872
7020
  });
6873
7021
  return zeroedOverlaps;
6874
7022
  }