@teselagen/sequence-utils 0.3.35 → 0.3.37

package/calculateEndStability.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Calculate End Stability (3' end stability) of a primer
+ *
+ * The maximum stability for the last five 3' bases of a left or right primer.
+ * Bigger numbers mean more stable 3' ends. The value is the maximum delta G
+ * (kcal/mol) for duplex disruption for the five 3' bases.
+ *
+ * According to Primer3 documentation:
+ * - Most stable 5mer duplex: GCGCG = 6.86 kcal/mol (SantaLucia 1998)
+ * - Most labile 5mer duplex: TATAT = 0.86 kcal/mol (SantaLucia 1998)
+ *
+ * @param {string} sequence - DNA sequence (5' to 3')
+ * @returns {number} - Delta G (kcal/mol) for the last 5 bases at 3' end
+ * @throws {Error} Invalid sequence or too short.
+ */
+export default function calculateEndStability(sequence: string): number;

package/calculateEndStability.test.d.ts

@@ -0,0 +1 @@
+export {};

package/calculateSantaLuciaTm.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Validate DNA sequence
+ *
+ * @param {string} sequence - DNA sequence
+ * @returns {boolean} - True if valid
+ */
+export function isValidSequence(sequence: string): boolean;
+/**
+ * Calculate melting temperature using SantaLucia (1998) method
+ *
+ * @param {string} sequence - DNA sequence (5' to 3')
+ * @returns {number} - Melting temperature in Celsius
+ * @throws {Error} Invalid sequence or too short.
+ */
+export default function calculateSantaLuciaTm(sequence: string): number;
+export namespace SANTA_LUCIA_NN {
+    namespace AA {
+        let dH: number;
+        let dS: number;
+    }
+    namespace TT {
+        let dH_1: number;
+        export { dH_1 as dH };
+        let dS_1: number;
+        export { dS_1 as dS };
+    }
+    namespace AT {
+        let dH_2: number;
+        export { dH_2 as dH };
+        let dS_2: number;
+        export { dS_2 as dS };
+    }
+    namespace TA {
+        let dH_3: number;
+        export { dH_3 as dH };
+        let dS_3: number;
+        export { dS_3 as dS };
+    }
+    namespace CA {
+        let dH_4: number;
+        export { dH_4 as dH };
+        let dS_4: number;
+        export { dS_4 as dS };
+    }
+    namespace TG {
+        let dH_5: number;
+        export { dH_5 as dH };
+        let dS_5: number;
+        export { dS_5 as dS };
+    }
+    namespace GT {
+        let dH_6: number;
+        export { dH_6 as dH };
+        let dS_6: number;
+        export { dS_6 as dS };
+    }
+    namespace AC {
+        let dH_7: number;
+        export { dH_7 as dH };
+        let dS_7: number;
+        export { dS_7 as dS };
+    }
+    namespace CT {
+        let dH_8: number;
+        export { dH_8 as dH };
+        let dS_8: number;
+        export { dS_8 as dS };
+    }
+    namespace AG {
+        let dH_9: number;
+        export { dH_9 as dH };
+        let dS_9: number;
+        export { dS_9 as dS };
+    }
+    namespace GA {
+        let dH_10: number;
+        export { dH_10 as dH };
+        let dS_10: number;
+        export { dS_10 as dS };
+    }
+    namespace TC {
+        let dH_11: number;
+        export { dH_11 as dH };
+        let dS_11: number;
+        export { dS_11 as dS };
+    }
+    namespace CG {
+        let dH_12: number;
+        export { dH_12 as dH };
+        let dS_12: number;
+        export { dS_12 as dS };
+    }
+    namespace GC {
+        let dH_13: number;
+        export { dH_13 as dH };
+        let dS_13: number;
+        export { dS_13 as dS };
+    }
+    namespace GG {
+        let dH_14: number;
+        export { dH_14 as dH };
+        let dS_14: number;
+        export { dS_14 as dS };
+    }
+    namespace CC {
+        let dH_15: number;
+        export { dH_15 as dH };
+        let dS_15: number;
+        export { dS_15 as dS };
+    }
+}
+export namespace SANTA_LUCIA_INIT {
+    export namespace GC_1 {
+        let dH_16: number;
+        export { dH_16 as dH };
+        let dS_16: number;
+        export { dS_16 as dS };
+    }
+    export { GC_1 as GC };
+    export namespace AT_1 {
+        let dH_17: number;
+        export { dH_17 as dH };
+        let dS_17: number;
+        export { dS_17 as dS };
+    }
+    export { AT_1 as AT };
+}

package/calculateSantaLuciaTm.test.d.ts

@@ -0,0 +1 @@
+export {};

package/index.cjs

@@ -3563,7 +3563,7 @@ const genbankFeatureTypes = [
   { name: "regulatory", color: "#3F6C51" },
   { name: "SecStr", color: "#7B4B94" },
   { name: "Site", color: "#7D82B8" },
-  { name: "telomere", color: "DE9151" },
+  { name: "telomere", color: "#DE9151" },
   { name: "tmRNA", color: "#B7E3CC" },
   { name: "unsure", color: "#C4FFB2" },
   { name: "V_segment", color: "#D6F7A3" },
@@ -6532,17 +6532,25 @@ function tidyUpSequenceData(pSeqData, options = {}) {
   });
   if (!noTranslationData) {
     seqData.translations = flatMap(seqData.translations, (translation) => {
+      var _a, _b;
       if (noCdsTranslations && translation.translationType === "CDS Feature") {
         return [];
       }
-      if (!translation.aminoAcids && !seqData.noSequence) {
-        translation.aminoAcids = getAminoAcidDataForEachBaseOfDna(
+      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,
+        true,
+        seqData.sequence.length
+      );
+      if (!expandedRange.aminoAcids && !seqData.noSequence) {
+        expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
           seqData.sequence,
-          translation.forward,
-          translation
+          expandedRange.forward,
+          expandedRange
         );
       }
-      return translation;
+      return expandedRange;
     });
   }
   if (annotationsAsObjects) {
@@ -16513,6 +16521,160 @@ function calculateNebTa(sequences, primerConc, { monovalentCationConc, polymeras
   }
 }
 __name(calculateNebTa, "calculateNebTa");
+const PRIMER3_PARAMS = {
+  saltMonovalent: 50,
+  // mM
+  saltDivalent: 1.5,
+  // mM
+  dntpConc: 0.6,
+  // mM
+  dnaConc: 50,
+  // nM
+  R: 1.987
+  // Gas constant (cal/K·mol)
+};
+const SANTA_LUCIA_NN = {
+  AA: { dH: -7.9, dS: -22.2 },
+  TT: { dH: -7.9, dS: -22.2 },
+  AT: { dH: -7.2, dS: -20.4 },
+  TA: { dH: -7.2, dS: -21.3 },
+  CA: { dH: -8.5, dS: -22.7 },
+  TG: { dH: -8.5, dS: -22.7 },
+  GT: { dH: -8.4, dS: -22.4 },
+  AC: { dH: -8.4, dS: -22.4 },
+  CT: { dH: -7.8, dS: -21 },
+  AG: { dH: -7.8, dS: -21 },
+  GA: { dH: -8.2, dS: -22.2 },
+  TC: { dH: -8.2, dS: -22.2 },
+  CG: { dH: -10.6, dS: -27.2 },
+  GC: { dH: -9.8, dS: -24.4 },
+  GG: { dH: -8, dS: -19.9 },
+  CC: { dH: -8, dS: -19.9 }
+};
+const SANTA_LUCIA_INIT = {
+  GC: { dH: 0.1, dS: -2.8 },
+  // initiation with terminal GC
+  AT: { dH: 2.3, dS: 4.1 }
+  // initiation with terminal AT
+};
+function getEffectiveMonovalentConc() {
+  let effectiveMono = PRIMER3_PARAMS.saltMonovalent;
+  {
+    const freeMg = Math.max(
+      0,
+      PRIMER3_PARAMS.saltDivalent - PRIMER3_PARAMS.dntpConc
+    );
+    effectiveMono += 120 * Math.sqrt(freeMg);
+  }
+  return effectiveMono;
+}
+__name(getEffectiveMonovalentConc, "getEffectiveMonovalentConc");
+function applySaltCorrection(deltaS, nnPairs) {
+  const effectiveMono = getEffectiveMonovalentConc();
+  return deltaS + 0.368 * nnPairs * Math.log(effectiveMono / 1e3);
+}
+__name(applySaltCorrection, "applySaltCorrection");
+function isValidSequence(sequence) {
+  return /^[ATGCN]+$/.test(sequence);
+}
+__name(isValidSequence, "isValidSequence");
+function calculateSantaLuciaTm(sequence) {
+  try {
+    sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+    if (!isValidSequence(sequence)) {
+      throw new Error("Invalid sequence: contains non-DNA characters");
+    }
+    if (sequence.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);
+      if (dinucleotide.includes("N")) {
+        continue;
+      }
+      const params = SANTA_LUCIA_NN[dinucleotide];
+      if (params) {
+        deltaH += params.dH;
+        deltaS += params.dS;
+      }
+    }
+    const firstBase = sequence[0];
+    const lastBase = sequence[sequence.length - 1];
+    if (firstBase === "G" || firstBase === "C") {
+      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;
+    }
+    if (lastBase === "G" || lastBase === "C") {
+      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;
+    }
+    const nnPairs = sequence.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));
+    return Tm - 273.15;
+  } catch (e) {
+    return `Error calculating Tm for sequence ${sequence}. ${e}`;
+  }
+}
+__name(calculateSantaLuciaTm, "calculateSantaLuciaTm");
+function calculateEndStability(sequence) {
+  try {
+    sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+    if (!isValidSequence(sequence)) {
+      throw new Error("Invalid sequence: contains non-DNA characters");
+    }
+    if (sequence.length < 5) {
+      throw new Error(
+        "Sequence too short: minimum length is 5 bases for end stability calculation"
+      );
+    }
+    const last5Bases = sequence.substring(sequence.length - 5);
+    let deltaH = 0;
+    let deltaS = 0;
+    for (let i = 0; i < 4; i++) {
+      const dinucleotide = last5Bases.substring(i, i + 2);
+      if (dinucleotide.includes("N")) {
+        continue;
+      }
+      const params = SANTA_LUCIA_NN[dinucleotide];
+      if (params) {
+        deltaH += params.dH;
+        deltaS += params.dS;
+      }
+    }
+    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;
+    } else {
+      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;
+    } else {
+      deltaH += SANTA_LUCIA_INIT.AT.dH;
+      deltaS += SANTA_LUCIA_INIT.AT.dS;
+    }
+    const T = 310.15;
+    const deltaG = deltaH - T * deltaS / 1e3;
+    return Math.round(Math.abs(deltaG) * 100) / 100;
+  } catch (e) {
+    return `Error calculating end stability for sequence ${sequence}. ${e}`;
+  }
+}
+__name(calculateEndStability, "calculateEndStability");
 function getDigestFragmentsForCutsites(sequenceLength, circular, cutsites, opts = {}) {
   const fragments = [];
   const pairs = [];
@@ -16674,9 +16836,11 @@ exports.annotateSingleSeq = annotateSingleSeq;
 exports.annotationTypes = annotationTypes;
 exports.autoAnnotate = autoAnnotate;
 exports.bioData = bioData;
+exports.calculateEndStability = calculateEndStability;
 exports.calculateNebTa = calculateNebTa;
 exports.calculateNebTm = calculateNebTm;
 exports.calculatePercentGC = calculatePercentGC;
+exports.calculateSantaLuciaTm = calculateSantaLuciaTm;
 exports.calculateTm = calculateTm;
 exports.computeDigestFragments = computeDigestFragments;
 exports.condensePairwiseAlignmentDifferences = condensePairwiseAlignmentDifferences;

package/index.d.ts

@@ -63,6 +63,8 @@ export { default as condensePairwiseAlignmentDifferences } from './condensePairw
 export { default as addGapsToSeqReads } from './addGapsToSeqReads';
 export { default as calculateNebTm } from './calculateNebTm';
 export { default as calculateNebTa } from './calculateNebTa';
+export { default as calculateSantaLuciaTm } from './calculateSantaLuciaTm';
+export { default as calculateEndStability } from './calculateEndStability';
 export { default as getDigestFragmentsForCutsites } from './getDigestFragmentsForCutsites';
 export { default as getDigestFragmentsForRestrictionEnzymes } from './getDigestFragmentsForRestrictionEnzymes';
 export { default as convertDnaCaretPositionOrRangeToAA } from './convertDnaCaretPositionOrRangeToAA';

package/index.js

@@ -3561,7 +3561,7 @@ const genbankFeatureTypes = [
   { name: "regulatory", color: "#3F6C51" },
   { name: "SecStr", color: "#7B4B94" },
   { name: "Site", color: "#7D82B8" },
-  { name: "telomere", color: "DE9151" },
+  { name: "telomere", color: "#DE9151" },
   { name: "tmRNA", color: "#B7E3CC" },
   { name: "unsure", color: "#C4FFB2" },
   { name: "V_segment", color: "#D6F7A3" },
@@ -6530,17 +6530,25 @@ function tidyUpSequenceData(pSeqData, options = {}) {
   });
   if (!noTranslationData) {
     seqData.translations = flatMap(seqData.translations, (translation) => {
+      var _a, _b;
       if (noCdsTranslations && translation.translationType === "CDS Feature") {
         return [];
       }
-      if (!translation.aminoAcids && !seqData.noSequence) {
-        translation.aminoAcids = getAminoAcidDataForEachBaseOfDna(
+      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,
+        true,
+        seqData.sequence.length
+      );
+      if (!expandedRange.aminoAcids && !seqData.noSequence) {
+        expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
           seqData.sequence,
-          translation.forward,
-          translation
+          expandedRange.forward,
+          expandedRange
         );
       }
-      return translation;
+      return expandedRange;
     });
   }
   if (annotationsAsObjects) {
@@ -16511,6 +16519,160 @@ function calculateNebTa(sequences, primerConc, { monovalentCationConc, polymeras
   }
 }
 __name(calculateNebTa, "calculateNebTa");
+const PRIMER3_PARAMS = {
+  saltMonovalent: 50,
+  // mM
+  saltDivalent: 1.5,
+  // mM
+  dntpConc: 0.6,
+  // mM
+  dnaConc: 50,
+  // nM
+  R: 1.987
+  // Gas constant (cal/K·mol)
+};
+const SANTA_LUCIA_NN = {
+  AA: { dH: -7.9, dS: -22.2 },
+  TT: { dH: -7.9, dS: -22.2 },
+  AT: { dH: -7.2, dS: -20.4 },
+  TA: { dH: -7.2, dS: -21.3 },
+  CA: { dH: -8.5, dS: -22.7 },
+  TG: { dH: -8.5, dS: -22.7 },
+  GT: { dH: -8.4, dS: -22.4 },
+  AC: { dH: -8.4, dS: -22.4 },
+  CT: { dH: -7.8, dS: -21 },
+  AG: { dH: -7.8, dS: -21 },
+  GA: { dH: -8.2, dS: -22.2 },
+  TC: { dH: -8.2, dS: -22.2 },
+  CG: { dH: -10.6, dS: -27.2 },
+  GC: { dH: -9.8, dS: -24.4 },
+  GG: { dH: -8, dS: -19.9 },
+  CC: { dH: -8, dS: -19.9 }
+};
+const SANTA_LUCIA_INIT = {
+  GC: { dH: 0.1, dS: -2.8 },
+  // initiation with terminal GC
+  AT: { dH: 2.3, dS: 4.1 }
+  // initiation with terminal AT
+};
+function getEffectiveMonovalentConc() {
+  let effectiveMono = PRIMER3_PARAMS.saltMonovalent;
+  {
+    const freeMg = Math.max(
+      0,
+      PRIMER3_PARAMS.saltDivalent - PRIMER3_PARAMS.dntpConc
+    );
+    effectiveMono += 120 * Math.sqrt(freeMg);
+  }
+  return effectiveMono;
+}
+__name(getEffectiveMonovalentConc, "getEffectiveMonovalentConc");
+function applySaltCorrection(deltaS, nnPairs) {
+  const effectiveMono = getEffectiveMonovalentConc();
+  return deltaS + 0.368 * nnPairs * Math.log(effectiveMono / 1e3);
+}
+__name(applySaltCorrection, "applySaltCorrection");
+function isValidSequence(sequence) {
+  return /^[ATGCN]+$/.test(sequence);
+}
+__name(isValidSequence, "isValidSequence");
+function calculateSantaLuciaTm(sequence) {
+  try {
+    sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+    if (!isValidSequence(sequence)) {
+      throw new Error("Invalid sequence: contains non-DNA characters");
+    }
+    if (sequence.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);
+      if (dinucleotide.includes("N")) {
+        continue;
+      }
+      const params = SANTA_LUCIA_NN[dinucleotide];
+      if (params) {
+        deltaH += params.dH;
+        deltaS += params.dS;
+      }
+    }
+    const firstBase = sequence[0];
+    const lastBase = sequence[sequence.length - 1];
+    if (firstBase === "G" || firstBase === "C") {
+      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;
+    }
+    if (lastBase === "G" || lastBase === "C") {
+      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;
+    }
+    const nnPairs = sequence.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));
+    return Tm - 273.15;
+  } catch (e) {
+    return `Error calculating Tm for sequence ${sequence}. ${e}`;
+  }
+}
+__name(calculateSantaLuciaTm, "calculateSantaLuciaTm");
+function calculateEndStability(sequence) {
+  try {
+    sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+    if (!isValidSequence(sequence)) {
+      throw new Error("Invalid sequence: contains non-DNA characters");
+    }
+    if (sequence.length < 5) {
+      throw new Error(
+        "Sequence too short: minimum length is 5 bases for end stability calculation"
+      );
+    }
+    const last5Bases = sequence.substring(sequence.length - 5);
+    let deltaH = 0;
+    let deltaS = 0;
+    for (let i = 0; i < 4; i++) {
+      const dinucleotide = last5Bases.substring(i, i + 2);
+      if (dinucleotide.includes("N")) {
+        continue;
+      }
+      const params = SANTA_LUCIA_NN[dinucleotide];
+      if (params) {
+        deltaH += params.dH;
+        deltaS += params.dS;
+      }
+    }
+    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;
+    } else {
+      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;
+    } else {
+      deltaH += SANTA_LUCIA_INIT.AT.dH;
+      deltaS += SANTA_LUCIA_INIT.AT.dS;
+    }
+    const T = 310.15;
+    const deltaG = deltaH - T * deltaS / 1e3;
+    return Math.round(Math.abs(deltaG) * 100) / 100;
+  } catch (e) {
+    return `Error calculating end stability for sequence ${sequence}. ${e}`;
+  }
+}
+__name(calculateEndStability, "calculateEndStability");
 function getDigestFragmentsForCutsites(sequenceLength, circular, cutsites, opts = {}) {
   const fragments = [];
   const pairs = [];
@@ -16673,9 +16835,11 @@ export {
   annotationTypes,
   autoAnnotate,
   bioData,
+  calculateEndStability,
   calculateNebTa,
   calculateNebTm,
   calculatePercentGC,
+  calculateSantaLuciaTm,
   calculateTm,
   computeDigestFragments,
   condensePairwiseAlignmentDifferences,

package/index.umd.cjs

@@ -3565,7 +3565,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     { name: "regulatory", color: "#3F6C51" },
     { name: "SecStr", color: "#7B4B94" },
     { name: "Site", color: "#7D82B8" },
-    { name: "telomere", color: "DE9151" },
+    { name: "telomere", color: "#DE9151" },
     { name: "tmRNA", color: "#B7E3CC" },
     { name: "unsure", color: "#C4FFB2" },
     { name: "V_segment", color: "#D6F7A3" },
@@ -6534,17 +6534,25 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     });
     if (!noTranslationData) {
       seqData.translations = flatMap(seqData.translations, (translation) => {
+        var _a, _b;
         if (noCdsTranslations && translation.translationType === "CDS Feature") {
           return [];
         }
-        if (!translation.aminoAcids && !seqData.noSequence) {
-          translation.aminoAcids = getAminoAcidDataForEachBaseOfDna(
+        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,
+          true,
+          seqData.sequence.length
+        );
+        if (!expandedRange.aminoAcids && !seqData.noSequence) {
+          expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
             seqData.sequence,
-            translation.forward,
-            translation
+            expandedRange.forward,
+            expandedRange
           );
         }
-        return translation;
+        return expandedRange;
       });
     }
     if (annotationsAsObjects) {
@@ -16515,6 +16523,160 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
     }
   }
   __name(calculateNebTa, "calculateNebTa");
