@teselagen/sequence-utils 0.3.38-beta.3 → 0.3.41

package/index.umd.cjs

@@ -2590,10 +2590,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       }
     }
-    return null;
   }
   __name(getOverlapOfNonCircularRanges, "getOverlapOfNonCircularRanges");
-  function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible = false) {
+  function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible) {
     const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
       rangeA,
       maxRangeLength
@@ -2614,22 +2613,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       });
     });
-    if (joinIfPossible && normalizedRangeA.length === 2 && normalizedRangeB.length === 2 && maxRangeLength) {
-      const joinedOverlap = {};
-      overlaps = flatMap(overlaps, (o) => {
-        if (o.start === 0) {
-          joinedOverlap.end = o.end;
-          return [];
-        } else if (o.end === maxRangeLength - 1) {
-          joinedOverlap.start = o.start;
-          return [];
-        }
-        return [o];
-      });
-      if (Object.keys(joinedOverlap).length > 0) {
-        overlaps.push(joinedOverlap);
-      }
-    }
     return overlaps;
   }
   __name(getOverlapsOfPotentiallyCircularRanges, "getOverlapsOfPotentiallyCircularRanges");
@@ -2701,7 +2684,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     if (!overlaps.length) {
       return rangeToBeTrimmed;
     }
-    const splitRangesToBeTrimmed = splitRangeIntoTwoPartsIfItIsCircular(rangeToBeTrimmed, sequenceLength);
+    const splitRangesToBeTrimmed = splitRangeIntoTwoPartsIfItIsCircular(
+      rangeToBeTrimmed,
+      sequenceLength
+    );
     splitRangesToBeTrimmed.forEach(function(nonCircularRangeToBeTrimmed, index) {
       overlaps.forEach(function(overlap) {
         if (nonCircularRangeToBeTrimmed) {
@@ -2744,7 +2730,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         end: outputTrimmedRange.end
       });
     }
-    return void 0;
   }
   __name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
   function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, maxLength) {
@@ -2891,36 +2876,28 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       }
     }
