npm - @teselagen/sequence-utils - Versions diffs - 0.3.41 → 0.3.42-beta.2 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (239) hide show

package/index.cjs CHANGED Viewed

@@ -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));
@@ -6842,7 +6977,7 @@ function addSizeIdName(frag, sequenceLength) {
 }
 __name(addSizeIdName, "addSizeIdName");
 function isEnzymeType2S(e) {
-  return e.site.length < e.topSnipOffset || e.site.length < e.bottomSnipOffset;
+  return e.site.length < (e.topSnipOffset || 0) || e.site.length < (e.bottomSnipOffset || 0);
 }
 __name(isEnzymeType2S, "isEnzymeType2S");
 function insertGapsIntoRefSeq(refSeq, seqReads) {
@@ -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));
@@ -7290,7 +7402,8 @@ function adjustAnnotationsToRotation(annotationsToBeAdjusted, positionToRotateTo
 }
 __name(adjustAnnotationsToRotation, "adjustAnnotationsToRotation");
 function adjustAnnotationsToInsert(annotationsToBeAdjusted, insertStart, insertLength) {
-  return map(annotationsToBeAdjusted, (annotation) => {
+  const annotations = Array.isArray(annotationsToBeAdjusted) ? annotationsToBeAdjusted : Object.values(annotationsToBeAdjusted);
+  return annotations.map((annotation) => {
     return __spreadValues(__spreadValues({}, adjustRangeToInsert(annotation, insertStart, insertLength)), annotation.locations && {
       locations: annotation.locations.map(
         (loc) => adjustRangeToInsert(loc, insertStart, insertLength)
@@ -7309,16 +7422,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 +7449,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 +7459,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 +7480,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 +7496,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 +7514,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 +7548,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 +7567,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 +7589,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 +7615,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 +15263,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 +15294,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 +15315,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 +15327,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 +15352,9 @@ function findNearestRangeOfSequenceOverlapToPosition(sequenceToSearch, overlapSe
     index = result.index;
     distance = newDistance;
   }
+  if (index === void 0) {
+    return null;
+  }
   return normalizeRange(
     {
       start: index,
@@ -15251,9 +15399,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 +15507,10 @@ function findSequenceMatchesTopStrand(sequence, searchString, options = {}) {
         true
       );
     } else {
-      searchStringToUse = convertAmbiguousStringToRegex(searchStringToUse);
+      searchStringToUse = convertAmbiguousStringToRegex(
+        searchStringToUse,
+        false
+      );
     }
   }
   if (!searchStringToUse) return [];
@@ -15477,7 +15630,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 +15670,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 +15767,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 +15783,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 +15817,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 +15857,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 +15904,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 +15921,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 +15950,8 @@ __name(pairwise, "pairwise");
 function getReverseAminoAcidStringFromSequenceString(sequenceString) {
   const aminoAcidsPerBase = getAminoAcidDataForEachBaseOfDna(
     sequenceString,
+    false,
+    null,
     false
   );
   const aaArray = [];
@@ -15828,7 +15990,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 +16000,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 +16035,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 +16061,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 +16092,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 +16108,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 +16150,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 +16165,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 +16242,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 +16262,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 +16335,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 +16370,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 +16562,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 +16576,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 +16697,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 +16744,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 +16827,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 +16847,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 +16875,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 +16901,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 +16927,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 +16983,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 +17005,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 +17019,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 +17091,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 +17167,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 +17194,4 @@ exports.shiftAnnotationsByLen = shiftAnnotationsByLen;
 exports.threeLetterSequenceStringToAminoAcidMap = threeLetterSequenceStringToAminoAcidMap;
 exports.tidyUpAnnotation = tidyUpAnnotation;
 exports.tidyUpSequenceData = tidyUpSequenceData;
+exports.types = types;