@datagrok/sequence-translator 0.0.9 → 1.0.1

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

@@ -93,9 +93,9 @@ 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              0 V3000\n';
+  macroMolBlock += '  0  0  0  0  0  0            999 V3000\n';
   macroMolBlock += 'M  V30 BEGIN CTAB\n';
   let atomBlock = '';
   let bondBlock = '';
@@ -103,22 +103,33 @@ 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++) {
+    molBlocks[i] = molBlocks[i].replaceAll('(-\nM  V30 ', '(')
+      .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);
@@ -130,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;
@@ -184,7 +199,7 @@ export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oc
     while (indexCollection != -1) {
       indexCollection += 28;
       const collectionEnd = molBlocks[i].indexOf(')', indexCollection);
-      const collectionEntries = molBlocks[i].substring(indexCollection, collectionEnd).split(' ');
+      const collectionEntries = molBlocks[i].substring(indexCollection, collectionEnd).split(' ').slice(1);
       collectionEntries.forEach((e) => {
         collection.push(parseInt(e) + natom);
       });
@@ -192,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;
@@ -209,18 +223,20 @@ export function linkV3000(molBlocks: string[], twoMolecules: boolean = false, oc
 
     collectionBlock += ')\n';
   } else {
+    collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length + ' -\n';
     for (let i = 0; i < collNumber; i++) {
-      collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(';
+      collectionBlock += 'M  V30 ';
       const entriesCurrent = i + 1 == collNumber ? collection.length - (collNumber - 1)*entries : entries;
-      for (let j = 0; j < entriesCurrent; j++)
-        collectionBlock += (j + 1 == entriesCurrent) ? collection[entries*i + j] : collection[entries*i + j] + ' ';
-
-      collectionBlock += ')\n';
+      for (let j = 0; j < entriesCurrent; j++) {
+        collectionBlock += (j + 1 == entriesCurrent) ?
+          (i == collNumber - 1 ? collection[entries*i + j] + ')\n' : collection[entries*i + j] + ' -\n') :
+          collection[entries*i + j] + ' ';
+      }
     }
   }
 
   //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,3 +1,6 @@
+// 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,
@@ -10,98 +13,196 @@ import {asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
 const noTranslationTableAvailable = 'No translation table available';
 export const undefinedInputSequence = 'Type of input sequence is undefined';
 
-export function isValidSequence(sequence: string): {
-  indexOfFirstNotValidCharacter: number,
-  expectedSynthesizer: string | null,
-  expectedTechnology: string | null
-} {
+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
+} {
+  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 {indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null};
+    return {indexOfFirstNotValidChar: 0, synthesizer: null, technology: null};
 
-  let outputIndices = Array(possibleSynthesizers.length).fill(0);
+  let outputIndex = 0;
 
   const firstUniqueCharacters = ['r', 'd'];
   const nucleotides = ['A', 'U', 'T', 'C', 'G'];
 
-  possibleSynthesizers.forEach((synthesizer, synthesizerIndex) => {
+  possibleSynthesizers.forEach((synthesizer) => {
     const codes = getAllCodesOfSynthesizer(synthesizer);
-    while (outputIndices[synthesizerIndex] < sequence.length) {
-      const matchedCode = codes
-        .find((c) => c == sequence.slice(outputIndices[synthesizerIndex], outputIndices[synthesizerIndex] + c.length));
+    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'
-        outputIndices[synthesizerIndex] > 1 &&
-        nucleotides.includes(sequence[outputIndices[synthesizerIndex]]) &&
-        firstUniqueCharacters.includes(sequence[outputIndices[synthesizerIndex] - 2])
+        outputIndex > 1 &&
+        nucleotides.includes(sequence[outputIndex]) &&
+        firstUniqueCharacters.includes(sequence[outputIndex - 2])
       ) break;
 
       if ( // for mistake pattern 'ArA'
-        firstUniqueCharacters.includes(sequence[outputIndices[synthesizerIndex] + 1]) &&
-        nucleotides.includes(sequence[outputIndices[synthesizerIndex]])
+        firstUniqueCharacters.includes(sequence[outputIndex + 1]) &&
+        nucleotides.includes(sequence[outputIndex])
       ) {
-        outputIndices[synthesizerIndex]++;
+        outputIndex++;
         break;
       }
 
-      outputIndices[synthesizerIndex] += matchedCode.length;
+      outputIndex += matchedCode.length;
     }
   });
 
-  const indexOfExpectedSythesizer = Math.max(...outputIndices);
-  const indexOfFirstNotValidCharacter = (indexOfExpectedSythesizer == sequence.length) ? -1 : indexOfExpectedSythesizer;
-  const expectedSynthesizer = possibleSynthesizers[outputIndices.indexOf(indexOfExpectedSythesizer)];
-  if (indexOfFirstNotValidCharacter != -1) {
+  const indexOfFirstNotValidChar = (outputIndex == sequence.length) ? -1 : outputIndex;
+  if (indexOfFirstNotValidChar != -1) {
     return {
-      indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
-      expectedSynthesizer: expectedSynthesizer,
-      expectedTechnology: null,
+      indexOfFirstNotValidChar: indexOfFirstNotValidChar,
+      synthesizer: possibleSynthesizers,
+      technology: null,
     };
   }
 
-  const possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, expectedSynthesizer);
+  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 {indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null};
+    return {indexOfFirstNotValidChar: 0, synthesizer: null, technology: null};
 
-  outputIndices = Array(possibleTechnologies.length).fill(0);
+  outputIndex = 0;
 
-  possibleTechnologies.forEach((technology: string, technologyIndex: number) => {
-    const codes = Object.keys(map[expectedSynthesizer][technology]);
-    while (outputIndices[technologyIndex] < sequence.length) {
-      const matchedCode = codes
-        .find((c) => c == sequence.slice(outputIndices[technologyIndex], outputIndices[technologyIndex] + c.length));
+  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'
-        outputIndices[technologyIndex] > 1 &&
-        nucleotides.includes(sequence[outputIndices[technologyIndex]]) &&
-        firstUniqueCharacters.includes(sequence[outputIndices[technologyIndex] - 2])
+        outputIndex > 1 &&
+        nucleotides.includes(sequence[outputIndex]) &&
+        firstUniqueCharacters.includes(sequence[outputIndex - 2])
       ) break;
 
       if ( // for mistake pattern 'ArA'
-        firstUniqueCharacters.includes(sequence[outputIndices[technologyIndex] + 1]) &&
-        nucleotides.includes(sequence[outputIndices[technologyIndex]])
+        firstUniqueCharacters.includes(sequence[outputIndex + 1]) &&
+        nucleotides.includes(sequence[outputIndex])
       ) {
-        outputIndices[technologyIndex]++;
+        outputIndex++;
         break;
       }
 
-      outputIndices[technologyIndex] += matchedCode.length;
+      outputIndex += matchedCode.length;
     }
   });
 
-  const indexOfExpectedTechnology = Math.max(...outputIndices);
-  const expectedTechnology = possibleTechnologies[outputIndices.indexOf(indexOfExpectedTechnology)];
-
   return {
-    indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
-    expectedSynthesizer: expectedSynthesizer,
-    expectedTechnology: expectedTechnology,
+    indexOfFirstNotValidChar: indexOfFirstNotValidChar,
+    synthesizer: possibleSynthesizers,
+    technology: [possibleTechnologies[outputIndex]],
   };
 }
 
@@ -140,93 +241,91 @@ function getListOfPossibleTechnologiesByFirstMatchedCode(sequence: string, synth
   return technologies;
 }
 
-export function convertSequence(text: string) {
-  text = text.replace(/\s/g, '');
-  const seq = text;
-  const output = isValidSequence(seq);
-  if (output.indexOfFirstNotValidCharacter != -1) {
+export function convertSequence(sequence: string, output: {
+  indexOfFirstNotValidChar: number, synthesizer: string[] | null, technology: string[] | null}) {
+  if (output.indexOfFirstNotValidChar != -1) {
     return {
       // type: '',
-      indexOfFirstNotValidCharacter: JSON.stringify(output),
+      indexOfFirstNotValidChar: JSON.stringify(output),
       Error: undefinedInputSequence,
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.expectedTechnology == TECHNOLOGIES.DNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.RAW_NUCLEOTIDES)) {//&& output.technology!.includes(TECHNOLOGIES.DNA)) {
     return {
-      type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.DNA,
-      Nucleotides: seq,
-      BioSpring: asoGapmersNucleotidesToBioSpring(seq),
-      GCRS: asoGapmersNucleotidesToGcrs(seq),
+      type: SYNTHESIZERS.RAW_NUCLEOTIDES, // + ' ' + TECHNOLOGIES.DNA,
+      Nucleotides: sequence,
+      BioSpring: asoGapmersNucleotidesToBioSpring(sequence),
+      GCRS: asoGapmersNucleotidesToGcrs(sequence),
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.BIOSPRING && output.expectedTechnology == TECHNOLOGIES.ASO_GAPMERS) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.BIOSPRING) && output.technology!.includes(TECHNOLOGIES.ASO_GAPMERS)) {
     return {
       type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.ASO_GAPMERS,
-      Nucleotides: asoGapmersBioSpringToNucleotides(seq),
-      BioSpring: seq,
-      GCRS: asoGapmersBioSpringToGcrs(seq),
+      Nucleotides: asoGapmersBioSpringToNucleotides(sequence),
+      BioSpring: sequence,
+      GCRS: asoGapmersBioSpringToGcrs(sequence),
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.ASO_GAPMERS) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS) && output.technology!.includes(TECHNOLOGIES.ASO_GAPMERS)) {
     return {
       type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.ASO_GAPMERS,
-      Nucleotides: asoGapmersGcrsToNucleotides(seq),
-      BioSpring: asoGapmersGcrsToBioSpring(seq),
-      Mermade12: gcrsToMermade12(seq),
-      GCRS: seq,
+      Nucleotides: asoGapmersGcrsToNucleotides(sequence),
+      BioSpring: asoGapmersGcrsToBioSpring(sequence),
+      Mermade12: gcrsToMermade12(sequence),
+      GCRS: sequence,
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.expectedTechnology == TECHNOLOGIES.RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.RAW_NUCLEOTIDES) && output.technology!.includes(TECHNOLOGIES.RNA)) {
     return {
       type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.RNA,
-      Nucleotides: seq,
-      BioSpring: siRnaNucleotideToBioSpringSenseStrand(seq),
-      Axolabs: siRnaNucleotideToAxolabsSenseStrand(seq),
-      GCRS: siRnaNucleotidesToGcrs(seq),
+      Nucleotides: sequence,
+      BioSpring: siRnaNucleotideToBioSpringSenseStrand(sequence),
+      Axolabs: siRnaNucleotideToAxolabsSenseStrand(sequence),
+      GCRS: siRnaNucleotidesToGcrs(sequence),
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.BIOSPRING && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.BIOSPRING) && output.technology!.includes(TECHNOLOGIES.SI_RNA)) {
     return {
       type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.SI_RNA,
-      Nucleotides: siRnaBioSpringToNucleotides(seq),
-      BioSpring: seq,
-      Axolabs: siRnaBioSpringToAxolabs(seq),
-      GCRS: siRnaBioSpringToGcrs(seq),
+      Nucleotides: siRnaBioSpringToNucleotides(sequence),
+      BioSpring: sequence,
+      Axolabs: siRnaBioSpringToAxolabs(sequence),
+      GCRS: siRnaBioSpringToGcrs(sequence),
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.AXOLABS && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.AXOLABS)) {
     return {
       type: SYNTHESIZERS.AXOLABS + ' ' + TECHNOLOGIES.SI_RNA,
-      Nucleotides: siRnaAxolabsToNucleotides(seq),
-      BioSpring: siRnaAxolabsToBioSpring(seq),
-      Axolabs: seq,
-      GCRS: siRnaAxolabsToGcrs(seq),
+      Nucleotides: siRnaAxolabsToNucleotides(sequence),
+      BioSpring: siRnaAxolabsToBioSpring(sequence),
+      Axolabs: sequence,
+      GCRS: siRnaAxolabsToGcrs(sequence),
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS) && output.technology!.includes(TECHNOLOGIES.SI_RNA)) {
     return {
       type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.SI_RNA,
-      Nucleotides: siRnaGcrsToNucleotides(seq),
-      BioSpring: siRnaGcrsToBioSpring(seq),
-      Axolabs: siRnaGcrsToAxolabs(seq),
-      MM12: gcrsToMermade12(seq),
-      GCRS: seq,
+      Nucleotides: siRnaGcrsToNucleotides(sequence),
+      BioSpring: siRnaGcrsToBioSpring(sequence),
+      Axolabs: siRnaGcrsToAxolabs(sequence),
+      MM12: gcrsToMermade12(sequence),
+      GCRS: sequence,
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.GCRS)) {
     return {
       type: SYNTHESIZERS.GCRS,
-      Nucleotides: gcrsToNucleotides(seq),
-      GCRS: seq,
-      Mermade12: gcrsToMermade12(seq),
+      Nucleotides: gcrsToNucleotides(sequence),
+      GCRS: sequence,
+      Mermade12: gcrsToMermade12(sequence),
     };
   }
-  if (output.expectedSynthesizer == SYNTHESIZERS.MERMADE_12) {
+  if (output.synthesizer!.includes(SYNTHESIZERS.MERMADE_12)) {
     return {
       type: SYNTHESIZERS.MERMADE_12,
       Nucleotides: noTranslationTableAvailable,
       GCRS: noTranslationTableAvailable,
-      Mermade12: seq,
+      Mermade12: sequence,
     };
   }
   return {