@teselagen/sequence-utils 0.3.32 → 0.3.36

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@teselagen/sequence-utils",
-  "version": "0.3.32",
+  "version": "0.3.36",
   "type": "module",
   "dependencies": {
     "escape-string-regexp": "5.0.0",
-    "jsondiffpatch": "0.4.1",
+    "jsondiffpatch": "0.7.3",
     "string-splice": "^1.3.0",
     "lodash-es": "^4.17.21",
     "shortid": "2.2.16",

package/proteinAlphabet.d.ts

@@ -108,6 +108,14 @@ declare const proteinAlphabet: {
         color: string;
         mass: number;
     };
+    O: {
+        value: string;
+        name: string;
+        threeLettersName: string;
+        colorByFamily: string;
+        color: string;
+        mass: number;
+    };
     M: {
         value: string;
         name: string;

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/diffUtils.js

@@ -1,5 +1,5 @@
 import { cloneDeep, forEach } from "lodash-es";
-import { diff, patch, reverse } from "jsondiffpatch/dist/jsondiffpatch.umd";
+import { diff, patch, reverse } from "jsondiffpatch";
 
 import tidyUpSequenceData from "./tidyUpSequenceData";
 

package/src/filterSequenceString.js

@@ -103,7 +103,7 @@ export function getAcceptedChars({
   isMixedRnaAndDna
 } = {}) {
   return isProtein
-    ? `${extended_protein_letters.toLowerCase()}}`
+    ? `${extended_protein_letters.toLowerCase()}`
     : isOligo
       ? ambiguous_rna_letters.toLowerCase() + "t"
       : isRna

package/src/getAminoAcidDataForEachBaseOfDna.js

@@ -186,6 +186,9 @@ export default function getAminoAcidDataForEachBaseOfDna(
   optionalSubrangeRange,
   isProteinSequence
 ) {
+  if (!originalSequenceString) {
+    return [];
+  }
   // Obtain derived properties, see getTranslatedSequenceProperties
   const {
     sequenceString,
@@ -205,7 +208,7 @@ export default function getAminoAcidDataForEachBaseOfDna(
   // Iterate over the DNA sequence length in increments of 3
   for (let index = 0; index < sequenceStringLength; index += 3) {
     let aminoAcid;
-    const aminoAcidIndex = index / 3;
+    const aminoAcidIndex = Math.floor(index / 3);
     let codonPositionsInCDS;
     let basesRead;
 

package/src/getSequenceDataBetweenRange.test.js

@@ -225,22 +225,14 @@ describe("getSequenceDataBetweenRange", () => {
         end: 3
       }
     );
-    res.should.containSubset({
-      sequence: "gc",
-      features: [
-        {
-          start: 0,
-          end: 1,
-          locations: [
-            {
-              start: 0,
-              end: 1
-            }
-          ],
-          name: "happy"
-        }
-      ]
-    });
+    res.features.should.containSubset([
+      {
+        start: 0,
+        end: 1,
+        name: "happy"
+      }
+    ]);
+    res.sequence.should.equal("gc");
   });
   it("feature with locations, non circular enclosing range", () => {
     const res = getSequenceDataBetweenRange(
@@ -283,7 +275,7 @@ describe("getSequenceDataBetweenRange", () => {
       ]
     });
   });
-  it.only("feature with locations, non circular, non-fully enclosing range - it should trim the start/end correctly to match the location", () => {
+  it("feature with locations, non circular, non-fully enclosing range - it should trim the start/end correctly to match the location", () => {
     const res = getSequenceDataBetweenRange(
       {
         sequence: "gggatgcatgca",

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/insertSequenceDataAtPositionOrRange.js

@@ -27,9 +27,10 @@ export default function insertSequenceDataAtPositionOrRange(
     ...options
   });
   const newSequenceData = cloneDeep(existingSequenceData);
-  const insertLength = sequenceDataToInsert.proteinSequence
-    ? sequenceDataToInsert.proteinSequence.length * 3
-    : sequenceDataToInsert.sequence.length;
+  const insertLength =
+    sequenceDataToInsert.isProtein && sequenceDataToInsert.proteinSequence
+      ? sequenceDataToInsert.proteinSequence.length * 3
+      : sequenceDataToInsert.sequence.length;
   let caretPosition = caretPositionOrRange;
 
   const isInsertSameLengthAsSelection =
@@ -187,7 +188,7 @@ function adjustAnnotationsToDelete(annotationsToBeAdjusted, range, maxLength) {
         ...newRange,
         start: newLocations[0].start,
         end: newLocations[newLocations.length - 1].end,
-        ...(newLocations.length > 1 && { locations: newLocations })
+        ...(newLocations.length > 0 && { locations: newLocations })
       };
     } else {
       return newRange;

package/src/proteinAlphabet.js

@@ -112,6 +112,15 @@ const proteinAlphabet = {
     mass: 128.17228
   },
 
+  O: {
+    value: "O",
+    name: "Pyrrolysine",
+    threeLettersName: "Pyl",
+    colorByFamily: "#FFC0CB",
+    color: "hsl(264.7, 100%, 69%)",
+    mass: 255.313
+  },
+
   M: {
     value: "M",
     name: "Methionine",

package/src/threeLetterSequenceStringToAminoAcidMap.js

@@ -1,6 +1,6 @@
 import proteinAlphabet from "./proteinAlphabet";
 
-const threeLetterSequenceStringToAminoAcidMap = {
+const initThreeLetterSequenceStringToAminoAcidMap = {
   gct: proteinAlphabet.A,
   gcc: proteinAlphabet.A,
   gca: proteinAlphabet.A,
@@ -99,8 +99,80 @@ const threeLetterSequenceStringToAminoAcidMap = {
   taa: proteinAlphabet["*"],
   tag: proteinAlphabet["*"],
   tga: proteinAlphabet["*"],
+  uaa: proteinAlphabet["*"],
+  uag: proteinAlphabet["*"],
+  uga: proteinAlphabet["*"],
   "...": proteinAlphabet["."],
   "---": proteinAlphabet["-"]
 };
 
+// IUPAC nucleotide codes (DNA/RNA) with U awareness
+const IUPAC = {
+  A: ["A"],
+  C: ["C"],
+  G: ["G"],
+  T: ["T"],
+  U: ["U"],
+
+  R: ["A", "G"],
+  Y: ["C", "T", "U"],
+  K: ["G", "T", "U"],
+  M: ["A", "C"],
+  S: ["G", "C"],
+  W: ["A", "T", "U"],
+  B: ["C", "G", "T", "U"],
+  D: ["A", "G", "T", "U"],
+  H: ["A", "C", "T", "U"],
+  V: ["A", "C", "G"],
+  N: ["A", "C", "G", "T", "U"],
+  X: ["A", "C", "G", "T", "U"]
+};
+
+
+function expandAndResolve(threeLetterCodon) {
+  const chars = threeLetterCodon.toUpperCase().split("");
+  const picks = chars.map((c) => IUPAC[c] || [c]);
+
+  let allPossibleThreeLetterCodons = [""];
+  for (const set of picks) {
+    const next = [];
+    for (const prefix of allPossibleThreeLetterCodons) for (const b of set) next.push(prefix + b);
+    allPossibleThreeLetterCodons = next;
+  }
+  let foundAminoAcid = null;
+  for (const codon of allPossibleThreeLetterCodons) {
+    const lowerCodon = codon.toLowerCase();
+    const aminoAcidObj = initThreeLetterSequenceStringToAminoAcidMap[lowerCodon] ?? initThreeLetterSequenceStringToAminoAcidMap[lowerCodon.replace(/u/g, "t")] ?? initThreeLetterSequenceStringToAminoAcidMap[lowerCodon.replace(/t/g, "u")];
+    if (aminoAcidObj) {
+      if (!foundAminoAcid) {
+        foundAminoAcid = aminoAcidObj;
+      } else if (foundAminoAcid.value !== aminoAcidObj.value ) {
+        return null
+      }
+    } else {
+      return null;
+    }
+  }
+  return foundAminoAcid;
+}
+
+function getCodonToAminoAcidMap() {
+  const map = initThreeLetterSequenceStringToAminoAcidMap;
+  // generate all IUPAC 3-mers
+  const codes = Object.keys(IUPAC);
+  for (const a of codes)
+    for (const b of codes)
+      for (const c of codes) {
+        const codon = a + b + c;
+        const lowerCodon = codon.toLowerCase();
+        if (map[lowerCodon]) continue;
+        const aminoAcidObj = expandAndResolve(codon);
+        if (aminoAcidObj) map[lowerCodon] = aminoAcidObj;
+      }
+
+  return map;
+}
+
+const threeLetterSequenceStringToAminoAcidMap = getCodonToAminoAcidMap();
+
 export default threeLetterSequenceStringToAminoAcidMap;

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;
     });
   }
 

package/threeLetterSequenceStringToAminoAcidMap.d.ts

@@ -879,6 +879,30 @@ declare const threeLetterSequenceStringToAminoAcidMap: {
         color: string;
         mass: number;
     };
+    uaa: {
+        value: string;
+        name: string;
+        threeLettersName: string;
+        colorByFamily: string;
+        color: string;
+        mass: number;
+    };
+    uag: {
+        value: string;
+        name: string;
+        threeLettersName: string;
+        colorByFamily: string;
+        color: string;
+        mass: number;
+    };
+    uga: {
+        value: string;
+        name: string;
+        threeLettersName: string;
+        colorByFamily: string;
+        color: string;
+        mass: number;
+    };
     "...": {
         value: string;
         name: string;