@teselagen/sequence-utils 0.3.41 → 0.3.42-beta.1

package/index.cjs

@@ -519,9 +519,9 @@ var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
 var freeProcess = moduleExports$1 && freeGlobal.process;
 var nodeUtil = function() {
   try {
-    var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
-    if (types) {
-      return types;
+    var types2 = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
+    if (types2) {
+      return types2;
     }
     return freeProcess && freeProcess.binding && freeProcess.binding("util");
   } catch (e) {
@@ -2588,9 +2588,10 @@ function getOverlapOfNonCircularRanges(rangeA, rangeB) {
       }
     }
   }
+  return null;
 }
 __name(getOverlapOfNonCircularRanges, "getOverlapOfNonCircularRanges");
-function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible) {
+function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength, joinIfPossible = false) {
   const normalizedRangeA = splitRangeIntoTwoPartsIfItIsCircular(
     rangeA,
     maxRangeLength
@@ -2611,6 +2612,22 @@ function getOverlapsOfPotentiallyCircularRanges(rangeA, rangeB, maxRangeLength,
       }
     });
   });
+  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");
@@ -2682,10 +2699,7 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
   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) {
@@ -2728,6 +2742,7 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
       end: outputTrimmedRange.end
     });
   }
+  return void 0;
 }
 __name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
 function adjustRangeToDeletionOfAnotherRange(rangeToBeAdjusted, anotherRange, maxLength) {
@@ -2874,28 +2889,36 @@ function collapseOverlapsGeneratedFromRangeComparisonIfPossible(overlaps, sequen
       }
     }
   }
+  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;
   };
@@ -2941,7 +2964,7 @@ function isPositionWithinRange(position, range, sequenceLength, includeStartEdge
   return positionFits;
 }
 __name(isPositionWithinRange, "isPositionWithinRange");
