@datagrok/sequence-translator 0.0.12 → 1.0.2

package/src/structures-works/map.ts

@@ -1,9 +1,13 @@
+import * as DG from 'datagrok-api/dg';
+import {getAllCodesOfSynthesizer} from './sequence-codes-tools';
+
 export const SYNTHESIZERS = {
   RAW_NUCLEOTIDES: 'Raw Nucleotides',
   BIOSPRING: 'BioSpring Codes',
   GCRS: 'Janssen GCRS Codes',
   AXOLABS: 'Axolabs Codes',
   MERMADE_12: 'Mermade 12',
+  LCMS: 'LCMS',
 };
 export const TECHNOLOGIES = {
   DNA: 'DNA',
@@ -52,7 +56,7 @@ export const MODIFICATIONS: {[index: string]: {molecularWeight: number, left: st
 export const stadardPhosphateLinkSmiles = 'OP(=O)(O)O';
 export const map: {[synthesizer: string]:
   {[technology: string]: {[code: string]:
-    {'name': string, 'weight': number, 'normalized': string, 'SMILES': string}}}} = {
+    {'name'?: string, 'weight'?: number, 'normalized'?: string, 'SMILES': string}}}} = {
       'Raw Nucleotides': {
         'DNA': {
           'A': {
@@ -458,6 +462,7 @@ export const map: {[synthesizer: string]:
             'SMILES': 'OC[C@H]1O[C@@H](N2C3N=C(N)NC(=O)C=3N=C2)[C@H](OC)[C@@H]1O',
           },
         },
+        'Others': {},
       },
       'Mermade 12': {
         'For 2\'-OMe and 2\'-F modified siRNA': {
@@ -559,4 +564,164 @@ export const map: {[synthesizer: string]:
           },
         },
       },
+      // 'LCMS': {
+      //   'For 2\'-OMe and 2\'-F modified siRNA': {
     };
+
+export const lcmsToGcrs = `LCMS, GCRS
+A, A
+C, C
+/5mC/, (5m)C
+G, G
+T, T
+rA, rA
+rC, rC
+rG, rG
+rU, rU
+mA, mA
+mC, mC
+/5mmC/, (5m)mC
+mG, mG
+mU, mU
+fA, fA
+fC, fC
+/5mfC/, (5m)fC
+fG, fG
+fU, fU
+/afA/, afA
+/afC/, afC
+/afG/, afG
+/afU/, afU
++A, lna A
++C, lna C
++G, lna G
++T, lna T
+/moeA/, moeA
+/moeC/, moeC
+/5mmoeC/, (5m)moeC
+/moeG/, moeG
+/moeT/, moeT
+/moeU/, moeU
+/xA/, Anp
+/xC/, Cnp
+/x5mC/, (5m)Cnp
+/xG/, Gnp
+/xT/, Tnp
+/xrA/, rAnp
+/xrC/, rCnp
+/xrG/, rGnp
+/xrU/, rUnp
+/xmA/, mAnp
+/xmC/, mCnp
+/x5mmC/, (5m)mCnp
+/xmG/, mGnp
+/xmU/, mUnp
+/xfA/, fAnp
+/xfC/, fCnp
+/xfG/, fGnp
+/xfT/, fTnp
+/xfU/, fUnp
+/xafA/, afAnp
+/xafC/, afCnp
+/xafG/, afGnp
+/xafU/, afUnp
+/xeA/, eAnp
+/xeC/, eCnp
+/xeG/, eGnp
+/xeU/, eUnp
+/xmoeA/, moeAnp
+/xmoeC/, moeCnp
+/x5mmoeC/, (5m)moeCnp
+/xmoeG/, moeGnp
+/xmoeU/, moeUnp
+/UNA-A/, (UNA-A)
+/UNA-C/, (UNA-C)
+/UNA-G/, (UNA-G)
+/UNA-T/, (UNA-T)
+/UNA-U/, (UNA-U)
+/GNA-A/, (GNA-A)
+/GNA-C/, (GNA-C)
+/GNA-G/, (GNA-G)
+/GNA-T/, (GNA-T)
+/GNA-U/, (GNA-U)
+/5CholTEG/, (5-CholTEG)
+/3CholTEG/, (TEGChol-3)
+/Toco/, Toco
+/Palm/, Palm
+/GalNAc/, GalNAc
+/GalNAc2/, GalNAc2
+/GalNAc3/, GalNAc3
+/GalNAc6/, GalNAc6
+/GalNAc7/, GalNAc7
+/GalNAc9/, GalNAc9
+/GalNAc14/, GalNAc14
+/NAG37/, NAG37
+/HEG/, (HEG)
+/TEG/, (TEG)
+/AmmC6/, (NHC6)
+/AmmC7/, (NHC7)
+/AmmC12/, (NHC12)
+/invAb/, (invabasic)
+/invdT/, (invdT)
+/VPmU/, (vinu)
+*, ps
+/2-C16U/, 2-C16U 
+/2-C18w9U/, 2-C18w9U
+/JDi-Palm/, JDi-Palm
+/J2-CONC16U/, J2-CONC16U
+/J2-C3NC16U/, J2-C3NC16U
+/J-C15Ada/, J-C15Ada
+/J-2C15AdaU/, J-2C15AdaU
+/J-C16NC6/, J-C16NC6
+/R2-C6NH-U/, R2-C6NH-U
+/J-M1/, J-M1
+/J-B1/, J-B1
+/J-B2/, J-B2
+/J-M2/, J-M2
+/2-C16C/, 2-C16C
+/2-C16A/, 2-C16A
+/2-C16G/, 2-C16G
+/R2-C6NH-G/, R2-C6NH-G
+/R2-C6NH-C/, R2-C6NH-C
+/J2-CONC16A/, J2-CONC16A
+/J2-CONC16C/, J2-CONC16C
+/J2-CONC16G/, J2-CONC16G
+/J2-C15AdaC/, J2-C15AdaC
+/J2-M2U/, J2-M2U
+/J2-B2U/, J2-B2U
+/J2-C3NC16C/, J2-C3NC16C
+/J2-C3NC16G/, J2-C3NC16G
+/R2-C6NH-A/, R2-C6NH-A
+/J2-C15AdaA/, J2-C15AdaA
+/J2-C3NC16A/, J2-C3NC16A
+/J-C5-SER-1/, J-C5-SER-1
+/J-C16-SER-1/, J-C16-SER-1
+/J-A2/, J-A2
+/J-A1/, J-A1
+/J2-C15AdaG/, J2-C15AdaG
+/J-C16NAsp/, J-C16NAsp
+/J2-C16NC6U/, J2-C16NC6U
+/J-C5-REBO-1/, J-C5-REBO-1
+/J-C16-REBO-1/, J-C16-REBO-1
+/J-C16-IND-1/, J-C16-IND-1
+/J-C5-IND-1/, J-C5-IND-1
+/J-1C15Ada-2Man/, J-1C15Ada-2Man
+/JG-1C15Ada-23DiMan/, JG-1C15Ada-2,3DiMan
+/J-TriManPC/, J-TriManPC
+/J-triManPO/, J-triManPO
+/J-A4/, J-A4
+/J-Ara-1/, J-Ara-1
+/J-Ara-2/, J-Ara-2
+/J-AcCS/, J-AcCS
+/J-CbCS/, J-CbCS
+/J-MtCD/, J-MtCD`;
+
+function differenceOfTwoArrays(a: string[], b: string[]): string[] {
+  return a.filter((x) => !b.includes(x));
+}
+
+const codesWithSmiles = getAllCodesOfSynthesizer(SYNTHESIZERS.GCRS);
+const allGcrsCodes = DG.DataFrame.fromCsv(lcmsToGcrs).getCol('GCRS').toList();
+export const gcrsCodesWithoutSmiles = differenceOfTwoArrays(allGcrsCodes, codesWithSmiles);
+for (const e of gcrsCodesWithoutSmiles)
+  map[SYNTHESIZERS.GCRS]['Others'][e] = {'SMILES': ''};

package/src/structures-works/mol-transformations.ts

@@ -93,7 +93,7 @@ export function getNucleotidesMol(smilesCodes: string[], oclRender: boolean = fa
   return linkV3000(molBlocks, false, oclRender);
 }
 
-export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oclRender: boolean = false) {
+export function linkV3000(molBlocks: string[], twoChains: boolean = false, oclRender: boolean = false) {
   let macroMolBlock = '\nDatagrok macromolecule handler\n\n';
   macroMolBlock += '  0  0  0  0  0  0            999 V3000\n';
   macroMolBlock += 'M  V30 BEGIN CTAB\n';
@@ -103,10 +103,9 @@ export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oc
   const collection: number [] = [];
   let natom = 0;
   let nbond = 0;
-  let sequenceShift = 0;
   let xShift = 0;
 
-  if (twoMolecules && molBlocks.length > 1)
+  if (twoChains && molBlocks.length > 1)
     molBlocks[1] = invertNucleotidesV3000(molBlocks[1]);
 
   for (let i = 0; i < molBlocks.length; i++) {
@@ -114,13 +113,23 @@ export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oc
       .replaceAll('-\nM  V30 ', '').replaceAll(' )', ')');
     const numbers = extractAtomsBondsNumbersV3000(molBlocks[i]);
     const coordinates = extractAtomDataV3000(molBlocks[i]);
+
+    if (twoChains) {
+      const xShiftRight = Math.min(...coordinates.x);
+      const yShift = i == 0 ? Math.min(...coordinates.y) - 1 : Math.max(...coordinates.y) + 1;
+      for (let j = 0; j < coordinates.x.length; j++)
+        coordinates.x[j] -= xShiftRight;
+      for (let j = 0; j < coordinates.y.length; j++)
+        coordinates.y[j] -= yShift;
+    }
+
     let indexAtoms = molBlocks[i].indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
     indexAtoms = molBlocks[i].indexOf('\n', indexAtoms);
     let index = indexAtoms;
     let indexEnd = indexAtoms;
 
     for (let j = 0; j < numbers.natom; j++) {
-      if (coordinates.atomIndex[j] != 1 || i == 0 || twoMolecules) {
+      if (coordinates.atomIndex[j] != 1 || i == 0 || twoChains) {
         //rewrite atom number
         index = molBlocks[i].indexOf('V30', index) + 4;
         indexEnd = molBlocks[i].indexOf(' ', index);
@@ -132,13 +141,17 @@ export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oc
         index = molBlocks[i].indexOf(' ', index) + 1;
         indexEnd = molBlocks[i].indexOf(' ', index);
 
-        const totalShift = xShift - coordinates.x[0];
-        let coordinate = Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd)) + totalShift))/10000;
+        const totalShift = twoChains ? 0 : xShift - coordinates.x[0];
+        let coordinate = twoChains ?
+          Math.round(10000*coordinates.x[j])/10000 :
+          Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd)) + totalShift))/10000;
         molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
 
         index = molBlocks[i].indexOf(' ', index) + 1;
         indexEnd = molBlocks[i].indexOf(' ', index);
