@teselagen/sequence-utils 0.3.37 → 0.3.38-beta.2

package/index.umd.cjs

@@ -2590,9 +2590,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       }
     }
+    return null;
   }
   __name(getOverlapOfNonCircularRanges, "getOverlapOfNonCircularRanges");
-  function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible) {
+  function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible = false) {
     const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
       rangeA,
       maxRangeLength
@@ -2613,6 +2614,22 @@ 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");
@@ -2684,10 +2701,7 @@ 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) {
@@ -2730,6 +2744,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         end: outputTrimmedRange.end
       });
     }
+    return void 0;
   }
   __name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
   function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, maxLength) {
@@ -2876,28 +2891,36 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
       }
     }
+    return overlaps;
   }
   __name(collapseOverlapsGeneratedFromRangeComparisonIfPossible, "collapseOverlapsGeneratedFromRangeComparisonIfPossible");
   function provideInclusiveOptions(funToWrap) {
-    return function() {
-      const args = Array.prototype.slice.call(arguments);
+    return function(...args) {
       const options = args[args.length - 1];
       if (options && (options.inclusive1BasedEnd || options.inclusive1BasedStart)) {
         args.forEach(function(arg, index) {
-          if (arg && arg.start > -1 && options.inclusive1BasedStart) {
-            args[index] = assign(arg, { start: arg.start - 1 });
+          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.end > -1 && options.inclusive1BasedEnd) {
-            args[index] = assign(arg, { end: arg.end - 1 });
+          if (potentialRange && typeof potentialRange.end === "number" && potentialRange.end > -1 && options.inclusive1BasedEnd) {
+            args[index] = assign(potentialRange, {
+              end: potentialRange.end - 1
+            });
           }
         });
       }
       let returnVal = funToWrap.apply(this, args);
-      if (returnVal && returnVal.start > -1 && options && options.inclusive1BasedStart) {
-        returnVal = assign(returnVal, { start: returnVal.start + 1 });
+      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.end > -1 && options && options.inclusive1BasedEnd) {
-        returnVal = assign(returnVal, { end: returnVal.end + 1 });
+      if (potentialReturn && typeof potentialReturn.end === "number" && potentialReturn.end > -1 && options && options.inclusive1BasedEnd) {
+        returnVal = assign(potentialReturn, { end: potentialReturn.end + 1 });
       }
       return returnVal;
     };
@@ -2943,7 +2966,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return positionFits;
   }
   __name(isPositionWithinRange, "isPositionWithinRange");
-  function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions) {
+  function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions = false) {
     let position = pPosition;
     if (position < 0) {
       position += sequenceLength;
@@ -3123,7 +3146,9 @@ 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 {
@@ -3143,7 +3168,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
   function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
-    let yOffset = [];
+    let yOffset = 0;
     const openYOffsetFound = YOffsetLevelsWithRanges.some(
       function(rangesAlreadyAddedToYOffset, index) {
         const rangeBlocked = rangesAlreadyAddedToYOffset.some(
@@ -3156,6 +3181,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         );
         if (!rangeBlocked) {
           yOffset = index;
+          if (assignYOffsetToRange) range.yOffset = index;
           rangesAlreadyAddedToYOffset.push(range);
           return true;
         }
@@ -3164,6 +3190,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     );
     if (!openYOffsetFound) {
       yOffset = YOffsetLevelsWithRanges.length;
+      if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length;
     }
     return yOffset;
   }
@@ -3175,7 +3202,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     ranges.forEach(function(range) {
       const yOffset = getYOffsetForPotentiallyCircularRange(
         range,
-        yOffsetLevels
+        yOffsetLevels,
+        assignYOffsetToRange
       );
       yOffsets.push(yOffset);
       if (yOffset > maxYOffset) {
@@ -3190,21 +3218,20 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(getYOffsetsForPotentiallyCircularRanges, "getYOffsetsForPotentiallyCircularRanges");
   const invertRange = provideInclusiveOptions(invertRange$1);
   function invertRange$1(rangeOrCaret, rangeMax) {
-    if (rangeOrCaret.start > -1) {
+    if (typeof rangeOrCaret !== "number" && rangeOrCaret.start > -1) {
       const start = rangeOrCaret.end + 1;
       const end = rangeOrCaret.start - 1;
       return {
         start: normalizePositionByRangeLength(start, rangeMax, false),
         end: normalizePositionByRangeLength(end, rangeMax, false)
       };
-    } else {
-      if (rangeOrCaret > -1) {
-        return {
-          start: normalizePositionByRangeLength(rangeOrCaret, rangeMax, false),
-          end: normalizePositionByRangeLength(rangeOrCaret - 1, rangeMax, false)
-        };
-      }
+    } else if (typeof rangeOrCaret === "number" && 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) {
@@ -3258,9 +3285,10 @@ 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 = {};
-    newSubrange.start = subRange.start - containerRange.start;
-    newSubrange.end = subRange.end - containerRange.start;
+    const newSubrange = {
+      start: subRange.start - containerRange.start,
+      end: subRange.end - containerRange.start
+    };
     if (newSubrange.start < 0) {
       newSubrange.start += sequenceLength;
     }
@@ -3271,10 +3299,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(zeroSubrangeByContainerRange, "zeroSubrangeByContainerRange");
   function adjustRangeToRotation(rangeToBeAdjusted, rotateTo = 0, rangeLength) {
-    const mod = rangeLength ? modulo : identity;
+    const mod = /* @__PURE__ */ __name((n) => rangeLength ? modulo(n, rangeLength) : n, "mod");
     const newRange = assign({}, rangeToBeAdjusted, {
-      start: mod(rangeToBeAdjusted.start - (rotateTo || 0), rangeLength),
-      end: mod(rangeToBeAdjusted.end - (rotateTo || 0), rangeLength)
+      start: mod(rangeToBeAdjusted.start - (rotateTo || 0)),
+      end: mod(rangeToBeAdjusted.end - (rotateTo || 0))
     });
     return newRange;
   }
@@ -3360,7 +3388,11 @@ 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 {
@@ -3380,13 +3412,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
                 };
                 const range = {
                   start: matchStart,
-                  end: normalizePositionByRangeLength(matchEnd - 1, seqLen2)
+                  end: normalizePositionByRangeLength(matchEnd - 1, seqLen2, false)
                 };
                 if (!annotationsToAddBySeqId[id])
                   annotationsToAddBySeqId[id] = [];
                 annotationsToAddBySeqId[id].push(__spreadProps(__spreadValues({}, isReverse ? {
-                  start: reversePositionInRange(range.end, seqLen2),
-                  end: reversePositionInRange(range.start, seqLen2)
+                  start: reversePositionInRange(range.end, seqLen2, false),
+                  end: reversePositionInRange(range.start, seqLen2, false)
                 } : range), {
                   strand: isReverse ? -1 : 1,
                   id: ann.id
@@ -3417,14 +3449,22 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       const origSeq = seqsToAnnotateById[id];
       const alreadyExistingAnnsByStartEnd = {};
       forEach(origSeq.annotations, (ann) => {
-        alreadyExistingAnnsByStartEnd[getStartEndStr(ann, { compareName })] = ann;
+        alreadyExistingAnnsByStartEnd[getStartEndStr(
+          __spreadProps(__spreadValues({}, ann), { strand: typeof ann.strand === "string" ? 1 : ann.strand }),
+          { compareName }
+        )] = ann;
       });
       const warningCounter = {};
       const toAdd = anns.filter((ann) => {
-        const alreadyExistingAnn = alreadyExistingAnnsByStartEnd[getStartEndStr(ann, { compareName })];
+        const alreadyExistingAnn = alreadyExistingAnnsByStartEnd[getStartEndStr(
+          __spreadProps(__spreadValues({}, ann), {
+            strand: typeof ann.strand === "string" ? 1 : ann.strand
+          }),
+          { compareName }
+        )];
         if (alreadyExistingAnn) return false;
-        if (warnIfMoreThan) {
-          warningCounter[ann.id] = (warningCounter[ann.id] || 0) + 1;
+        if (warnIfMoreThan && ann.id !== void 0) {
+          warningCounter[String(ann.id)] = (warningCounter[String(ann.id)] || 0) + 1;
         }
         return true;
       }).sort((a, b) => a.start - b.start);
@@ -3433,16 +3473,23 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       }
       warnIfMoreThan && forEach(warningCounter, (num, annId) => {
         if (num > warnIfMoreThan) {
-          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);
+          const warnings = toReturn["__more_than_warnings"] || {};
+          warnings[id] = warnings[id] || [];
+          warnings[id].push(annId);
+          toReturn["__more_than_warnings"] = warnings;
         }
       });
     });
     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 : ""}`;
   }
@@ -3456,13 +3503,12 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     let hitLeftCaret;
     let hitRightCaret;
     for (const bp of regString.replace("(", "").replace(")", "")) {
-      let maybeHandleRightCaret = function(justAdded) {
+      let maybeHandleRightCaret = /* @__PURE__ */ __name(function(justAdded) {
         if (hitRightCaret) {
           rightOfCaretHolder += justAdded;
           afterRightCaretHolder = `${rightOfCaretHolder}${afterRightCaretHolder.length ? "|" : ""}${afterRightCaretHolder}`;
         }
-      };
-      __name(maybeHandleRightCaret, "maybeHandleRightCaret");
+      }, "maybeHandleRightCaret");
       const ambigVal = ambiguous_dna_values[bp.toUpperCase()];
       if (ambigVal && ambigVal.length > 1) {
         let valToUse;
@@ -3647,16 +3693,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       })),
       "name"
     );
-    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 featureOverrides = typeof window !== "undefined" && get$1(window, "tg_featureTypeOverrides") || typeof global !== "undefined" && get$1(global, "tg_featureTypeOverrides") || [];
+    const mappedOverrides = featureOverrides.map((fo) => {
       const originalGenbankFeat = keyedGBFeats[fo.name];
       return __spreadValues(__spreadValues(__spreadValues({}, originalGenbankFeat), fo), originalGenbankFeat ? { isOverridden: true } : { isCustomType: true });
     });
-    featureOverrides = keyBy(featureOverrides, "name");
-    return __spreadValues(__spreadValues({}, keyedGBFeats), featureOverrides);
+    const keyedOverrides = keyBy(mappedOverrides, "name");
+    return __spreadValues(__spreadValues({}, keyedGBFeats), keyedOverrides);
   }, "getMergedFeatureMap");
-  const getFeatureToColorMap = /* @__PURE__ */ __name(({ includeHidden } = {}) => {
+  const getFeatureToColorMap = /* @__PURE__ */ __name(({
+    includeHidden
+  } = {}) => {
     const toRet = {};
     filter(
       getMergedFeatureMap(),
@@ -3666,7 +3713,9 @@ 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) {
@@ -3971,10 +4020,15 @@ 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.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;
+    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;
     }
     const forwardRegExpPattern = new RegExp(restrictionEnzyme.forwardRegex, "ig");
     const sequence = pSequence;
@@ -3999,54 +4053,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 = reversePositionInRange(
-        cutsite.topSnipPosition,
-        rangeLength,
-        true
-      );
-      cutsite.bottomSnipPosition = reversePositionInRange(
-        cutsite.bottomSnipPosition,
-        rangeLength,
-        true
-      );
-      if (cutsite.cutsTwice) {
-        cutsite.upstreamTopSnip = reversePositionInRange(
-          cutsite.upstreamTopSnip,
+      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,
           rangeLength,
-          true
+          false
         );
-        cutsite.upstreamBottomSnip = reversePositionInRange(
-          cutsite.upstreamBottomSnip,
+        cutsite.recognitionSiteRange.end = reversePositionInRange(
+          cutsite.recognitionSiteRange.end,
           rangeLength,
-          true
+          false
         );
       }
-      cutsite.recognitionSiteRange.start = reversePositionInRange(
-        cutsite.recognitionSiteRange.start,
-        rangeLength,
-        false
-      );
-      cutsite.recognitionSiteRange.end = reversePositionInRange(
-        cutsite.recognitionSiteRange.end,
-        rangeLength,
-        false
-      );
-      return assign({}, cutsite, {
+      return __spreadProps(__spreadValues({}, 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: {
+        recognitionSiteRange: cutsite.recognitionSiteRange ? {
           start: cutsite.recognitionSiteRange.end,
           end: cutsite.recognitionSiteRange.start
-        },
+        } : void 0,
         forward: false
       });
     }
@@ -4058,7 +4112,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     let restrictionCutSite;
     const recognitionSiteLength = restrictionEnzyme.site.length;
     const originalSequence = sequence;
-    const originalSequenceLength = sequence.length;
+    const originalSequenceLengthVal = sequence.length;
     if (circular) {
       sequence += sequence;
     }
@@ -4067,7 +4121,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     let startIndex = 0;
     let subSequence = sequence;
     while (matchIndex !== -1) {
-      const recognitionSiteRange = {};
+      const recognitionSiteRange = {
+        start: 0,
+        end: 0
+      };
       let start;
       let end;
       let upstreamTopSnip = null;
@@ -4082,37 +4139,39 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       recognitionSiteRange.end = matchIndex + recognitionSiteLength - 1 + startIndex;
       end = recognitionSiteRange.end;
       if (restrictionEnzyme.cutType === 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;
+        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;
+              }
             }
-            upstreamTopBeforeBottom = true;
+            upstreamTopSnip = normalizePositionByRangeLength(
+              upstreamTopSnip,
+              originalSequenceLengthVal,
+              true
+            );
+            upstreamBottomSnip = normalizePositionByRangeLength(
+              upstreamBottomSnip,
+              originalSequenceLengthVal,
+              true
+            );
           } else {
-            if (start > upstreamBottomSnip) {
-              start = upstreamBottomSnip + 1;
-            }
+            upstreamTopSnip = null;
+            upstreamBottomSnip = null;
           }
-          upstreamTopSnip = normalizePositionByRangeLength(
-            upstreamTopSnip,
-            originalSequenceLength,
-            true
-          );
-          upstreamBottomSnip = normalizePositionByRangeLength(
-            upstreamBottomSnip,
-            originalSequenceLength,
-            true
-          );
-        } else {
-          upstreamTopSnip = null;
-          upstreamBottomSnip = null;
         }
       }
-      topSnipPosition = recognitionSiteRange.start + restrictionEnzyme.topSnipOffset;
-      bottomSnipPosition = recognitionSiteRange.start + restrictionEnzyme.bottomSnipOffset;
+      topSnipPosition = recognitionSiteRange.start + (restrictionEnzyme.topSnipOffset || 0);
+      bottomSnipPosition = recognitionSiteRange.start + (restrictionEnzyme.bottomSnipOffset || 0);
       if (bottomSnipPosition <= currentSequenceLength && topSnipPosition <= currentSequenceLength) {
         fitsWithinSequence = true;
         if (topSnipPosition > bottomSnipPosition) {
@@ -4127,61 +4186,70 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         }
         topSnipPosition = normalizePositionByRangeLength(
           topSnipPosition,
-          originalSequenceLength,
+          originalSequenceLengthVal,
           true
         );
         bottomSnipPosition = normalizePositionByRangeLength(
           bottomSnipPosition,
-          originalSequenceLength,
+          originalSequenceLengthVal,
           true
         );
       } else {
         topSnipPosition = null;
         bottomSnipPosition = null;
       }
-      if (fitsWithinSequence && start >= 0 && end >= 0 && start < originalSequenceLength && end < currentSequenceLength) {
+      if (fitsWithinSequence && start >= 0 && end >= 0 && start < originalSequenceLengthVal && end < currentSequenceLength) {
         start = normalizePositionByRangeLength(
           start,
-          originalSequenceLength,
+          originalSequenceLengthVal,
+          false
+        );
+        end = normalizePositionByRangeLength(
+          end,
+          originalSequenceLengthVal,
           false
         );
-        end = normalizePositionByRangeLength(end, originalSequenceLength, false);
         recognitionSiteRange.start = normalizePositionByRangeLength(
           recognitionSiteRange.start,
-          originalSequenceLength,
+          originalSequenceLengthVal,
           false
         );
         recognitionSiteRange.end = normalizePositionByRangeLength(
           recognitionSiteRange.end,
-          originalSequenceLength,
+          originalSequenceLengthVal,
           false
         );
         let cutRange = {
           start: -1,
           end: -1
         };
-        if (topSnipPosition !== bottomSnipPosition) {
+        if (topSnipPosition !== null && bottomSnipPosition !== null && topSnipPosition !== bottomSnipPosition) {
           cutRange = topSnipBeforeBottom ? {
             start: topSnipPosition,
             end: normalizePositionByRangeLength(
               bottomSnipPosition - 1,
-              originalSequenceLength
+              originalSequenceLengthVal
             )
           } : {
             start: bottomSnipPosition,
             end: normalizePositionByRangeLength(
               topSnipPosition - 1,
-              originalSequenceLength
+              originalSequenceLengthVal
             )
           };
         }
-        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,
@@ -4203,16 +4271,19 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return restrictionCutSites;
   }
   __name(cutSequence, "cutSequence");
-  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;
+  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] = [];
       }
-    }
-    return cutsitesByName;
+      cutsitesByNameMap[name].push(cutsite);
+    });
+    return cutsitesByNameMap;
   }
   __name(getCutsitesFromSequence, "getCutsitesFromSequence");
   function computeDigestFragments({
@@ -4230,9 +4301,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const fragments = [];
     const overlappingEnzymes = [];
     const pairs = [];
-    const sortedCutsites = cutsites.sort((a, b) => {
-      return a.topSnipPosition - b.topSnipPosition;
-    });
+    const sortedCutsites = cutsites.filter(
+      (c) => c.topSnipPosition != null && c.bottomSnipPosition != null
+    );
     if (!circular && cutsites.length) {
       sortedCutsites.push({
         id: "seqTerm_" + shortid(),
@@ -4241,6 +4312,8 @@ 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,
@@ -4251,26 +4324,34 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         },
         forward: true,
         name: "Sequence_Terminus",
+        type: "START_OR_END_OF_SEQ",
         restrictionEnzyme: {
-          name: "Sequence_Terminus"
+          name: "Sequence_Terminus",
+          site: "",
+          forwardRegex: "",
+          reverseRegex: ""
         }
       });
     }
+    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) => {
-          if (index2 === index + 1 || index2 === 0) {
+          const isAdjacent = index2 === index + 1 || index === sortedCutsites.length - 1 && index2 === 0;
+          if (isAdjacent) {
             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;
@@ -4315,12 +4396,17 @@ 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 === cut2,
+        madeFromOneCutsite: cut1.id === cut2.id,
         start,
         end,
         size,
@@ -4361,12 +4447,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     includeOverAndUnderHangs
   }) {
     const cutsitesByName = getCutsitesFromSequence(sequence, circular, enzymes);
-    return computeDigestFragments({
+    const digest = 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) {
@@ -5935,7 +6023,8 @@ 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;
@@ -5981,10 +6070,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     if (aa) {
       return aa;
     }
-    const letter = degenerateDnaToAminoAcidMap[
-      sequenceString.replace("x", "n")
-      //replace x's with n's as those are equivalent dna chars
-    ] || "x";
+    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"
+    );
     return proteinAlphabet[letter.toUpperCase()];
   }
   __name(getAminoAcidFromSequenceTriplet, "getAminoAcidFromSequenceTriplet");
@@ -6381,25 +6473,25 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     circular,
     name
   }) {
-    location.start = parseInt(location.start, 10);
-    location.end = parseInt(location.end, 10);
+    location.start = parseInt(String(location.start), 10);
+    location.end = parseInt(String(location.end), 10);
     if (convertAnnotationsFromAAIndices) {
       location.start = location.start * 3;
       location.end = location.end * 3 + 2;
     }
-    if (location.start < 0 || !(location.start <= size - 1) || location.start > size - 1) {
+    if (size !== void 0 && (location.start < 0 || 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 (location.end < 0 || !(location.end <= size - 1) || location.end > size - 1) {
+    if (size !== void 0 && (location.end < 0 || 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 (location.start > location.end && circular === false) {
+    if (size !== void 0 && location.start > location.end && circular === false) {
       messages.push(
         "Invalid circular annotation detected for " + name + ". end set to 1"
       );
@@ -6408,21 +6500,30 @@ 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, { doNotExcludeAsterisk } = {}) {
+  function getAminoAcidStringFromSequenceString(sequenceString, options = {}) {
+    const { doNotExcludeAsterisk } = options;
     const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
       sequenceString,
-      true
+      true,
+      null,
+      false
     );
     const aaArray = [];
     let aaString = "";
     aminoAcidsPerBase.forEach((aa, index) => {
+      var _a;
       if (!aa.fullCodon) {
         return;
       }
-      if (!doNotExcludeAsterisk && index >= aminoAcidsPerBase.length - 3 && aa.aminoAcid.value === "*") {
+      if (!doNotExcludeAsterisk && index >= aminoAcidsPerBase.length - 3 && ((_a = aa.aminoAcid) == null ? void 0 : _a.value) === "*") {
+        return;
+      }
+      if (aa.aminoAcidIndex === null || !aa.aminoAcid) {
         return;
       }
       aaArray[aa.aminoAcidIndex] = aa.aminoAcid.value;
@@ -6449,7 +6550,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       messages: []
     };
     if (!seqData) {
-      seqData = {};
+      seqData = { sequence: "" };
     }
     if (!seqData.sequence) {
       seqData.sequence = "";
@@ -6512,25 +6613,27 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const featureTypes = getFeatureTypes();
     annotationTypes.forEach((annotationType) => {
       if (!Array.isArray(seqData[annotationType])) {
-        if (typeof seqData[annotationType] === "object") {
-          seqData[annotationType] = Object.keys(seqData[annotationType]).map(
-            (key) => {
-              return seqData[annotationType][key];
-            }
-          );
+        if (seqData[annotationType] && 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) => {
@@ -6538,7 +6641,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,
@@ -6548,8 +6651,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         if (!expandedRange.aminoAcids && !seqData.noSequence) {
           expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
             seqData.sequence,
-            expandedRange.forward,
-            expandedRange
+            expandedRange.forward || false,
+            expandedRange,
+            false
           );
         }
         return expandedRange;
@@ -6557,19 +6661,22 @@ 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) {
@@ -6579,17 +6686,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(tidyUpSequenceData, "tidyUpSequenceData");
   const getDiffFromSeqs = /* @__PURE__ */ __name((oldData, newData, { ignoreKeys = [] } = {}) => {
-    oldData = tidyUpSequenceData(oldData, {
+    const cleanedOldData = tidyUpSequenceData(oldData, {
       annotationsAsObjects: true,
       noTranslationData: true,
       doNotRemoveInvalidChars: true
     });
-    newData = tidyUpSequenceData(newData, {
+    const cleanedNewData = tidyUpSequenceData(newData, {
       annotationsAsObjects: true,
       noTranslationData: true,
       doNotRemoveInvalidChars: true
     });
-    [oldData, newData].forEach((d) => {
+    [cleanedOldData, cleanedNewData].forEach((d) => {
       [
         "cutsites",
         "orfs",
@@ -6612,27 +6719,26 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         });
       }
     });
-    return diff(oldData, newData);
+    return diff(cleanedOldData, cleanedNewData);
   }, "getDiffFromSeqs");
-  const patchSeqWithDiff = /* @__PURE__ */ __name((oldData, diff2, { ignoreKeys = [] } = {}) => {
+  const patchSeqWithDiff = /* @__PURE__ */ __name((oldData, diffData, { ignoreKeys = [] } = {}) => {
     ignoreKeys.forEach((k) => {
-      delete diff2[k];
+      delete diffData[k];
     });
-    return patch(
-      tidyUpSequenceData(cloneDeep(oldData), {
-        annotationsAsObjects: true,
-        doNotRemoveInvalidChars: true
-      }),
-      diff2
-    );
+    const tidyOld = tidyUpSequenceData(cloneDeep(oldData), {
+      annotationsAsObjects: true,
+      doNotRemoveInvalidChars: true
+    });
+    return patch(tidyOld, diffData);
   }, "patchSeqWithDiff");
-  const reverseSeqDiff = /* @__PURE__ */ __name((diff2) => {
-    return reverse(diff2);
+  const reverseSeqDiff = /* @__PURE__ */ __name((diffData) => {
+    return reverse(diffData);
   }, "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;
@@ -6676,14 +6782,19 @@ 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]: __spreadProps(__spreadValues({}, fullSeq), {
-          id: fullSeqId
-        })
+        [fullSeqId]: {
+          sequence: fullSeq.sequence,
+          circular: fullSeq.circular,
+          annotations: fullSeq.features || []
+        }
       },
       annotationsToCheckById: {
         [searchSeqId]: __spreadProps(__spreadValues({}, searchSeq), {
@@ -6733,7 +6844,9 @@ 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({
@@ -6748,7 +6861,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const overlappingEnzymes = [];
     const pairs = [];
     const sortedCutsites = cutsites.sort((a, b) => {
-      return a.topSnipPosition - b.topSnipPosition;
+      return (a.topSnipPosition || 0) - (b.topSnipPosition || 0);
     });
     sortedCutsites.forEach((cutsite1, index) => {
       if (computePartialDigest && !computePartialDigestDisabled) {
@@ -6765,11 +6878,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     });
     pairs.forEach(([cut1, cut2]) => {
       const start = normalizePositionByRangeLength(
-        cut1.topSnipPosition,
+        cut1.topSnipPosition || 0,
         sequenceLength
       );
       const end = normalizePositionByRangeLength(
-        cut2.topSnipPosition - 1,
+        (cut2.topSnipPosition || 0) - 1,
         sequenceLength
       );
       if (!isCircular && start > end) {
@@ -6783,6 +6896,7 @@ 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,
@@ -6793,6 +6907,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
               name: "Start Of Seq"
             }
           },
+          // Cast
           cut2
         };
         fragments.push(addSizeIdName(frag1, sequenceLength));
@@ -6895,27 +7010,18 @@ 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 (caretPositionOrRange && caretPositionOrRange.start > -1) {
+    if (typeof caretPositionOrRange !== "number" && caretPositionOrRange && caretPositionOrRange.start > -1) {
       if (getRangeLength(caretPositionOrRange, bpString.length) === bpString.length) {
         return insertString;
       }
       const ranges = splitRangeIntoTwoPartsIfItIsCircular(
-        invertRange(caretPositionOrRange, bpString.length)
+        invertRange(
+          caretPositionOrRange,
+          bpString.length
+        ),
+        bpString.length
       );
       stringToReturn = "";
       ranges.forEach((range, index) => {
@@ -6941,6 +7047,16 @@ 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;
   }
@@ -6966,11 +7082,17 @@ 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) {
@@ -6986,11 +7108,14 @@ 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"));
@@ -7024,7 +7149,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,
@@ -7043,7 +7168,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,
@@ -7062,7 +7187,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,
@@ -7085,39 +7210,6 @@ 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.
@@ -7125,7 +7217,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,
@@ -7144,7 +7236,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,
@@ -7163,7 +7255,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,
@@ -7197,14 +7289,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;
@@ -7224,7 +7316,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;
@@ -7259,11 +7351,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.apply(arr, arr.splice(0, count));
+    arr.push(...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));
@@ -7311,16 +7403,24 @@ 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 = caretPositionOrRange;
-    const isInsertSameLengthAsSelection = sequenceDataToInsert.sequence.length === getRangeLength(caretPositionOrRange, existingSequenceData.sequence.length);
-    if (caretPositionOrRange.start > -1 && getRangeLength(
+    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(
       caretPositionOrRange,
       existingSequenceData.sequence.length
     ) === existingSequenceData.sequence.length) {
+      const emptyAnnotations = modifiableTypes.reduce(
+        (acc, type) => {
+          acc[type] = [];
+          return acc;
+        },
+        {}
+      );
       existingSequenceData = tidyUpSequenceData(
-        __spreadProps(__spreadValues(__spreadValues({}, existingSequenceData), modifiableTypes.reduce((acc, type) => {
-          return acc[type] = [];
-        }, {})), {
+        __spreadProps(__spreadValues(__spreadValues({}, existingSequenceData), emptyAnnotations), {
           sequence: "",
           doNotRemoveInvalidChars: true,
           proteinSequence: "",
@@ -7330,7 +7430,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       );
       newSequenceData.chromatogramData = void 0;
     } else if (newSequenceData.chromatogramData && newSequenceData.chromatogramData.baseTraces) {
-      if (caretPositionOrRange && caretPositionOrRange.start > -1) {
+      if (typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > -1) {
         if (caretPositionOrRange.start > caretPositionOrRange.end) {
           newSequenceData.chromatogramData = trimChromatogram({
             chromatogramData: newSequenceData.chromatogramData,
@@ -7340,14 +7440,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
             },
             justBaseCalls: isInsertSameLengthAsSelection
           });
-          newSequenceData.chromatogramData = trimChromatogram({
-            chromatogramData: newSequenceData.chromatogramData,
-            range: {
-              start: 0,
-              end: caretPositionOrRange.end
-            },
-            justBaseCalls: isInsertSameLengthAsSelection
-          });
+          if (newSequenceData.chromatogramData) {
+            newSequenceData.chromatogramData = trimChromatogram({
+              chromatogramData: newSequenceData.chromatogramData,
+              range: {
+                start: 0,
+                end: caretPositionOrRange.end
+              },
+              justBaseCalls: isInsertSameLengthAsSelection
+            });
+          }
         } else {
           newSequenceData.chromatogramData = trimChromatogram({
             chromatogramData: newSequenceData.chromatogramData,
@@ -7359,10 +7461,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           });
         }
       }
-      if (sequenceDataToInsert.sequence) {
+      if (sequenceDataToInsert.sequence && newSequenceData.chromatogramData) {
         insertIntoChromatogram({
           chromatogramData: newSequenceData.chromatogramData,
-          caretPosition: caretPositionOrRange.start > -1 ? caretPositionOrRange.start : caretPositionOrRange,
+          caretPosition: typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > -1 ? caretPositionOrRange.start : caretPositionOrRange,
           seqToInsert: sequenceDataToInsert.sequence,
           justBaseCalls: isInsertSameLengthAsSelection
         });
@@ -7375,14 +7477,15 @@ 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 (caretPositionOrRange && caretPositionOrRange.start > -1) {
+      if (!existingAnnotations) return;
+      if (typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > -1) {
         const range = caretPositionOrRange;
         caretPosition = range.start > range.end ? 0 : range.start;
         existingAnnotations = adjustAnnotationsToDelete(
@@ -7392,22 +7495,23 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         );
       }
       newSequenceData[annotationType] = [];
-      newSequenceData[annotationType] = newSequenceData[annotationType].concat(
-        adjustAnnotationsToInsert(
-          existingAnnotations,
-          caretPosition,
-          insertLength
-        )
-      );
-      newSequenceData[annotationType] = newSequenceData[annotationType].concat(
-        adjustAnnotationsToInsert(
-          sequenceDataToInsert[annotationType],
-          0,
-          caretPosition
-        )
-      );
+      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)
+          );
+        }
+      }
     });
-    if (maintainOriginSplit && caretPositionOrRange && caretPositionOrRange.start > caretPositionOrRange.end) {
+    if (maintainOriginSplit && typeof caretPositionOrRange !== "number" && caretPositionOrRange.start > caretPositionOrRange.end) {
       const caretPosToRotateTo = existingSequenceData.sequence.length - caretPositionOrRange.start;
       return rotateSequenceDataToPosition(
         newSequenceData,
@@ -7425,6 +7529,7 @@ 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,
@@ -7443,11 +7548,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     justBaseCalls
   }) {
     if (!seqToInsert.length) return;
-    chromatogramData.baseCalls && chromatogramData.baseCalls.splice(
-      caretPosition,
-      0,
-      ...seqToInsert.split("")
-    );
+    if (chromatogramData.baseCalls) {
+      chromatogramData.baseCalls.splice(
+        caretPosition,
+        0,
+        ...seqToInsert.split("")
+      );
+    }
     if (justBaseCalls) {
       return chromatogramData;
     }
@@ -7463,8 +7570,20 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         tTrace: toPush
       });
     }
-    chromatogramData.baseTraces && chromatogramData.baseTraces.splice(caretPosition, 0, ...baseTracesToInsert);
-    chromatogramData.qualNums && chromatogramData.qualNums.splice(caretPosition, 0, ...qualNumsToInsert);
+    if (chromatogramData.baseTraces) {
+      chromatogramData.baseTraces.splice(
+        caretPosition,
+        0,
+        ...baseTracesToInsert
+      );
+    }
+    if (chromatogramData.qualNums) {
+      chromatogramData.qualNums.splice(
+        caretPosition,
+        0,
+        ...qualNumsToInsert
+      );
+    }
     return chromatogramData;
   }
   __name(insertIntoChromatogram, "insertIntoChromatogram");
@@ -7477,17 +7596,23 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       "baseCalls",
       ...justBaseCalls ? [] : ["qualNums", "baseTraces", "basePos"]
     ].forEach((type) => {
-      chromatogramData[type] && chromatogramData[type].splice(start, end - start + 1);
+      if (chromatogramData[type]) {
+        chromatogramData[type].splice(start, end - start + 1);
+      }
     });
     return chromatogramData;
   }
   __name(trimChromatogram, "trimChromatogram");
   function deleteSequenceDataAtRange(sequenceData, range) {
-    return insertSequenceDataAtPositionOrRange({}, sequenceData, range);
+    return insertSequenceDataAtPositionOrRange(
+      { sequence: "" },
+      sequenceData,
+      range
+    );
   }
   __name(deleteSequenceDataAtRange, "deleteSequenceDataAtRange");
   function doesEnzymeChopOutsideOfRecognitionSite(enzyme) {
-    if (enzyme.topSnipOffset > enzyme.site.length || enzyme.bottomSnipOffset > enzyme.site.length) {
+    if (enzyme.topSnipOffset && enzyme.bottomSnipOffset && (enzyme.topSnipOffset > enzyme.site.length || enzyme.bottomSnipOffset > enzyme.site.length)) {
       return true;
     } else {
       return false;
@@ -15119,10 +15244,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[annotation.id] = annotation;
+      result.push(annotation);
     }
     return result;
   }
@@ -15150,16 +15275,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 ? void 0 : generateAnnotations(
+      translations: isProtein ? [] : generateAnnotations(
         numTranslations || 5,
         0,
         sequenceLength - 1,
@@ -15171,7 +15296,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         sequenceLength - 1,
         sequenceLength / 3
       ),
-      primers: isProtein ? void 0 : generateAnnotations(numPrimers || 10, 0, sequenceLength - 1, 50),
+      primers: isProtein ? [] : generateAnnotations(numPrimers || 10, 0, sequenceLength - 1, 50),
       parts: generateAnnotations(
         numParts || 10,
         0,
@@ -15183,15 +15308,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(generateSequenceData, "generateSequenceData");
   function generateSequence(m = 9, isProtein) {
     let s = "";
-    const r = isProtein ? "" : "gatc";
+    const r = isProtein ? "ACDEFGHIKLMNPQRSTVWY" : "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, isLinear) {
-    if (!positionStart) positionStart = 0;
+  function findNearestRangeOfSequenceOverlapToPosition(sequenceToSearch, overlapSequence, positionStart = 0, isLinear) {
     if (sequenceToSearch.length < overlapSequence.length) {
       return null;
     }
@@ -15209,6 +15333,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       index = result.index;
       distance = newDistance;
     }
+    if (index === void 0) {
+      return null;
+    }
     return normalizeRange(
       {
         start: index,
@@ -15253,9 +15380,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
             internalStartCodonIndices: [],
             frame: start % 3,
             forward,
-            annotationTypePlural: "orfs",
+            // annotationTypePlural: "orfs",
             isOrf: true,
-            id: shortid()
+            id: shortid(),
+            type: "orf",
+            name: "ORF"
           });
         }
       }
@@ -15296,7 +15425,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return nonDuplicatedOrfRanges;
   }
   __name(getOrfsFromSequence, "getOrfsFromSequence");
-  function findOrfsInPlasmid(sequence, circular, minimumOrfSize, useAdditionalOrfStartCodons) {
+  function findOrfsInPlasmid(sequence, circular, minimumOrfSize, useAdditionalOrfStartCodons, isProteinOrOligo) {
+    if (isProteinOrOligo) {
+      return [];
+    }
     const forwardOrfs = getOrfsFromSequence({
       sequence,
       minimumOrfSize,
@@ -15356,7 +15488,10 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           true
         );
       } else {
-        searchStringToUse = convertAmbiguousStringToRegex(searchStringToUse);
+        searchStringToUse = convertAmbiguousStringToRegex(
+          searchStringToUse,
+          false
+        );
       }
     }
     if (!searchStringToUse) return [];
@@ -15476,7 +15611,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }
   __name(getCodonRangeForAASliver, "getCodonRangeForAASliver");
   function getComplementAminoAcidStringFromSequenceString(sequenceString) {
-    const aaString = getAminoAcidStringFromSequenceString(sequenceString, true);
+    const aaString = getAminoAcidStringFromSequenceString(sequenceString, {
+      doNotExcludeAsterisk: true
+    });
     return aaString.split("").reverse().join("");
   }
   __name(getComplementAminoAcidStringFromSequenceString, "getComplementAminoAcidStringFromSequenceString");
@@ -15514,26 +15651,30 @@ 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] = [];
+      annotationTypes.reduce(
+        (acc, type) => {
+          if (exclude[type]) {
+            acc[type] = [];
+            return acc;
+          }
+          acc[type] = getAnnotationsBetweenRange(
+            seqDataToUse[type],
+            range,
+            seqDataToUse.sequence.length,
+            excludePartial[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
       );
@@ -15598,7 +15739,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(getAnnotationsBetweenRange, "getAnnotationsBetweenRange");
   function getComplementSequenceAndAnnotations(pSeqObj, options = {}) {
     const seqObj = tidyUpSequenceData(
-      getSequenceDataBetweenRange(pSeqObj, options.range),
+      getSequenceDataBetweenRange(pSeqObj, options.range || null),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       options
     );
     const newSeqObj = Object.assign({}, seqObj, {
@@ -15613,7 +15755,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const { topSnipOffset, bottomSnipOffset } = restrictionEnzyme;
     if (topSnipOffset === bottomSnipOffset) {
       return "blunt";
-    } else if (topSnipOffset < bottomSnipOffset) {
+    } else if (topSnipOffset !== void 0 && bottomSnipOffset !== void 0 && topSnipOffset < bottomSnipOffset) {
       return "5' overhang";
     } else {
       return "3' overhang";
@@ -15647,7 +15789,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       leftHandSide: "",
       rightHandSide: ""
     };
-    if (isPositionWithinRange(position, range)) {
+    if (isPositionWithinRange(position, range, sequence.length)) {
       result.leftHandSide = getSequenceWithinRange(
         {
           start: range.start,
@@ -15687,13 +15829,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     }
   }
   __name(getOverlapBetweenTwoSequences, "getOverlapBetweenTwoSequences");
-  function getPossiblePartsFromSequenceAndEnzyme(seqData, restrictionEnzymes) {
-    restrictionEnzymes = restrictionEnzymes.length ? restrictionEnzymes : [restrictionEnzymes];
+  function getPossiblePartsFromSequenceAndEnzymes(seqData, restrictionEnzymes) {
+    const enzymes = Array.isArray(restrictionEnzymes) ? restrictionEnzymes : [restrictionEnzymes];
     const bps = seqData.sequence;
     const seqLen = bps.length;
-    const circular = seqData.circular;
+    const circular = seqData.circular || false;
     let cutsites = [];
-    restrictionEnzymes.forEach((enzyme) => {
+    enzymes.forEach((enzyme) => {
       const newCutsites = cutSequenceByRestrictionEnzyme(bps, circular, enzyme);
       cutsites = cutsites.concat(newCutsites);
     });
@@ -15734,13 +15876,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
       return parts;
     }
   }
-  __name(getPossiblePartsFromSequenceAndEnzyme, "getPossiblePartsFromSequenceAndEnzyme");
+  __name(getPossiblePartsFromSequenceAndEnzymes, "getPossiblePartsFromSequenceAndEnzymes");
   function getPartBetweenEnzymesWithInclusiveOverhangs(cut1, cut2, seqLen) {
     const firstCutOffset = getEnzymeRelativeOffset(cut1.restrictionEnzyme);
     const secondCutOffset = getEnzymeRelativeOffset(cut2.restrictionEnzyme);
-    const start = cut1.topSnipBeforeBottom ? cut1.topSnipPosition : cut1.bottomSnipPosition;
+    const start = (cut1.topSnipBeforeBottom ? cut1.topSnipPosition : cut1.bottomSnipPosition) || 0;
     const end = normalizePositionByRangeLength(
-      (cut2.topSnipBeforeBottom ? cut2.bottomSnipPosition : cut2.topSnipPosition) - 1,
+      (cut2.topSnipBeforeBottom ? cut2.bottomSnipPosition || 0 : cut2.topSnipPosition || 0) - 1,
       seqLen
     );
     return {
@@ -15751,20 +15893,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 - enzyme.topSnipOffset;
+    return (enzyme.bottomSnipOffset || 0) - (enzyme.topSnipOffset || 0);
   }
   __name(getEnzymeRelativeOffset, "getEnzymeRelativeOffset");
   function pairwise(list) {
@@ -15780,6 +15922,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   function getReverseAminoAcidStringFromSequenceString(sequenceString) {
     const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
       sequenceString,
+      false,
+      null,
       false
     );
     const aaArray = [];
@@ -15818,7 +15962,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(getReverseComplementAnnotation, "getReverseComplementAnnotation");
   function getReverseComplementSequenceAndAnnoations(pSeqObj, options = {}) {
     const seqObj = tidyUpSequenceData(
-      getSequenceDataBetweenRange(pSeqObj, options.range),
+      getSequenceDataBetweenRange(pSeqObj, options.range || null),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       __spreadValues({ doNotRemoveInvalidChars: true }, options)
     );
     const newSeqObj = Object.assign(
@@ -15827,17 +15972,20 @@ 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
@@ -15859,10 +16007,13 @@ 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++) {
@@ -15882,15 +16033,17 @@ 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: {
+            annotation: __spreadProps(__spreadValues({}, annotation), {
               start: 0,
               end: sequenceLength - 1,
-              id: `__tempAnnRemoveMe__${annotation.id}`
-            },
+              id: `__tempAnnRemoveMe__${annotation.id}`,
+              overlapsSelf: false
+            }),
             sequenceLength,
             bpsPerRow,
             annotationsToRowsMap,
@@ -15911,7 +16064,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         splitForwardReverse
       });
       if (containsLocations) {
-        annotation.locations.forEach((location) => {
+        (_a = annotation.locations) == null ? void 0 : _a.forEach((location) => {
           mapAnnotationToRows({
             annotation,
             sequenceLength,
@@ -15927,7 +16080,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     forEach(annotationsToRowsMap, (annotationsForRow, i) => {
       annotationsToRowsMap[i] = filter(
         annotationsForRow,
-        (ann) => !startsWith(ann.id, "__tempAnnRemoveMe__")
+        (ann) => !startsWith(String(ann.id), "__tempAnnRemoveMe__")
       );
     });
     return annotationsToRowsMap;
@@ -15969,6 +16122,13 @@ 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) => {
@@ -15977,32 +16137,74 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
               }
             });
           } else {
-            if (index > 0 && //second half of an annotation range
-            annotationsForRow.length && //there are already annotations within the row
-            annotationsForRow[annotationsForRow.length - 1].annotation === annotation) {
+            if (index > 0 && annotationsForRow.length && annotationsForRow[annotationsForRow.length - 1].annotation === annotation) {
               yOffset = annotationsForRow[annotationsForRow.length - 1].yOffset;
             } else {
-              yOffset = getYOffsetForPotentiallyCircularRange(
-                annotation,
-                yOffsetsForRow
-              );
+              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
+              });
             }
-            if (!yOffsetsForRow[yOffset]) yOffsetsForRow[yOffset] = [];
-            yOffsetsForRow[yOffset].push({
-              start,
-              end
-            });
           }
         }
-        annotationsForRow.push(__spreadProps(__spreadValues(__spreadValues({
+        annotationsForRow.push(__spreadProps(__spreadValues(__spreadValues(__spreadProps(__spreadValues({}, annotation), {
           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"
         }));
       }
     });
@@ -16012,10 +16214,14 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const clonedSeqData = cloneDeep(sequenceData);
     annotationTypes.forEach((annotationType) => {
       if (annotationType !== "cutsites") {
-        const maxYOffset = getYOffsetsForPotentiallyCircularRanges(
-          clonedSeqData[annotationType]
-        ).maxYOffset;
-        clonedSeqData[annotationType].maxYOffset = maxYOffset;
+        const annotations = clonedSeqData[annotationType];
+        if (annotations) {
+          const maxYOffset = getYOffsetsForPotentiallyCircularRanges(
+            annotations,
+            true
+          ).maxYOffset;
+          clonedSeqData[annotationType].maxYOffset = maxYOffset;
+        }
       }
     });
     return clonedSeqData;
@@ -16028,14 +16234,19 @@ 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 = {};
+      const row = {
+        rowNumber,
+        start: 0,
+        end: 0,
+        sequence: ""
+      };
       row.rowNumber = rowNumber;
       row.start = rowNumber * bpsPerRow;
       row.end = (rowNumber + 1) * bpsPerRow - 1 < sequenceLength ? (rowNumber + 1) * bpsPerRow - 1 : sequenceLength - 1;
@@ -16096,17 +16307,16 @@ 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 - numOfBeginningSoftClipped;
+          adjustedSeqReadPos2 = seqRead2.pos - Number(numOfBeginningSoftClipped);
         }
         for (let componentI = 0; componentI < splitSeqRead.length; componentI++) {
           if (splitSeqRead[componentI].slice(-1) === "I") {
@@ -16132,10 +16342,11 @@ 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 - numOfBeginningSoftClipped;
+        adjustedSeqReadPos = seqRead.pos - Number(numOfBeginningSoftClipped);
       }
       let eachSeqReadWithGaps = seqRead.seq.split("");
       if (adjustedSeqReadPos > 0) {
@@ -16323,10 +16534,11 @@ 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 - numOfBeginningSoftClipped;
+        adjustedSeqReadPos = seq.pos - Number(numOfBeginningSoftClipped);
         if (adjustedSeqReadPos < 0) {
           seqReadLengthsBeforeRefSeqStart.push(Math.abs(adjustedSeqReadPos));
         }
@@ -16336,13 +16548,14 @@ 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 - numOfBeginningSoftClipped;
+        adjustedSeqReadPos = seqReads[i - 1].pos - Number(numOfBeginningSoftClipped);
         if (adjustedSeqReadPos > 0) {
           if (longestSeqReadLength > 0) {
             eachSeqReadWithGaps.unshift("-".repeat(longestSeqReadLength + 1));
@@ -16456,11 +16669,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) {
@@ -16503,9 +16716,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           `${sequences.length} sequences received when 2 primers were expected`
         );
       }
-      const meltingTemperatures = sequences.map(
-        (seq) => calculateNebTm(seq, primerConc, { monovalentCationConc })
-      );
+      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;
+      });
       meltingTemperatures.sort((a, b) => a - b);
       const lowerMeltingTemp = meltingTemperatures[0];
       let annealingTemp;
@@ -16582,17 +16799,17 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(isValidSequence, "isValidSequence");
   function calculateSantaLuciaTm(sequence) {
     try {
-      sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
-      if (!isValidSequence(sequence)) {
+      const seq = sequence == null ? void 0 : sequence.toUpperCase().trim();
+      if (!isValidSequence(seq)) {
         throw new Error("Invalid sequence: contains non-DNA characters");
       }
-      if (sequence.length < 2) {
+      if (seq.length < 2) {
         throw new Error("Sequence too short: minimum length is 2 bases");
       }
       let deltaH = 0;
       let deltaS = 0;
-      for (let i = 0; i < sequence.length - 1; i++) {
-        const dinucleotide = sequence.substring(i, i + 2);
+      for (let i = 0; i < seq.length - 1; i++) {
+        const dinucleotide = seq.substring(i, i + 2);
         if (dinucleotide.includes("N")) {
           continue;
         }
@@ -16602,23 +16819,23 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
           deltaS += params.dS;
         }
       }
-      const firstBase = sequence[0];
-      const lastBase = sequence[sequence.length - 1];
+      const firstBase = seq[0];
+      const lastBase = seq[seq.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 = sequence.length - 1;
+      const nnPairs = seq.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));
@@ -16630,16 +16847,16 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   __name(calculateSantaLuciaTm, "calculateSantaLuciaTm");
   function calculateEndStability(sequence) {
     try {
-      sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
-      if (!isValidSequence(sequence)) {
+      const seq = sequence == null ? void 0 : sequence.toUpperCase().trim();
+      if (!isValidSequence(seq)) {
         throw new Error("Invalid sequence: contains non-DNA characters");
       }
-      if (sequence.length < 5) {
+      if (seq.length < 5) {
         throw new Error(
           "Sequence too short: minimum length is 5 bases for end stability calculation"
         );
       }
-      const last5Bases = sequence.substring(sequence.length - 5);
+      const last5Bases = seq.substring(seq.length - 5);
       let deltaH = 0;
       let deltaS = 0;
       for (let i = 0; i < 4; i++) {
@@ -16656,18 +16873,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;
@@ -16682,24 +16899,40 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     const pairs = [];
     if (!cutsites.length) return [];
     let sortedCutsites = cutsites.sort((a, b) => {
-      return a.topSnipPosition - b.topSnipPosition;
+      return (a.topSnipPosition || 0) - (b.topSnipPosition || 0);
     });
     if (!circular) {
       sortedCutsites = [
         {
+          start: 0,
+          end: 0,
           topSnipPosition: 0,
           bottomSnipPosition: 0,
           overhangSize: 0,
           type: "START_OR_END_OF_SEQ",
-          name: "START_OF_SEQ"
+          name: "START_OF_SEQ",
+          restrictionEnzyme: {
+            name: "START_OF_SEQ",
+            site: "",
+            forwardRegex: "",
+            reverseRegex: ""
+          }
         },
         ...sortedCutsites,
         {
+          start: sequenceLength,
+          end: sequenceLength,
           topSnipPosition: sequenceLength,
           bottomSnipPosition: sequenceLength,
           overhangSize: 0,
           type: "START_OR_END_OF_SEQ",
-          name: "END_OF_SEQ"
+          name: "END_OF_SEQ",
+          restrictionEnzyme: {
+            name: "END_OF_SEQ",
+            site: "",
+            forwardRegex: "",
+            reverseRegex: ""
+          }
         }
       ];
     }
@@ -16722,11 +16955,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     });
     pairs.forEach(([cut1, cut2]) => {
       const start = normalizePositionByRangeLength(
-        cut1.topSnipPosition,
+        cut1.topSnipPosition || 0,
         sequenceLength
       );
       const end = normalizePositionByRangeLength(
-        cut2.topSnipPosition - 1,
+        (cut2.topSnipPosition || 0) - 1,
         sequenceLength
       );
       const fragmentRange = { start, end };
@@ -16744,7 +16977,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
         })
       }, fragmentRange), {
         size,
-        id
+        id,
+        name: `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps`
+        // Add missing name property
       }));
     });
     fragments.filter((fragment) => {
@@ -16756,21 +16991,33 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     return fragments;
   }
   __name(getDigestFragmentsForCutsites, "getDigestFragmentsForCutsites");
-  function getDigestFragmentsForRestrictionEnzymes(sequence, circular, restrictionEnzymeOrEnzymes, opts) {
-    const restrictionEnzymes = Array.isArray(restrictionEnzymeOrEnzymes) ? restrictionEnzymeOrEnzymes : [restrictionEnzymeOrEnzymes];
-    const cutsites = flatMap(restrictionEnzymes, (restrictionEnzyme) => {
-      return cutSequenceByRestrictionEnzyme(
-        sequence,
-        circular,
-        restrictionEnzyme
-      );
-    });
-    return getDigestFragmentsForCutsites(
-      sequence.length,
+  function getDigestFragmentsForRestrictionEnzymes(sequence, circular, contextEnzymes, options) {
+    const cutsitesByName = getCutsitesFromSequence(
+      sequence,
       circular,
-      cutsites,
-      opts
+      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
+      );
+      if (fullLengthFragmentIndex > -1) {
+        fragments.splice(fullLengthFragmentIndex, 1);
+      }
+    }
+    return fragments.sort((a, b) => {
+      return a.start - b.start || b.size - a.size;
+    });
   }
   __name(getDigestFragmentsForRestrictionEnzymes, "getDigestFragmentsForRestrictionEnzymes");
   function convertAACaretPositionOrRangeToDna(rangeOrCaret) {
@@ -16816,11 +17063,13 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   }) {
     modifiableTypes.forEach((annotationType) => {
       const existingAnnotations = seqData[annotationType];
-      seqData[annotationType] = adjustAnnotationsToInsert(
-        existingAnnotations,
-        caretPosition,
-        insertLength
-      );
+      if (existingAnnotations) {
+        seqData[annotationType] = adjustAnnotationsToInsert(
+          existingAnnotations,
+          caretPosition,
+          insertLength
+        );
+      }
     });
   }
   __name(shiftAnnotationsByLen, "shiftAnnotationsByLen");
@@ -16890,7 +17139,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   exports2.getMergedFeatureMap = getMergedFeatureMap;
   exports2.getOrfsFromSequence = getOrfsFromSequence;
   exports2.getOverlapBetweenTwoSequences = getOverlapBetweenTwoSequences;
-  exports2.getPossiblePartsFromSequenceAndEnzymes = getPossiblePartsFromSequenceAndEnzyme;
+  exports2.getPossiblePartsFromSequenceAndEnzymes = getPossiblePartsFromSequenceAndEnzymes;
   exports2.getReverseAminoAcidStringFromSequenceString = getReverseAminoAcidStringFromSequenceString;
   exports2.getReverseComplementAminoAcidStringFromSequenceString = getReverseComplementAminoAcidStringFromSequenceString;
   exports2.getReverseComplementAnnotation = getReverseComplementAnnotation;