-function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions) {
+function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions = false) {
   let position = pPosition;
   if (position < 0) {
     position += sequenceLength;
@@ -3115,15 +3138,19 @@ function getRandomInt$1(min, max) {
 }
 __name(getRandomInt$1, "getRandomInt$1");
 function getSequenceWithinRange(range, sequence) {
-  if (range.start < 0 || range.end < 0) return "";
+  if (range.start < 0 || range.end < 0) {
+    if (typeof sequence === "string") return "";
+    return [];
+  }
   if (range.start > range.end) {
-    let subSequence = sequence.slice(range.start, sequence.length);
+    const subSequence = sequence.slice(range.start, sequence.length);
     if (typeof subSequence === "string") {
-      subSequence += sequence.slice(0, range.end + 1);
+      return subSequence + sequence.slice(0, range.end + 1);
     } else {
-      subSequence = subSequence.concat(sequence.slice(0, range.end + 1));
+      return subSequence.concat(
+        sequence.slice(0, range.end + 1)
+      );
     }
-    return subSequence;
   } else {
     return sequence.slice(range.start, range.end + 1);
   }
@@ -3141,7 +3168,7 @@ function getShortestDistanceBetweenTwoPositions(position1, position2, sequenceLe
 }
 __name(getShortestDistanceBetweenTwoPositions, "getShortestDistanceBetweenTwoPositions");
 function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, assignYOffsetToRange) {
-  let yOffset = [];
+  let yOffset = 0;
   const openYOffsetFound = YOffsetLevelsWithRanges.some(
     function(rangesAlreadyAddedToYOffset, index) {
       const rangeBlocked = rangesAlreadyAddedToYOffset.some(
@@ -3154,6 +3181,7 @@ function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, a
       );
       if (!rangeBlocked) {
         yOffset = index;
+        if (assignYOffsetToRange) range.yOffset = index;
         rangesAlreadyAddedToYOffset.push(range);
         return true;
       }
@@ -3162,6 +3190,7 @@ function getYOffsetForPotentiallyCircularRange(range, YOffsetLevelsWithRanges, a
   );
   if (!openYOffsetFound) {
     yOffset = YOffsetLevelsWithRanges.length;
+    if (assignYOffsetToRange) range.yOffset = YOffsetLevelsWithRanges.length;
   }
   return yOffset;
 }
@@ -3173,7 +3202,8 @@ function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
   ranges.forEach(function(range) {
     const yOffset = getYOffsetForPotentiallyCircularRange(
       range,
-      yOffsetLevels
+      yOffsetLevels,
+      assignYOffsetToRange
     );
     yOffsets.push(yOffset);
     if (yOffset > maxYOffset) {
@@ -3188,21 +3218,20 @@ function getYOffsetsForPotentiallyCircularRanges(ranges, assignYOffsetToRange) {
 __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) {
@@ -3256,9 +3285,10 @@ function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength)
       "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;
   }
@@ -3269,10 +3299,10 @@ function zeroSubrangeByContainerRange(subRange, containerRange, sequenceLength)
 }
 __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;
 }
@@ -3358,7 +3388,11 @@ function autoAnnotate({
     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 {
@@ -3378,13 +3412,13 @@ function autoAnnotate({
               };
               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
@@ -3415,14 +3449,22 @@ function autoAnnotate({
     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);
@@ -3431,16 +3473,23 @@ function autoAnnotate({
     }
     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 : ""}`;
 }
@@ -3454,13 +3503,12 @@ function convertApELikeRegexToRegex(regString = "") {
   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;
@@ -3645,16 +3693,17 @@ const getMergedFeatureMap = /* @__PURE__ */ __name(() => {
     })),
     "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(),
@@ -3664,7 +3713,9 @@ const getFeatureToColorMap = /* @__PURE__ */ __name(({ includeHidden } = {}) =>
   });
   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) {
@@ -3969,10 +4020,15 @@ __name(requireShortid, "requireShortid");
 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;
@@ -3997,54 +4053,54 @@ function cutSequenceByRestrictionEnzyme(pSequence, circular, restrictionEnzyme)
   }
   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
     });
   }
@@ -4056,7 +4112,7 @@ function cutSequence(forwardRegExpPattern, restrictionEnzyme, sequence, circular
   let restrictionCutSite;
   const recognitionSiteLength = restrictionEnzyme.site.length;
   const originalSequence = sequence;
-  const originalSequenceLength = sequence.length;
+  const originalSequenceLengthVal = sequence.length;
   if (circular) {
     sequence += sequence;
   }
@@ -4065,7 +4121,10 @@ function cutSequence(forwardRegExpPattern, restrictionEnzyme, sequence, circular
   let startIndex = 0;
   let subSequence = sequence;
   while (matchIndex !== -1) {
-    const recognitionSiteRange = {};
+    const recognitionSiteRange = {
+      start: 0,
+      end: 0
+    };
     let start;
     let end;
     let upstreamTopSnip = null;
@@ -4080,37 +4139,39 @@ function cutSequence(forwardRegExpPattern, restrictionEnzyme, sequence, circular
     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) {
@@ -4125,61 +4186,70 @@ function cutSequence(forwardRegExpPattern, restrictionEnzyme, sequence, circular
       }
       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,
@@ -4201,16 +4271,19 @@ function cutSequence(forwardRegExpPattern, restrictionEnzyme, sequence, circular
   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({
@@ -4228,9 +4301,9 @@ function computeDigestFragments({
   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(),
@@ -4239,6 +4312,8 @@ function computeDigestFragments({
       overhangBps: "",
       topSnipPosition: 0,
       bottomSnipPosition: 0,
+      overhangSize: 0,
+      // Added to satisfy CutSite
       upstreamTopSnip: 0,
       upstreamBottomSnip: 0,
       upstreamTopBeforeBottom: false,
@@ -4249,26 +4324,34 @@ function computeDigestFragments({
       },
       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;
@@ -4313,12 +4396,17 @@ function computeDigestFragments({
       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,
@@ -4359,12 +4447,14 @@ function getDigestFragsForSeqAndEnzymes({
   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) {
@@ -5933,7 +6023,8 @@ function expandAndResolve(threeLetterCodon) {
   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;
@@ -5979,10 +6070,13 @@ function getAminoAcidFromSequenceTriplet(sequenceString) {
   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");
@@ -6196,9 +6290,15 @@ function filterSequenceString(sequenceString = "", {
   name,
   isProtein,
   isRna,
+  getAcceptedInsertChars,
   isMixedRnaAndDna
 } = {}) {
-  const acceptedChars = getAcceptedChars({
+  const acceptedChars = isFunction(getAcceptedInsertChars) ? getAcceptedInsertChars({
+    isOligo,
+    isProtein,
+    isRna,
+    isMixedRnaAndDna
+  }) : getAcceptedChars({
     isOligo,
     isProtein,
     isRna,
@@ -6379,25 +6479,25 @@ function coerceLocation({
   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"
     );
@@ -6406,21 +6506,30 @@ function coerceLocation({
 }
 __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;
@@ -6440,6 +6549,8 @@ function tidyUpSequenceData(pSeqData, options = {}) {
     doNotProvideIdsForAnnotations,
     noCdsTranslations,
     convertAnnotationsFromAAIndices,
+    isMixedRnaAndDna,
+    getAcceptedInsertChars,
     topLevelSeqData
   } = options;
   let seqData = cloneDeep(pSeqData);
@@ -6447,7 +6558,7 @@ function tidyUpSequenceData(pSeqData, options = {}) {
     messages: []
   };
   if (!seqData) {
-    seqData = {};
+    seqData = { sequence: "" };
   }
   if (!seqData.sequence) {
     seqData.sequence = "";
@@ -6470,14 +6581,21 @@ function tidyUpSequenceData(pSeqData, options = {}) {
   }
   if (!doNotRemoveInvalidChars) {
     if (seqData.isProtein) {
-      const [newSeq] = filterSequenceString(seqData.proteinSequence, __spreadProps(__spreadValues({}, topLevelSeqData || seqData), {
-        isProtein: true
+      const [newSeq] = filterSequenceString(seqData.proteinSequence, __spreadProps(__spreadValues({
+        isMixedRnaAndDna,
+        additionalValidChars
+      }, topLevelSeqData || seqData), {
+        isProtein: true,
+        getAcceptedInsertChars
       }));
       seqData.proteinSequence = newSeq;
     } else {
-      const [newSeq] = filterSequenceString(seqData.sequence, __spreadValues({
-        additionalValidChars
-      }, topLevelSeqData || seqData));
+      const [newSeq] = filterSequenceString(seqData.sequence, __spreadProps(__spreadValues({
+        additionalValidChars,
+        isMixedRnaAndDna
+      }, topLevelSeqData || seqData), {
+        getAcceptedInsertChars
+      }));
       seqData.sequence = newSeq;
     }
   }
@@ -6510,25 +6628,27 @@ function tidyUpSequenceData(pSeqData, options = {}) {
   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) => {
@@ -6536,7 +6656,7 @@ function tidyUpSequenceData(pSeqData, options = {}) {
       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,
@@ -6546,8 +6666,9 @@ function tidyUpSequenceData(pSeqData, options = {}) {
       if (!expandedRange.aminoAcids && !seqData.noSequence) {
         expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
           seqData.sequence,
-          expandedRange.forward,
-          expandedRange
+          expandedRange.forward || false,
+          expandedRange,
+          false
         );
       }
       return expandedRange;
@@ -6555,19 +6676,22 @@ function tidyUpSequenceData(pSeqData, options = {}) {
   }
   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) {
@@ -6577,17 +6701,17 @@ function tidyUpSequenceData(pSeqData, options = {}) {
 }
 __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",
@@ -6610,27 +6734,29 @@ const getDiffFromSeqs = /* @__PURE__ */ __name((oldData, newData, { ignoreKeys =
       });
     }
   });
-  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");
+const types = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
 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;
@@ -6674,14 +6800,19 @@ function getAllInsertionsInSeqReads(seqReads) {
   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), {
@@ -6731,7 +6862,9 @@ const aminoAcidToDegenerateRnaMap = {
   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({
@@ -6746,7 +6879,7 @@ function getVirtualDigest({
   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) {
@@ -6763,11 +6896,11 @@ function getVirtualDigest({
   });
   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) {
@@ -6781,6 +6914,7 @@ function getVirtualDigest({
             name: "End Of Seq"
           }
         }
+        // Cast to CutSite as it's a mock
       };
       const frag2 = {
         start: 0,
@@ -6791,6 +6925,7 @@ function getVirtualDigest({
             name: "Start Of Seq"
           }
         },
+        // Cast
         cut2
       };
       fragments.push(addSizeIdName(frag1, sequenceLength));
@@ -6893,27 +7028,18 @@ function findApproxMatches(searchSeq, targetSeq, maxMismatches, circular = false
   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) => {
@@ -6939,6 +7065,16 @@ function adjustBpsToReplaceOrInsert(bpString, insertString = "", caretPositionOr
   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;
 }
@@ -6964,11 +7100,17 @@ const calcTmMethods = {
    * 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) {
@@ -6984,11 +7126,14 @@ const calcTmMethods = {
       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"));
@@ -7022,7 +7167,7 @@ const calcTmMethods = {
    * @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,
@@ -7041,7 +7186,7 @@ const calcTmMethods = {
         6.5,
         11.1
       ];
-    } else if (type == this.TABLE_SUGIMOTO) {
+    } else if (type === this.TABLE_SUGIMOTO) {
       return [
         8,
         5.6,
@@ -7060,7 +7205,7 @@ const calcTmMethods = {
         9.4,
         11.9
       ];
-    } else if (type == this.TABLE_UNIFIED) {
+    } else if (type === this.TABLE_UNIFIED) {
       return [
         7.9,
         7.2,
@@ -7083,39 +7228,6 @@ const calcTmMethods = {
       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.
@@ -7123,7 +7235,7 @@ const calcTmMethods = {
    * @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,
@@ -7142,7 +7254,7 @@ const calcTmMethods = {
         17.3,
         26.7
       ];
-    } else if (type == this.TABLE_SUGIMOTO) {
+    } else if (type === this.TABLE_SUGIMOTO) {
       return [
         21.9,
         15.2,
@@ -7161,7 +7273,7 @@ const calcTmMethods = {
         25.5,
         29
       ];
-    } else if (type == this.TABLE_UNIFIED) {
+    } else if (type === this.TABLE_UNIFIED) {
       return [
         22.2,
         20.4,
@@ -7195,14 +7307,14 @@ const calcTmMethods = {
    */
   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;
@@ -7222,7 +7334,7 @@ const calcTmMethods = {
    */
   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;
@@ -7257,11 +7369,11 @@ function rotateBpsToPosition(bps, caretPosition) {
 __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));
@@ -7309,16 +7421,24 @@ function insertSequenceDataAtPositionOrRange(_sequenceDataToInsert, _existingSeq
   }, 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: "",
@@ -7328,7 +7448,7 @@ function insertSequenceDataAtPositionOrRange(_sequenceDataToInsert, _existingSeq
     );
     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,
@@ -7338,14 +7458,16 @@ function insertSequenceDataAtPositionOrRange(_sequenceDataToInsert, _existingSeq
           },
           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,
@@ -7357,10 +7479,10 @@ function insertSequenceDataAtPositionOrRange(_sequenceDataToInsert, _existingSeq
         });
       }
     }
-    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
       });
@@ -7373,14 +7495,15 @@ function insertSequenceDataAtPositionOrRange(_sequenceDataToInsert, _existingSeq
   );
   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(
@@ -7390,22 +7513,23 @@ function insertSequenceDataAtPositionOrRange(_sequenceDataToInsert, _existingSeq
       );
     }
     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,
@@ -7423,6 +7547,7 @@ function adjustAnnotationsToDelete(annotationsToBeAdjusted, range, maxLength) {
       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,
@@ -7441,11 +7566,13 @@ function insertIntoChromatogram({
   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;
   }
@@ -7461,8 +7588,20 @@ function insertIntoChromatogram({
       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");
@@ -7475,17 +7614,23 @@ function trimChromatogram({
     "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;
@@ -15117,10 +15262,10 @@ defaultEnzymes.forEach((name) => {
   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;
 }
@@ -15148,16 +15293,16 @@ function generateSequenceData({
   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,
@@ -15169,7 +15314,7 @@ function generateSequenceData({
       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,
@@ -15181,15 +15326,14 @@ function generateSequenceData({
 __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;
   }
@@ -15207,6 +15351,9 @@ function findNearestRangeOfSequenceOverlapToPosition(sequenceToSearch, overlapSe
     index = result.index;
     distance = newDistance;
   }
+  if (index === void 0) {
+    return null;
+  }
   return normalizeRange(
     {
       start: index,
@@ -15251,9 +15398,11 @@ function getOrfsFromSequence(options) {
           internalStartCodonIndices: [],
           frame: start % 3,
           forward,
-          annotationTypePlural: "orfs",
+          // annotationTypePlural: "orfs",
           isOrf: true,
-          id: shortid()
+          id: shortid(),
+          type: "orf",
+          name: "ORF"
         });
       }
     }
@@ -15357,7 +15506,10 @@ function findSequenceMatchesTopStrand(sequence, searchString, options = {}) {
         true
       );
     } else {
-      searchStringToUse = convertAmbiguousStringToRegex(searchStringToUse);
+      searchStringToUse = convertAmbiguousStringToRegex(
+        searchStringToUse,
+        false
+      );
     }
   }
   if (!searchStringToUse) return [];
@@ -15477,7 +15629,9 @@ function getCodonRangeForAASliver(aminoAcidPositionInSequence, aminoAcidSliver,
 }
 __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");
@@ -15515,26 +15669,30 @@ function getSequenceDataBetweenRange(seqData, range, options = {}) {
       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
     );
@@ -15608,7 +15766,8 @@ function getAnnotationsBetweenRange(annotationsToBeAdjusted, range, maxLength, s
 __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, {
@@ -15623,7 +15782,7 @@ function getCutsiteType(restrictionEnzyme) {
   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";
@@ -15657,7 +15816,7 @@ function getLeftAndRightOfSequenceInRangeGivenPosition(range, position, sequence
     leftHandSide: "",
     rightHandSide: ""
   };
-  if (isPositionWithinRange(position, range)) {
+  if (isPositionWithinRange(position, range, sequence.length)) {
     result.leftHandSide = getSequenceWithinRange(
       {
         start: range.start,
@@ -15697,13 +15856,13 @@ function getOverlapBetweenTwoSequences(sequenceToFind, sequenceToSearchIn) {
   }
 }
 __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);
   });
@@ -15744,13 +15903,13 @@ function getPossiblePartsFromSequenceAndEnzyme(seqData, restrictionEnzymes) {
     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 {
@@ -15761,20 +15920,20 @@ function getPartBetweenEnzymesWithInclusiveOverhangs(cut1, cut2, seqLen) {
     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) {
@@ -15790,6 +15949,8 @@ __name(pairwise, "pairwise");
 function getReverseAminoAcidStringFromSequenceString(sequenceString) {
   const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
     sequenceString,
+    false,
+    null,
     false
   );
   const aaArray = [];
@@ -15828,7 +15989,8 @@ function getReverseComplementAnnotation(annotation, sequenceLength) {
 __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(
@@ -15837,17 +15999,20 @@ function getReverseComplementSequenceAndAnnoations(pSeqObj, options = {}) {
     {
       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
@@ -15869,10 +16034,13 @@ __name(getReverseSequenceString, "getReverseSequenceString");
 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++) {
@@ -15892,15 +16060,17 @@ function mapAnnotationsToRows(annotations, sequenceLength, bpsPerRow, { splitFor
   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,
@@ -15921,7 +16091,7 @@ function mapAnnotationsToRows(annotations, sequenceLength, bpsPerRow, { splitFor
       splitForwardReverse
     });
     if (containsLocations) {
-      annotation.locations.forEach((location) => {
+      (_a = annotation.locations) == null ? void 0 : _a.forEach((location) => {
         mapAnnotationToRows({
           annotation,
           sequenceLength,
@@ -15937,7 +16107,7 @@ function mapAnnotationsToRows(annotations, sequenceLength, bpsPerRow, { splitFor
   forEach(annotationsToRowsMap, (annotationsForRow, i) => {
     annotationsToRowsMap[i] = filter(
       annotationsForRow,
-      (ann) => !startsWith(ann.id, "__tempAnnRemoveMe__")
+      (ann) => !startsWith(String(ann.id), "__tempAnnRemoveMe__")
     );
   });
   return annotationsToRowsMap;
@@ -15979,6 +16149,13 @@ function mapAnnotationToRows({
             yOffset = ann.yOffset;
           }
         });
+        if (yOffset === void 0) {
+          annotationsForRow.forEach((ann) => {
+            if (ann.id === annotation.id) {
+              yOffset = ann.yOffset;
+            }
+          });
+        }
       } else {
         if (location) {
           annotationsForRow.forEach((ann) => {
@@ -15987,32 +16164,74 @@ function mapAnnotationToRows({
             }
           });
         } 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"
       }));
     }
   });
@@ -16022,10 +16241,14 @@ function prepareCircularViewData(sequenceData) {
   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;
@@ -16038,14 +16261,19 @@ function prepareRowData(sequenceData, bpsPerRow) {
   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;
@@ -16106,17 +16334,16 @@ function addGapsToSeqReads(refSeq, seqReads) {
     }
   }
   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") {
@@ -16142,10 +16369,11 @@ function addGapsToSeqReads(refSeq, seqReads) {
       }
     });
     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) {
@@ -16333,10 +16561,11 @@ function addGapsToSeqReads(refSeq, seqReads) {
   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));
       }
@@ -16346,13 +16575,14 @@ function addGapsToSeqReads(refSeq, seqReads) {
   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));
@@ -16466,11 +16696,11 @@ function calculateNebTm(sequence, { monovalentCationConc = 0.05, primerConc = 5e
     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) {
@@ -16513,9 +16743,13 @@ function calculateNebTa(sequences, primerConc, { monovalentCationConc, polymeras
         `${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;
@@ -16592,17 +16826,17 @@ function isValidSequence(sequence) {
 __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;
       }
@@ -16612,23 +16846,23 @@ function calculateSantaLuciaTm(sequence) {
         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));
@@ -16640,16 +16874,16 @@ function calculateSantaLuciaTm(sequence) {
 __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++) {
@@ -16666,18 +16900,18 @@ function calculateEndStability(sequence) {
     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;
@@ -16692,24 +16926,40 @@ function getDigestFragmentsForCutsites(sequenceLength, circular, cutsites, opts
   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: ""
+        }
       }
     ];
   }
@@ -16732,11 +16982,11 @@ function getDigestFragmentsForCutsites(sequenceLength, circular, cutsites, opts
   });
   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 };
@@ -16754,7 +17004,9 @@ function getDigestFragmentsForCutsites(sequenceLength, circular, cutsites, opts
       })
     }, fragmentRange), {
       size,
-      id
+      id,
+      name: `${cut1.restrictionEnzyme.name} -- ${cut2.restrictionEnzyme.name} ${size} bps`
+      // Add missing name property
     }));
   });
   fragments.filter((fragment) => {
@@ -16766,21 +17018,33 @@ function getDigestFragmentsForCutsites(sequenceLength, circular, cutsites, opts
   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) {
@@ -16826,11 +17090,13 @@ function shiftAnnotationsByLen({
 }) {
   modifiableTypes.forEach((annotationType) => {
     const existingAnnotations = seqData[annotationType];
-    seqData[annotationType] = adjustAnnotationsToInsert(
-      existingAnnotations,
-      caretPosition,
-      insertLength
-    );
+    if (existingAnnotations) {
+      seqData[annotationType] = adjustAnnotationsToInsert(
+        existingAnnotations,
+        caretPosition,
+        insertLength
+      );
+    }
   });
 }
 __name(shiftAnnotationsByLen, "shiftAnnotationsByLen");
@@ -16900,7 +17166,7 @@ exports.getMassOfAaString = getMassOfAaString;
 exports.getMergedFeatureMap = getMergedFeatureMap;
 exports.getOrfsFromSequence = getOrfsFromSequence;
 exports.getOverlapBetweenTwoSequences = getOverlapBetweenTwoSequences;
-exports.getPossiblePartsFromSequenceAndEnzymes = getPossiblePartsFromSequenceAndEnzyme;
+exports.getPossiblePartsFromSequenceAndEnzymes = getPossiblePartsFromSequenceAndEnzymes;
 exports.getReverseAminoAcidStringFromSequenceString = getReverseAminoAcidStringFromSequenceString;
 exports.getReverseComplementAminoAcidStringFromSequenceString = getReverseComplementAminoAcidStringFromSequenceString;
 exports.getReverseComplementAnnotation = getReverseComplementAnnotation;
@@ -16927,3 +17193,4 @@ exports.shiftAnnotationsByLen = shiftAnnotationsByLen;
 exports.threeLetterSequenceStringToAminoAcidMap = threeLetterSequenceStringToAminoAcidMap;
 exports.tidyUpAnnotation = tidyUpAnnotation;
 exports.tidyUpSequenceData = tidyUpSequenceData;
+exports.types = types;