+  const PRIMER3_PARAMS = {
+    saltMonovalent: 50,
+    // mM
+    saltDivalent: 1.5,
+    // mM
+    dntpConc: 0.6,
+    // mM
+    dnaConc: 50,
+    // nM
+    R: 1.987
+    // Gas constant (cal/K·mol)
+  };
+  const SANTA_LUCIA_NN = {
+    AA: { dH: -7.9, dS: -22.2 },
+    TT: { dH: -7.9, dS: -22.2 },
+    AT: { dH: -7.2, dS: -20.4 },
+    TA: { dH: -7.2, dS: -21.3 },
+    CA: { dH: -8.5, dS: -22.7 },
+    TG: { dH: -8.5, dS: -22.7 },
+    GT: { dH: -8.4, dS: -22.4 },
+    AC: { dH: -8.4, dS: -22.4 },
+    CT: { dH: -7.8, dS: -21 },
+    AG: { dH: -7.8, dS: -21 },
+    GA: { dH: -8.2, dS: -22.2 },
+    TC: { dH: -8.2, dS: -22.2 },
+    CG: { dH: -10.6, dS: -27.2 },
+    GC: { dH: -9.8, dS: -24.4 },
+    GG: { dH: -8, dS: -19.9 },
+    CC: { dH: -8, dS: -19.9 }
+  };
+  const SANTA_LUCIA_INIT = {
+    GC: { dH: 0.1, dS: -2.8 },
+    // initiation with terminal GC
+    AT: { dH: 2.3, dS: 4.1 }
+    // initiation with terminal AT
+  };
+  function getEffectiveMonovalentConc() {
+    let effectiveMono = PRIMER3_PARAMS.saltMonovalent;
+    {
+      const freeMg = Math.max(
+        0,
+        PRIMER3_PARAMS.saltDivalent - PRIMER3_PARAMS.dntpConc
+      );
+      effectiveMono += 120 * Math.sqrt(freeMg);
+    }
+    return effectiveMono;
+  }
+  __name(getEffectiveMonovalentConc, "getEffectiveMonovalentConc");
+  function applySaltCorrection(deltaS, nnPairs) {
+    const effectiveMono = getEffectiveMonovalentConc();
+    return deltaS + 0.368 * nnPairs * Math.log(effectiveMono / 1e3);
+  }
+  __name(applySaltCorrection, "applySaltCorrection");
+  function isValidSequence(sequence) {
+    return /^[ATGCN]+$/.test(sequence);
+  }
+  __name(isValidSequence, "isValidSequence");
+  function calculateSantaLuciaTm(sequence) {
+    try {
+      sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+      if (!isValidSequence(sequence)) {
+        throw new Error("Invalid sequence: contains non-DNA characters");
+      }
+      if (sequence.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);
+        if (dinucleotide.includes("N")) {
+          continue;
+        }
+        const params = SANTA_LUCIA_NN[dinucleotide];
+        if (params) {
+          deltaH += params.dH;
+          deltaS += params.dS;
+        }
+      }
+      const firstBase = sequence[0];
+      const lastBase = sequence[sequence.length - 1];
+      if (firstBase === "G" || firstBase === "C") {
+        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;
+      }
+      if (lastBase === "G" || lastBase === "C") {
+        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;
+      }
+      const nnPairs = sequence.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));
+      return Tm - 273.15;
+    } catch (e) {
+      return `Error calculating Tm for sequence ${sequence}. ${e}`;
+    }
+  }
+  __name(calculateSantaLuciaTm, "calculateSantaLuciaTm");
+  function calculateEndStability(sequence) {
+    try {
+      sequence = sequence == null ? void 0 : sequence.toUpperCase().trim();
+      if (!isValidSequence(sequence)) {
+        throw new Error("Invalid sequence: contains non-DNA characters");
+      }
+      if (sequence.length < 5) {
+        throw new Error(
+          "Sequence too short: minimum length is 5 bases for end stability calculation"
+        );
+      }
+      const last5Bases = sequence.substring(sequence.length - 5);
+      let deltaH = 0;
+      let deltaS = 0;
+      for (let i = 0; i < 4; i++) {
+        const dinucleotide = last5Bases.substring(i, i + 2);
+        if (dinucleotide.includes("N")) {
+          continue;
+        }
+        const params = SANTA_LUCIA_NN[dinucleotide];
+        if (params) {
+          deltaH += params.dH;
+          deltaS += params.dS;
+        }
+      }
+      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;
+      } else {
+        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;
+      } else {
+        deltaH += SANTA_LUCIA_INIT.AT.dH;
+        deltaS += SANTA_LUCIA_INIT.AT.dS;
+      }
+      const T = 310.15;
+      const deltaG = deltaH - T * deltaS / 1e3;
+      return Math.round(Math.abs(deltaG) * 100) / 100;
+    } catch (e) {
+      return `Error calculating end stability for sequence ${sequence}. ${e}`;
+    }
+  }
+  __name(calculateEndStability, "calculateEndStability");
   function getDigestFragmentsForCutsites(sequenceLength, circular, cutsites, opts = {}) {
     const fragments = [];
     const pairs = [];
@@ -16676,9 +16838,11 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
   exports2.annotationTypes = annotationTypes;
   exports2.autoAnnotate = autoAnnotate;
   exports2.bioData = bioData;
+  exports2.calculateEndStability = calculateEndStability;
   exports2.calculateNebTa = calculateNebTa;
   exports2.calculateNebTm = calculateNebTm;
   exports2.calculatePercentGC = calculatePercentGC;
+  exports2.calculateSantaLuciaTm = calculateSantaLuciaTm;
   exports2.calculateTm = calculateTm;
   exports2.computeDigestFragments = computeDigestFragments;
   exports2.condensePairwiseAlignmentDifferences = condensePairwiseAlignmentDifferences;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/sequence-utils",
-  "version": "0.3.35",
+  "version": "0.3.37",
   "type": "module",
   "dependencies": {
     "escape-string-regexp": "5.0.0",

package/src/calculateEndStability.js

@@ -0,0 +1,86 @@
+import {
+  isValidSequence,
+  SANTA_LUCIA_NN,
+  SANTA_LUCIA_INIT
+} from "./calculateSantaLuciaTm.js";
+
+/**
+ * Calculate End Stability (3' end stability) of a primer
+ *
+ * The maximum stability for the last five 3' bases of a left or right primer.
+ * Bigger numbers mean more stable 3' ends. The value is the maximum delta G
+ * (kcal/mol) for duplex disruption for the five 3' bases.
+ *
+ * According to Primer3 documentation:
+ * - Most stable 5mer duplex: GCGCG = 6.86 kcal/mol (SantaLucia 1998)
+ * - Most labile 5mer duplex: TATAT = 0.86 kcal/mol (SantaLucia 1998)
+ *
+ * @param {string} sequence - DNA sequence (5' to 3')
+ * @returns {number} - Delta G (kcal/mol) for the last 5 bases at 3' end
+ * @throws {Error} Invalid sequence or too short.
+ */
+export default function calculateEndStability(sequence) {
+  try {
+    sequence = sequence?.toUpperCase().trim();
+
+    if (!isValidSequence(sequence)) {
+      throw new Error("Invalid sequence: contains non-DNA characters");
+    }
+
+    if (sequence.length < 5) {
+      throw new Error(
+        "Sequence too short: minimum length is 5 bases for end stability calculation"
+      );
+    }
+
+    const last5Bases = sequence.substring(sequence.length - 5);
+
+    let deltaH = 0; // kcal/mol
+    let deltaS = 0; // cal/K·mol
+
+    // Calculate nearest-neighbor contributions for the 4 dinucleotides
+    for (let i = 0; i < 4; i++) {
+      const dinucleotide = last5Bases.substring(i, i + 2);
+
+      if (dinucleotide.includes("N")) {
+        continue;
+      }
+
+      const params = SANTA_LUCIA_NN[dinucleotide];
+      if (params) {
+        deltaH += params.dH;
+        deltaS += params.dS;
+      }
+    }
+
+    // Add initiation parameters for terminal base pairs
+    const firstBase = last5Bases[0];
+    const lastBase = last5Bases[last5Bases.length - 1];
+
+    // Terminal GC or AT initiation
+    if (firstBase === "G" || firstBase === "C") {
+      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;
+    }
+
+    if (lastBase === "G" || lastBase === "C") {
+      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;
+    }
+
+    // Calculate deltaG at 37°C (310.15 K)
+    // deltaG = deltaH - T * deltaS
+    const T = 310.15; // 37°C in Kelvin
+    const deltaG = deltaH - (T * deltaS) / 1000; // Result in kcal/mol
+
+    return Math.round(Math.abs(deltaG) * 100) / 100;
+  } catch (e) {
+    return `Error calculating end stability for sequence ${sequence}. ${e}`;
+  }
+}

package/src/calculateEndStability.test.js

@@ -0,0 +1,21 @@
+import assert from "assert";
+import calculateEndStability from "./calculateEndStability";
+
+describe("Calculate the stability of the primer ends.", () => {
+  it("should return the end stability score of a given primer sequence", () => {
+    assert.equal(calculateEndStability("AGCGGATAACAATTTCACACAGGA"), 3.89);
+    assert.equal(calculateEndStability("AGCGGATAACAATTTCAC"), 3.24);
+    assert.equal(calculateEndStability("AGCGGATAACAATTTcac"), 3.24);
+    assert.equal(calculateEndStability("ataataccgcgccacatagc"), 2.99);
+    assert.equal(calculateEndStability("AGCGGATAACAATACNNN"), 0.6);
+    assert.equal(calculateEndStability("AGCGGATAACAATACnnn"), 0.6);
+    assert.equal(
+      calculateEndStability("AGCGGATAACAYZAKLPATAC"),
+      "Error calculating end stability for sequence AGCGGATAACAYZAKLPATAC. Error: Invalid sequence: contains non-DNA characters"
+    );
+    assert.equal(
+      calculateEndStability("AGCG"),
+      "Error calculating end stability for sequence AGCG. Error: Sequence too short: minimum length is 5 bases for end stability calculation"
+    );
+  });
+});

package/src/calculateSantaLuciaTm.js

@@ -0,0 +1,177 @@
+/**
+ * Primer3 Melting Temperature Calculator
+ *
+ * Implements the melting temperature calculation algorithm from Primer3
+ * based on the documentation at https://primer3.ut.ee/primer3web_help.htm
+ *
+ * Uses SantaLucia (1998) nearest-neighbor thermodynamics method with
+ * fixed Primer3 custom parameters:
+ * - Formula: SantaLucia (1998)
+ * - Salt correction: SantaLucia (1998)
+ * - Monovalent salt: 50.0 mM
+ * - Divalent salt: 1.5 mM
+ * - dNTP concentration: 0.6 mM
+ * - DNA concentration: 50.0 nM
+ *
+ * References:
+ * - SantaLucia JR (1998) "A unified view of polymer, dumbbell and
+ *   oligonucleotide DNA nearest-neighbor thermodynamics",
+ *   Proc Natl Acad Sci 95:1460-65
+ */
+
+// Primer3 custom parameters (fixed)
+const PRIMER3_PARAMS = {
+  saltMonovalent: 50.0, // mM
+  saltDivalent: 1.5, // mM
+  dntpConc: 0.6, // mM
+  dnaConc: 50.0, // nM
+  R: 1.987 // Gas constant (cal/K·mol)
+};
+
+// SantaLucia (1998) nearest-neighbor parameters
+// dH in kcal/mol, dS in cal/K·mol
+export const SANTA_LUCIA_NN = {
+  AA: { dH: -7.9, dS: -22.2 },
+  TT: { dH: -7.9, dS: -22.2 },
+  AT: { dH: -7.2, dS: -20.4 },
+  TA: { dH: -7.2, dS: -21.3 },
+  CA: { dH: -8.5, dS: -22.7 },
+  TG: { dH: -8.5, dS: -22.7 },
+  GT: { dH: -8.4, dS: -22.4 },
+  AC: { dH: -8.4, dS: -22.4 },
+  CT: { dH: -7.8, dS: -21.0 },
+  AG: { dH: -7.8, dS: -21.0 },
+  GA: { dH: -8.2, dS: -22.2 },
+  TC: { dH: -8.2, dS: -22.2 },
+  CG: { dH: -10.6, dS: -27.2 },
+  GC: { dH: -9.8, dS: -24.4 },
+  GG: { dH: -8.0, dS: -19.9 },
+  CC: { dH: -8.0, dS: -19.9 }
+};
+
+// Initiation parameters (SantaLucia 1998)
+export const SANTA_LUCIA_INIT = {
+  GC: { dH: 0.1, dS: -2.8 }, // initiation with terminal GC
+  AT: { dH: 2.3, dS: 4.1 } // initiation with terminal AT
+};
+
+/**
+ * Calculate effective monovalent cation concentration
+ * Accounts for divalent cations (Mg2+) binding to dNTPs
+ * Formula from von Ahsen et al. (2001)
+ *
+ * @returns {number} - Effective monovalent concentration in mM
+ */
+function getEffectiveMonovalentConc() {
+  let effectiveMono = PRIMER3_PARAMS.saltMonovalent;
+
+  // Adjust for divalent cations
+  if (PRIMER3_PARAMS.saltDivalent > 0) {
+    const freeMg = Math.max(
+      0,
+      PRIMER3_PARAMS.saltDivalent - PRIMER3_PARAMS.dntpConc
+    );
+    effectiveMono += 120 * Math.sqrt(freeMg);
+  }
+
+  return effectiveMono;
+}
+
+/**
+ * Apply SantaLucia (1998) salt correction to entropy
+ *
+ * @param {number} deltaS - Entropy in cal/K·mol
+ * @param {number} nnPairs - Number of nearest-neighbor pairs
+ * @returns {number} - Corrected entropy in cal/K·mol
+ */
+function applySaltCorrection(deltaS, nnPairs) {
+  const effectiveMono = getEffectiveMonovalentConc();
+  // SantaLucia (1998) salt correction
+  return deltaS + 0.368 * nnPairs * Math.log(effectiveMono / 1000);
+}
+
+/**
+ * Validate DNA sequence
+ *
+ * @param {string} sequence - DNA sequence
+ * @returns {boolean} - True if valid
+ */
+export function isValidSequence(sequence) {
+  return /^[ATGCN]+$/.test(sequence);
+}
+
+/**
+ * Calculate melting temperature using SantaLucia (1998) method
+ *
+ * @param {string} sequence - DNA sequence (5' to 3')
+ * @returns {number} - Melting temperature in Celsius
+ * @throws {Error} Invalid sequence or too short.
+ */
+export default function calculateSantaLuciaTm(sequence) {
+  // Convert to uppercase and validate
+  try {
+    sequence = sequence?.toUpperCase().trim();
+
+    if (!isValidSequence(sequence)) {
+      throw new Error("Invalid sequence: contains non-DNA characters");
+    }
+
+    if (sequence.length < 2) {
+      throw new Error("Sequence too short: minimum length is 2 bases");
+    }
+
+    let deltaH = 0; // kcal/mol
+    let deltaS = 0; // cal/K·mol
+
+    // Calculate nearest-neighbor contributions
+    for (let i = 0; i < sequence.length - 1; i++) {
+      const dinucleotide = sequence.substring(i, i + 2);
+
+      // Skip if contains N
+      if (dinucleotide.includes("N")) {
+        continue;
+      }
+
+      const params = SANTA_LUCIA_NN[dinucleotide];
+      if (params) {
+        deltaH += params.dH;
+        deltaS += params.dS;
+      }
+    }
+
+    // Add initiation parameters
+    const firstBase = sequence[0];
+    const lastBase = sequence[sequence.length - 1];
+
+    // Terminal GC or AT initiation
+    if (firstBase === "G" || firstBase === "C") {
+      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;
+    }
+
+    if (lastBase === "G" || lastBase === "C") {
+      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;
+    }
+
+    // Apply salt correction
+    const nnPairs = sequence.length - 1;
+    deltaS = applySaltCorrection(deltaS, nnPairs);
+
+    // Calculate Tm using: Tm = deltaH / (deltaS + R * ln(C/4))
+    // where C is DNA concentration in M (convert from nM)
+    const C = PRIMER3_PARAMS.dnaConc * 1e-9; // Convert nM to M
+    const Tm = (deltaH * 1000) / (deltaS + PRIMER3_PARAMS.R * Math.log(C / 4));
+
+    // Convert from Kelvin to Celsius
+    return Tm - 273.15;
+  } catch (e) {
+    return `Error calculating Tm for sequence ${sequence}. ${e}`;
+  }
+}

package/src/calculateSantaLuciaTm.test.js

@@ -0,0 +1,39 @@
+import assert from "assert";
+import calculateSantaLuciaTm from "./calculateSantaLuciaTm";
+
+describe("calculate Tm based on SantaLucia 1998", () => {
+  it("should return the melting temperature of a given sequence, if no degenerate bases are present", () => {
+    assert.equal(
+      calculateSantaLuciaTm("AGCGGATAACAATTTCACACAGGA"),
+      60.805947394707346
+    );
+    assert.equal(
+      calculateSantaLuciaTm("AGCGGATAACAATTTCAC"),
+      50.301642635069356
+    );
+    assert.equal(
+      calculateSantaLuciaTm("AGCGGATAACAATTTcac"),
+      50.301642635069356
+    );
+    assert.equal(
+      calculateSantaLuciaTm("ataataccgcgccacatagc"),
+      58.27798862992364
+    );
+    assert.equal(
+      calculateSantaLuciaTm("AGCGGATAACAATACNNN"),
+      40.92944342497407
+    );
+    assert.equal(
+      calculateSantaLuciaTm("AGCGGATAACAATACnnn"),
+      40.92944342497407
+    );
+    assert.equal(
+      calculateSantaLuciaTm("AGCGGATAACAYZAKLPATAC"),
+      "Error calculating Tm for sequence AGCGGATAACAYZAKLPATAC. Error: Invalid sequence: contains non-DNA characters"
+    );
+    assert.equal(
+      calculateSantaLuciaTm("A"),
+      "Error calculating Tm for sequence A. Error: Sequence too short: minimum length is 2 bases"
+    );
+  });
+});

package/src/featureTypesAndColors.js

@@ -17,7 +17,7 @@ const genbankFeatureTypes = [
   { name: "regulatory", color: "#3F6C51" },
   { name: "SecStr", color: "#7B4B94" },
   { name: "Site", color: "#7D82B8" },
-  { name: "telomere", color: "DE9151" },
+  { name: "telomere", color: "#DE9151" },
   { name: "tmRNA", color: "#B7E3CC" },
   { name: "unsure", color: "#C4FFB2" },
   { name: "V_segment", color: "#D6F7A3" },

package/src/index.js

@@ -96,6 +96,8 @@ export { default as condensePairwiseAlignmentDifferences } from "./condensePairw
 export { default as addGapsToSeqReads } from "./addGapsToSeqReads";
 export { default as calculateNebTm } from "./calculateNebTm";
 export { default as calculateNebTa } from "./calculateNebTa";
+export { default as calculateSantaLuciaTm } from "./calculateSantaLuciaTm";
+export { default as calculateEndStability } from "./calculateEndStability";
 export { default as getDigestFragmentsForCutsites } from "./getDigestFragmentsForCutsites";
 export { default as getDigestFragmentsForRestrictionEnzymes } from "./getDigestFragmentsForRestrictionEnzymes";
 export { default as convertDnaCaretPositionOrRangeToAA } from "./convertDnaCaretPositionOrRangeToAA";

package/src/tidyUpSequenceData.js

@@ -9,6 +9,7 @@ import tidyUpAnnotation from "./tidyUpAnnotation";
 import getDegenerateDnaStringFromAaString from "./getDegenerateDnaStringFromAAString";
 import { getFeatureTypes } from "./featureTypesAndColors";
 import getAminoAcidStringFromSequenceString from "./getAminoAcidStringFromSequenceString";
+import { expandOrContractRangeByLength } from "@teselagen/range-utils";
 
 export default function tidyUpSequenceData(pSeqData, options = {}) {
   const {
@@ -137,14 +138,21 @@ export default function tidyUpSequenceData(pSeqData, options = {}) {
         //filter off cds translations
         return [];
       }
-      if (!translation.aminoAcids && !seqData.noSequence) {
-        translation.aminoAcids = getAminoAcidDataForEachBaseOfDna(
+      const codonStart = translation?.notes?.codon_start?.[0] - 1 || 0;
+      const expandedRange = expandOrContractRangeByLength(
+        translation,
+        -codonStart,
+        true,
+        seqData.sequence.length
+      );
+      if (!expandedRange.aminoAcids && !seqData.noSequence) {
+        expandedRange.aminoAcids = getAminoAcidDataForEachBaseOfDna(
           seqData.sequence,
-          translation.forward,
-          translation
+          expandedRange.forward,
+          expandedRange
         );
       }
-      return translation;
+      return expandedRange;
     });
   }