-        coordinate = Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd)) + sequenceShift))/10000;
+        coordinate = twoChains ?
+          Math.round(10000*coordinates.y[j])/10000 :
+          Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd))))/10000;
         molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
 
         index = molBlocks[i].indexOf('\n', index) + 1;
@@ -194,10 +207,9 @@ export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oc
       indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=(', indexCollection);
     }
 
-    natom += twoMolecules ? numbers.natom : numbers.natom - 1;
+    natom += twoChains ? numbers.natom : numbers.natom - 1;
     nbond += numbers.nbond;
-    xShift += twoMolecules ? 0 : coordinates.x[numbers.natom - 1] - coordinates.x[0];
-    sequenceShift += twoMolecules ? -7 : 0;
+    xShift += twoChains ? 0 : coordinates.x[numbers.natom - 1] - coordinates.x[0];
   }
 
   const entries = 4;
@@ -224,7 +236,7 @@ export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oc
   }
 
   //generate file
-  twoMolecules? natom : natom++;
+  twoChains? natom : natom++;
   macroMolBlock += 'M  V30 COUNTS ' + natom + ' ' + nbond + ' 0 0 0\n';
   macroMolBlock += 'M  V30 BEGIN ATOM\n';
   macroMolBlock += atomBlock;

package/src/structures-works/save-sense-antisense.ts