-    return overlaps;
   }
   __name(collapseOverlapsGeneratedFromRangeComparisonIfPossible, "collapseOverlapsGeneratedFromRangeComparisonIfPossible");
   function provideInclusiveOptions(funToWrap) {
-    return function(...args) {
+    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) {
-          const potentialRange = arg;
-          if (potentialRange && typeof potentialRange.start === "number" && potentialRange.start > -1 && options.inclusive1BasedStart) {
-            args[index] = assign(potentialRange, {
-              start: potentialRange.start - 1
-            });
+          if (arg && arg.start > -1 && options.inclusive1BasedStart) {
+            args[index] = assign(arg, { start: arg.start - 1 });
           }
-          if (potentialRange && typeof potentialRange.end === "number" && potentialRange.end > -1 && options.inclusive1BasedEnd) {
-            args[index] = assign(potentialRange, {
-              end: potentialRange.end - 1
-            });
+          if (arg && arg.end > -1 && options.inclusive1BasedEnd) {
+            args[index] = assign(arg, { end: arg.end - 1 });
           }
         });
       }
       let returnVal = funToWrap.apply(this, args);
-      const potentialReturn = returnVal;
-      if (potentialReturn && typeof potentialReturn.start === "number" && potentialReturn.start > -1 && options && options.inclusive1BasedStart) {
-        returnVal = assign(potentialReturn, {
-          start: potentialReturn.start + 1
-        });
+      if (returnVal && returnVal.start > -1 && options && options.inclusive1BasedStart) {
+        returnVal = assign(returnVal, { start: returnVal.start + 1 });
       }
-      if (potentialReturn && typeof potentialReturn.end === "number" && potentialReturn.end > -1 && options && options.inclusive1BasedEnd) {
-        returnVal = assign(potentialReturn, { end: potentialReturn.end + 1 });
+      if (returnVal && returnVal.end > -1 && options && options.inclusive1BasedEnd) {
+        returnVal = assign(returnVal, { end: returnVal.end + 1 });
       }
       return returnVal;
     };
@@ -2966,7 +2943,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return positionFits;
   }
   __name(isPositionWithinRange, "isPositionWithinRange");
-  function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions = false) {
+  function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions) {
     let position = pPosition;
     if (position < 0) {
       position += sequenceLength;
@@ -3146,9 +3123,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       if (typeof subSequence === "string") {
         subSequence += sequence.slice(0, range.end + 1);
       } else {
-        subSequence = subSequence.concat(
-          sequence.slice(0, range.end + 1)
-        );
+        subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
       }
       return subSequence;
     } else {
@@ -3168,7 +3143,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
   function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
-    let yOffset = 0;
+    let yOffset = [];
     const openYOffsetFound = YOffsetLevelsWithRanges.some(
       function(rangesAlreadyAddedToYOffset, index) {
         const rangeBlocked = rangesAlreadyAddedToYOffset.some(
@@ -3181,7 +3156,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         );
         if (!rangeBlocked) {
           yOffset = index;
-          if (assignYOffsetToRange) range.yOffset = index;
           rangesAlreadyAddedToYOffset.push(range);
           return true;
         }
@@ -3190,7 +3164,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     );
     if (!openYOffsetFound) {
       yOffset = YOffsetLevelsWithRanges.length;
-      if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length;
     }
     return yOffset;
   }
@@ -3202,8 +3175,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     ranges.forEach(function(range) {
       const yOffset = getYOffsetForPotentiallyCircularRange(
         range,
-        yOffsetLevels,
-        assignYOffsetToRange
+        yOffsetLevels
       );
       yOffsets.push(yOffset);
       if (yOffset > maxYOffset) {
@@ -3218,20 +3190,21 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(getYOffsetsForPotentiallyCircularRanges, "getYOffsetsForPotentiallyCircularRanges");
   const invertRange = provideInclusiveOptions(invertRange$1);
   function invertRange$1(rangeOrCaret, rangeMax) {
-    if (typeof rangeOrCaret !== "number" && rangeOrCaret.start > -1) {
+    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 (typeof rangeOrCaret === "number" && rangeOrCaret > -1) {
-      return {
-        start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
-        end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
-      };
+    } else {
+      if (rangeOrCaret > -1) {
+        return {
+          start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
+          end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
+        };
+      }
     }
-    return void 0;
   }
   __name(invertRange$1, "invertRange$1");
   function isPositionCloserToRangeStartThanRangeEnd(position, range, maxLength) {
@@ -3285,10 +3258,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         "subRange must be fully contained by containerRange! Otherwise this function does not make sense"
       );
     }
-    const newSubrange = {
-      start: subRange.start - containerRange.start,
-      end: subRange.end - containerRange.start
-    };
+    const newSubrange = {};
+    newSubrange.start = subRange.start - containerRange.start;
+    newSubrange.end = subRange.end - containerRange.start;
     if (newSubrange.start < 0) {
       newSubrange.start += sequenceLength;
     }
@@ -3299,10 +3271,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(zeroSubrangeByContainerRange, "zeroSubrangeByContainerRange");
   function adjustRangeToRotation(rangeToBeAdjusted, rotateTo = 0, rangeLength) {
-    const mod = /* @__PURE__ */ __name((n) => rangeLength ? modulo(n, rangeLength) : n, "mod");
+    const mod = rangeLength ? modulo : identity;
     const newRange = assign({}, rangeToBeAdjusted, {
-      start: mod(rangeToBeAdjusted.start - (rotateTo || 0)),
-      end: mod(rangeToBeAdjusted.end - (rotateTo || 0))
+      start: mod(rangeToBeAdjusted.start - (rotateTo || 0), rangeLength),
+      end: mod(rangeToBeAdjusted.end - (rotateTo || 0), rangeLength)
     });
     return newRange;
   }
@@ -3388,11 +3360,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       forEach(
         omitBy(seqsToAnnotateById, (s) => !s.sequence.length),
         ({ circular, sequence }, id) => {
-          function getMatches({
-            seqToMatchAgainst,
-            isReverse,
-            seqLen: seqLen2
-          }) {
+          function getMatches({ seqToMatchAgainst, isReverse, seqLen: seqLen2 }) {
             let match;
             let lastMatch;
             try {
@@ -3412,13 +3380,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
                 };
                 const range = {
                   start: matchStart,
-                  end: normalizePositionByRangeLength(matchEnd - 1, seqLen2, false)
+                  end: normalizePositionByRangeLength(matchEnd - 1, seqLen2)
                 };
                 if (!annotationsToAddBySeqId[id])
                   annotationsToAddBySeqId[id] = [];
                 annotationsToAddBySeqId[id].push(__spreadProps(__spreadValues({}, isReverse ? {
-                  start: reversePositionInRange(range.end, seqLen2, false),
-                  end: reversePositionInRange(range.start, seqLen2, false)
+                  start: reversePositionInRange(range.end, seqLen2),
+                  end: reversePositionInRange(range.start, seqLen2)
                 } : range), {
                   strand: isReverse ? -1 : 1,
                   id: ann.id
@@ -3449,22 +3417,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       const origSeq = seqsToAnnotateById[id];
       const alreadyExistingAnnsByStartEnd = {};
       forEach(origSeq.annotations, (ann) => {
-        alreadyExistingAnnsByStartEnd[getStartEndStr(
-          __spreadProps(__spreadValues({}, ann), { strand: typeof ann.strand === "string" ? 1 : ann.strand }),
-          { compareName }
-        )] = ann;
+        alreadyExistingAnnsByStartEnd[getStartEndStr(ann, { compareName })] = ann;
       });
       const warningCounter = {};
       const toAdd = anns.filter((ann) => {
-        const alreadyExistingAnn = alreadyExistingAnnsByStartEnd[getStartEndStr(
-          __spreadProps(__spreadValues({}, ann), {
-            strand: typeof ann.strand === "string" ? 1 : ann.strand
-          }),
-          { compareName }
-        )];
+        const alreadyExistingAnn = alreadyExistingAnnsByStartEnd[getStartEndStr(ann, { compareName })];
         if (alreadyExistingAnn) return false;
-        if (warnIfMoreThan && ann.id !== void 0) {
-          warningCounter[String(ann.id)] = (warningCounter[String(ann.id)] || 0) + 1;
+        if (warnIfMoreThan) {
+          warningCounter[ann.id] = (warningCounter[ann.id] || 0) + 1;
         }
         return true;
       }).sort((a, b) => a.start - b.start);
@@ -3473,23 +3433,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       }
       warnIfMoreThan && forEach(warningCounter, (num, annId) => {
         if (num > warnIfMoreThan) {
-          const warnings = toReturn["__more_than_warnings"] || {};
-          warnings[id] = warnings[id] || [];
-          warnings[id].push(annId);
-          toReturn["__more_than_warnings"] = warnings;
+          toReturn.__more_than_warnings = toReturn.__more_than_warnings || {};
+          toReturn.__more_than_warnings[id] = toReturn.__more_than_warnings[id] || [];
+          toReturn.__more_than_warnings[id].push(annId);
         }
       });
     });
     return toReturn;
   }
   __name(autoAnnotate, "autoAnnotate");
-  function getStartEndStr({
-    start,
-    end,
-    name,
-    strand,
-    forward
-  }, { compareName }) {
+  function getStartEndStr({ start, end, name, strand, forward }, { compareName }) {
     const isReverse = strand === -1 || forward === false;
     return `${start}-${end}-${isReverse ? "rev" : "for"}-${compareName ? name : ""}`;
   }
@@ -3503,12 +3456,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     let hitLeftCaret;
     let hitRightCaret;
     for (const bp of regString.replace("(", "").replace(")", "")) {
-      let maybeHandleRightCaret = /* @__PURE__ */ __name(function(justAdded) {
+      let maybeHandleRightCaret = function(justAdded) {
         if (hitRightCaret) {
           rightOfCaretHolder += justAdded;
           afterRightCaretHolder = `${rightOfCaretHolder}${afterRightCaretHolder.length ? "|" : ""}${afterRightCaretHolder}`;
         }
-      }, "maybeHandleRightCaret");
+      };
+      __name(maybeHandleRightCaret, "maybeHandleRightCaret");
       const ambigVal = ambiguous_dna_values[bp.toUpperCase()];
       if (ambigVal && ambigVal.length > 1) {
         let valToUse;
@@ -3693,17 +3647,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       })),
       "name"
     );
-    const featureOverrides = typeof window !== "undefined" && get$1(window, "tg_featureTypeOverrides") || typeof global !== "undefined" && get$1(global, "tg_featureTypeOverrides") || [];
-    const mappedOverrides = featureOverrides.map((fo) => {
+    let featureOverrides = typeof window !== "undefined" && get$1(window, "tg_featureTypeOverrides") || typeof global !== "undefined" && get$1(global, "tg_featureTypeOverrides");
+    featureOverrides = featureOverrides || [];
+    featureOverrides = featureOverrides.map((fo) => {
       const originalGenbankFeat = keyedGBFeats[fo.name];
       return __spreadValues(__spreadValues(__spreadValues({}, originalGenbankFeat), fo), originalGenbankFeat ? { isOverridden: true } : { isCustomType: true });
     });
-    const keyedOverrides = keyBy(mappedOverrides, "name");
-    return __spreadValues(__spreadValues({}, keyedGBFeats), keyedOverrides);
+    featureOverrides = keyBy(featureOverrides, "name");
+    return __spreadValues(__spreadValues({}, keyedGBFeats), featureOverrides);
   }, "getMergedFeatureMap");
-  const getFeatureToColorMap = /* @__PURE__ */ __name(({
-    includeHidden
-  } = {}) => {
+  const getFeatureToColorMap = /* @__PURE__ */ __name(({ includeHidden } = {}) => {
     const toRet = {};
     filter(
       getMergedFeatureMap(),
@@ -3713,9 +3666,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     });
     return toRet;
   }, "getFeatureToColorMap");
-  const getFeatureTypes = /* @__PURE__ */ __name(({
-    includeHidden
-  } = {}) => filter(getMergedFeatureMap(), (f) => includeHidden ? true : !f.isHidden).map(
+  const getFeatureTypes = /* @__PURE__ */ __name(({ includeHidden } = {}) => filter(getMergedFeatureMap(), (f) => includeHidden ? true : !f.isHidden).map(
     (f) => f.name
   ), "getFeatureTypes");
   function getDefaultExportFromCjs(x) {
@@ -4020,15 +3971,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   var shortidExports = requireShortid();
   const shortid = /* @__PURE__ */ getDefaultExportFromCjs(shortidExports);
   function cutSequenceByRestrictionEnzyme(pSequence, circular, restrictionEnzyme) {
-    if (!restrictionEnzyme.forwardRegex || // Add check for undefined
-    !restrictionEnzyme.reverseRegex || // Add check for undefined
-    restrictionEnzyme.forwardRegex.length === 0 || restrictionEnzyme.reverseRegex.length === 0) {
-      console.warn(
-        "Cannot cut sequence. Enzyme restriction site must be at least 1 bp long."
-      );
-      const returnVal = [];
-      returnVal.error = "Cannot cut sequence. Enzyme restriction site must be at least 1 bp long.";
-      return returnVal;
+    if (restrictionEnzyme.forwardRegex.length === 0 || restrictionEnzyme.reverseRegex.length === 0) {
+      const returnArray = [];
+      returnArray.error = "Cannot cut sequence. Enzyme restriction site must be at least 1 bp long.";
+      return returnArray;
     }
     const forwardRegExpPattern = new RegExp(restrictionEnzyme.forwardRegex, "ig");
     const sequence = pSequence;
@@ -4053,54 +3999,54 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     }
     return cutsitesForward.concat(cutsitesReverse);
     function reverseAllPositionsOfCutsite(cutsite, rangeLength) {
-      cutsite = assign({}, cutsite);
       cutsite.start = reversePositionInRange(cutsite.start, rangeLength, false);
       cutsite.end = reversePositionInRange(cutsite.end, rangeLength, false);
-      cutsite.topSnipPosition = cutsite.topSnipPosition != null ? reversePositionInRange(cutsite.topSnipPosition, rangeLength, true) : null;
-      cutsite.bottomSnipPosition = cutsite.bottomSnipPosition != null ? reversePositionInRange(cutsite.bottomSnipPosition, rangeLength, true) : null;
-      if (cutsite.cutType === 1 && cutsite.cutsTwice) {
-        if (cutsite.upstreamTopSnip != null && cutsite.upstreamBottomSnip != null) {
-          cutsite.upstreamTopSnip = reversePositionInRange(
-            cutsite.upstreamTopSnip,
-            rangeLength,
-            true
-          );
-          cutsite.upstreamBottomSnip = reversePositionInRange(
-            cutsite.upstreamBottomSnip,
-            rangeLength,
-            true
-          );
-        }
-      }
-      if (cutsite.recognitionSiteRange) {
-        cutsite.recognitionSiteRange = __spreadValues({}, cutsite.recognitionSiteRange);
-        cutsite.recognitionSiteRange.start = reversePositionInRange(
-          cutsite.recognitionSiteRange.start,
+      cutsite.topSnipPosition = reversePositionInRange(
+        cutsite.topSnipPosition,
+        rangeLength,
+        true
+      );
+      cutsite.bottomSnipPosition = reversePositionInRange(
+        cutsite.bottomSnipPosition,
+        rangeLength,
+        true
+      );
+      if (cutsite.cutsTwice) {
+        cutsite.upstreamTopSnip = reversePositionInRange(
+          cutsite.upstreamTopSnip,
           rangeLength,
-          false
+          true
         );
-        cutsite.recognitionSiteRange.end = reversePositionInRange(
-          cutsite.recognitionSiteRange.end,
+        cutsite.upstreamBottomSnip = reversePositionInRange(
+          cutsite.upstreamBottomSnip,
           rangeLength,
-          false
+          true
         );
       }
-      return __spreadProps(__spreadValues({}, cutsite), {
+      cutsite.recognitionSiteRange.start = reversePositionInRange(
+        cutsite.recognitionSiteRange.start,
+        rangeLength,
+        false
+      );
+      cutsite.recognitionSiteRange.end = reversePositionInRange(
+        cutsite.recognitionSiteRange.end,
+        rangeLength,
+        false
+      );
+      return assign({}, cutsite, {
         start: cutsite.end,
         end: cutsite.start,
-        overhangBps: getReverseComplementSequenceString(
-          cutsite.overhangBps || ""
-        ),
+        overhangBps: getReverseComplementSequenceString(cutsite.overhangBps),
         topSnipPosition: cutsite.bottomSnipPosition,
         bottomSnipPosition: cutsite.topSnipPosition,
         upstreamTopSnip: cutsite.upstreamBottomSnip,
         upstreamBottomSnip: cutsite.upstreamTopSnip,
         upstreamTopBeforeBottom: !!cutsite.upstreamTopBeforeBottom,
         topSnipBeforeBottom: !!cutsite.topSnipBeforeBottom,
-        recognitionSiteRange: cutsite.recognitionSiteRange ? {
+        recognitionSiteRange: {
           start: cutsite.recognitionSiteRange.end,
           end: cutsite.recognitionSiteRange.start
-        } : void 0,
+        },
         forward: false
       });
     }
@@ -4112,7 +4058,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     let restrictionCutSite;
     const recognitionSiteLength = restrictionEnzyme.site.length;
     const originalSequence = sequence;
-    const originalSequenceLengthVal = sequence.length;
+    const originalSequenceLength = sequence.length;
     if (circular) {
       sequence += sequence;
     }
@@ -4121,10 +4067,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     let startIndex = 0;
     let subSequence = sequence;
     while (matchIndex !== -1) {
-      const recognitionSiteRange = {
-        start: 0,
-        end: 0
-      };
+      const recognitionSiteRange = {};
       let start;
       let end;
       let upstreamTopSnip = null;
@@ -4139,39 +4082,37 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       recognitionSiteRange.end = matchIndex + recognitionSiteLength - 1 + startIndex;
       end = recognitionSiteRange.end;
       if (restrictionEnzyme.cutType === 1) {
-        if (restrictionEnzyme.usForward != null && restrictionEnzyme.usReverse != null) {
-          upstreamTopSnip = recognitionSiteRange.end - restrictionEnzyme.usForward;
-          upstreamBottomSnip = recognitionSiteRange.end - restrictionEnzyme.usReverse;
-          if (upstreamTopSnip >= 0 && upstreamBottomSnip >= 0) {
-            fitsWithinSequence = true;
-            if (upstreamTopSnip < upstreamBottomSnip) {
-              if (start > upstreamTopSnip) {
-                start = upstreamTopSnip + 1;
-              }
-              upstreamTopBeforeBottom = true;
-            } else {
-              if (start > upstreamBottomSnip) {
-                start = upstreamBottomSnip + 1;
-              }
+        upstreamTopSnip = recognitionSiteRange.end - restrictionEnzyme.usForward;
+        upstreamBottomSnip = recognitionSiteRange.end - restrictionEnzyme.usReverse;
+        if (upstreamTopSnip >= 0 && upstreamBottomSnip >= 0) {
+          fitsWithinSequence = true;
+          if (upstreamTopSnip < upstreamBottomSnip) {
+            if (start > upstreamTopSnip) {
+              start = upstreamTopSnip + 1;
             }
-            upstreamTopSnip = normalizePositionByRangeLength(
-              upstreamTopSnip,
-              originalSequenceLengthVal,
-              true
-            );
-            upstreamBottomSnip = normalizePositionByRangeLength(
-              upstreamBottomSnip,
-              originalSequenceLengthVal,
-              true
-            );
+            upstreamTopBeforeBottom = true;
           } else {
-            upstreamTopSnip = null;
-            upstreamBottomSnip = null;
+            if (start > upstreamBottomSnip) {
+              start = upstreamBottomSnip + 1;
+            }
           }
+          upstreamTopSnip = normalizePositionByRangeLength(
+            upstreamTopSnip,
+            originalSequenceLength,
+            true
+          );
+          upstreamBottomSnip = normalizePositionByRangeLength(
+            upstreamBottomSnip,
+            originalSequenceLength,
+            true
+          );
+        } else {
+          upstreamTopSnip = null;
+          upstreamBottomSnip = null;
         }
       }
-      topSnipPosition = recognitionSiteRange.start + (restrictionEnzyme.topSnipOffset || 0);
-      bottomSnipPosition = recognitionSiteRange.start + (restrictionEnzyme.bottomSnipOffset || 0);
+      topSnipPosition = recognitionSiteRange.start + restrictionEnzyme.topSnipOffset;
+      bottomSnipPosition = recognitionSiteRange.start + restrictionEnzyme.bottomSnipOffset;
       if (bottomSnipPosition <= currentSequenceLength && topSnipPosition <= currentSequenceLength) {
         fitsWithinSequence = true;
         if (topSnipPosition > bottomSnipPosition) {
@@ -4186,70 +4127,61 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
         topSnipPosition = normalizePositionByRangeLength(
           topSnipPosition,
-          originalSequenceLengthVal,
+          originalSequenceLength,
           true
         );
         bottomSnipPosition = normalizePositionByRangeLength(
           bottomSnipPosition,
-          originalSequenceLengthVal,
+          originalSequenceLength,
           true
         );
       } else {
         topSnipPosition = null;
         bottomSnipPosition = null;
       }
-      if (fitsWithinSequence && start >= 0 && end >= 0 && start < originalSequenceLengthVal && end < currentSequenceLength) {
+      if (fitsWithinSequence && start >= 0 && end >= 0 && start < originalSequenceLength && end < currentSequenceLength) {
         start = normalizePositionByRangeLength(
           start,
-          originalSequenceLengthVal,
-          false
-        );
-        end = normalizePositionByRangeLength(
-          end,
-          originalSequenceLengthVal,
+          originalSequenceLength,
           false
         );
+        end = normalizePositionByRangeLength(end, originalSequenceLength, false);
         recognitionSiteRange.start = normalizePositionByRangeLength(
           recognitionSiteRange.start,
-          originalSequenceLengthVal,
+          originalSequenceLength,
           false
         );
         recognitionSiteRange.end = normalizePositionByRangeLength(
           recognitionSiteRange.end,
-          originalSequenceLengthVal,
+          originalSequenceLength,
           false
         );
         let cutRange = {
           start: -1,
           end: -1
         };
-        if (topSnipPosition !== null && bottomSnipPosition !== null && topSnipPosition !== bottomSnipPosition) {
+        if (topSnipPosition !== bottomSnipPosition) {
           cutRange = topSnipBeforeBottom ? {
             start: topSnipPosition,
             end: normalizePositionByRangeLength(
               bottomSnipPosition - 1,
-              originalSequenceLengthVal
+              originalSequenceLength
             )
           } : {
             start: bottomSnipPosition,
             end: normalizePositionByRangeLength(
               topSnipPosition - 1,
-              originalSequenceLengthVal
+              originalSequenceLength
             )
           };
         }
-        const overhangBps = getSequenceWithinRange(
-          cutRange,
-          originalSequence
-        );
+        const overhangBps = getSequenceWithinRange(cutRange, originalSequence);
         restrictionCutSite = {
           id: shortid(),
           start,
           end,
           topSnipPosition,
-          // Allow null
           bottomSnipPosition,
-          // Allow null
           topSnipBeforeBottom,
           overhangBps,
           overhangSize: overhangBps.length,
@@ -4271,19 +4203,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return restrictionCutSites;
   }
   __name(cutSequence, "cutSequence");
-  function getCutsitesFromSequence(sequence, circular, contextEnzymes) {
-    const cutsites = flatMap(contextEnzymes, (enzyme) => {
-      return cutSequenceByRestrictionEnzyme(sequence, circular, enzyme);
-    });
-    const cutsitesByNameMap = {};
-    cutsites.forEach((cutsite) => {
-      const name = cutsite.name || "";
-      if (!cutsitesByNameMap[name]) {
-        cutsitesByNameMap[name] = [];
+  function getCutsitesFromSequence(sequence, circular, restrictionEnzymes) {
+    const cutsitesByName = {};
+    for (let i = 0; i < restrictionEnzymes.length; i++) {
+      const re = restrictionEnzymes[i];
+      const cutsites = cutSequenceByRestrictionEnzyme(sequence, circular, re);
+      if (cutsites.length) {
+        cutsitesByName[re.name] = cutsites;
       }
-      cutsitesByNameMap[name].push(cutsite);
-    });
-    return cutsitesByNameMap;
+    }
+    return cutsitesByName;
   }
   __name(getCutsitesFromSequence, "getCutsitesFromSequence");
   function computeDigestFragments({
@@ -4301,9 +4230,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const fragments = [];
     const overlappingEnzymes = [];
     const pairs = [];
-    const sortedCutsites = cutsites.filter(
-      (c) => c.topSnipPosition != null && c.bottomSnipPosition != null
-    );
+    const sortedCutsites = cutsites.sort((a, b) => {
+      return a.topSnipPosition - b.topSnipPosition;
+    });
     if (!circular && cutsites.length) {
       sortedCutsites.push({
         id: "seqTerm_" + shortid(),
@@ -4312,8 +4241,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         overhangBps: "",
         topSnipPosition: 0,
         bottomSnipPosition: 0,
-        overhangSize: 0,
-        // Added to satisfy CutSite
         upstreamTopSnip: 0,
         upstreamBottomSnip: 0,
         upstreamTopBeforeBottom: false,
@@ -4324,34 +4251,26 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         },
         forward: true,
         name: "Sequence_Terminus",
-        type: "START_OR_END_OF_SEQ",
         restrictionEnzyme: {
-          name: "Sequence_Terminus",
-          site: "",
-          forwardRegex: "",
-          reverseRegex: ""
+          name: "Sequence_Terminus"
         }
       });
     }
-    sortedCutsites.sort((a, b) => {
-      return a.topSnipPosition - b.topSnipPosition;
-    });
     sortedCutsites.forEach((cutsite1, index) => {
-      if (!computeDigestDisabled) {
-        pairs.push([
-          cutsite1,
-          sortedCutsites[index + 1] ? sortedCutsites[index + 1] : sortedCutsites[0]
-        ]);
-      }
       if (computePartialDigest && !computePartialDigestDisabled) {
         sortedCutsites.forEach((cs, index2) => {
-          const isAdjacent = index2 === index + 1 || index === sortedCutsites.length - 1 && index2 === 0;
-          if (isAdjacent) {
+          if (index2 === index + 1 || index2 === 0) {
             return;
           }
           pairs.push([cutsite1, sortedCutsites[index2]]);
         });
       }
+      if (!computeDigestDisabled) {
+        pairs.push([
+          cutsite1,
+          sortedCutsites[index + 1] ? sortedCutsites[index + 1] : sortedCutsites[0]
+        ]);
+      }
     });
     pairs.forEach((r) => {
       let [cut1, cut2] = r;
@@ -4396,17 +4315,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         cut2.name = "Linear_Sequence_End";
         cut2.restrictionEnzyme.name = "Linear_Sequence_End";
       }
-      cut1 = __spreadProps(__spreadValues({}, cut1), {
-        isOverhangIncludedInFragmentSize: cut1.name !== "Linear_Sequence_Start" && cut1.name !== "Sequence_Terminus" && (cut1.overhangSize || 0) > 0 && !!cut1.topSnipBeforeBottom
-      });
-      cut2 = __spreadProps(__spreadValues({}, cut2), {
-        isOverhangIncludedInFragmentSize: cut2.name !== "Linear_Sequence_End" && cut2.name !== "Sequence_Terminus" && (cut2.overhangSize || 0) > 0 && !cut2.topSnipBeforeBottom
-      });
       const id = start + "-" + end + "-" + size + "-";
       const name = `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps`;
+      getRangeLength({ start, end }, sequenceLength);
       fragments.push({
         isFormedFromLinearEnd,
-        madeFromOneCutsite: cut1.id === cut2.id,
+        madeFromOneCutsite: cut1 === cut2,
         start,
         end,
         size,
@@ -4447,14 +4361,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     includeOverAndUnderHangs
   }) {
     const cutsitesByName = getCutsitesFromSequence(sequence, circular, enzymes);
-    const digest = computeDigestFragments({
+    return computeDigestFragments({
       includeOverAndUnderHangs,
       cutsites: flatMap(cutsitesByName),
       sequenceLength: sequence.length,
       circular
     });
-    digest.fragments.sort((a, b) => b.size - a.size);
-    return digest;
   }
   __name(getDigestFragsForSeqAndEnzymes, "getDigestFragsForSeqAndEnzymes");
   function cloneRegExp(re) {
@@ -6023,8 +5935,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     let allPossibleThreeLetterCodons = [""];
     for (const set of picks) {
       const next = [];
-      for (const prefix of allPossibleThreeLetterCodons)
-        for (const b of set) next.push(prefix + b);
+      for (const prefix of allPossibleThreeLetterCodons) for (const b of set) next.push(prefix + b);
       allPossibleThreeLetterCodons = next;
     }
     let foundAminoAcid = null;
@@ -6070,13 +5981,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     if (aa) {
       return aa;
     }
-    const letter = (
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      degenerateDnaToAminoAcidMap[
-        sequenceString.replace("x", "n")
-        //replace x's with n's as those are equivalent dna chars
-      ] || "x"
-    );
+    const letter = degenerateDnaToAminoAcidMap[
+      sequenceString.replace("x", "n")
+      //replace x's with n's as those are equivalent dna chars
+    ] || "x";
     return proteinAlphabet[letter.toUpperCase()];
   }
   __name(getAminoAcidFromSequenceTriplet, "getAminoAcidFromSequenceTriplet");
@@ -6473,25 +6381,25 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     circular,
     name
   }) {
-    location.start = parseInt(String(location.start), 10);
-    location.end = parseInt(String(location.end), 10);
+    location.start = parseInt(location.start, 10);
+    location.end = parseInt(location.end, 10);
     if (convertAnnotationsFromAAIndices) {
       location.start = location.start * 3;
       location.end = location.end * 3 + 2;
     }
-    if (size !== void 0 && (location.start < 0 || location.start > size - 1)) {
+    if (location.start < 0 || !(location.start <= size - 1) || location.start > size - 1) {
       messages.push(
         "Invalid annotation start: " + location.start + " detected for " + location.name + " and set to size: " + size
       );
       location.start = Math.max(0, size - (isProtein ? 3 : 1));
     }
-    if (size !== void 0 && (location.end < 0 || location.end > size - 1)) {
+    if (location.end < 0 || !(location.end <= size - 1) || location.end > size - 1) {
       messages.push(
         "Invalid annotation end:  " + location.end + " detected for " + location.name + " and set to seq size: " + size
       );
       location.end = Math.max(0, size - 1);
     }
-    if (size !== void 0 && location.start > location.end && circular === false) {
+    if (location.start > location.end && circular === false) {
       messages.push(
         "Invalid circular annotation detected for " + name + ". end set to 1"
       );
@@ -6500,30 +6408,21 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(coerceLocation, "coerceLocation");
   function getDegenerateDnaStringFromAAString(aaString) {
-    return aaString.split("").map(
-      (char) => aminoAcidToDegenerateDnaMap[char.toLowerCase()] || "nnn"
-    ).join("");
+    return aaString.split("").map((char) => aminoAcidToDegenerateDnaMap[char.toLowerCase()] || "nnn").join("");
   }
   __name(getDegenerateDnaStringFromAAString, "getDegenerateDnaStringFromAAString");
-  function getAminoAcidStringFromSequenceString(sequenceString, options = {}) {
-    const { doNotExcludeAsterisk } = options;
+  function getAminoAcidStringFromSequenceString(sequenceString, { doNotExcludeAsterisk } = {}) {
     const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
       sequenceString,
-      true,
-      null,
-      false
+      true
     );
     const aaArray = [];
     let aaString = "";
     aminoAcidsPerBase.forEach((aa, index) => {
-      var _a;
       if (!aa.fullCodon) {
         return;
       }
-      if (!doNotExcludeAsterisk && index >= aminoAcidsPerBase.length - 3 && ((_a = aa.aminoAcid) == null ? void 0 : _a.value) === "*") {
-        return;
-      }
-      if (aa.aminoAcidIndex === null || !aa.aminoAcid) {
+      if (!doNotExcludeAsterisk && index >= aminoAcidsPerBase.length - 3 && aa.aminoAcid.value === "*") {
         return;
       }
       aaArray[aa.aminoAcidIndex] = aa.aminoAcid.value;
@@ -6550,7 +6449,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       messages: []
     };
     if (!seqData) {
-      seqData = { sequence: "" };
+      seqData = {};
     }
     if (!seqData.sequence) {
       seqData.sequence = "";
@@ -6613,27 +6512,25 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const featureTypes = getFeatureTypes();
     annotationTypes.forEach((annotationType) => {
       if (!Array.isArray(seqData[annotationType])) {
-        if (seqData[annotationType] && typeof seqData[annotationType] === "object") {
-          seqData[annotationType] = Object.keys(
-            seqData[annotationType]
-          ).map((key) => {
-            return seqData[annotationType][key];
-          });
+        if (typeof seqData[annotationType] === "object") {
+          seqData[annotationType] = Object.keys(seqData[annotationType]).map(
+            (key) => {
+              return seqData[annotationType][key];
+            }
+          );
         } else {
           seqData[annotationType] = [];
         }
       }
-      seqData[annotationType] = seqData[annotationType].filter(
-        (annotation) => {
-          return tidyUpAnnotation(annotation, __spreadProps(__spreadValues({}, options), {
-            featureTypes,
-            sequenceData: seqData,
-            convertAnnotationsFromAAIndices,
-            mutative: true,
-            annotationType
-          }));
-        }
-      );
+      seqData[annotationType] = seqData[annotationType].filter((annotation) => {
+        return tidyUpAnnotation(annotation, __spreadProps(__spreadValues({}, options), {
+          featureTypes,
+          sequenceData: seqData,
+          convertAnnotationsFromAAIndices,
+          mutative: true,
+          annotationType
+        }));
+      });
     });
     if (!noTranslationData) {
       seqData.translations = flatMap(seqData.translations, (translation) => {
@@ -6641,7 +6538,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         if (noCdsTranslations && translation.translationType === "CDS Feature") {
           return [];
         }
-        const codonStart = ((_b = (_a = translation == null ? void 0 : translation.notes) == null ? void 0 : _a["codon_start"]) == null ? void 0 : _b[0]) - 1 || 0;
+        const codonStart = ((_b = (_a = translation == null ? void 0 : translation.notes) == null ? void 0 : _a.codon_start) == null ? void 0 : _b[0]) - 1 || 0;
         const expandedRange = expandOrContractRangeByLength(
           translation,
           -codonStart,
@@ -6651,9 +6548,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         if (!expandedRange.aminoAcids && !seqData.noSequence) {
           expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
             seqData.sequence,
-            expandedRange.forward || false,
-            expandedRange,
-            false
+            expandedRange.forward,
+            expandedRange
           );
         }
         return expandedRange;
@@ -6661,22 +6557,19 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     }
     if (annotationsAsObjects) {
       annotationTypes.forEach((name) => {
-        seqData[name] = seqData[name].reduce(
-          (acc, item) => {
-            let itemId;
-            if (item.id || item.id === 0) {
-              itemId = item.id;
-            } else {
-              itemId = shortid();
-              if (!doNotProvideIdsForAnnotations) {
-                item.id = itemId;
-              }
+        seqData[name] = seqData[name].reduce((acc, item) => {
+          let itemId;
+          if (item.id || item.id === 0) {
+            itemId = item.id;
+          } else {
+            itemId = shortid();
+            if (!doNotProvideIdsForAnnotations) {
+              item.id = itemId;
             }
-            acc[itemId] = item;
-            return acc;
-          },
-          {}
-        );
+          }
+          acc[itemId] = item;
+          return acc;
+        }, {});
       });
     }
     if (logMessages && response.messages.length > 0) {
@@ -6686,17 +6579,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(tidyUpSequenceData, "tidyUpSequenceData");
   const getDiffFromSeqs = /* @__PURE__ */ __name((oldData, newData, { ignoreKeys = [] } = {}) => {
-    const cleanedOldData = tidyUpSequenceData(oldData, {
+    oldData = tidyUpSequenceData(oldData, {
       annotationsAsObjects: true,
       noTranslationData: true,
       doNotRemoveInvalidChars: true
     });
-    const cleanedNewData = tidyUpSequenceData(newData, {
+    newData = tidyUpSequenceData(newData, {
       annotationsAsObjects: true,
       noTranslationData: true,
       doNotRemoveInvalidChars: true
     });
-    [cleanedOldData, cleanedNewData].forEach((d) => {
+    [oldData, newData].forEach((d) => {
       [
         "cutsites",
         "orfs",
@@ -6719,26 +6612,27 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         });
       }
     });
-    return diff(cleanedOldData, cleanedNewData);
+    return diff(oldData, newData);
   }, "getDiffFromSeqs");
-  const patchSeqWithDiff = /* @__PURE__ */ __name((oldData, diffData, { ignoreKeys = [] } = {}) => {
+  const patchSeqWithDiff = /* @__PURE__ */ __name((oldData, diff2, { ignoreKeys = [] } = {}) => {
     ignoreKeys.forEach((k) => {
-      delete diffData[k];
-    });
-    const tidyOld = tidyUpSequenceData(cloneDeep(oldData), {
-      annotationsAsObjects: true,
-      doNotRemoveInvalidChars: true
+      delete diff2[k];
     });
-    return patch(tidyOld, diffData);
+    return patch(
+      tidyUpSequenceData(cloneDeep(oldData), {
+        annotationsAsObjects: true,
+        doNotRemoveInvalidChars: true
+      }),
+      diff2
+    );
   }, "patchSeqWithDiff");
-  const reverseSeqDiff = /* @__PURE__ */ __name((diffData) => {
-    return reverse(diffData);
+  const reverseSeqDiff = /* @__PURE__ */ __name((diff2) => {
+    return reverse(diff2);
   }, "reverseSeqDiff");
   function getAllInsertionsInSeqReads(seqReads) {
     const allInsertionsInSeqReads = [];
     seqReads.forEach((seqRead) => {
       const splitSeqRead = seqRead.cigar.match(/([0-9]*[MDI])/g);
-      if (!splitSeqRead) return;
       for (let componentI = 0; componentI < splitSeqRead.length; componentI++) {
         if (splitSeqRead[componentI].slice(-1) === "I") {
           let bpPosOfInsertion = seqRead.pos;
@@ -6782,19 +6676,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return sortedInsertions;
   }
   __name(getAllInsertionsInSeqReads, "getAllInsertionsInSeqReads");
-  function annotateSingleSeq({
-    fullSeq,
-    searchSeq
-  }) {
+  function annotateSingleSeq({ fullSeq, searchSeq }) {
     const fullSeqId = fullSeq.id || "fullSeqId";
     const searchSeqId = searchSeq.id || "searchSeqId";
     const results = autoAnnotate({
       seqsToAnnotateById: {
-        [fullSeqId]: {
-          sequence: fullSeq.sequence,
-          circular: fullSeq.circular,
-          annotations: fullSeq.features || []
-        }
+        [fullSeqId]: __spreadProps(__spreadValues({}, fullSeq), {
+          id: fullSeqId
+        })
       },
       annotationsToCheckById: {
         [searchSeqId]: __spreadProps(__spreadValues({}, searchSeq), {
@@ -6844,9 +6733,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     z: "sar"
   };
   function getDegenerateRnaStringFromAAString(aaString) {
-    return aaString.split("").map(
-      (char) => aminoAcidToDegenerateRnaMap[char.toLowerCase()] || "nnn"
-    ).join("");
+    return aaString.split("").map((char) => aminoAcidToDegenerateRnaMap[char.toLowerCase()] || "nnn").join("");
   }
   __name(getDegenerateRnaStringFromAAString, "getDegenerateRnaStringFromAAString");
   function getVirtualDigest({
@@ -6861,7 +6748,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const overlappingEnzymes = [];
     const pairs = [];
     const sortedCutsites = cutsites.sort((a, b) => {
-      return (a.topSnipPosition || 0) - (b.topSnipPosition || 0);
+      return a.topSnipPosition - b.topSnipPosition;
     });
     sortedCutsites.forEach((cutsite1, index) => {
       if (computePartialDigest && !computePartialDigestDisabled) {
@@ -6878,11 +6765,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     });
     pairs.forEach(([cut1, cut2]) => {
       const start = normalizePositionByRangeLength(
-        cut1.topSnipPosition || 0,
+        cut1.topSnipPosition,
         sequenceLength
       );
       const end = normalizePositionByRangeLength(
-        (cut2.topSnipPosition || 0) - 1,
+        cut2.topSnipPosition - 1,
         sequenceLength
       );
       if (!isCircular && start > end) {
@@ -6896,7 +6783,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
               name: "End Of Seq"
             }
           }
-          // Cast to CutSite as it's a mock
         };
         const frag2 = {
           start: 0,
@@ -6907,7 +6793,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
               name: "Start Of Seq"
             }
           },
-          // Cast
           cut2
         };
         fragments.push(addSizeIdName(frag1, sequenceLength));
@@ -7010,18 +6895,27 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return matches;
   }
   __name(findApproxMatches, "findApproxMatches");
+  var spliceString$1;
+  var hasRequiredSpliceString;
+  function requireSpliceString() {
+    if (hasRequiredSpliceString) return spliceString$1;
+    hasRequiredSpliceString = 1;
+    spliceString$1 = /* @__PURE__ */ __name(function spliceSlice(str, index, count, add) {
+      return str.slice(0, index) + (add || "") + str.slice(index + count);
+    }, "spliceSlice");
+    return spliceString$1;
+  }
+  __name(requireSpliceString, "requireSpliceString");
+  var spliceStringExports = requireSpliceString();
+  const spliceString = /* @__PURE__ */ getDefaultExportFromCjs(spliceStringExports);
   function adjustBpsToReplaceOrInsert(bpString, insertString = "", caretPositionOrRange) {
     let stringToReturn = bpString;
-    if (typeof caretPositionOrRange !== "number" && caretPositionOrRange && caretPositionOrRange.start > -1) {
+    if (caretPositionOrRange && caretPositionOrRange.start > -1) {
       if (getRangeLength(caretPositionOrRange, bpString.length) === bpString.length) {
         return insertString;
       }
       const ranges = splitRangeIntoTwoPartsIfItIsCircular(
-        invertRange(
-          caretPositionOrRange,
-          bpString.length
-        ),
-        bpString.length
+        invertRange(caretPositionOrRange, bpString.length)
       );
       stringToReturn = "";
       ranges.forEach((range, index) => {
@@ -7047,16 +6941,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return stringToReturn;
   }
   __name(adjustBpsToReplaceOrInsert, "adjustBpsToReplaceOrInsert");
-  const spliceString = /* @__PURE__ */ __name((str, index, count, add) => {
-    let i = index;
-    if (i < 0) {
-      i = str.length + i;
-      if (i < 0) {
-        i = 0;
-      }
-    }
-    return str.slice(0, i) + (add || "") + str.slice(i + count);
-  }, "spliceString");
   function calculatePercentGC(bps) {
     return (bps.match(/[cg]/gi) || []).length / bps.length * 100 || 0;
   }
@@ -7082,17 +6966,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
      * monovalentCationConc - THe monovalent salt concentration. Defaults to 50e-3M.
      * return - Temperature for the given sequence, in Celsius.
      */
-    calculateTemperature: /* @__PURE__ */ __name(function(_sequence, {
-      type,
-      A,
-      R,
-      primerConc,
-      monovalentCationConc
-    } = {}) {
+    calculateTemperature: /* @__PURE__ */ __name(function(_sequence, { type, A, R, primerConc, monovalentCationConc } = {}) {
       const sequence = (_sequence || "").toLowerCase();
       if (typeof type === "undefined") {
         type = this.TABLE_BRESLAUER;
-      } else if (type !== this.TABLE_BRESLAUER && type !== this.TABLE_UNIFIED && type !== this.TABLE_SUGIMOTO) {
+      } else if (type != this.TABLE_BRESLAUER && type != this.TABLE_UNIFIED && type != this.TABLE_SUGIMOTO) {
         throw new Error("Invalid table type!");
       }
       if (!A) {
@@ -7108,14 +6986,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         monovalentCationConc = this.monovalentCationConc;
       }
       const sequenceLength = sequence.length;
-      if (sequenceLength === 0) {
+      if (sequenceLength == 0) {
         return 0;
       }
       const deltaHTable = this.getDeltaHTable(type);
       const deltaSTable = this.getDeltaSTable(type);
-      if (!deltaHTable || !deltaSTable) {
-        return 0;
-      }
       const neighbors = [];
       neighbors.push(this.calculateReps(sequence, "aa"));
       neighbors.push(this.calculateNumberOfOccurrences(sequence, "at"));
@@ -7149,7 +7024,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
      * @return {Number[]} deltaH table for given algorithm.
      */
     getDeltaHTable: /* @__PURE__ */ __name(function(type) {
-      if (type === this.TABLE_BRESLAUER) {
+      if (type == this.TABLE_BRESLAUER) {
         return [
           9.1,
           8.6,
@@ -7168,7 +7043,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           6.5,
           11.1
         ];
-      } else if (type === this.TABLE_SUGIMOTO) {
+      } else if (type == this.TABLE_SUGIMOTO) {
         return [
           8,
           5.6,
@@ -7187,7 +7062,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           9.4,
           11.9
         ];
-      } else if (type === this.TABLE_UNIFIED) {
+      } else if (type == this.TABLE_UNIFIED) {
         return [
           7.9,
           7.2,
@@ -7210,6 +7085,39 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         return null;
       }
     }, "getDeltaHTable"),
+    // "AA/TT": -7.9, 7.9
+    // "AT/TA": -7.2, 7.2
+    // "AC/TG": -8.4, 8.4
+    // "AG/TC": -7.8, 7.8
+    // "TT/AA": -7.9, 7.9
+    // "TA/AT": -7.2, 7.2
+    // "TG/AC": -8.5, 8.2
+    // "TC/AG": -8.2, 8.5
+    // "CC/GG": -8.0, 8.0
+    // "CA/GT": -8.5, 8.5
+    // "CT/GA": -7.8, 7.8
+    // "CG/GC": -10.6, 10.6
+    // "GG/CC": -8.0, 8.0
+    // "GA/CT": -8.2, 8.2,
+    // "GT/CA": -8.4, 8.4
+    // "GC/CG": -9.8, 9.8
+    // aa, at, ac, ag, tt, ta, tc, tg, cc, ca, ct, cg, gg, ga, gt, gc
+    // "AA/TT": -22.2,22.2,
+    // "AT/TA": -20.4,20.4,
+    // "AC/TG": -22.4,22.4,
+    // "AG/TC": -21.0,21.0,
+    // "TT/AA": -22.2,22.2,
+    // "TA/AT": -21.3,21.3,
+    // "TC/AG": -22.2,22.2,
+    // "TG/AC": -22.7,22.7,
+    // "CC/GG": -19.9,19.9,
+    // "CA/GT": -22.7,22.7,
+    // "CT/GA": -21.0,21.0,
+    // "CG/GC": -27.2,27.2,
+    // "GG/CC": -19.9,19.9,
+    // "GT/CA": -22.4,22.2,
+    // "GA/CT": -22.2,22.4,
+    // "GC/CG": -24.4,24.4
     /**
      * @private
      * Function to return deltaS table for given algorithm.
@@ -7217,7 +7125,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
      * @return {Number[]} deltaS table for given algorithm.
      */
     getDeltaSTable: /* @__PURE__ */ __name(function(type) {
-      if (type === this.TABLE_BRESLAUER) {
+      if (type == this.TABLE_BRESLAUER) {
         return [
           24,
           23.9,
@@ -7236,7 +7144,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           17.3,
           26.7
         ];
-      } else if (type === this.TABLE_SUGIMOTO) {
+      } else if (type == this.TABLE_SUGIMOTO) {
         return [
           21.9,
           15.2,
@@ -7255,7 +7163,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           25.5,
           29
         ];
-      } else if (type === this.TABLE_UNIFIED) {
+      } else if (type == this.TABLE_UNIFIED) {
         return [
           22.2,
           20.4,
@@ -7289,14 +7197,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
      */
     calculateReps: /* @__PURE__ */ __name(function(sequence, target) {
       const sequenceLength = sequence.length;
-      if (sequenceLength === 0) {
+      if (sequenceLength == 0) {
         return 0;
       }
       let numFound = 0;
       let seqOffset = 0;
       while (true) {
         const foundSeq = sequence.indexOf(target, seqOffset);
-        if (foundSeq === -1) {
+        if (foundSeq == -1) {
           break;
         }
         seqOffset = foundSeq + 1;
@@ -7316,7 +7224,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
      */
     calculateNumberOfOccurrences: /* @__PURE__ */ __name(function(sequence, target) {
       const sequenceLength = sequence.length;
-      if (sequenceLength === 0) {
+      if (sequenceLength == 0) {
         return 0;
       }
       const numberFound = sequence.split(target).length - 1;
@@ -7351,11 +7259,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(rotateBpsToPosition, "rotateBpsToPosition");
   function arrayRotate(arr, count) {
     count -= arr.length * Math.floor(count / arr.length);
-    arr.push(...arr.splice(0, count));
+    arr.push.apply(arr, arr.splice(0, count));
     return arr;
   }
   __name(arrayRotate, "arrayRotate");
-  function rotateSequenceDataToPosition(sequenceData, caretPosition, options = {}) {
+  function rotateSequenceDataToPosition(sequenceData, caretPosition, options) {
     const newSequenceData = tidyUpSequenceData(sequenceData, __spreadValues({
       doNotRemoveInvalidChars: true
     }, options));
@@ -7403,24 +7311,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     }, options));
     const newSequenceData = cloneDeep(existingSequenceData);
     const insertLength = sequenceDataToInsert.isProtein && sequenceDataToInsert.proteinSequence ? sequenceDataToInsert.proteinSequence.length * 3 : sequenceDataToInsert.sequence.length;
-    let caretPosition = typeof caretPositionOrRange === "number" ? caretPositionOrRange : caretPositionOrRange.start;
-    const isInsertSameLengthAsSelection = typeof caretPositionOrRange !== "number" && sequenceDataToInsert.sequence.length === getRangeLength(
-      caretPositionOrRange,
-      existingSequenceData.sequence.length
-    );
-    if (typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > -1 && getRangeLength(
+    let caretPosition = caretPositionOrRange;
+    const isInsertSameLengthAsSelection = sequenceDataToInsert.sequence.length === getRangeLength(caretPositionOrRange, existingSequenceData.sequence.length);
+    if (caretPositionOrRange.start > -1 && getRangeLength(
       caretPositionOrRange,
       existingSequenceData.sequence.length
     ) === existingSequenceData.sequence.length) {
-      const emptyAnnotations = modifiableTypes.reduce(
-        (acc, type) => {
-          acc[type] = [];
-          return acc;
-        },
-        {}
-      );
       existingSequenceData = tidyUpSequenceData(
-        __spreadProps(__spreadValues(__spreadValues({}, existingSequenceData), emptyAnnotations), {
+        __spreadProps(__spreadValues(__spreadValues({}, existingSequenceData), modifiableTypes.reduce((acc, type) => {
+          return acc[type] = [];
+        }, {})), {
           sequence: "",
           doNotRemoveInvalidChars: true,
           proteinSequence: "",
@@ -7430,7 +7330,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       );
       newSequenceData.chromatogramData = void 0;
     } else if (newSequenceData.chromatogramData && newSequenceData.chromatogramData.baseTraces) {
-      if (typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > -1) {
+      if (caretPositionOrRange && caretPositionOrRange.start > -1) {
         if (caretPositionOrRange.start > caretPositionOrRange.end) {
           newSequenceData.chromatogramData = trimChromatogram({
             chromatogramData: newSequenceData.chromatogramData,
@@ -7440,16 +7340,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
             },
             justBaseCalls: isInsertSameLengthAsSelection
           });
-          if (newSequenceData.chromatogramData) {
-            newSequenceData.chromatogramData = trimChromatogram({
-              chromatogramData: newSequenceData.chromatogramData,
-              range: {
-                start: 0,
-                end: caretPositionOrRange.end
-              },
-              justBaseCalls: isInsertSameLengthAsSelection
-            });
-          }
+          newSequenceData.chromatogramData = trimChromatogram({
+            chromatogramData: newSequenceData.chromatogramData,
+            range: {
+              start: 0,
+              end: caretPositionOrRange.end
+            },
+            justBaseCalls: isInsertSameLengthAsSelection
+          });
         } else {
           newSequenceData.chromatogramData = trimChromatogram({
             chromatogramData: newSequenceData.chromatogramData,
@@ -7461,10 +7359,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           });
         }
       }
-      if (sequenceDataToInsert.sequence && newSequenceData.chromatogramData) {
+      if (sequenceDataToInsert.sequence) {
         insertIntoChromatogram({
           chromatogramData: newSequenceData.chromatogramData,
-          caretPosition: typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > -1 ? caretPositionOrRange.start : caretPositionOrRange,
+          caretPosition: caretPositionOrRange.start > -1 ? caretPositionOrRange.start : caretPositionOrRange,
           seqToInsert: sequenceDataToInsert.sequence,
           justBaseCalls: isInsertSameLengthAsSelection
         });
@@ -7477,15 +7375,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     );
     newSequenceData.size = newSequenceData.sequence.length;
     newSequenceData.proteinSequence = adjustBpsToReplaceOrInsert(
-      existingSequenceData.proteinSequence || "",
-      sequenceDataToInsert.proteinSequence || "",
+      existingSequenceData.proteinSequence,
+      sequenceDataToInsert.proteinSequence,
       convertDnaCaretPositionOrRangeToAA(caretPositionOrRange)
     );
-    newSequenceData.proteinSize = (newSequenceData.proteinSequence || "").length;
+    newSequenceData.proteinSize = newSequenceData.proteinSequence.length;
     modifiableTypes.forEach((annotationType) => {
       let existingAnnotations = existingSequenceData[annotationType];
-      if (!existingAnnotations) return;
-      if (typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > -1) {
+      if (caretPositionOrRange && caretPositionOrRange.start > -1) {
         const range = caretPositionOrRange;
         caretPosition = range.start > range.end ? 0 : range.start;
         existingAnnotations = adjustAnnotationsToDelete(
@@ -7495,23 +7392,22 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         );
       }
       newSequenceData[annotationType] = [];
-      const annotationsToInsert = sequenceDataToInsert[annotationType];
-      if (newSequenceData[annotationType]) {
-        newSequenceData[annotationType] = newSequenceData[annotationType].concat(
-          adjustAnnotationsToInsert(
-            existingAnnotations,
-            caretPosition,
-            insertLength
-          )
-        );
-        if (annotationsToInsert) {
-          newSequenceData[annotationType] = newSequenceData[annotationType].concat(
-            adjustAnnotationsToInsert(annotationsToInsert, 0, caretPosition)
-          );
-        }
-      }
+      newSequenceData[annotationType] = newSequenceData[annotationType].concat(
+        adjustAnnotationsToInsert(
+          existingAnnotations,
+          caretPosition,
+          insertLength
+        )
+      );
+      newSequenceData[annotationType] = newSequenceData[annotationType].concat(
+        adjustAnnotationsToInsert(
+          sequenceDataToInsert[annotationType],
+          0,
+          caretPosition
+        )
+      );
     });
-    if (maintainOriginSplit && typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > caretPositionOrRange.end) {
+    if (maintainOriginSplit && caretPositionOrRange && caretPositionOrRange.start > caretPositionOrRange.end) {
       const caretPosToRotateTo = existingSequenceData.sequence.length - caretPositionOrRange.start;
       return rotateSequenceDataToPosition(
         newSequenceData,
@@ -7529,7 +7425,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         maxLength
       );
       const newLocations = annotation.locations && annotation.locations.map((loc) => adjustRangeToDeletionOfAnotherRange(loc, range, maxLength)).filter((range2) => !!range2);
-      if (!newRange) return null;
       if (newLocations && newLocations.length) {
         return __spreadValues(__spreadProps(__spreadValues({}, newRange), {
           start: newLocations[0].start,
@@ -7548,13 +7443,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     justBaseCalls
   }) {
     if (!seqToInsert.length) return;
-    if (chromatogramData.baseCalls) {
-      chromatogramData.baseCalls.splice(
-        caretPosition,
-        0,
-        ...seqToInsert.split("")
-      );
-    }
+    chromatogramData.baseCalls && chromatogramData.baseCalls.splice(
+      caretPosition,
+      0,
+      ...seqToInsert.split("")
+    );
     if (justBaseCalls) {
       return chromatogramData;
     }
@@ -7570,20 +7463,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         tTrace: toPush
       });
     }
-    if (chromatogramData.baseTraces) {
-      chromatogramData.baseTraces.splice(
-        caretPosition,
-        0,
-        ...baseTracesToInsert
-      );
-    }
-    if (chromatogramData.qualNums) {
-      chromatogramData.qualNums.splice(
-        caretPosition,
-        0,
-        ...qualNumsToInsert
-      );
-    }
+    chromatogramData.baseTraces && chromatogramData.baseTraces.splice(caretPosition, 0, ...baseTracesToInsert);
+    chromatogramData.qualNums && chromatogramData.qualNums.splice(caretPosition, 0, ...qualNumsToInsert);
     return chromatogramData;
   }
   __name(insertIntoChromatogram, "insertIntoChromatogram");
@@ -7596,23 +7477,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       "baseCalls",
       ...justBaseCalls ? [] : ["qualNums", "baseTraces", "basePos"]
     ].forEach((type) => {
-      if (chromatogramData[type]) {
-        chromatogramData[type].splice(start, end - start + 1);
-      }
+      chromatogramData[type] && chromatogramData[type].splice(start, end - start + 1);
     });
     return chromatogramData;
   }
   __name(trimChromatogram, "trimChromatogram");
   function deleteSequenceDataAtRange(sequenceData, range) {
-    return insertSequenceDataAtPositionOrRange(
-      { sequence: "" },
-      sequenceData,
-      range
-    );
+    return insertSequenceDataAtPositionOrRange({}, sequenceData, range);
   }
   __name(deleteSequenceDataAtRange, "deleteSequenceDataAtRange");
   function doesEnzymeChopOutsideOfRecognitionSite(enzyme) {
-    if (enzyme.topSnipOffset && enzyme.bottomSnipOffset && (enzyme.topSnipOffset > enzyme.site.length || enzyme.bottomSnipOffset > enzyme.site.length)) {
+    if (enzyme.topSnipOffset > enzyme.site.length || enzyme.bottomSnipOffset > enzyme.site.length) {
       return true;
     } else {
       return false;
@@ -15244,10 +15119,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     defaultEnzymesByName[name] = aliasedEnzymesByName[name];
   });
   function generateAnnotations(numberOfAnnotationsToGenerate, start, end, maxLength) {
-    const result = [];
+    const result = {};
     for (let i = 0; i < numberOfAnnotationsToGenerate; i++) {
       const annotation = generateAnnotation(start, end, maxLength);
-      result.push(annotation);
+      result[annotation.id] = annotation;
     }
     return result;
   }
@@ -15275,16 +15150,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     numPrimers,
     numTranslations
   } = {}) {
-    const proteinSequence = isProtein ? generateSequence(sequenceLength, true) : "";
-    const sequence = !isProtein ? generateSequence(sequenceLength) : "";
+    const proteinSequence = isProtein && generateSequence(sequenceLength, true);
+    const sequence = !isProtein && generateSequence(sequenceLength);
     return {
       circular: isProtein ? false : Math.random() > 0.5,
-      name: "p-" + Math.floor(Math.random() * 100),
+      name: "p-" + Math.floor(Math.random * 100),
       description: "",
-      isProtein: !!isProtein,
+      isProtein,
       sequence,
       proteinSequence,
-      translations: isProtein ? [] : generateAnnotations(
+      translations: isProtein ? void 0 : generateAnnotations(
         numTranslations || 5,
         0,
         sequenceLength - 1,
@@ -15296,7 +15171,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         sequenceLength - 1,
         sequenceLength / 3
       ),
-      primers: isProtein ? [] : generateAnnotations(numPrimers || 10, 0, sequenceLength - 1, 50),
+      primers: isProtein ? void 0 : generateAnnotations(numPrimers || 10, 0, sequenceLength - 1, 50),
       parts: generateAnnotations(
         numParts || 10,
         0,
@@ -15308,14 +15183,15 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(generateSequenceData, "generateSequenceData");
   function generateSequence(m = 9, isProtein) {
     let s = "";
-    const r = isProtein ? "ACDEFGHIKLMNPQRSTVWY" : "gatc";
+    const r = isProtein ? "" : "gatc";
     for (let i = 0; i < m; i++) {
       s += r.charAt(Math.floor(Math.random() * r.length));
     }
     return s;
   }
   __name(generateSequence, "generateSequence");
-  function findNearestRangeOfSequenceOverlapToPosition(sequenceToSearch, overlapSequence, positionStart = 0, isLinear) {
+  function findNearestRangeOfSequenceOverlapToPosition(sequenceToSearch, overlapSequence, positionStart, isLinear) {
+    if (!positionStart) positionStart = 0;
     if (sequenceToSearch.length < overlapSequence.length) {
       return null;
     }
@@ -15333,9 +15209,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       index = result.index;
       distance = newDistance;
     }
-    if (index === void 0) {
-      return null;
-    }
     return normalizeRange(
       {
         start: index,
@@ -15380,11 +15253,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
             internalStartCodonIndices: [],
             frame: start % 3,
             forward,
-            // annotationTypePlural: "orfs",
+            annotationTypePlural: "orfs",
             isOrf: true,
-            id: shortid(),
-            type: "orf",
-            name: "ORF"
+            id: shortid()
           });
         }
       }
@@ -15488,10 +15359,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           true
         );
       } else {
-        searchStringToUse = convertAmbiguousStringToRegex(
-          searchStringToUse,
-          false
-        );
+        searchStringToUse = convertAmbiguousStringToRegex(searchStringToUse);
       }
     }
     if (!searchStringToUse) return [];
@@ -15611,9 +15479,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(getCodonRangeForAASliver, "getCodonRangeForAASliver");
   function getComplementAminoAcidStringFromSequenceString(sequenceString) {
-    const aaString = getAminoAcidStringFromSequenceString(sequenceString, {
-      doNotExcludeAsterisk: true
-    });
+    const aaString = getAminoAcidStringFromSequenceString(sequenceString, true);
     return aaString.split("").reverse().join("");
   }
   __name(getComplementAminoAcidStringFromSequenceString, "getComplementAminoAcidStringFromSequenceString");
@@ -15651,30 +15517,26 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         sequence: getSequenceWithinRange(range, seqDataToUse.sequence),
         proteinSequence: getSequenceWithinRange(
           convertDnaCaretPositionOrRangeToAA(range),
-          seqDataToUse.proteinSequence || ""
+          seqDataToUse.proteinSequence
         )
       },
-      annotationTypes.reduce(
-        (acc, type) => {
-          if (exclude[type]) {
-            acc[type] = [];
-            return acc;
-          }
-          acc[type] = getAnnotationsBetweenRange(
-            seqDataToUse[type],
-            range,
-            seqDataToUse.sequence.length,
-            excludePartial[type]
-          );
+      annotationTypes.reduce((acc, type) => {
+        if (exclude[type]) {
+          acc[type] = [];
           return acc;
-        },
-        {}
-      )
+        }
+        acc[type] = getAnnotationsBetweenRange(
+          seqDataToUse[type],
+          range,
+          seqDataToUse.sequence.length,
+          excludePartial[type]
+        );
+        return acc;
+      }, {})
     );
     if (range.overlapsSelf) {
       const extendedSeqData = insertSequenceDataAtPositionOrRange(
         { sequence: seqDataToReturn.sequence },
-        // Wrapping in object as per assumed signature
         seqDataToUse,
         range.start
       );
@@ -15715,6 +15577,15 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       }
       const overlaps = getZeroedRangeOverlaps(annotation, range, maxLength).map(
         (overlap) => {
+          const allLocations = annotation.locations;
+          if (allLocations && allLocations.length) {
+            const newLocations = allLocations.filter((loc) => {
+              return isRangeWithinRange(loc, overlap, maxLength);
+            });
+            return assignIn({}, annotation, overlap, {
+              locations: newLocations
+            });
+          }
           return assignIn({}, annotation, overlap);
         }
       );
@@ -15739,8 +15610,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(getAnnotationsBetweenRange, "getAnnotationsBetweenRange");
   function getComplementSequenceAndAnnotations(pSeqObj, options = {}) {
     const seqObj = tidyUpSequenceData(
-      getSequenceDataBetweenRange(pSeqObj, options.range || null),
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getSequenceDataBetweenRange(pSeqObj, options.range),
       options
     );
     const newSeqObj = Object.assign({}, seqObj, {
@@ -15755,7 +15625,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const { topSnipOffset, bottomSnipOffset } = restrictionEnzyme;
     if (topSnipOffset === bottomSnipOffset) {
       return "blunt";
-    } else if (topSnipOffset !== void 0 && bottomSnipOffset !== void 0 && topSnipOffset < bottomSnipOffset) {
+    } else if (topSnipOffset < bottomSnipOffset) {
       return "5' overhang";
     } else {
       return "3' overhang";
@@ -15789,7 +15659,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       leftHandSide: "",
       rightHandSide: ""
     };
-    if (isPositionWithinRange(position, range, sequence.length)) {
+    if (isPositionWithinRange(position, range)) {
       result.leftHandSide = getSequenceWithinRange(
         {
           start: range.start,
@@ -15829,13 +15699,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     }
   }
   __name(getOverlapBetweenTwoSequences, "getOverlapBetweenTwoSequences");
-  function getPossiblePartsFromSequenceAndEnzymes(seqData, restrictionEnzymes) {
-    const enzymes = Array.isArray(restrictionEnzymes) ? restrictionEnzymes : [restrictionEnzymes];
+  function getPossiblePartsFromSequenceAndEnzyme(seqData, restrictionEnzymes) {
+    restrictionEnzymes = restrictionEnzymes.length ? restrictionEnzymes : [restrictionEnzymes];
     const bps = seqData.sequence;
     const seqLen = bps.length;
-    const circular = seqData.circular || false;
+    const circular = seqData.circular;
     let cutsites = [];
-    enzymes.forEach((enzyme) => {
+    restrictionEnzymes.forEach((enzyme) => {
       const newCutsites = cutSequenceByRestrictionEnzyme(bps, circular, enzyme);
       cutsites = cutsites.concat(newCutsites);
     });
@@ -15876,13 +15746,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       return parts;
     }
   }
-  __name(getPossiblePartsFromSequenceAndEnzymes, "getPossiblePartsFromSequenceAndEnzymes");
+  __name(getPossiblePartsFromSequenceAndEnzyme, "getPossiblePartsFromSequenceAndEnzyme");
   function getPartBetweenEnzymesWithInclusiveOverhangs(cut1, cut2, seqLen) {
     const firstCutOffset = getEnzymeRelativeOffset(cut1.restrictionEnzyme);
     const secondCutOffset = getEnzymeRelativeOffset(cut2.restrictionEnzyme);
-    const start = (cut1.topSnipBeforeBottom ? cut1.topSnipPosition : cut1.bottomSnipPosition) || 0;
+    const start = cut1.topSnipBeforeBottom ? cut1.topSnipPosition : cut1.bottomSnipPosition;
     const end = normalizePositionByRangeLength(
-      (cut2.topSnipBeforeBottom ? cut2.bottomSnipPosition || 0 : cut2.topSnipPosition || 0) - 1,
+      (cut2.topSnipBeforeBottom ? cut2.bottomSnipPosition : cut2.topSnipPosition) - 1,
       seqLen
     );
     return {
@@ -15893,20 +15763,20 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       firstCut: cut1,
       //the offset is always counting with 0 being at the top snip position
       firstCutOffset,
-      firstCutOverhang: cut1.overhangBps || "",
-      firstCutOverhangTop: firstCutOffset > 0 ? cut1.overhangBps || "" : "",
-      firstCutOverhangBottom: firstCutOffset < 0 ? getComplementSequenceString(cut1.overhangBps || "") : "",
+      firstCutOverhang: cut1.overhangBps,
+      firstCutOverhangTop: firstCutOffset > 0 ? cut1.overhangBps : "",
+      firstCutOverhangBottom: firstCutOffset < 0 ? getComplementSequenceString(cut1.overhangBps) : "",
       secondCut: cut2,
       //the offset is always counting with 0 being at the top snip position
       secondCutOffset,
-      secondCutOverhang: cut2.overhangBps || "",
-      secondCutOverhangTop: secondCutOffset < 0 ? cut2.overhangBps || "" : "",
-      secondCutOverhangBottom: secondCutOffset > 0 ? getComplementSequenceString(cut2.overhangBps || "") : ""
+      secondCutOverhang: cut2.overhangBps,
+      secondCutOverhangTop: secondCutOffset < 0 ? cut2.overhangBps : "",
+      secondCutOverhangBottom: secondCutOffset > 0 ? getComplementSequenceString(cut2.overhangBps) : ""
     };
   }
   __name(getPartBetweenEnzymesWithInclusiveOverhangs, "getPartBetweenEnzymesWithInclusiveOverhangs");
   function getEnzymeRelativeOffset(enzyme) {
-    return (enzyme.bottomSnipOffset || 0) - (enzyme.topSnipOffset || 0);
+    return enzyme.bottomSnipOffset - enzyme.topSnipOffset;
   }
   __name(getEnzymeRelativeOffset, "getEnzymeRelativeOffset");
   function pairwise(list) {
@@ -15922,8 +15792,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   function getReverseAminoAcidStringFromSequenceString(sequenceString) {
     const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
       sequenceString,
-      false,
-      null,
       false
     );
     const aaArray = [];
@@ -15962,8 +15830,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(getReverseComplementAnnotation, "getReverseComplementAnnotation");
   function getReverseComplementSequenceAndAnnoations(pSeqObj, options = {}) {
     const seqObj = tidyUpSequenceData(
-      getSequenceDataBetweenRange(pSeqObj, options.range || null),
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getSequenceDataBetweenRange(pSeqObj, options.range),
       __spreadValues({ doNotRemoveInvalidChars: true }, options)
     );
     const newSeqObj = Object.assign(
@@ -15972,20 +15839,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       {
         sequence: getReverseComplementSequenceString(seqObj.sequence)
       },
-      annotationTypes.reduce(
-        (acc, type) => {
-          if (seqObj[type]) {
-            acc[type] = map(seqObj[type], (annotation) => {
-              return getReverseComplementAnnotation(
-                annotation,
-                seqObj.sequence.length
-              );
-            });
-          }
-          return acc;
-        },
-        {}
-      )
+      annotationTypes.reduce((acc, type) => {
+        if (seqObj[type]) {
+          acc[type] = map(seqObj[type], (annotation) => {
+            return getReverseComplementAnnotation(
+              annotation,
+              seqObj.sequence.length
+            );
+          });
+        }
+        return acc;
+      }, {})
     );
     return tidyUpSequenceData(newSeqObj, __spreadValues({
       doNotRemoveInvalidChars: true
@@ -16007,13 +15871,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   function guessIfSequenceIsDnaAndNotProtein(seq, options = {}) {
     const { threshold = 0.9, loose } = options;
     const dnaLetters = options.dnaLetters || loose ? [...ambiguous_dna_letters.split(""), "U"] : ["G", "A", "T", "C", "U"];
-    const dnaLetterMap = dnaLetters.reduce(
-      (acc, letter) => {
-        acc[letter.toUpperCase()] = true;
-        return acc;
-      },
-      {}
-    );
+    const dnaLetterMap = dnaLetters.reduce((acc, letter) => {
+      acc[letter.toUpperCase()] = true;
+      return acc;
+    }, {});
     let count = 0;
     if (!seq || !seq.length) return true;
     for (let index = 0; index < seq.length; index++) {
@@ -16033,17 +15894,15 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const yOffsetLevelMap = {};
     const wrappedAnnotations = {};
     forEach(annotations, (annotation) => {
-      var _a;
       const containsLocations = !!(annotation.locations && annotation.locations.length);
       if (annotation.overlapsSelf) {
         if (!wrappedAnnotations[annotation.id]) {
           mapAnnotationToRows({
-            annotation: __spreadProps(__spreadValues({}, annotation), {
+            annotation: {
               start: 0,
               end: sequenceLength - 1,
-              id: `__tempAnnRemoveMe__${annotation.id}`,
-              overlapsSelf: false
-            }),
+              id: `__tempAnnRemoveMe__${annotation.id}`
+            },
             sequenceLength,
             bpsPerRow,
             annotationsToRowsMap,
@@ -16064,7 +15923,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         splitForwardReverse
       });
       if (containsLocations) {
-        (_a = annotation.locations) == null ? void 0 : _a.forEach((location) => {
+        annotation.locations.forEach((location) => {
           mapAnnotationToRows({
             annotation,
             sequenceLength,
@@ -16080,7 +15939,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     forEach(annotationsToRowsMap, (annotationsForRow, i) => {
       annotationsToRowsMap[i] = filter(
         annotationsForRow,
-        (ann) => !startsWith(String(ann.id), "__tempAnnRemoveMe__")
+        (ann) => !startsWith(ann.id, "__tempAnnRemoveMe__")
       );
     });
     return annotationsToRowsMap;
@@ -16122,13 +15981,6 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
               yOffset = ann.yOffset;
             }
           });
-          if (yOffset === void 0) {
-            annotationsForRow.forEach((ann) => {
-              if (ann.id === annotation.id) {
-                yOffset = ann.yOffset;
-              }
-            });
-          }
         } else {
           if (location) {
             annotationsForRow.forEach((ann) => {
@@ -16137,74 +15989,32 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
               }
             });
           } else {
-            if (index > 0 && annotationsForRow.length && annotationsForRow[annotationsForRow.length - 1].annotation === annotation) {
+            if (index > 0 && //second half of an annotation range
+            annotationsForRow.length && //there are already annotations within the row
+            annotationsForRow[annotationsForRow.length - 1].annotation === annotation) {
               yOffset = annotationsForRow[annotationsForRow.length - 1].yOffset;
             } else {
-              const siblingRangesOnThisRow = ranges.slice(index + 1).filter((r) => {
-                const rStartRow = Math.floor(r.start / bpsPerRow);
-                const rEndRow = Math.floor(r.end / bpsPerRow);
-                return rowNumber >= rStartRow && rowNumber <= rEndRow;
-              });
-              if (siblingRangesOnThisRow.length > 0) {
-                let foundYOffset = -1;
-                yOffsetsForRow.some((rangesAlreadyAddedToYOffset, levelIndex) => {
-                  const rangeBlocked = rangesAlreadyAddedToYOffset.some(
-                    (comparisonRange) => {
-                      return checkIfPotentiallyCircularRangesOverlap(
-                        range,
-                        comparisonRange
-                      );
-                    }
-                  );
-                  if (rangeBlocked) return false;
-                  const siblingBlocked = siblingRangesOnThisRow.some(
-                    (siblingRange) => {
-                      return rangesAlreadyAddedToYOffset.some((comparisonRange) => {
-                        return checkIfPotentiallyCircularRangesOverlap(
-                          siblingRange,
-                          comparisonRange
-                        );
-                      });
-                    }
-                  );
-                  if (!siblingBlocked) {
-                    foundYOffset = levelIndex;
-                    return true;
-                  }
-                  return false;
-                });
-                if (foundYOffset > -1) {
-                  yOffset = foundYOffset;
-                  yOffsetsForRow[foundYOffset].push(range);
-                } else {
-                  yOffset = yOffsetsForRow.length;
-                  yOffsetsForRow.push([range]);
-                }
-              } else {
-                yOffset = getYOffsetForPotentiallyCircularRange(
-                  range,
-                  yOffsetsForRow,
-                  false
-                );
-              }
-            }
-            if (yOffset !== void 0) {
-              if (!yOffsetsForRow[yOffset]) yOffsetsForRow[yOffset] = [];
-              yOffsetsForRow[yOffset].push({
-                start,
-                end
-              });
+              yOffset = getYOffsetForPotentiallyCircularRange(
+                annotation,
+                yOffsetsForRow
+              );
             }
+            if (!yOffsetsForRow[yOffset]) yOffsetsForRow[yOffset] = [];
+            yOffsetsForRow[yOffset].push({
+              start,
+              end
+            });
           }
         }
-        annotationsForRow.push(__spreadProps(__spreadValues(__spreadValues(__spreadProps(__spreadValues({}, annotation), {
+        annotationsForRow.push(__spreadProps(__spreadValues(__spreadValues({
           id: annotation.id,
           annotation,
           start,
           end
-        }), containsLocations && { containsLocations }), location && { isJoinedLocation: !!location }), {
+        }, containsLocations && { containsLocations }), location && { isJoinedLocation: !!location }), {
           yOffset,
           enclosingRangeType: range.type
+          //either "beginning", "end" or "beginningAndEnd"
         }));
       }
     });
@@ -16214,14 +16024,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const clonedSeqData = cloneDeep(sequenceData);
     annotationTypes.forEach((annotationType) => {
       if (annotationType !== "cutsites") {
-        const annotations = clonedSeqData[annotationType];
-        if (annotations) {
-          const maxYOffset = getYOffsetsForPotentiallyCircularRanges(
-            annotations,
-            true
-          ).maxYOffset;
-          clonedSeqData[annotationType].maxYOffset = maxYOffset;
-        }
+        const maxYOffset = getYOffsetsForPotentiallyCircularRanges(
+          clonedSeqData[annotationType]
+        ).maxYOffset;
+        clonedSeqData[annotationType].maxYOffset = maxYOffset;
       }
     });
     return clonedSeqData;
@@ -16234,19 +16040,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const rowMap = {};
     annotationTypes.forEach((type) => {
       rowMap[type] = mapAnnotationsToRows(
-        sequenceData[type] || [],
+        sequenceData[type],
         sequenceLength,
         bpsPerRow,
         { splitForwardReverse: type === "primers" }
       );
     });
     for (let rowNumber = 0; rowNumber < totalRows; rowNumber++) {
-      const row = {
-        rowNumber,
-        start: 0,
-        end: 0,
-        sequence: ""
-      };
+      const row = {};
       row.rowNumber = rowNumber;
       row.start = rowNumber * bpsPerRow;
       row.end = (rowNumber + 1) * bpsPerRow - 1 < sequenceLength ? (rowNumber + 1) * bpsPerRow - 1 : sequenceLength - 1;
@@ -16307,16 +16108,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       }
     }
     const refSeqWithGaps = insertGapsIntoRefSeq(refSeq.sequence, seqReads);
-    const seqReadsWithGaps = [{ name: refSeq.name, sequence: refSeqWithGaps.toUpperCase() }];
+    const seqReadsWithGaps = [
+      { name: refSeq.name, sequence: refSeqWithGaps.toUpperCase() }
+    ];
     seqReads.forEach((seqRead) => {
       const allInsertionsInSeqReads = [];
       seqReads.forEach((seqRead2) => {
         const splitSeqRead = seqRead2.cigar.match(/([0-9]*[SMDI])/g);
-        if (!splitSeqRead) return;
         let adjustedSeqReadPos2 = cloneDeep(seqRead2.pos);
         if (splitSeqRead[0].slice(-1) === "S") {
           const numOfBeginningSoftClipped = splitSeqRead[0].slice(0, -1);
-          adjustedSeqReadPos2 = seqRead2.pos - Number(numOfBeginningSoftClipped);
+          adjustedSeqReadPos2 = seqRead2.pos - numOfBeginningSoftClipped;
         }
         for (let componentI = 0; componentI < splitSeqRead.length; componentI++) {
           if (splitSeqRead[componentI].slice(-1) === "I") {
@@ -16342,11 +16144,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       });
       const splitSeqReadChunk = seqRead.cigar.match(/([0-9]*[SMDI])/g);
-      if (!splitSeqReadChunk) return;
       let adjustedSeqReadPos = cloneDeep(seqRead.pos);
       if (splitSeqReadChunk[0].slice(-1) === "S") {
         const numOfBeginningSoftClipped = splitSeqReadChunk[0].slice(0, -1);
-        adjustedSeqReadPos = seqRead.pos - Number(numOfBeginningSoftClipped);
+        adjustedSeqReadPos = seqRead.pos - numOfBeginningSoftClipped;
       }
       let eachSeqReadWithGaps = seqRead.seq.split("");
       if (adjustedSeqReadPos > 0) {
@@ -16534,11 +16335,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const seqReadLengthsBeforeRefSeqStart = [];
     seqReads.forEach((seq) => {
       const splitSeqReadChunk = seq.cigar.match(/([0-9]*[SMDI])/g);
-      if (!splitSeqReadChunk) return;
       let adjustedSeqReadPos = cloneDeep(seq.pos);
       if (splitSeqReadChunk[0].slice(-1) === "S") {
         const numOfBeginningSoftClipped = splitSeqReadChunk[0].slice(0, -1);
-        adjustedSeqReadPos = seq.pos - Number(numOfBeginningSoftClipped);
+        adjustedSeqReadPos = seq.pos - numOfBeginningSoftClipped;
         if (adjustedSeqReadPos < 0) {
           seqReadLengthsBeforeRefSeqStart.push(Math.abs(adjustedSeqReadPos));
         }
@@ -16548,14 +16348,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     for (let i = 1; i < seqReadsWithGaps.length; i++) {
       const eachSeqReadWithGaps = seqReadsWithGaps[i].sequence.split("");
       const splitSeqReadChunk = seqReads[i - 1].cigar.match(/([0-9]*[SMDI])/g);
-      if (!splitSeqReadChunk) continue;
       let adjustedSeqReadPos = cloneDeep(seqReads[i - 1].pos);
       if (seqReadLengthsBeforeRefSeqStart.length > 0) {
         longestSeqReadLength = Math.max(...seqReadLengthsBeforeRefSeqStart);
       }
       if (splitSeqReadChunk[0].slice(-1) === "S") {
         const numOfBeginningSoftClipped = splitSeqReadChunk[0].slice(0, -1);
-        adjustedSeqReadPos = seqReads[i - 1].pos - Number(numOfBeginningSoftClipped);
+        adjustedSeqReadPos = seqReads[i - 1].pos - numOfBeginningSoftClipped;
         if (adjustedSeqReadPos > 0) {
           if (longestSeqReadLength > 0) {
             eachSeqReadWithGaps.unshift("-".repeat(longestSeqReadLength + 1));
@@ -16669,11 +16468,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       for (let i = 0; i < seq.length; i++) {
         if (i === 0 || i === seq.length - 1) {
           if (seq[i] === "G" || seq[i] === "C") {
-            hi += sequenceToEnthalpyMap["initiationWithTerminalGC"];
-            si += sequenceToEntropyMap["initiationWithTerminalGC"];
+            hi += sequenceToEnthalpyMap.initiationWithTerminalGC;
+            si += sequenceToEntropyMap.initiationWithTerminalGC;
           } else if (seq[i] === "A" || seq[i] === "T") {
-            hi += sequenceToEnthalpyMap["initiationWithTerminalAT"];
-            si += sequenceToEntropyMap["initiationWithTerminalAT"];
+            hi += sequenceToEnthalpyMap.initiationWithTerminalAT;
+            si += sequenceToEntropyMap.initiationWithTerminalAT;
           }
         }
         if (i < seq.length - 1) {
@@ -16716,13 +16515,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           `${sequences.length} sequences received when 2 primers were expected`
         );
       }
-      const meltingTemperatures = sequences.map((seq) => {
-        const tm = calculateNebTm(seq, { monovalentCationConc, primerConc });
-        if (typeof tm !== "number") {
-          throw new Error(`Invalid Tm calculated for ${seq}: ${tm}`);
-        }
-        return tm;
-      });
+      const meltingTemperatures = sequences.map(
+        (seq) => calculateNebTm(seq, primerConc, { monovalentCationConc })
+      );
       meltingTemperatures.sort((a, b) => a - b);
       const lowerMeltingTemp = meltingTemperatures[0];
       let annealingTemp;
@@ -16799,17 +16594,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(isValidSequence, "isValidSequence");
   function calculateSantaLuciaTm(sequence) {
     try {
-      const seq = sequence == null ? void 0 : sequence.toUpperCase().trim();
-      if (!isValidSequence(seq)) {
+      sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+      if (!isValidSequence(sequence)) {
         throw new Error("Invalid sequence: contains non-DNA characters");
       }
-      if (seq.length < 2) {
+      if (sequence.length < 2) {
         throw new Error("Sequence too short: minimum length is 2 bases");
       }
       let deltaH = 0;
       let deltaS = 0;
-      for (let i = 0; i < seq.length - 1; i++) {
-        const dinucleotide = seq.substring(i, i + 2);
+      for (let i = 0; i < sequence.length - 1; i++) {
+        const dinucleotide = sequence.substring(i, i + 2);
         if (dinucleotide.includes("N")) {
           continue;
         }
@@ -16819,23 +16614,23 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           deltaS += params.dS;
         }
       }
-      const firstBase = seq[0];
-      const lastBase = seq[seq.length - 1];
+      const firstBase = sequence[0];
+      const lastBase = sequence[sequence.length - 1];
       if (firstBase === "G" || firstBase === "C") {
-        deltaH += SANTA_LUCIA_INIT["GC"].dH;
-        deltaS += SANTA_LUCIA_INIT["GC"].dS;
+        deltaH += SANTA_LUCIA_INIT.GC.dH;
+        deltaS += SANTA_LUCIA_INIT.GC.dS;
       } else {
-        deltaH += SANTA_LUCIA_INIT["AT"].dH;
-        deltaS += SANTA_LUCIA_INIT["AT"].dS;
+        deltaH += SANTA_LUCIA_INIT.AT.dH;
+        deltaS += SANTA_LUCIA_INIT.AT.dS;
       }
       if (lastBase === "G" || lastBase === "C") {
-        deltaH += SANTA_LUCIA_INIT["GC"].dH;
-        deltaS += SANTA_LUCIA_INIT["GC"].dS;
+        deltaH += SANTA_LUCIA_INIT.GC.dH;
+        deltaS += SANTA_LUCIA_INIT.GC.dS;
       } else {
-        deltaH += SANTA_LUCIA_INIT["AT"].dH;
-        deltaS += SANTA_LUCIA_INIT["AT"].dS;
+        deltaH += SANTA_LUCIA_INIT.AT.dH;
+        deltaS += SANTA_LUCIA_INIT.AT.dS;
       }
-      const nnPairs = seq.length - 1;
+      const nnPairs = sequence.length - 1;
       deltaS = applySaltCorrection(deltaS, nnPairs);
       const C = PRIMER3_PARAMS.dnaConc * 1e-9;
       const Tm = deltaH * 1e3 / (deltaS + PRIMER3_PARAMS.R * Math.log(C / 4));
@@ -16847,16 +16642,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(calculateSantaLuciaTm, "calculateSantaLuciaTm");
   function calculateEndStability(sequence) {
     try {
-      const seq = sequence == null ? void 0 : sequence.toUpperCase().trim();
-      if (!isValidSequence(seq)) {
+      sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+      if (!isValidSequence(sequence)) {
         throw new Error("Invalid sequence: contains non-DNA characters");
       }
-      if (seq.length < 5) {
+      if (sequence.length < 5) {
         throw new Error(
           "Sequence too short: minimum length is 5 bases for end stability calculation"
         );
       }
-      const last5Bases = seq.substring(seq.length - 5);
+      const last5Bases = sequence.substring(sequence.length - 5);
       let deltaH = 0;
       let deltaS = 0;
       for (let i = 0; i < 4; i++) {
@@ -16873,18 +16668,18 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       const firstBase = last5Bases[0];
       const lastBase = last5Bases[last5Bases.length - 1];
       if (firstBase === "G" || firstBase === "C") {
-        deltaH += SANTA_LUCIA_INIT["GC"].dH;
-        deltaS += SANTA_LUCIA_INIT["GC"].dS;
+        deltaH += SANTA_LUCIA_INIT.GC.dH;
+        deltaS += SANTA_LUCIA_INIT.GC.dS;
       } else {
-        deltaH += SANTA_LUCIA_INIT["AT"].dH;
-        deltaS += SANTA_LUCIA_INIT["AT"].dS;
+        deltaH += SANTA_LUCIA_INIT.AT.dH;
+        deltaS += SANTA_LUCIA_INIT.AT.dS;
       }
       if (lastBase === "G" || lastBase === "C") {
-        deltaH += SANTA_LUCIA_INIT["GC"].dH;
-        deltaS += SANTA_LUCIA_INIT["GC"].dS;
+        deltaH += SANTA_LUCIA_INIT.GC.dH;
+        deltaS += SANTA_LUCIA_INIT.GC.dS;
       } else {
-        deltaH += SANTA_LUCIA_INIT["AT"].dH;
-        deltaS += SANTA_LUCIA_INIT["AT"].dS;
+        deltaH += SANTA_LUCIA_INIT.AT.dH;
+        deltaS += SANTA_LUCIA_INIT.AT.dS;
       }
       const T = 310.15;
       const deltaG = deltaH - T * deltaS / 1e3;
@@ -16899,40 +16694,24 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const pairs = [];
     if (!cutsites.length) return [];
     let sortedCutsites = cutsites.sort((a, b) => {
-      return (a.topSnipPosition || 0) - (b.topSnipPosition || 0);
+      return a.topSnipPosition - b.topSnipPosition;
     });
     if (!circular) {
       sortedCutsites = [
         {
-          start: 0,
-          end: 0,
           topSnipPosition: 0,
           bottomSnipPosition: 0,
           overhangSize: 0,
           type: "START_OR_END_OF_SEQ",
-          name: "START_OF_SEQ",
-          restrictionEnzyme: {
-            name: "START_OF_SEQ",
-            site: "",
-            forwardRegex: "",
-            reverseRegex: ""
-          }
+          name: "START_OF_SEQ"
         },
         ...sortedCutsites,
         {
-          start: sequenceLength,
-          end: sequenceLength,
           topSnipPosition: sequenceLength,
           bottomSnipPosition: sequenceLength,
           overhangSize: 0,
           type: "START_OR_END_OF_SEQ",
-          name: "END_OF_SEQ",
-          restrictionEnzyme: {
-            name: "END_OF_SEQ",
-            site: "",
-            forwardRegex: "",
-            reverseRegex: ""
-          }
+          name: "END_OF_SEQ"
         }
       ];
     }
@@ -16955,11 +16734,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     });
     pairs.forEach(([cut1, cut2]) => {
       const start = normalizePositionByRangeLength(
-        cut1.topSnipPosition || 0,
+        cut1.topSnipPosition,
         sequenceLength
       );
       const end = normalizePositionByRangeLength(
-        (cut2.topSnipPosition || 0) - 1,
+        cut2.topSnipPosition - 1,
         sequenceLength
       );
       const fragmentRange = { start, end };
@@ -16977,9 +16756,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         })
       }, fragmentRange), {
         size,
-        id,
-        name: `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps`
-        // Add missing name property
+        id
       }));
     });
     fragments.filter((fragment) => {
@@ -16991,33 +16768,21 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return fragments;
   }
   __name(getDigestFragmentsForCutsites, "getDigestFragmentsForCutsites");
-  function getDigestFragmentsForRestrictionEnzymes(sequence, circular, contextEnzymes, options) {
-    const cutsitesByName = getCutsitesFromSequence(
-      sequence,
-      circular,
-      Array.isArray(contextEnzymes) ? contextEnzymes : [contextEnzymes]
-    );
-    const digest = computeDigestFragments(__spreadProps(__spreadValues({
-      cutsites: flatMap(cutsitesByName),
-      sequenceLength: sequence.length,
-      circular
-    }, options), {
-      computePartialDigest: (options == null ? void 0 : options.computePartialDigest) || (options == null ? void 0 : options.computePartialDigests)
-    }));
-    const fragments = uniqBy(digest.fragments, (fragment) => {
-      return `${fragment.start}-${fragment.end}-${fragment.size}`;
-    });
-    if (circular && ((options == null ? void 0 : options.computePartialDigest) || (options == null ? void 0 : options.computePartialDigests))) {
-      const fullLengthFragmentIndex = fragments.findIndex(
-        (f) => f.size === sequence.length
+  function getDigestFragmentsForRestrictionEnzymes(sequence, circular, restrictionEnzymeOrEnzymes, opts) {
+    const restrictionEnzymes = Array.isArray(restrictionEnzymeOrEnzymes) ? restrictionEnzymeOrEnzymes : [restrictionEnzymeOrEnzymes];
+    const cutsites = flatMap(restrictionEnzymes, (restrictionEnzyme) => {
+      return cutSequenceByRestrictionEnzyme(
+        sequence,
+        circular,
+        restrictionEnzyme
       );
-      if (fullLengthFragmentIndex > -1) {
-        fragments.splice(fullLengthFragmentIndex, 1);
-      }
-    }
-    return fragments.sort((a, b) => {
-      return a.start - b.start || b.size - a.size;
     });
+    return getDigestFragmentsForCutsites(
+      sequence.length,
+      circular,
+      cutsites,
+      opts
+    );
   }
   __name(getDigestFragmentsForRestrictionEnzymes, "getDigestFragmentsForRestrictionEnzymes");
   function convertAACaretPositionOrRangeToDna(rangeOrCaret) {
@@ -17063,13 +16828,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }) {
     modifiableTypes.forEach((annotationType) => {
       const existingAnnotations = seqData[annotationType];
-      if (existingAnnotations) {
-        seqData[annotationType] = adjustAnnotationsToInsert(
-          existingAnnotations,
-          caretPosition,
-          insertLength
-        );
-      }
+      seqData[annotationType] = adjustAnnotationsToInsert(
+        existingAnnotations,
+        caretPosition,
+        insertLength
+      );
     });
   }
   __name(shiftAnnotationsByLen, "shiftAnnotationsByLen");
@@ -17139,7 +16902,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   exports2.getMergedFeatureMap = getMergedFeatureMap;
   exports2.getOrfsFromSequence = getOrfsFromSequence;
   exports2.getOverlapBetweenTwoSequences = getOverlapBetweenTwoSequences;
-  exports2.getPossiblePartsFromSequenceAndEnzymes = getPossiblePartsFromSequenceAndEnzymes;
+  exports2.getPossiblePartsFromSequenceAndEnzymes = getPossiblePartsFromSequenceAndEnzyme;
   exports2.getReverseAminoAcidStringFromSequenceString = getReverseAminoAcidStringFromSequenceString;
   exports2.getReverseComplementAminoAcidStringFromSequenceString = getReverseComplementAminoAcidStringFromSequenceString;
   exports2.getReverseComplementAnnotation = getReverseComplementAnnotation;