@teselagen/bio-parsers 0.4.18 → 0.4.20

package/index.umd.cjs

@@ -1400,14 +1400,14 @@ var __async = (__this, __arguments, generator) => {
   __name(baseIsSet, "baseIsSet");
   var nodeIsSet = nodeUtil && nodeUtil.isSet;
   var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
-  var CLONE_DEEP_FLAG$2 = 1, CLONE_FLAT_FLAG$1 = 2, CLONE_SYMBOLS_FLAG$2 = 4;
+  var CLONE_DEEP_FLAG$2 = 1, CLONE_FLAT_FLAG$1 = 2, CLONE_SYMBOLS_FLAG$3 = 4;
   var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag$1 = "[object Map]", numberTag$1 = "[object Number]", objectTag$1 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$1 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]", weakMapTag = "[object WeakMap]";
   var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
   var cloneableTags = {};
   cloneableTags[argsTag$1] = cloneableTags[arrayTag$1] = cloneableTags[arrayBufferTag$1] = cloneableTags[dataViewTag$1] = cloneableTags[boolTag$1] = cloneableTags[dateTag$1] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$1] = cloneableTags[numberTag$1] = cloneableTags[objectTag$1] = cloneableTags[regexpTag$1] = cloneableTags[setTag$1] = cloneableTags[stringTag$1] = cloneableTags[symbolTag$1] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
   cloneableTags[errorTag$1] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
   function baseClone(value, bitmask, customizer, key, object, stack) {
-    var result, isDeep = bitmask & CLONE_DEEP_FLAG$2, isFlat = bitmask & CLONE_FLAT_FLAG$1, isFull = bitmask & CLONE_SYMBOLS_FLAG$2;
+    var result, isDeep = bitmask & CLONE_DEEP_FLAG$2, isFlat = bitmask & CLONE_FLAT_FLAG$1, isFull = bitmask & CLONE_SYMBOLS_FLAG$3;
     if (customizer) {
       result = object ? customizer(value, key, object, stack) : customizer(value);
     }
@@ -1467,6 +1467,11 @@ var __async = (__this, __arguments, generator) => {
     return result;
   }
   __name(baseClone, "baseClone");
+  var CLONE_SYMBOLS_FLAG$2 = 4;
+  function clone(value) {
+    return baseClone(value, CLONE_SYMBOLS_FLAG$2);
+  }
+  __name(clone, "clone");
   var CLONE_DEEP_FLAG$1 = 1, CLONE_SYMBOLS_FLAG$1 = 4;
   function cloneDeep(value) {
     return baseClone(value, CLONE_DEEP_FLAG$1 | CLONE_SYMBOLS_FLAG$1);
@@ -2409,6 +2414,45 @@ var __async = (__this, __arguments, generator) => {
     }
   }
   __name(trimRangeByAnotherRange, "trimRangeByAnotherRange");
+  function provideInclusiveOptions(funToWrap) {
+    return function() {
+      const args = Array.prototype.slice.call(arguments);
+      const options = args[args.length - 1];
+      if (options && (options.inclusive1BasedEnd || options.inclusive1BasedStart)) {
+        args.forEach(function(arg, index) {
+          if (arg && arg.start > -1 && options.inclusive1BasedStart) {
+            args[index] = assign(arg, { start: arg.start - 1 });
+          }
+          if (arg && arg.end > -1 && options.inclusive1BasedEnd) {
+            args[index] = assign(arg, { end: arg.end - 1 });
+          }
+        });
+      }
+      let returnVal = funToWrap.apply(this, args);
+      if (returnVal && returnVal.start > -1 && options && options.inclusive1BasedStart) {
+        returnVal = assign(returnVal, { start: returnVal.start + 1 });
+      }
+      if (returnVal && returnVal.end > -1 && options && options.inclusive1BasedEnd) {
+        returnVal = assign(returnVal, { end: returnVal.end + 1 });
+      }
+      return returnVal;
+    };
+  }
+  __name(provideInclusiveOptions, "provideInclusiveOptions");
+  const getRangeLength = provideInclusiveOptions(getRangeLength$1);
+  function getRangeLength$1(range, rangeMax) {
+    let toRet;
+    if (range.end < range.start) {
+      toRet = rangeMax - range.start + range.end + 1;
+    } else {
+      toRet = range.end - range.start + 1;
+    }
+    if (range.overlapsSelf && rangeMax) {
+      toRet += rangeMax;
+    }
+    return toRet;
+  }
+  __name(getRangeLength$1, "getRangeLength$1");
   function isRangeWithinRange(rangeToCheck, containingRange, maxLength) {
     const ranges = trimRangeByAnotherRange(
       rangeToCheck,
@@ -2420,6 +2464,22 @@ var __async = (__this, __arguments, generator) => {
     return !ranges;
   }
   __name(isRangeWithinRange, "isRangeWithinRange");
+  function isPositionWithinRange(position, range, sequenceLength, includeStartEdge, includeEndEdge) {
+    const ranges = splitRangeIntoTwoPartsIfItIsCircular(range, sequenceLength);
+    const positionFits = ranges.some(function(range2) {
+      if (position < range2.start) {
+        return false;
+      } else {
+        if (position <= range2.end) {
+          return true;
+        } else {
+          return false;
+        }
+      }
+    });
+    return positionFits;
+  }
+  __name(isPositionWithinRange, "isPositionWithinRange");
   function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPositions) {
     let position = pPosition;
     if (position < 0) {
@@ -2430,6 +2490,23 @@ var __async = (__this, __arguments, generator) => {
     return position < 0 ? 0 : position > sequenceLength - 1 ? sequenceLength - 1 : position;
   }
   __name(normalizePositionByRangeLength, "normalizePositionByRangeLength");
+  function normalizeRange(range, sequenceLength) {
+    return assign({}, range, {
+      start: normalizePositionByRangeLength(range.start, sequenceLength),
+      end: normalizePositionByRangeLength(range.end, sequenceLength)
+    });
+  }
+  __name(normalizeRange, "normalizeRange");
+  function expandOrContractRangeByLength(range, shiftBy, shiftStart, sequenceLength) {
+    const rangeToReturn = clone(range);
+    if (shiftStart) {
+      rangeToReturn.start -= shiftBy;
+    } else {
+      rangeToReturn.end += shiftBy;
+    }
+    return normalizeRange(rangeToReturn, sequenceLength);
+  }
+  __name(expandOrContractRangeByLength, "expandOrContractRangeByLength");
   function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
     return assign({}, rangeToBeAdjusted, {
       start: normalizePositionByRangeLength(
@@ -2443,6 +2520,118 @@ var __async = (__this, __arguments, generator) => {
     });
   }
   __name(translateRange, "translateRange");
+  function flipRelativeRange(innerRange, outerRange, sequenceLength) {
+    const isFullyContained = isRangeWithinRange(
+      innerRange,
+      outerRange,
+      sequenceLength
+    );
+    if (isFullyContained) {
+      return flipFullyContainedRange(innerRange, outerRange, sequenceLength);
+    } else {
+      return flipNonFullyContainedRange(innerRange, outerRange, sequenceLength);
+    }
+  }
+  __name(flipRelativeRange, "flipRelativeRange");
+  function flipNonFullyContainedRange(innerRange, outerRange, sequenceLength) {
+    const outerFullyContained = isRangeWithinRange(
+      outerRange,
+      innerRange,
+      sequenceLength
+    );
+    let flippedInnerRange;
+    if (outerFullyContained) {
+      const expandBy1 = getRangeLength(
+        {
+          start: innerRange.start,
+          end: outerRange.start
+        },
+        sequenceLength
+      ) - 1;
+      flippedInnerRange = expandOrContractRangeByLength(
+        outerRange,
+        expandBy1,
+        false,
+        sequenceLength
+      );
+      const expandBy2 = getRangeLength(
+        {
+          end: innerRange.end,
+          start: outerRange.end
+        },
+        sequenceLength
+      ) - 1;
+      flippedInnerRange = expandOrContractRangeByLength(
+        flippedInnerRange,
+        expandBy2,
+        true,
+        sequenceLength
+      );
+    } else {
+      const overlaps = getOverlapsOfPotentiallyCircularRanges(
+        innerRange,
+        outerRange,
+        sequenceLength
+      );
+      if (overlaps.length >= 1) {
+        const firstOverlap = overlaps[0];
+        const overlapExtendsForward = firstOverlap.start !== outerRange.start;
+        const flippedTruncatedInner = flipFullyContainedRange(
+          firstOverlap,
+          outerRange,
+          sequenceLength
+        );
+        const lengthToExtend = getRangeLength(innerRange, sequenceLength) - getRangeLength(flippedTruncatedInner, sequenceLength);
+        flippedInnerRange = expandOrContractRangeByLength(
+          flippedTruncatedInner,
+          lengthToExtend,
+          overlapExtendsForward,
+          sequenceLength
+        );
+      } else {
+        throw new Error(
+          "This case (relative ranges that do not overlap) is unsupported! "
+        );
+      }
+    }
+    return flippedInnerRange;
+  }
+  __name(flipNonFullyContainedRange, "flipNonFullyContainedRange");
+  function flipFullyContainedRange(innerRange, outerRange, sequenceLength) {
+    const translateBy = -outerRange.start;
+    const translatedOuterRange = translateRange(
+      outerRange,
+      translateBy,
+      sequenceLength
+    );
+    const translatedInnerRange = translateRange(
+      innerRange,
+      translateBy,
+      sequenceLength
+    );
+    const translatedFlippedInnerRange = flipNonOriginSpanningContainedRange(
+      translatedInnerRange,
+      translatedOuterRange,
+      sequenceLength
+    );
+    const flippedInnerRange = translateRange(
+      translatedFlippedInnerRange,
+      -translateBy,
+      sequenceLength
+    );
+    return flippedInnerRange;
+  }
+  __name(flipFullyContainedRange, "flipFullyContainedRange");
+  function flipNonOriginSpanningContainedRange(innerRange, outerRange, sequenceLength) {
+    const offsetFromStart = innerRange.start - outerRange.start;
+    const newInnerEnd = outerRange.end - offsetFromStart;
+    const innerRangeLength = getRangeLength(innerRange, sequenceLength);
+    return {
+      end: newInnerEnd,
+      start: newInnerEnd - (innerRangeLength - 1)
+    };
+  }
+  __name(flipNonOriginSpanningContainedRange, "flipNonOriginSpanningContainedRange");
   function getSequenceWithinRange(range, sequence) {
     if (range.start < 0 || range.end < 0)
       return "";
@@ -3246,7 +3435,7 @@ var __async = (__this, __arguments, generator) => {
         return new RegExp(regexMatch[1], regexMatch[2]);
       }
       __name(cloneRegExp2, "cloneRegExp");
-      function clone(arg) {
+      function clone2(arg) {
         if ((typeof arg === "undefined" ? "undefined" : _typeof(arg)) !== "object") {
           return arg;
         }
@@ -3254,7 +3443,7 @@ var __async = (__this, __arguments, generator) => {
           return null;
         }
         if (isArray2(arg)) {
-          return arg.map(clone);
+          return arg.map(clone2);
         }
         if (arg instanceof Date) {
           return new Date(arg.getTime());
@@ -3265,12 +3454,12 @@ var __async = (__this, __arguments, generator) => {
         var cloned = {};
         for (var name2 in arg) {
           if (Object.prototype.hasOwnProperty.call(arg, name2)) {
-            cloned[name2] = clone(arg[name2]);
+            cloned[name2] = clone2(arg[name2]);
           }
         }
         return cloned;
       }
-      __name(clone, "clone");
+      __name(clone2, "clone");
       var DiffContext = function(_Context) {
         inherits2(DiffContext2, _Context);
         function DiffContext2(left, right) {
@@ -3286,7 +3475,7 @@ var __async = (__this, __arguments, generator) => {
           key: "setResult",
           value: /* @__PURE__ */ __name(function setResult(result) {
             if (this.options.cloneDiffValues && (typeof result === "undefined" ? "undefined" : _typeof(result)) === "object") {
-              var clone$$1 = typeof this.options.cloneDiffValues === "function" ? this.options.cloneDiffValues : clone;
+              var clone$$1 = typeof this.options.cloneDiffValues === "function" ? this.options.cloneDiffValues : clone2;
               if (_typeof(result[0]) === "object") {
                 result[0] = clone$$1(result[0]);
               }
@@ -5598,7 +5787,7 @@ var __async = (__this, __arguments, generator) => {
         }, {
           key: "clone",
           value: /* @__PURE__ */ __name(function clone$$1(value) {
-            return clone(value);
+            return clone2(value);
           }, "clone$$1")
         }]);
         return DiffPatcher2;
@@ -7122,123 +7311,167 @@ var __async = (__this, __arguments, generator) => {
     return proteinAlphabet[letter.toUpperCase()];
   }
   __name(getAminoAcidFromSequenceTriplet, "getAminoAcidFromSequenceTriplet");
-  function getAminoAcidDataForEachBaseOfDna(originalSequenceString, forward, optionalSubrangeRange, isProteinSequence) {
+  function getNextTriplet(index, sequenceString, exonRange) {
+    let triplet = "";
+    let internalIndex;
+    const codonPositions = [];
+    const isBaseInExon = /* @__PURE__ */ __name((baseIndex) => exonRange.some(
+      (r) => isPositionWithinRange(baseIndex, r, sequenceString.length)
+    ), "isBaseInExon");
+    for (internalIndex = index; internalIndex < sequenceString.length; internalIndex++) {
+      if (triplet.length === 3) {
+        break;
+      }
+      if (isBaseInExon(internalIndex)) {
+        triplet += sequenceString[internalIndex];
+        codonPositions.push(internalIndex);
+      }
+    }
+    return { triplet, basesRead: internalIndex - index, codonPositions };
+  }
+  __name(getNextTriplet, "getNextTriplet");
+  function getTranslatedSequenceProperties(originalSequenceString, forward, optionalSubrangeRange, isProteinSequence) {
     const originalSequenceStringLength = isProteinSequence ? originalSequenceString.length * 3 : originalSequenceString.length;
     let sequenceString = originalSequenceString;
-    let startOffset = 0;
+    const translationRange = { start: 0, end: originalSequenceStringLength - 1 };
     if (optionalSubrangeRange) {
       sequenceString = getSequenceWithinRange(
         optionalSubrangeRange,
         originalSequenceString
       );
-      startOffset = optionalSubrangeRange.start;
+      translationRange.start = optionalSubrangeRange.start;
+      translationRange.end = optionalSubrangeRange.end;
     }
     const sequenceStringLength = isProteinSequence ? sequenceString.length * 3 : sequenceString.length;
-    const aminoAcidDataForEachBaseOfDNA = [];
-    let codonRange;
-    let revCompGapLength = 0;
-    let aminoAcidIndex = 0;
-    if (!forward) {
-      aminoAcidIndex = Math.floor((sequenceStringLength - 1) / 3);
-      revCompGapLength = sequenceStringLength % 3;
-      codonRange = translateRange(
-        {
-          start: 0,
-          end: revCompGapLength - 1
-        },
-        startOffset,
+    if (!isProteinSequence && !forward) {
+      sequenceString = getReverseComplementSequenceString(sequenceString);
+    }
+    const absoluteExonRange = !isProteinSequence && optionalSubrangeRange && optionalSubrangeRange.locations ? optionalSubrangeRange.locations : [translationRange];
+    const exonRange = absoluteExonRange.map((range) => {
+      let outputRange = translateRange(
+        range,
+        -translationRange.start,
         originalSequenceStringLength
       );
-      if (revCompGapLength > 0) {
-        for (let i2 = 0; i2 < revCompGapLength; i2++) {
-          aminoAcidDataForEachBaseOfDNA.push({
-            aminoAcid: getAminoAcidFromSequenceTriplet("xxx"),
-            //fake xxx triplet returns the ambiguous X amino acid
-            positionInCodon: revCompGapLength - i2 - 1,
-            aminoAcidIndex,
-            sequenceIndex: codonRange.start + i2,
-            codonRange,
-            fullCodon: false
-          });
-        }
-        aminoAcidIndex--;
+      if (!forward) {
+        outputRange = flipRelativeRange(
+          outputRange,
+          { start: 0, end: sequenceStringLength - 1 },
+          sequenceStringLength
+        );
       }
+      return outputRange;
+    });
+    return {
+      sequenceString,
+      translationRange,
+      sequenceStringLength,
+      originalSequenceStringLength,
+      exonRange
+    };
+  }
+  __name(getTranslatedSequenceProperties, "getTranslatedSequenceProperties");
+  function positionInCdsToPositionInMainSequence(index, forward, translationRange, mainSequenceLength) {
+    let outputRange = translateRange(
+      { start: index, end: index },
+      translationRange.start,
+      mainSequenceLength
+    );
+    if (!forward) {
+      outputRange = flipRelativeRange(
+        outputRange,
+        translationRange,
+        mainSequenceLength
+      );
     }
-    for (let index = 2 + revCompGapLength; index < sequenceStringLength; index += 3) {
+    return outputRange.start;
+  }
+  __name(positionInCdsToPositionInMainSequence, "positionInCdsToPositionInMainSequence");
+  function getAminoAcidDataForEachBaseOfDna(originalSequenceString, forward, optionalSubrangeRange, isProteinSequence) {
+    const {
+      sequenceString,
+      translationRange,
+      sequenceStringLength,
+      originalSequenceStringLength,
+      exonRange
+    } = getTranslatedSequenceProperties(
+      originalSequenceString,
+      forward,
+      optionalSubrangeRange,
+      isProteinSequence
+    );
+    const aminoAcidDataForEachBaseOfDNA = [];
+    for (let index = 0; index < sequenceStringLength; index += 3) {
       let aminoAcid;
+      const aminoAcidIndex = index / 3;
+      let codonPositionsInCDS;
+      let basesRead;
       if (isProteinSequence) {
-        aminoAcid = proteinAlphabet[sequenceString[(index - 2) / 3].toUpperCase()];
+        codonPositionsInCDS = [0, 1, 2].map((i2) => index + i2);
+        basesRead = 3;
+        aminoAcid = proteinAlphabet[sequenceString[index / 3].toUpperCase()];
       } else {
-        let triplet = sequenceString.slice(index - 2, index + 1);
-        if (!forward) {
-          triplet = getReverseComplementSequenceString(triplet);
-        }
-        aminoAcid = getAminoAcidFromSequenceTriplet(triplet);
-      }
-      codonRange = translateRange(
-        {
-          start: index - 2,
-          end: index
-        },
-        startOffset,
-        originalSequenceStringLength
+        const {
+          triplet,
+          basesRead: _basesRead,
+          codonPositions
+        } = getNextTriplet(index, sequenceString, exonRange);
+        basesRead = _basesRead;
+        codonPositionsInCDS = codonPositions;
+        aminoAcid = triplet.length === 3 ? getAminoAcidFromSequenceTriplet(triplet) : getAminoAcidFromSequenceTriplet("xxx");
+      }
+      const absoluteCodonPositions = codonPositionsInCDS.map(
+        (i2) => positionInCdsToPositionInMainSequence(
+          i2,
+          forward,
+          translationRange,
+          originalSequenceStringLength
+        )
       );
-      aminoAcidDataForEachBaseOfDNA.push({
-        aminoAcid,
-        //gap amino acid
-        positionInCodon: forward ? 0 : 2,
-        aminoAcidIndex,
-        sequenceIndex: codonRange.start,
-        codonRange,
-        fullCodon: true
-      });
-      aminoAcidDataForEachBaseOfDNA.push({
-        aminoAcid,
-        //gap amino acid
-        positionInCodon: 1,
-        aminoAcidIndex,
-        sequenceIndex: codonRange.start + 1,
-        codonRange,
-        fullCodon: true
-      });
-      aminoAcidDataForEachBaseOfDNA.push({
-        aminoAcid,
-        //gap amino acid
-        positionInCodon: forward ? 2 : 0,
-        aminoAcidIndex,
-        sequenceIndex: codonRange.start + 2,
-        codonRange,
-        fullCodon: true
-      });
-      if (forward) {
-        aminoAcidIndex++;
-      } else {
-        aminoAcidIndex--;
+      const codonRange = forward ? {
+        start: absoluteCodonPositions[0],
+        end: absoluteCodonPositions[codonPositionsInCDS.length - 1]
+      } : {
+        start: absoluteCodonPositions[codonPositionsInCDS.length - 1],
+        end: absoluteCodonPositions[0]
+      };
+      let positionInCodon = 0;
+      for (let i2 = 0; i2 < basesRead; i2++) {
+        const posInCds = i2 + index;
+        if (codonPositionsInCDS.includes(posInCds)) {
+          aminoAcidDataForEachBaseOfDNA.push({
+            aminoAcid,
+            positionInCodon,
+            aminoAcidIndex,
+            sequenceIndex: absoluteCodonPositions[i2],
+            codonRange,
+            fullCodon: codonPositionsInCDS.length === 3
+          });
+          positionInCodon++;
+        } else {
+          aminoAcidDataForEachBaseOfDNA.push({
+            aminoAcid: null,
+            positionInCodon: null,
+            aminoAcidIndex: null,
+            sequenceIndex: positionInCdsToPositionInMainSequence(
+              posInCds,
+              forward,
+              translationRange,
+              originalSequenceStringLength
+            ),
+            codonRange: null,
+            fullCodon: null
+          });
+        }
       }
-    }
-    const lengthOfEndBpsNotCoveredByAminoAcids = sequenceStringLength - aminoAcidDataForEachBaseOfDNA.length;
-    codonRange = translateRange(
-      {
-        start: sequenceStringLength - lengthOfEndBpsNotCoveredByAminoAcids,
-        end: sequenceStringLength - 1
-      },
-      startOffset,
-      originalSequenceStringLength
-    );
-    for (let j = 0; j < lengthOfEndBpsNotCoveredByAminoAcids; j++) {
-      aminoAcidDataForEachBaseOfDNA.push({
-        aminoAcid: getAminoAcidFromSequenceTriplet("xxx"),
-        //fake xxx triplet returns the gap amino acid
-        positionInCodon: j,
-        aminoAcidIndex,
-        sequenceIndex: codonRange.start + j,
-        fullCodon: false,
-        codonRange
-      });
+      index += basesRead - codonPositionsInCDS.length;
     }
     if (sequenceStringLength !== aminoAcidDataForEachBaseOfDNA.length) {
       throw new Error("something went wrong!");
     }
+    if (!forward) {
+      aminoAcidDataForEachBaseOfDNA.reverse();
+    }
     return aminoAcidDataForEachBaseOfDNA;
   }
   __name(getAminoAcidDataForEachBaseOfDna, "getAminoAcidDataForEachBaseOfDna");
@@ -7684,9 +7917,9 @@ var __async = (__this, __arguments, generator) => {
     // Helix initiation for deltaS
     R: 1.987,
     // Gas constant (cal/(K*mol)).
-    C: 5e-7,
+    primerConc: 5e-7,
     // Oligo concentration. 0.5uM is typical for PCR.
-    Na: 0.05,
+    monovalentCationConc: 0.05,
     // Monovalent salt concentration. 50mM is typical for PCR.
     /**
      * Calculates temperature for DNA sequence using a given algorithm.
@@ -7694,10 +7927,11 @@ var __async = (__this, __arguments, generator) => {
      * type - Either Teselagen.bio.tools.TemperatureCalculator.TABLE_BRESLAUER, TABLE_SUGIMOTO, or TABLE_UNIFIED
      * A - Helix initation for deltaS. Defaults to -10.8.
      * R - The gas constant, in cal/(K*mol). Defaults to 0.5e-6M.
-     * Na - THe monovalent salt concentration. Defaults to 50e-3M.
+     * monovalentCationConc - THe monovalent salt concentration. Defaults to 50e-3M.
      * return - Temperature for the given sequence, in Celsius.
      */
-    calculateTemperature: function(sequence, type, A, R, C, Na) {
+    calculateTemperature: 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) {
@@ -7709,11 +7943,11 @@ var __async = (__this, __arguments, generator) => {
       if (!R) {
         R = this.R;
       }
-      if (!C) {
-        C = this.C;
+      if (!primerConc) {
+        primerConc = this.primerConc;
       }
-      if (!Na) {
-        Na = this.Na;
+      if (!monovalentCationConc) {
+        monovalentCationConc = this.monovalentCationConc;
       }
       const sequenceLength = sequence.length;
       if (sequenceLength == 0) {
@@ -7744,11 +7978,8 @@ var __async = (__this, __arguments, generator) => {
         sumDeltaH = sumDeltaH + neighbors[i2] * deltaHTable[i2];
         sumDeltaS = sumDeltaS + neighbors[i2] * deltaSTable[i2];
       }
-      const temperature = -1e3 * sumDeltaH / (A + -sumDeltaS + R * Math.log(C / 4)) - 273.15 + 16.6 * Math.LOG10E * Math.log(Na);
-      if (temperature < 0) {
-        return 0;
-      }
-      return temperature.toFixed(2);
+      const temperature = -1e3 * sumDeltaH / (A + -sumDeltaS + R * Math.log(primerConc / 4)) - 273.15 + 16.6 * Math.LOG10E * Math.log(monovalentCationConc);
+      return temperature;
     },
     /**
      * @private
@@ -7818,6 +8049,39 @@ var __async = (__this, __arguments, generator) => {
         return null;
       }
     },
+    // "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.

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@teselagen/bio-parsers",
-  "version": "0.4.18",
+  "version": "0.4.20",
   "dependencies": {
-    "@teselagen/sequence-utils": "0.3.24",
+    "@teselagen/sequence-utils": "0.3.25",
     "@teselagen/range-utils": "0.3.7",
     "@gmod/gff": "^1.2.1",
     "buffer": "^6.0.3",
@@ -10,7 +10,7 @@
     "color": "^4.2.3",
     "fast-xml-parser": "^4.2.5",
     "fflate": "^0.8.0",
-    "lodash": "^4.17.21",
+    "lodash-es": "^4.17.21",
     "string_decoder": "^1.3.0",
     "validate.io-nonnegative-integer-array": "^1.0.1"
   },