@@ -1,10 +1,13 @@
 import * as ui from 'datagrok-api/ui';
 import {sequenceToMolV3000} from '../structures-works/from-monomers';
 import {linkV3000} from '../structures-works/mol-transformations';
+import {getFormat} from '../structures-works/sequence-codes-tools';
 
 export function saveSdf(as: string, ss: string, oneEntity: boolean, fit3dx: boolean) {
-  const molSS = sequenceToMolV3000(ss);
-  const molAS = sequenceToMolV3000(as, true);
+  const formatAs = getFormat(as);
+  const formatSs = getFormat(ss);
+  const molSS = sequenceToMolV3000(ss, false, false, formatSs!);
+  const molAS = sequenceToMolV3000(as, true, false, formatAs!);
   let result: string;
   if (oneEntity)
     result = linkV3000([molSS, molAS], true, !fit3dx) + '\n\n$$$$\n';

package/src/structures-works/sequence-codes-tools.ts

@@ -1,6 +1,4 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-// import * as DG from 'datagrok-api/dg';
+
 import {map, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS} from './map';
 import {asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
   asoGapmersBioSpringToNucleotides, asoGapmersBioSpringToGcrs, asoGapmersGcrsToNucleotides,
@@ -8,29 +6,110 @@ import {asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
   siRnaNucleotideToAxolabsSenseStrand, siRnaNucleotidesToGcrs, siRnaBioSpringToNucleotides,
   siRnaBioSpringToAxolabs, siRnaBioSpringToGcrs, siRnaAxolabsToNucleotides,
   siRnaAxolabsToBioSpring, siRnaAxolabsToGcrs, siRnaGcrsToNucleotides,
-  siRnaGcrsToBioSpring, siRnaGcrsToAxolabs, gcrsToNucleotides} from './converters';
+  siRnaGcrsToBioSpring, siRnaGcrsToAxolabs, gcrsToNucleotides, gcrsToLcms} from './converters';
 
 const noTranslationTableAvailable = 'No translation table available';
 export const undefinedInputSequence = 'Type of input sequence is undefined';
 
-export function isValidSequence(sequence: string): {
+export function getFormat(sequence: string): string | null {
+  const possibleSynthesizers = getListOfPossibleSynthesizersByFirstMatchedCode(sequence);
+
+  if (possibleSynthesizers.length == 0)
+    return null;
+
+  let outputIndex = 0;
+
+  const firstUniqueCharacters = ['r', 'd'];
+  const nucleotides = ['A', 'U', 'T', 'C', 'G'];
+
+  possibleSynthesizers.forEach((synthesizer) => {
+    const codes = getAllCodesOfSynthesizer(synthesizer);
+    while (outputIndex < sequence.length) {
+      const matchedCode = codes.find((c) => c == sequence.slice(outputIndex, outputIndex + c.length));
+
+      if (matchedCode == null)
+        break;
+
+      if ( // for mistake pattern 'rAA'
+        outputIndex > 1 &&
+        nucleotides.includes(sequence[outputIndex]) &&
+        firstUniqueCharacters.includes(sequence[outputIndex - 2])
+      ) break;
+
+      if ( // for mistake pattern 'ArA'
+        firstUniqueCharacters.includes(sequence[outputIndex + 1]) &&
+        nucleotides.includes(sequence[outputIndex])
+      ) {
+        outputIndex++;
+        break;
+      }
+
+      outputIndex += matchedCode.length;
+    }
+  });
+
+  const indexOfFirstNotValidChar = (outputIndex == sequence.length) ? -1 : outputIndex;
+  if (indexOfFirstNotValidChar != -1)
+    return possibleSynthesizers[0];
+
+  const possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, possibleSynthesizers[0]);
+
+  if (possibleTechnologies.length == 0)
+    return null;
+
+  outputIndex = 0;
+
+  possibleTechnologies.forEach((technology: string) => {
+    const codes = Object.keys(map[possibleSynthesizers[0]][technology]);
+    while (outputIndex < sequence.length) {
+      const matchedCode = codes.find((c) => c == sequence.slice(outputIndex, outputIndex + c.length));
+
+      if (matchedCode == null)
+        break;
+
+      if ( // for mistake pattern 'rAA'
+        outputIndex > 1 &&
+        nucleotides.includes(sequence[outputIndex]) &&
+        firstUniqueCharacters.includes(sequence[outputIndex - 2])
+      ) break;
+
+      if ( // for mistake pattern 'ArA'
+        firstUniqueCharacters.includes(sequence[outputIndex + 1]) &&
+        nucleotides.includes(sequence[outputIndex])
+      ) {
+        outputIndex++;
+        break;
+      }
+
+      outputIndex += matchedCode.length;
+    }
+  });
+
+  return possibleSynthesizers[0];
+}
+
+export function isValidSequence(sequence: string, format: string | null): {
   indexOfFirstNotValidChar: number,
-  synthesizer: string | null,
-  technology: string | null
+  synthesizer: string[] | null,
+  technology: string[] | null
 } {
-  let possibleSynthesizers = getListOfPossibleSynthesizersByFirstMatchedCode(sequence);
-
-  if (possibleSynthesizers.length > 1) {
-    const synthesizer = ui.choiceInput('Choose synthesizer from list: ', possibleSynthesizers[0], possibleSynthesizers);
-    ui.dialog('Choose Synthesizer')
-      .add(ui.panel([synthesizer.root], {style: {fontWeight: 'bold'}}))
-      .onOK(() => possibleSynthesizers = [synthesizer.value])
-      .onCancel(() => {
-        possibleSynthesizers = [possibleSynthesizers[0]];
-        grok.shell.warning('Input sequence is expected to be in format ' + possibleSynthesizers[0]);
-      })
-      .show();
-  } else if (possibleSynthesizers.length == 0)
+  const possibleSynthesizers = format == null ?
+    getListOfPossibleSynthesizersByFirstMatchedCode(sequence) :
+    [format];
+
+  // if (possibleSynthesizers.length > 1) {
+  //   const synthesizer = ui.choiceInput('Choose synthesizer from list: ', possibleSynthesizers[0],
+  //  possibleSynthesizers);
+  //   ui.dialog('Choose Synthesizer')
+  //     .add(ui.panel([synthesizer.root], {style: {fontWeight: 'bold'}}))
+  //     .onOK(() => possibleSynthesizers = [synthesizer.value])
+  //     .onCancel(() => {
+  //       possibleSynthesizers = [possibleSynthesizers[0]];
+  //       grok.shell.warning('Input sequence is expected to be in format ' + possibleSynthesizers[0]);
+  //     })
+  //     .show();
+  // } else if (possibleSynthesizers.length == 0)
+  if (possibleSynthesizers.length == 0)
     return {indexOfFirstNotValidChar: 0, synthesizer: null, technology: null};
 
   let outputIndex = 0;
@@ -68,24 +147,26 @@ export function isValidSequence(sequence: string): {
   if (indexOfFirstNotValidChar != -1) {
     return {
       indexOfFirstNotValidChar: indexOfFirstNotValidChar,
-      synthesizer: possibleSynthesizers[0],
+      synthesizer: possibleSynthesizers,
       technology: null,
     };
   }
 
-  let possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, possibleSynthesizers[0]);
-
-  if (possibleTechnologies.length > 1) {
-    const technology = ui.choiceInput('Choose technology from list: ', possibleTechnologies[0], possibleTechnologies);
-    ui.dialog('Choose Technology')
-      .add(ui.panel([technology.root], {style: {fontWeight: 'bold'}}))
-      .onOK(() => possibleTechnologies = [technology.value])
-      .onCancel(() => {
-        possibleTechnologies = [possibleTechnologies[0]];
-        grok.shell.warning('Input sequence is expected to be in format ' + possibleTechnologies[0]);
-      })
-      .show();
-  } else if (possibleTechnologies.length == 0)
+  const possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, possibleSynthesizers[0]);
+
+  // if (possibleTechnologies.length > 1) {
+  //   const technology = ui.choiceInput('Choose technology from list: ', possibleTechnologies[0],
+  // possibleTechnologies);
+  //   ui.dialog('Choose Technology')
+  //     .add(ui.panel([technology.root], {style: {fontWeight: 'bold'}}))
+  //     .onOK(() => possibleTechnologies = [technology.value])
+  //     .onCancel(() => {
+  //       possibleTechnologies = [possibleTechnologies[0]];
+  //       grok.shell.warning('Input sequence is expected to be in format ' + possibleTechnologies[0]);
+  //     })
+  //     .show();
+  // } else if (possibleTechnologies.length == 0)
+  if (possibleTechnologies.length == 0)
     return {indexOfFirstNotValidChar: 0, synthesizer: null, technology: null};
 
   outputIndex = 0;
@@ -118,16 +199,16 @@ export function isValidSequence(sequence: string): {
 
   return {
     indexOfFirstNotValidChar: indexOfFirstNotValidChar,
-    synthesizer: possibleSynthesizers[0],
-    technology: possibleTechnologies[outputIndex],
+    synthesizer: possibleSynthesizers,
+    technology: [possibleTechnologies[outputIndex]],
   };
 }
 
-function getAllCodesOfSynthesizer(synthesizer: string): string[] {
+export function getAllCodesOfSynthesizer(synthesizer: string): string[] {
   let codes: string[] = [];
   for (const technology of Object.keys(map[synthesizer]))
     codes = codes.concat(Object.keys(map[synthesizer][technology]));
-  return codes.concat(Object.keys(MODIFICATIONS));
+  return codes.concat(Object.keys(MODIFICATIONS)).concat(',');
 }
 
 function getListOfPossibleSynthesizersByFirstMatchedCode(sequence: string): string[] {
@@ -159,7 +240,7 @@ function getListOfPossibleTechnologiesByFirstMatchedCode(sequence: string, synth
 }
 
 export function convertSequence(sequence: string, output: {
-  indexOfFirstNotValidChar: number, synthesizer: string | null, technology: string | null}) {
+  indexOfFirstNotValidChar: number, synthesizer: string[] | null, technology: string[] | null}) {
   if (output.indexOfFirstNotValidChar != -1) {
     return {
       // type: '',
@@ -167,15 +248,15 @@ export function convertSequence(sequence: string, output: {
       Error: undefinedInputSequence,
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.technology == TECHNOLOGIES.DNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.RAW_NUCLEOTIDES)) {//&& output.technology!.includes(TECHNOLOGIES.DNA)) {
     return {
-      type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.DNA,
+      type: SYNTHESIZERS.RAW_NUCLEOTIDES, // + ' ' + TECHNOLOGIES.DNA,
       Nucleotides: sequence,
       BioSpring: asoGapmersNucleotidesToBioSpring(sequence),
       GCRS: asoGapmersNucleotidesToGcrs(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.BIOSPRING && output.technology == TECHNOLOGIES.ASO_GAPMERS) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.BIOSPRING) && output.technology!.includes(TECHNOLOGIES.ASO_GAPMERS)) {
     return {
       type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.ASO_GAPMERS,
       Nucleotides: asoGapmersBioSpringToNucleotides(sequence),
@@ -183,16 +264,17 @@ export function convertSequence(sequence: string, output: {
       GCRS: asoGapmersBioSpringToGcrs(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.GCRS && output.technology == TECHNOLOGIES.ASO_GAPMERS) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS) && output.technology!.includes(TECHNOLOGIES.ASO_GAPMERS)) {
     return {
       type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.ASO_GAPMERS,
       Nucleotides: asoGapmersGcrsToNucleotides(sequence),
       BioSpring: asoGapmersGcrsToBioSpring(sequence),
       Mermade12: gcrsToMermade12(sequence),
       GCRS: sequence,
+      LCMS: gcrsToLcms(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.technology == TECHNOLOGIES.RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.RAW_NUCLEOTIDES) && output.technology!.includes(TECHNOLOGIES.RNA)) {
     return {
       type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.RNA,
       Nucleotides: sequence,
@@ -201,7 +283,7 @@ export function convertSequence(sequence: string, output: {
       GCRS: siRnaNucleotidesToGcrs(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.BIOSPRING && output.technology == TECHNOLOGIES.SI_RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.BIOSPRING) && output.technology!.includes(TECHNOLOGIES.SI_RNA)) {
     return {
       type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.SI_RNA,
       Nucleotides: siRnaBioSpringToNucleotides(sequence),
@@ -210,7 +292,7 @@ export function convertSequence(sequence: string, output: {
       GCRS: siRnaBioSpringToGcrs(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.AXOLABS && output.technology == TECHNOLOGIES.SI_RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.AXOLABS)) {
     return {
       type: SYNTHESIZERS.AXOLABS + ' ' + TECHNOLOGIES.SI_RNA,
       Nucleotides: siRnaAxolabsToNucleotides(sequence),
@@ -219,7 +301,7 @@ export function convertSequence(sequence: string, output: {
       GCRS: siRnaAxolabsToGcrs(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.GCRS && output.technology == TECHNOLOGIES.SI_RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS) && output.technology!.includes(TECHNOLOGIES.SI_RNA)) {
     return {
       type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.SI_RNA,
       Nucleotides: siRnaGcrsToNucleotides(sequence),
@@ -227,17 +309,19 @@ export function convertSequence(sequence: string, output: {
       Axolabs: siRnaGcrsToAxolabs(sequence),
       MM12: gcrsToMermade12(sequence),
       GCRS: sequence,
+      LCMS: gcrsToLcms(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.GCRS) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS)) {
     return {
       type: SYNTHESIZERS.GCRS,
       Nucleotides: gcrsToNucleotides(sequence),
       GCRS: sequence,
       Mermade12: gcrsToMermade12(sequence),
+      LCMS: gcrsToLcms(sequence),
     };
   }
-  if (output.synthesizer == SYNTHESIZERS.MERMADE_12) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.MERMADE_12)) {
     return {
       type: SYNTHESIZERS.MERMADE_12,
       Nucleotides: noTranslationTableAvailable,