@teselagen/bio-parsers 0.4.18 → 0.4.20

package/index.cjs

@@ -1398,14 +1398,14 @@ function baseIsSet(value) {
 __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);
   }
@@ -1465,6 +1465,11 @@ function baseClone(value, bitmask, customizer, key, object, stack) {
   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);
@@ -2407,6 +2412,45 @@ function trimRangeByAnotherRange(rangeToBeTrimmed, trimmingRange, sequenceLength
   }
 }
 __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,
@@ -2418,6 +2462,22 @@ function isRangeWithinRange(rangeToCheck, containingRange, maxLength) {
   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) {
@@ -2428,6 +2488,23 @@ function normalizePositionByRangeLength(pPosition, sequenceLength, isInBetweenPo
   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(
@@ -2441,6 +2518,118 @@ function translateRange(rangeToBeAdjusted, translateBy, rangeLength) {
   });
 }
 __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 "";
@@ -3244,7 +3433,7 @@ __name(requireEmpty, "requireEmpty");
       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;
       }
@@ -3252,7 +3441,7 @@ __name(requireEmpty, "requireEmpty");
         return null;
       }
       if (isArray2(arg)) {
-        return arg.map(clone);
+        return arg.map(clone2);
       }
       if (arg instanceof Date) {
         return new Date(arg.getTime());
@@ -3263,12 +3452,12 @@ __name(requireEmpty, "requireEmpty");
       var cloned = {};
       for (var name in arg) {
         if (Object.prototype.hasOwnProperty.call(arg, name)) {
-          cloned[name] = clone(arg[name]);
+          cloned[name] = clone2(arg[name]);
         }
       }
       return cloned;
     }
-    __name(clone, "clone");
+    __name(clone2, "clone");
     var DiffContext = function(_Context) {
       inherits2(DiffContext2, _Context);
       function DiffContext2(left, right) {
@@ -3284,7 +3473,7 @@ __name(requireEmpty, "requireEmpty");
         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]);
             }
@@ -5596,7 +5785,7 @@ __name(requireEmpty, "requireEmpty");
       }, {
         key: "clone",
         value: /* @__PURE__ */ __name(function clone$$1(value) {
-          return clone(value);
+          return clone2(value);
         }, "clone$$1")
       }]);
       return DiffPatcher2;
@@ -7120,123 +7309,167 @@ function getAminoAcidFromSequenceTriplet(sequenceString) {
   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 i = 0; i < revCompGapLength; i++) {
-        aminoAcidDataForEachBaseOfDNA.push({
-          aminoAcid: getAminoAcidFromSequenceTriplet("xxx"),
-          //fake xxx triplet returns the ambiguous X amino acid
-          positionInCodon: revCompGapLength - i - 1,
-          aminoAcidIndex,
-          sequenceIndex: codonRange.start + i,
-          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((i) => index + i);
+      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(
+      (i) => positionInCdsToPositionInMainSequence(
+        i,
+        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 i = 0; i < basesRead; i++) {
+      const posInCds = i + index;
+      if (codonPositionsInCDS.includes(posInCds)) {
+        aminoAcidDataForEachBaseOfDNA.push({
+          aminoAcid,
+          positionInCodon,
+          aminoAcidIndex,
+          sequenceIndex: absoluteCodonPositions[i],
+          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");
@@ -7682,9 +7915,9 @@ const calcTmMethods = {
   // 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.
@@ -7692,10 +7925,11 @@ const calcTmMethods = {
    * 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) {
@@ -7707,11 +7941,11 @@ const calcTmMethods = {
     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) {
@@ -7742,11 +7976,8 @@ const calcTmMethods = {
       sumDeltaH = sumDeltaH + neighbors[i] * deltaHTable[i];
       sumDeltaS = sumDeltaS + neighbors[i] * deltaSTable[i];
     }
-    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
@@ -7816,6 +8047,39 @@ const calcTmMethods = {
       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.