@datagrok/sequence-translator 0.0.4 → 0.0.5

package/src/package.ts

@@ -3,36 +3,38 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import * as OCL from 'openchemlib/full.js';
-import $ from "cash-dom";
-import {defineAxolabsPattern} from "./defineAxolabsPattern";
-import {map, stadardPhosphateLinkSmiles, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS} from "./map";
+import $ from 'cash-dom';
+import {defineAxolabsPattern} from './defineAxolabsPattern';
+import {saveSenseAntiSense} from './save-sense-antisense';
+import {map, stadardPhosphateLinkSmiles, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS} from './map';
 
-export let _package = new DG.Package();
+export const _package = new DG.Package();
 
-const defaultInput = "AGGTCCTCTTGACTTAGGCC";
-const undefinedInputSequence = "Type of input sequence is undefined";
-const noTranslationTableAvailable = "No translation table available";
+const defaultInput = 'AGGTCCTCTTGACTTAGGCC';
+const undefinedInputSequence = 'Type of input sequence is undefined';
+const noTranslationTableAvailable = 'No translation table available';
 const sequenceWasCopied = 'Copied';
 const tooltipSequence = 'Copy sequence';
 
-function getAllCodesOfSynthesizer(synthesizer: string) {
+function getAllCodesOfSynthesizer(synthesizer: string): string[] {
   let codes: string[] = [];
-  for (let technology of Object.keys(map[synthesizer]))
+  for (const technology of Object.keys(map[synthesizer]))
     codes = codes.concat(Object.keys(map[synthesizer][technology]));
   return codes.concat(Object.keys(MODIFICATIONS));
 }
 
 function getListOfPossibleSynthesizersByFirstMatchedCode(sequence: string): string[] {
-  let synthesizers: string[] = [];
+  const synthesizers: string[] = [];
   Object.keys(map).forEach((synthesizer: string) => {
     const codes = getAllCodesOfSynthesizer(synthesizer);
     //TODO: get first non-dropdown code when there are two modifications
     let start = 0;
-    for (let i = 0; i < sequence.length; i++)
+    for (let i = 0; i < sequence.length; i++) {
       if (sequence[i] == ')') {
         start = i + 1;
         break;
       }
+    }
     if (codes.some((s: string) => s == sequence.slice(start, start + s.length)))
       synthesizers.push(synthesizer);
   });
@@ -40,7 +42,7 @@ function getListOfPossibleSynthesizersByFirstMatchedCode(sequence: string): stri
 }
 
 function getListOfPossibleTechnologiesByFirstMatchedCode(sequence: string, synthesizer: string): string[] {
-  let technologies: string[] = [];
+  const technologies: string[] = [];
   Object.keys(map[synthesizer]).forEach((technology: string) => {
     const codes = Object.keys(map[synthesizer][technology]).concat(Object.keys(MODIFICATIONS));
     if (codes.some((s) => s == sequence.slice(0, s.length)))
@@ -49,32 +51,36 @@ function getListOfPossibleTechnologiesByFirstMatchedCode(sequence: string, synth
   return technologies;
 }
 
-function isValidSequence(sequence: string) {
-  let possibleSynthesizers = getListOfPossibleSynthesizersByFirstMatchedCode(sequence);
+export function isValidSequence(sequence: string): {
+  indexOfFirstNotValidCharacter: number,
+  expectedSynthesizer: string | null,
+  expectedTechnology: string | null
+} {
+  const possibleSynthesizers = getListOfPossibleSynthesizersByFirstMatchedCode(sequence);
   if (possibleSynthesizers.length == 0)
-    return { indexOfFirstNotValidCharacter: 0, expectedType: null };
+    return {indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null};
 
   let outputIndices = Array(possibleSynthesizers.length).fill(0);
 
-  const firstUniqueCharacters = ['r', 'd'], nucleotides = ["A", "U", "T", "C", "G"];
+  const firstUniqueCharacters = ['r', 'd'];
+  const nucleotides = ['A', 'U', 'T', 'C', 'G'];
 
   possibleSynthesizers.forEach((synthesizer, synthesizerIndex) => {
-    let codes = getAllCodesOfSynthesizer(synthesizer);
+    const codes = getAllCodesOfSynthesizer(synthesizer);
     while (outputIndices[synthesizerIndex] < sequence.length) {
-
-      let matchedCode = codes
+      const matchedCode = codes
         .find((c) => c == sequence.slice(outputIndices[synthesizerIndex], outputIndices[synthesizerIndex] + c.length));
 
       if (matchedCode == null)
         break;
 
-      if (  // for mistake pattern 'rAA'
+      if ( // for mistake pattern 'rAA'
         outputIndices[synthesizerIndex] > 1 &&
         nucleotides.includes(sequence[outputIndices[synthesizerIndex]]) &&
         firstUniqueCharacters.includes(sequence[outputIndices[synthesizerIndex] - 2])
       ) break;
 
-      if (  // for mistake pattern 'ArA'
+      if ( // for mistake pattern 'ArA'
         firstUniqueCharacters.includes(sequence[outputIndices[synthesizerIndex] + 1]) &&
         nucleotides.includes(sequence[outputIndices[synthesizerIndex]])
       ) {
@@ -92,16 +98,17 @@ function isValidSequence(sequence: string) {
   if (indexOfFirstNotValidCharacter != -1)
     return {
       indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
-      expectedType: expectedSynthesizer
+      expectedSynthesizer: expectedSynthesizer,
+      expectedTechnology: null
     };
 
   let possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, expectedSynthesizer);
   if (possibleTechnologies.length == 0)
-    return { indexOfFirstNotValidCharacter: 0, expectedRepresentation: null };
+    return { indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null };
 
   outputIndices = Array(possibleTechnologies.length).fill(0);
 
-  possibleTechnologies.forEach((technology, technologyIndex) => {
+  possibleTechnologies.forEach((technology: string, technologyIndex: number) => {
     let codes = Object.keys(map[expectedSynthesizer][technology]);
     while (outputIndices[technologyIndex] < sequence.length) {
 
@@ -111,7 +118,7 @@ function isValidSequence(sequence: string) {
       if (matchedCode == null)
         break;
 
-      if (  // for mistake pattern 'rAA'
+      if ( // for mistake pattern 'rAA'
         outputIndices[technologyIndex] > 1 &&
         nucleotides.includes(sequence[outputIndices[technologyIndex]]) &&
         firstUniqueCharacters.includes(sequence[outputIndices[technologyIndex] - 2])
@@ -134,7 +141,8 @@ function isValidSequence(sequence: string) {
 
   return {
     indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
-    expectedType: expectedSynthesizer + ' ' + expectedTechnology
+    expectedSynthesizer: expectedSynthesizer,
+    expectedTechnology: expectedTechnology
   };
 }
 
@@ -142,39 +150,51 @@ function sortByStringLengthInDescendingOrder(array: string[]): string[] {
   return array.sort(function(a: string, b: string) { return b.length - a.length; });
 }
 
-function getObjectWithCodesAndSmiles() {
-  let obj: {[code: string]: string} = {};
-  for (let synthesizer of Object.keys(map))
-    for (let technology of Object.keys(map[synthesizer]))
+function getObjectWithCodesAndSmiles(sequence: string) {
+  const obj: { [code: string]: string } = {};
+  for (const synthesizer of Object.keys(map))
+    for (const technology of Object.keys(map[synthesizer]))
       for (let code of Object.keys(map[synthesizer][technology]))
         obj[code] = map[synthesizer][technology][code].SMILES;
+  // TODO: create object based from synthesizer type to avoid key(codes) duplicates
+  const output = isValidSequence(sequence);
+  if (output.expectedSynthesizer == SYNTHESIZERS.MERMADE_12)
+    obj['g'] = map[SYNTHESIZERS.MERMADE_12][TECHNOLOGIES.SI_RNA]['g'].SMILES;
+  else if (output.expectedSynthesizer == SYNTHESIZERS.AXOLABS)
+    obj['g'] = map[SYNTHESIZERS.AXOLABS][TECHNOLOGIES.SI_RNA]['g'].SMILES;
   return obj;
 }
 
-export function sequenceToSmiles(sequence: string) {
-  const obj = getObjectWithCodesAndSmiles();
+export function sequenceToSmiles(sequence: string, inverted: boolean = false): string {
+  const obj = getObjectWithCodesAndSmiles(sequence);
   let codes = sortByStringLengthInDescendingOrder(Object.keys(obj));
-  let i = 0, smiles = '', codesList = [];
+  let i = 0;
+  let smiles = '';
+  const codesList = [];
   const links = ['s', 'ps', '*'];
-  const includesStandardLinkAlready = ["e", "h", "g", "f", "i", "l", "k", "j"];
+  const includesStandardLinkAlready = ['e', 'h', /*'g',*/ 'f', 'i', 'l', 'k', 'j'];
   const dropdowns = Object.keys(MODIFICATIONS);
   codes = codes.concat(dropdowns);
   while (i < sequence.length) {
-    let code = codes.find((s: string) => s == sequence.slice(i, i + s.length))!;
+    const code = codes.find((s: string) => s == sequence.slice(i, i + s.length))!;
     i += code.length;
-    codesList.push(code);
+    inverted ? codesList.unshift(code) : codesList.push(code);
   }
   for (let i = 0; i < codesList.length; i++) {
     if (dropdowns.includes(codesList[i])) {
-      smiles += (i >= codesList.length / 2) ?
-        MODIFICATIONS[codesList[i]].right :
-        MODIFICATIONS[codesList[i]].left;
+      if (i == codesList.length -1 || (i < codesList.length - 1 && links.includes(codesList[i + 1]))) {
+        smiles += (i >= codesList.length / 2) ?
+          MODIFICATIONS[codesList[i]].right:
+          MODIFICATIONS[codesList[i]].left;
+      } else if (i < codesList.length - 1) {
+        smiles += (i >= codesList.length / 2) ?
+          MODIFICATIONS[codesList[i]].right + stadardPhosphateLinkSmiles:
+          MODIFICATIONS[codesList[i]].left + stadardPhosphateLinkSmiles;
+      }
     } else {
-      if (links.includes(codesList[i]) && i > 1 && !includesStandardLinkAlready.includes(codesList[i - 1]))
-        smiles = smiles.slice(0, smiles.length - stadardPhosphateLinkSmiles.length + 1);
-      else if (links.includes(codesList[i]) ||
+      if (links.includes(codesList[i]) ||
         includesStandardLinkAlready.includes(codesList[i]) ||
-        (i < codesList.length - 1 && (links.includes(codesList[i + 1]) || dropdowns.includes(codesList[i + 1])))
+        (i < codesList.length - 1 && links.includes(codesList[i + 1]))
       )
         smiles += obj[codesList[i]];
       else
@@ -197,126 +217,221 @@ export function sequenceToSmiles(sequence: string) {
 
 //name: Sequence Translator
 //tags: app
-export function sequenceTranslator() {
-
-  let windows = grok.shell.windows;
+export function sequenceTranslator(): void {
+  const windows = grok.shell.windows;
   windows.showProperties = false;
   windows.showToolbox = false;
   windows.showHelp = false;
 
-  function updateTableAndMolecule(sequence: string) {
-    moleculeSvgDiv.innerHTML = "";
-    outputTableDiv.innerHTML = "";
-    let pi = DG.TaskBarProgressIndicator.create('Rendering table and molecule...');
+  function updateTableAndMolecule(sequence: string): void {
+    moleculeSvgDiv.innerHTML = '';
+    outputTableDiv.innerHTML = '';
+    const pi = DG.TaskBarProgressIndicator.create('Rendering table and molecule...');
+    let errorsExist = false;
     try {
-      let outputSequenceObj = convertSequence(sequence);
-      let tableRows = [];
-      for (let key of Object.keys(outputSequenceObj).slice(1)) {
+      const outputSequenceObj = convertSequence(sequence);
+      const tableRows = [];
+
+      for (const key of Object.keys(outputSequenceObj).slice(1)) {
+        let indexOfFirstNotValidCharacter = ('indexOfFirstNotValidCharacter' in outputSequenceObj) ?
+          JSON.parse(outputSequenceObj.indexOfFirstNotValidCharacter!).indexOfFirstNotValidCharacter :
+          -1;
+        if ('indexOfFirstNotValidCharacter' in outputSequenceObj) {
+          let indexOfFirstNotValidCharacter = ('indexOfFirstNotValidCharacter' in outputSequenceObj) ?
+            JSON.parse(outputSequenceObj.indexOfFirstNotValidCharacter!).indexOfFirstNotValidCharacter :
+            -1;
+          if (indexOfFirstNotValidCharacter != -1)
+            errorsExist = true;
+        }
+
         tableRows.push({
           'key': key,
-          'value': ("indexOfFirstNotValidCharacter" in outputSequenceObj) ?
+          'value': ('indexOfFirstNotValidCharacter' in outputSequenceObj) ?
             ui.divH([
-              ui.divText(sequence.slice(0, JSON.parse(outputSequenceObj.indexOfFirstNotValidCharacter!).indexOfFirstNotValidCharacter), {style: {color: "grey"}}),
+              ui.divText(sequence.slice(0, indexOfFirstNotValidCharacter), {style: {color: 'grey'}}),
               ui.tooltip.bind(
-                ui.divText(sequence.slice(JSON.parse(outputSequenceObj.indexOfFirstNotValidCharacter!).indexOfFirstNotValidCharacter), {style: {color: "red"}}),
-                "Expected format: " + JSON.parse(outputSequenceObj.indexOfFirstNotValidCharacter!).expectedType + ". Press 'SHOW CODES' button to see tables with valid codes"
-              )
+                ui.divText(sequence.slice(indexOfFirstNotValidCharacter), {style: {color: 'red'}}),
+                'Expected format: ' + JSON.parse(outputSequenceObj.indexOfFirstNotValidCharacter!).expectedSynthesizer + '. See tables with valid codes on the right'
+              ),
             ]) : //@ts-ignore
             ui.link(outputSequenceObj[key], () => navigator.clipboard.writeText(outputSequenceObj[key]).then(() => grok.shell.info(sequenceWasCopied)), tooltipSequence, '')
-        })
+        });
+      }
+
+      if (errorsExist) {
+        const expectedSynthesizer = JSON.parse(outputSequenceObj.indexOfFirstNotValidCharacter!).expectedSynthesizer.slice(0, -6);
+        asoGapmersGrid.onCellPrepare(function (gc) {
+          gc.style.backColor = (gc.gridColumn.name == expectedSynthesizer) ? 0xFFF00000 : 0xFFFFFFFF;
+        });
+        omeAndFluoroGrid.onCellPrepare(function (gc) {
+          gc.style.backColor = (gc.gridColumn.name == expectedSynthesizer) ? 0xFFF00000 : 0xFFFFFFFF;
+        });
+        switchInput.enabled = true;
+      } else {
+        asoGapmersGrid.onCellPrepare(function (gc) {
+          gc.style.backColor = 0xFFFFFFFF;
+        });
+        omeAndFluoroGrid.onCellPrepare(function (gc) {
+          gc.style.backColor = 0xFFFFFFFF;
+        });
       }
+
       outputTableDiv.append(
-        ui.div([DG.HtmlTable.create(tableRows, (item: { key: string; value: string; }) => [item.key, item.value], ['Code', 'Sequence']).root], 'table')
+        ui.div([
+          DG.HtmlTable.create(tableRows, (item: { key: string; value: string; }) => [item.key, item.value], ['Code', 'Sequence']).root
+        ], 'table')
       );
       semTypeOfInputSequence.textContent = 'Detected input type: ' + outputSequenceObj.type;
 
-      let width = $(window).width();
-      const canvas = ui.canvas(width, Math.round(width / 2));
-      let smiles = sequenceToSmiles(inputSequenceField.value.replace(/\s/g, ''));
-      // @ts-ignore
-      OCL.StructureView.drawMolecule(canvas, OCL.Molecule.fromSmiles(smiles), { suppressChiralText: true });
-      if (outputSequenceObj.type != undefinedInputSequence)
+      if (outputSequenceObj.type != undefinedInputSequence && outputSequenceObj.Error != undefinedInputSequence) {
+        let canvas = ui.canvas(300, 170);
+        canvas.addEventListener("click", () => {
+          let canv = ui.canvas($(window).width(), $(window).height());
+          const smiles = sequenceToSmiles(inputSequenceField.value.replace(/\s/g, ''));
+          // @ts-ignore
+          OCL.StructureView.drawMolecule(canv, OCL.Molecule.fromSmiles(smiles), { suppressChiralText: true });
+          ui.dialog('Molecule')
+            .add(canv)
+            .showModal(true);
+        });
+        $(canvas).on('mouseover', () => $(canvas).css('cursor', 'zoom-in'));
+        $(canvas).on('mouseout', () => $(canvas).css('cursor', 'default'));
+        const smiles = sequenceToSmiles(inputSequenceField.value.replace(/\s/g, ''));
+        // @ts-ignore
+        OCL.StructureView.drawMolecule(canvas, OCL.Molecule.fromSmiles(smiles), { suppressChiralText: true });
         moleculeSvgDiv.append(canvas);
+      } else
+        moleculeSvgDiv.innerHTML = '';
     } finally {
       pi.close();
     }
   }
 
-  let semTypeOfInputSequence = ui.divText('');
-  let moleculeSvgDiv = ui.block([]);
-  let outputTableDiv = ui.div([], 'table');
-  let inputSequenceField = ui.textInput("", defaultInput, (sequence: string) => updateTableAndMolecule(sequence));
-  updateTableAndMolecule(defaultInput);
-
-  let tablesWithCodes = ui.divV([
-    DG.HtmlTable.create(Object.keys(MODIFICATIONS), (item: string) => [item], ['Overhang modification']).root,
-    ui.div([], {style: {height: '30px'}})
-  ]);
-  for (let synthesizer of Object.keys(map)) {
-    for (let technology of Object.keys(map[synthesizer])) {
-      let tableRows = [];
-      for (let [key, value] of Object.entries(map[synthesizer][technology]))
-        tableRows.push({'name': value.name, 'code': key});
-      tablesWithCodes.append(
-        DG.HtmlTable.create(
-          tableRows,
-          (item: {name: string; code: string;}) => [item['name'], item['code']],
-          [synthesizer + ' ' + technology, 'Code']
-        ).root,
-        ui.div([], {style: {height: '30px'}})
-      );
-    }
-  }
-  let showCodesButton = ui.button('SHOW CODES', () => ui.dialog('Codes').add(tablesWithCodes).show());
-  let copySmiles = ui.button(
-    'COPY SMILES',
-    () => navigator.clipboard.writeText(sequenceToSmiles(inputSequenceField.value.replace(/\s/g, '')))
-      .then(() => grok.shell.info(sequenceWasCopied))
+  const semTypeOfInputSequence = ui.divText('');
+  const moleculeSvgDiv = ui.block([]);
+  const outputTableDiv = ui.div([], 'table');
+  const inputSequenceField = ui.textInput('', defaultInput, (sequence: string) => updateTableAndMolecule(sequence));
+
+  const asoDf = DG.DataFrame.fromObjects([
+    { Name: "2'MOE-5Me-rU", BioSpring: "5", "Janssen GCRS": "moeT" },
+    { Name: "2'MOE-rA", BioSpring: "6", "Janssen GCRS": "moeA" },
+    { Name: "2'MOE-5Me-rC", BioSpring: "7", "Janssen GCRS": "moe5mC" },
+    { Name: "2'MOE-rG", BioSpring: "8", "Janssen GCRS": "moeG" },
+    { Name: "5-Methyl-dC", BioSpring: "9", "Janssen GCRS": "5mC" },
+    { Name: "ps linkage", BioSpring: "*", "Janssen GCRS": "ps" },
+    { Name: "dA", BioSpring: "A", "Janssen GCRS": "A, dA" },
+    { Name: "dC", BioSpring: "C", "Janssen GCRS": "C, dC" },
+    { Name: "dG", BioSpring: "G", "Janssen GCRS": "G, dG" },
+    { Name: "dT", BioSpring: "T", "Janssen GCRS": "T, dT" },
+    { Name: "rA", BioSpring: "", "Janssen GCRS": "rA" },
+    { Name: "rC", BioSpring: "", "Janssen GCRS": "rC" },
+    { Name: "rG", BioSpring: "", "Janssen GCRS": "rG" },
+    { Name: "rU", BioSpring: "", "Janssen GCRS": "rU" }
+  ])!;
+  const asoGapmersGrid = DG.Viewer.grid(
+    asoDf, { showRowHeader: false, showCellTooltip: false }
   );
-  let saveMolFileButton = ui.bigButton('SAVE MOL FILE', () => {
-    let smiles = sequenceToSmiles(inputSequenceField.value.replace(/\s/g, ''));
-    let result = `${OCL.Molecule.fromSmiles(smiles).toMolfile()}\n`;
-    let element = document.createElement('a');
-    element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(result));
-    element.setAttribute('download', inputSequenceField.value.replace(/\s/g, '') + '.mol');
-    element.click();
+
+  asoDf.onCurrentCellChanged.subscribe((_) => {
+    navigator.clipboard.writeText(asoDf.currentCell.value).then(() => grok.shell.info('Copied'))
   });
 
+  let omeAndFluoroGrid = DG.Viewer.grid(
+    DG.DataFrame.fromObjects([
+      { Name: "2'-fluoro-U", BioSpring: "1", Axolabs: "Uf", "Janssen GCRS": "fU" },
+      { Name: "2'-fluoro-A", BioSpring: "2", Axolabs: "Af", "Janssen GCRS": "fA" },
+      { Name: "2'-fluoro-C", BioSpring: "3", Axolabs: "Cf", "Janssen GCRS": "fC" },
+      { Name: "2'-fluoro-G", BioSpring: "4", Axolabs: "Gf", "Janssen GCRS": "fG" },
+      { Name: "2'OMe-rU", BioSpring: "5", Axolabs: "u", "Janssen GCRS": "mU" },
+      { Name: "2'OMe-rA", BioSpring: "6", Axolabs: "a", "Janssen GCRS": "mA" },
+      { Name: "2'OMe-rC", BioSpring: "7", Axolabs: "c", "Janssen GCRS": "mC" },
+      { Name: "2'OMe-rG", BioSpring: "8", Axolabs: "g", "Janssen GCRS": "mG" },
+      { Name: "ps linkage", BioSpring: "*", Axolabs: "s", "Janssen GCRS": "ps" }
+    ])!, { showRowHeader: false, showCellTooltip: false }
+  );
+
+  const overhangModificationsGrid = DG.Viewer.grid(
+    DG.DataFrame.fromObjects([
+      { Name: "(invabasic)" },
+      { Name: "(GalNAc-2-JNJ)" }
+    ])!, { showRowHeader: false, showCellTooltip: false }
+  );
+  updateTableAndMolecule(defaultInput);
+
   const appMainDescription = ui.info([
-      ui.divText('\n How to convert one sequence:',{style:{'font-weight':'bolder'}}),
-      ui.divText("Paste sequence into the text field below"),
+      ui.divText('How to convert one sequence:',{style:{'font-weight':'bolder'}}),
+      ui.divText('Paste sequence into the text field below'),
       ui.divText('\n How to convert many sequences:',{style:{'font-weight':'bolder'}}),
-      ui.divText("1. Drag & drop an Excel or CSV file with sequences into Datagrok. The platform will automatically detect columns with sequences"),
+      ui.divText('1. Drag & drop an Excel or CSV file with sequences into Datagrok. The platform will automatically detect columns with sequences'),
       ui.divText('2. Right-click on the column header, then see the \'Convert\' menu'),
-      ui.divText("This will add the result column to the right of the table"),
+      ui.divText('This will add the result column to the right of the table'),
     ], 'Convert oligonucleotide sequences between Nucleotides, BioSpring, Axolabs, Mermade 12 and GCRS representations.'
   );
 
-  let v = grok.shell.newView('Sequence Translator', [
-    ui.tabControl({
-      'MAIN': ui.div([
-        appMainDescription,
-        ui.panel([
-          ui.div([
-            ui.h1('Input sequence'),
+  const codesTablesDiv = ui.splitV([
+    ui.box(ui.h2('ASO Gapmers'), { style: {maxHeight: '40px'} }),
+    asoGapmersGrid.root,
+    ui.box(ui.h2("2'-OMe and 2'-F siRNA"), { style: {maxHeight: '40px'} }),
+    omeAndFluoroGrid.root,
+    ui.box(ui.h2('Overhang modifications'), { style: {maxHeight: '40px'} }),
+    overhangModificationsGrid.root
+  ], { style: { maxWidth: '350px' } });
+
+  const tabControl = ui.tabControl({
+    'MAIN': ui.box(
+      ui.splitH([
+        ui.splitV([
+          ui.panel([
+            appMainDescription,
             ui.div([
-              inputSequenceField.root
-            ],'input-base')
-          ], 'sequenceInput'),
-          semTypeOfInputSequence,
-          ui.block([
-            ui.h1('Output'),
-            outputTableDiv
-          ]),
-          moleculeSvgDiv,
-          ui.divH([saveMolFileButton, showCodesButton, copySmiles])
-        ], 'sequence')
-      ]),
-      'AXOLABS': defineAxolabsPattern()
-    })
-  ]);
+              ui.h1('Input sequence'),
+              ui.div([
+                inputSequenceField.root,
+              ], 'input-base'),
+            ], 'sequenceInput'),
+            semTypeOfInputSequence,
+            ui.block([
+              ui.h1('Output'),
+              outputTableDiv,
+            ]),
+            moleculeSvgDiv,
+          ], 'sequence'),
+        ]),
+        codesTablesDiv,
+      ], {style: {height: '100%', width: '100%'}}),
+    ),
+    'AXOLABS': defineAxolabsPattern(),
+    'SDF': saveSenseAntiSense(),
+  });
+
+  let v = grok.shell.newView('Sequence Translator', [tabControl]);
   v.box = true;
 
+  const switchInput = ui.switchInput('Codes', true, (v: boolean) => (v) ?
+    $(codesTablesDiv).show() :
+    $(codesTablesDiv).hide()
+  );
+
+  const topPanel = [
+    ui.iconFA('download', () => {
+      const smiles = sequenceToSmiles(inputSequenceField.value.replace(/\s/g, ''));
+      const result = `${OCL.Molecule.fromSmiles(smiles).toMolfile()}\n`;
+      const element = document.createElement('a');
+      element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(result));
+      element.setAttribute('download', inputSequenceField.value.replace(/\s/g, '') + '.mol');
+      element.click();
+    }, 'Save .mol file'),
+    ui.iconFA('copy', () => {
+      navigator.clipboard.writeText(sequenceToSmiles(inputSequenceField.value.replace(/\s/g, '')))
+        .then(() => grok.shell.info(sequenceWasCopied));
+    }, 'Copy SMILES'),
+    switchInput.root,
+  ];
+
+  tabControl.onTabChanged.subscribe((_) =>
+    v.setRibbonPanels([(tabControl.currentPane.name == 'MAIN') ? topPanel : []]));
+  v.setRibbonPanels([topPanel]);
+
   $('.sequence')
     .children().css('padding','5px 0');
   $('.sequenceInput .input-base')
@@ -325,7 +440,7 @@ export function sequenceTranslator() {
     .css('resize','none')
     .css('min-height','50px')
     .css('width','100%')
-    .attr("spellcheck", "false");
+    .attr('spellcheck', 'false');
   $('.sequenceInput select')
     .css('width','100%');
 }
@@ -336,24 +451,25 @@ function convertSequence(text: string) {
   let output = isValidSequence(seq);
   if (output.indexOfFirstNotValidCharacter != -1)
     return {
+      // type: '',
       indexOfFirstNotValidCharacter: JSON.stringify(output),
       Error: undefinedInputSequence
     };
-  if (output.expectedType == SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.DNA)
+  if (output.expectedSynthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.expectedTechnology == TECHNOLOGIES.DNA)
     return {
       type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' +  TECHNOLOGIES.DNA,
       Nucleotides: seq,
       BioSpring: asoGapmersNucleotidesToBioSpring(seq),
       GCRS: asoGapmersNucleotidesToGcrs(seq)
     };
-  if (output.expectedType == SYNTHESIZERS.BIOSPRING + ' ' +  TECHNOLOGIES.ASO_GAPMERS)
+  if (output.expectedSynthesizer == SYNTHESIZERS.BIOSPRING && output.expectedTechnology == TECHNOLOGIES.ASO_GAPMERS)
     return {
       type: SYNTHESIZERS.BIOSPRING + ' ' +  TECHNOLOGIES.ASO_GAPMERS,
       Nucleotides: asoGapmersBioSpringToNucleotides(seq),
       BioSpring: seq,
       GCRS: asoGapmersBioSpringToGcrs(seq)
     };
-  if (output.expectedType == SYNTHESIZERS.GCRS + ' ' +  TECHNOLOGIES.ASO_GAPMERS)
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.ASO_GAPMERS)
     return {
       type: SYNTHESIZERS.GCRS + ' ' +  TECHNOLOGIES.ASO_GAPMERS,
       Nucleotides: asoGapmersGcrsToNucleotides(seq),
@@ -361,7 +477,7 @@ function convertSequence(text: string) {
       Mermade12: gcrsToMermade12(seq),
       GCRS: seq
     };
-  if (output.expectedType == SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' +  TECHNOLOGIES.RNA)
+  if (output.expectedSynthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.expectedTechnology == TECHNOLOGIES.RNA)
     return {
       type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' +  TECHNOLOGIES.RNA,
       Nucleotides: seq,
@@ -369,7 +485,7 @@ function convertSequence(text: string) {
       Axolabs: siRnaNucleotideToAxolabsSenseStrand(seq),
       GCRS: siRnaNucleotidesToGcrs(seq)
     };
-  if (output.expectedType == SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.SI_RNA)
+  if (output.expectedSynthesizer == SYNTHESIZERS.BIOSPRING && output.expectedTechnology == TECHNOLOGIES.SI_RNA)
     return {
       type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.SI_RNA,
       Nucleotides: siRnaBioSpringToNucleotides(seq),
@@ -377,7 +493,7 @@ function convertSequence(text: string) {
       Axolabs: siRnaBioSpringToAxolabs(seq),
       GCRS: siRnaBioSpringToGcrs(seq)
     };
-  if (output.expectedType == SYNTHESIZERS.AXOLABS + ' ' + TECHNOLOGIES.SI_RNA)
+  if (output.expectedSynthesizer == SYNTHESIZERS.AXOLABS && output.expectedTechnology == TECHNOLOGIES.SI_RNA)
     return {
       type: SYNTHESIZERS.AXOLABS + ' ' + TECHNOLOGIES.SI_RNA,
       Nucleotides: siRnaAxolabsToNucleotides(seq),
@@ -385,7 +501,7 @@ function convertSequence(text: string) {
       Axolabs: seq,
       GCRS: siRnaAxolabsToGcrs(seq)
     };
-  if (output.expectedType == SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.SI_RNA)
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.SI_RNA)
     return {
       type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.SI_RNA,
       Nucleotides: siRnaGcrsToNucleotides(seq),
@@ -394,14 +510,14 @@ function convertSequence(text: string) {
       MM12: gcrsToMermade12(seq),
       GCRS: seq
     };
-  if (output.expectedType == SYNTHESIZERS.GCRS)
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS)
     return {
       type: SYNTHESIZERS.GCRS,
       Nucleotides: gcrsToNucleotides(seq),
       GCRS: seq,
       Mermade12: gcrsToMermade12(seq)
     }
-  if (output.expectedType == SYNTHESIZERS.MERMADE_12)
+  if (output.expectedSynthesizer == SYNTHESIZERS.MERMADE_12)
     return {
       type: SYNTHESIZERS.MERMADE_12,
       Nucleotides: noTranslationTableAvailable,
@@ -417,47 +533,47 @@ function convertSequence(text: string) {
 //name: asoGapmersNucleotidesToBioSpring
 //input: string nucleotides {semType: DNA nucleotides}
 //output: string result {semType: BioSpring / Gapmers}
-export function asoGapmersNucleotidesToBioSpring(nucleotides: string) {
+export function asoGapmersNucleotidesToBioSpring(nucleotides: string): string {
   let count: number = -1;
-  const objForEdges: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "T": "5*", "A": "6*", "C": "7*", "G": "8*"};
-  const objForCenter: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "T": "T*", "A": "A*", "C": "9*", "G": "G*"};
+  const objForEdges: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'T': '5*', 'A': '6*', 'C': '7*', 'G': '8*'};
+  const objForCenter: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'T': 'T*', 'A': 'A*', 'C': '9*', 'G': 'G*'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|T|C|G)/g, function (x: string) {
     count++;
     return (count > 4 && count < 15) ? objForCenter[x] : objForEdges[x];
-  }).slice(0, (nucleotides.endsWith("(invabasic)") || nucleotides.endsWith("(GalNAc-2-JNJ)")) ? nucleotides.length : 2 * count + 1);
+  }).slice(0, (nucleotides.endsWith('(invabasic)') || nucleotides.endsWith('(GalNAc-2-JNJ)')) ? nucleotides.length : 2 * count + 1);
 }
 
 //name: asoGapmersNucleotidesToGcrs
 //input: string nucleotides {semType: DNA nucleotides}
 //output: string result {semType: GCRS / Gapmers}
-export function asoGapmersNucleotidesToGcrs(nucleotides: string) {
+export function asoGapmersNucleotidesToGcrs(nucleotides: string): string {
   let count: number = -1;
-  const objForEdges: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "T": "moeUnps", "A": "moeAnps", "C": "moe5mCnps", "G": "moeGnps"};
-  const objForCenter: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "C": "5mCps", "A": "Aps", "T": "Tps", "G": "Gps"};
+  const objForEdges: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'T': 'moeUnps', 'A': 'moeAnps', 'C': 'moe5mCnps', 'G': 'moeGnps'};
+  const objForCenter: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'C': '5mCps', 'A': 'Aps', 'T': 'Tps', 'G': 'Gps'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|T|C|G)/g, function (x: string) {
     count++;
     if (count < 5) return (count == 4) ? objForEdges[x].slice(0, -3) + 'ps' : objForEdges[x];
     if (count < 15) return (count == 14) ? objForCenter[x].slice(0, -2) + 'nps' : objForCenter[x];
     return objForEdges[x];
-  }).slice(0, (nucleotides.endsWith("(invabasic)") || nucleotides.endsWith("(GalNAc-2-JNJ)")) ? nucleotides.length : -3);
+  }).slice(0, (nucleotides.endsWith('(invabasic)') || nucleotides.endsWith('(GalNAc-2-JNJ)')) ? nucleotides.length : -3);
 }
 
 //name: asoGapmersBioSpringToNucleotides
 //input: string nucleotides {semType: BioSpring / Gapmers}
 //output: string result {semType: DNA nucleotides}
-export function asoGapmersBioSpringToNucleotides(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "*": "", "5": "T", "6": "A", "7": "C", "8": "G", "9": "C"};
+export function asoGapmersBioSpringToNucleotides(nucleotides: string): string {
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', '*': '', '5': 'T', '6': 'A', '7': 'C', '8': 'G', '9': 'C'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|\*|5|6|7|8|9)/g, function (x: string) {return obj[x];});
 }
 
 //name: asoGapmersBioSpringToGcrs
 //input: string nucleotides {semType: BioSpring / Gapmers}
 //output: string result {semType: GCRS / Gapmers}
-export function asoGapmersBioSpringToGcrs(nucleotides: string) {
+export function asoGapmersBioSpringToGcrs(nucleotides: string): string {
   let count: number = -1;
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "5*": "moeUnps", "6*": "moeAnps", "7*": "moe5mCnps", "8*": "moeGnps", "9*": "5mCps", "A*": "Aps", "T*": "Tps",
-    "G*": "Gps", "C*": "Cps", "5": "moeU", "6": "moeA", "7": "moe5mC", "8": "moeG"
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    '5*': 'moeUnps', '6*': 'moeAnps', '7*': 'moe5mCnps', '8*': 'moeGnps', '9*': '5mCps', 'A*': 'Aps', 'T*': 'Tps',
+    'G*': 'Gps', 'C*': 'Cps', '5': 'moeU', '6': 'moeA', '7': 'moe5mC', '8': 'moeG'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|5\*|6\*|7\*|8\*|9\*|A\*|T\*|G\*|C\*|5|6|7|8)/g, function (x: string) {
     count++;
@@ -468,9 +584,9 @@ export function asoGapmersBioSpringToGcrs(nucleotides: string) {
 //name: asoGapmersGcrsToBioSpring
 //input: string nucleotides {semType: GCRS / Gapmers}
 //output: string result {semType: BioSpring / Gapmers}
-export function asoGapmersGcrsToBioSpring(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "moeT": "5", "moeA": "6", "moe5mC": "7", "moeG": "8", "moeU": "5", "5mC": "9", "nps": "*", "ps": "*", "U": "T"
+export function asoGapmersGcrsToBioSpring(nucleotides: string): string {
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'moeT': '5', 'moeA': '6', 'moe5mC': '7', 'moeG': '8', 'moeU': '5', '5mC': '9', 'nps': '*', 'ps': '*', 'U': 'T'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|moeT|moeA|moe5mC|moeG|moeU|5mC|nps|ps|U)/g, function (x: string) {return obj[x];});
 }
@@ -479,7 +595,7 @@ export function asoGapmersGcrsToBioSpring(nucleotides: string) {
 //input: string nucleotides {semType: GCRS / Gapmers}
 //output: string result {semType: DNA nucleotides}
 export function asoGapmersGcrsToNucleotides(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "moe": "", "5m": "", "n": "", "ps": "", "U": "T"};
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'moe': '', '5m': '', 'n': '', 'ps': '', 'U': 'T'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|moe|5m|n|ps|U)/g, function (x: string) {return obj[x];});
 }
 
@@ -487,7 +603,7 @@ export function asoGapmersGcrsToNucleotides(nucleotides: string) {
 //input: string nucleotides {semType: BioSpring / siRNA}
 //output: string result {semType: RNA nucleotides}
 export function siRnaBioSpringToNucleotides(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "1": "U", "2": "A", "3": "C", "4": "G", "5": "U", "6": "A", "7": "C", "8": "G", "*": ""};
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', '1': 'U', '2': 'A', '3': 'C', '4': 'G', '5': 'U', '6': 'A', '7': 'C', '8': 'G', '*': ''};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|1|2|3|4|5|6|7|8|\*)/g, function (x: string) {return obj[x];});
 }
 
@@ -495,7 +611,7 @@ export function siRnaBioSpringToNucleotides(nucleotides: string) {
 //input: string nucleotides {semType: BioSpring / siRNA}
 //output: string result {semType: Axolabs / siRNA}
 export function siRnaBioSpringToAxolabs(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "1": "Uf", "2": "Af", "3": "Cf", "4": "Gf", "5": "u", "6": "a", "7": "c", "8": "g", "*": "s"};
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', '1': 'Uf', '2': 'Af', '3': 'Cf', '4': 'Gf', '5': 'u', '6': 'a', '7': 'c', '8': 'g', '*': 's'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|1|2|3|4|5|6|7|8|\*)/g, function (x: string) {return obj[x];});
 }
 
@@ -503,7 +619,7 @@ export function siRnaBioSpringToAxolabs(nucleotides: string) {
 //input: string nucleotides {semType: BioSpring / siRNA}
 //output: string result {semType: GCRS}
 export function siRnaBioSpringToGcrs(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "1": "fU", "2": "fA", "3": "fC", "4": "fG", "5": "mU", "6": "mA", "7": "mC", "8": "mG", "*": "ps"};
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', '1': 'fU', '2': 'fA', '3': 'fC', '4': 'fG', '5': 'mU', '6': 'mA', '7': 'mC', '8': 'mG', '*': 'ps'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|1|2|3|4|5|6|7|8|\*)/g, function (x: string) {return obj[x];});
 }
 
@@ -511,8 +627,8 @@ export function siRnaBioSpringToGcrs(nucleotides: string) {
 //input: string nucleotides {semType: Axolabs / siRNA}
 //output: string result {semType: GCRS}
 export function siRnaAxolabsToGcrs(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "Uf": "fU", "Af": "fA", "Cf": "fC", "Gf": "fG", "u": "mU", "a": "mA", "c": "mC", "g": "mG", "s": "ps"
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'Uf': 'fU', 'Af': 'fA', 'Cf': 'fC', 'Gf': 'fG', 'u': 'mU', 'a': 'mA', 'c': 'mC', 'g': 'mG', 's': 'ps'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|Uf|Af|Cf|Gf|u|a|c|g|s)/g, function (x: string) {return obj[x];});
 }
@@ -521,8 +637,8 @@ export function siRnaAxolabsToGcrs(nucleotides: string) {
 //input: string nucleotides {semType: Axolabs / siRNA}
 //output: string result {semType: BioSpring / siRNA}
 export function siRnaAxolabsToBioSpring(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "Uf": "1", "Af": "2", "Cf": "3", "Gf": "4", "u": "5", "a": "6", "c": "7", "g": "8", "s": "*"
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'Uf': '1', 'Af': '2', 'Cf': '3', 'Gf': '4', 'u': '5', 'a': '6', 'c': '7', 'g': '8', 's': '*'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|Uf|Af|Cf|Gf|u|a|c|g|s)/g, function (x: string) {return obj[x];});
 }
@@ -531,8 +647,8 @@ export function siRnaAxolabsToBioSpring(nucleotides: string) {
 //input: string nucleotides {semType: Axolabs / siRNA}
 //output: string result {semType: RNA nucleotides}
 export function siRnaAxolabsToNucleotides(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "Uf": "U", "Af": "A", "Cf": "C", "Gf": "G", "u": "U", "a": "A", "c": "C", "g": "G", "s": ""
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'Uf': 'U', 'Af': 'A', 'Cf': 'C', 'Gf': 'G', 'u': 'U', 'a': 'A', 'c': 'C', 'g': 'G', 's': ''
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|Uf|Af|Cf|Gf|u|a|c|g|s)/g, function (x: string) {return obj[x];});
 }
@@ -541,8 +657,8 @@ export function siRnaAxolabsToNucleotides(nucleotides: string) {
 //input: string nucleotides {semType: GCRS}
 //output: string result {semType: RNA nucleotides}
 export function siRnaGcrsToNucleotides(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "fU": "U", "fA": "A", "fC": "C", "fG": "G", "mU": "U", "mA": "A", "mC": "C", "mG": "G", "ps": ""
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'fU': 'U', 'fA': 'A', 'fC': 'C', 'fG': 'G', 'mU': 'U', 'mA': 'A', 'mC': 'C', 'mG': 'G', 'ps': ''
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|fU|fA|fC|fG|mU|mA|mC|mG|ps)/g, function (x: string) {return obj[x];});
 }
@@ -551,8 +667,8 @@ export function siRnaGcrsToNucleotides(nucleotides: string) {
 //input: string nucleotides {semType: GCRS}
 //output: string result {semType: BioSpring / siRNA}
 export function siRnaGcrsToBioSpring(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "fU": "1", "fA": "2", "fC": "3", "fG": "4", "mU": "5", "mA": "6", "mC": "7", "mG": "8", "ps": "*"
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'fU': '1', 'fA': '2', 'fC': '3', 'fG': '4', 'mU': '5', 'mA': '6', 'mC': '7', 'mG': '8', 'ps': '*'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|fU|fA|fC|fG|mU|mA|mC|mG|ps)/g, function (x: string) {return obj[x];});
 }
@@ -561,8 +677,8 @@ export function siRnaGcrsToBioSpring(nucleotides: string) {
 //input: string nucleotides {semType: GCRS}
 //output: string result {semType: Axolabs / siRNA}
 export function siRnaGcrsToAxolabs(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "fU": "Uf", "fA": "Af", "fC": "Cf", "fG": "Gf", "mU": "u", "mA": "a", "mC": "c", "mG": "g", "ps": "s"
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'fU': 'Uf', 'fA': 'Af', 'fC': 'Cf', 'fG': 'Gf', 'mU': 'u', 'mA': 'a', 'mC': 'c', 'mG': 'g', 'ps': 's'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|fU|fA|fC|fG|mU|mA|mC|mG|ps)/g, function (x: string) {return obj[x];});
 }
@@ -572,10 +688,10 @@ export function siRnaGcrsToAxolabs(nucleotides: string) {
 //output: string result {semType: BioSpring / siRNA}
 export function siRnaNucleotideToBioSpringSenseStrand(nucleotides: string) {
   let count: number = -1;
-  const objForLeftEdge: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "6*", "U": "5*", "G": "8*", "C": "7*"};
-  const objForRightEdge: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "*6", "U": "*5", "G": "*8", "C": "*7"};
-  const objForOddIndices: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "6", "U": "5", "G": "8", "C": "7"};
-  const objForEvenIndices: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "2", "U": "1", "G": "4", "C": "3"};
+  const objForLeftEdge: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': '6*', 'U': '5*', 'G': '8*', 'C': '7*'};
+  const objForRightEdge: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': '*6', 'U': '*5', 'G': '*8', 'C': '*7'};
+  const objForOddIndices: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': '6', 'U': '5', 'G': '8', 'C': '7'};
+  const objForEvenIndices: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': '2', 'U': '1', 'G': '4', 'C': '3'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function (x: string) {
     count++;
     if (count < 2) return objForLeftEdge[x];
@@ -589,10 +705,10 @@ export function siRnaNucleotideToBioSpringSenseStrand(nucleotides: string) {
 //output: string result {semType: GCRS}
 export function siRnaNucleotidesToGcrs(nucleotides: string) {
   let count: number = -1;
-  const objForLeftEdge: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "mAps", "U": "mUps", "G": "mGps", "C": "mCps"};
-  const objForRightEdge: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "psmA", "U": "psmU", "G": "psmG", "C": "psmC"};
-  const objForEvenIndices: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "fA", "U": "fU", "G": "fG", "C": "fC"};
-  const objForOddIndices: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "mA", "U": "mU", "G": "mG", "C": "mC"};
+  const objForLeftEdge: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'mAps', 'U': 'mUps', 'G': 'mGps', 'C': 'mCps'};
+  const objForRightEdge: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'psmA', 'U': 'psmU', 'G': 'psmG', 'C': 'psmC'};
+  const objForEvenIndices: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'fA', 'U': 'fU', 'G': 'fG', 'C': 'fC'};
+  const objForOddIndices: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'mA', 'U': 'mU', 'G': 'mG', 'C': 'mC'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function (x: string) {
     count++;
     if (count < 2) return objForLeftEdge[x];
@@ -606,9 +722,9 @@ export function siRnaNucleotidesToGcrs(nucleotides: string) {
 //output: string result {semType: Axolabs}
 export function siRnaNucleotideToAxolabsSenseStrand(nucleotides: string) {
   let count: number = -1;
-  const objForLeftEdge: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "as", "U": "us", "G": "gs", "C": "cs"};
-  const objForSomeIndices: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "Af", "U": "Uf", "G": "Gf", "C": "Cf"};
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "a", "U": "u", "G": "g", "C": "c"};
+  const objForLeftEdge: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'as', 'U': 'us', 'G': 'gs', 'C': 'cs'};
+  const objForSomeIndices: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'Af', 'U': 'Uf', 'G': 'Gf', 'C': 'Cf'};
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'a', 'U': 'u', 'G': 'g', 'C': 'c'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function (x: string) {
     count++;
     if (count < 2) return objForLeftEdge[x];
@@ -623,10 +739,10 @@ export function siRnaNucleotideToAxolabsSenseStrand(nucleotides: string) {
 //output: string result {semType: Axolabs}
 export function siRnaNucleotideToAxolabsAntisenseStrand(nucleotides: string) {
   let count: number = -1;
-  const objForSmallLinkages: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "as", "U": "us", "G": "gs", "C": "cs"};
-  const objForBigLinkages: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "Afs", "U": "Ufs", "G": "Gfs", "C": "Cfs"};
-  const objForSomeIndices: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "Af", "U": "Uf", "G": "Gf", "C": "Cf"};
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)", "A": "a", "U": "u", "G": "g", "C": "c"};
+  const objForSmallLinkages: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'as', 'U': 'us', 'G': 'gs', 'C': 'cs'};
+  const objForBigLinkages: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'Afs', 'U': 'Ufs', 'G': 'Gfs', 'C': 'Cfs'};
+  const objForSomeIndices: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'Af', 'U': 'Uf', 'G': 'Gf', 'C': 'Cf'};
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)', 'A': 'a', 'U': 'u', 'G': 'g', 'C': 'c'};
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function (x: string) {
     count++;
     if (count > 19 && count < 22) return objForSmallLinkages[x];
@@ -640,9 +756,9 @@ export function siRnaNucleotideToAxolabsAntisenseStrand(nucleotides: string) {
 //input: string nucleotides {semType: GCRS}
 //output: string result {semType: RNA nucleotides}
 export function gcrsToNucleotides(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "mAps": "A", "mUps": "U", "mGps": "G", "mCps": "C", "fAps": "A", "fUps": "U", "fGps": "G", "fCps": "C",
-    "fU": "U", "fA": "A", "fC": "C", "fG": "G", "mU": "U", "mA": "A", "mC": "C", "mG": "G"
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'mAps': 'A', 'mUps': 'U', 'mGps': 'G', 'mCps': 'C', 'fAps': 'A', 'fUps': 'U', 'fGps': 'G', 'fCps': 'C',
+    'fU': 'U', 'fA': 'A', 'fC': 'C', 'fG': 'G', 'mU': 'U', 'mA': 'A', 'mC': 'C', 'mG': 'G'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|mAps|mUps|mGps|mCps|fAps|fUps|fGps|fCps|fU|fA|fC|fG|mU|mA|mC|mG)/g, function (x: string) {return obj[x];});
 }
@@ -651,9 +767,130 @@ export function gcrsToNucleotides(nucleotides: string) {
 //input: string nucleotides {semType: GCRS}
 //output: string result {semType: Mermade 12 / siRNA}
 export function gcrsToMermade12(nucleotides: string) {
-  const obj: {[index: string]: string} = {"(invabasic)": "(invabasic)", "(GalNAc-2-JNJ)": "(GalNAc-2-JNJ)",
-    "mAps": "e", "mUps": "h", "mGps": "g", "mCps": "f", "fAps": "i", "fUps": "l", "fGps": "k", "fCps": "j", "fU": "L",
-    "fA": "I", "fC": "J", "fG": "K", "mU": "H", "mA": "E", "mC": "F", "mG": "G"
+  const obj: {[index: string]: string} = {'(invabasic)': '(invabasic)', '(GalNAc-2-JNJ)': '(GalNAc-2-JNJ)',
+    'mAps': 'e', 'mUps': 'h', 'mGps': 'g', 'mCps': 'f', 'fAps': 'i', 'fUps': 'l', 'fGps': 'k', 'fCps': 'j', 'fU': 'L',
+    'fA': 'I', 'fC': 'J', 'fG': 'K', 'mU': 'H', 'mA': 'E', 'mC': 'F', 'mG': 'G'
   };
   return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|mAps|mUps|mGps|mCps|fAps|fUps|fGps|fCps|fU|fA|fC|fG|mU|mA|mC|mG)/g, function (x: string) {return obj[x]});
 }
+
+async function saveTableAsSdFile(table: DG.DataFrame) {
+  if (!table.columns.contains('Compound Name'))
+    grok.shell.warning("File was saved without columns 'Compound Name', 'Compound Components', 'Cpd MW', 'Salt mass', 'Batch MW'!");
+  let structureColumn = table.columns.byName('Sequence');
+  let result = '';
+  for (let i = 0; i < table.rowCount; i++) {
+    try {
+      let smiles = sequenceToSmiles(structureColumn.get(i));
+      //@ts-ignore
+      let mol = new OCL.Molecule.fromSmiles(smiles);
+      result += `\n${mol.toMolfile()}\n`;
+      for (let col of table.columns)
+        result += `>  <${col.name}>\n${col.get(i)}\n\n`;
+      result += '$$$$';
+    }
+    catch (error) {
+      console.error(error);
+    }
+  }
+  let element = document.createElement('a');
+  element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(result));
+  element.setAttribute('download', table.name + '.sdf');
+  element.click();
+}
+
+function parseNumber(saltName: string) {
+  let i = saltName.length;
+  while (saltName.length > -1 && saltName[i] != '(')
+    i--;
+  return parseInt(saltName.slice(i + 2));
+}
+
+//tags: autostart
+export function autostartOligoSdFileSubscription() {
+  grok.events.onViewAdded.subscribe((v: any) => {
+    if (v.type == 'TableView' && v.dataFrame.columns.contains('Type'))
+      oligoSdFile(v.dataFrame);
+  });
+}
+
+let weightsObj: {[code: string]: number} = {};
+for (let synthesizer of Object.keys(map))
+  for (let technology of Object.keys(map[synthesizer]))
+    for (let code of Object.keys(map[synthesizer][technology]))
+      weightsObj[code] = map[synthesizer][technology][code].weight;
+
+function molecularWeight(sequence: string): number {
+  const codes = sortByStringLengthInDescendingOrder(Object.keys(weightsObj));
+  let weight = 0, i = 0;
+  while (i < sequence.length) {
+    let matchedCode = codes.find((s) => s == sequence.slice(i, i + s.length))!;
+    weight += weightsObj[sequence.slice(i, i + matchedCode.length)];
+    i += matchedCode!.length;
+  }
+  return weight - 61.97;
+}
+
+export function oligoSdFile(table: DG.DataFrame) {
+
+  function addColumns(t: DG.DataFrame) {
+    if (t.columns.contains('Compound Name'))
+      return grok.shell.error('Columns already exist!');
+
+    table.col('Source')?.init('Johnson and Johnson Pharma');
+    table.col('ICD')?.init('No Contract');
+
+    let sequence = t.col('Sequence')!;
+    let salt = t.col('Salt')!;
+    let equivalents = t.col('Equivalents')!;
+
+    t.columns.addNewString('Compound Name').init((i: number) => sequence.get(i));
+    t.columns.addNewString('Compound Comments').init((i: number) => (i > 0 && i % 2 == 0) ?
+      sequence.getString(i) + '; duplex of SS: ' + sequence.getString(i - 2) + ' and AS: ' + sequence.getString(i - 1) :
+      sequence.getString(i)
+    );
+    t.columns.addNewFloat('Cpd MW').init((i: number) => ((i + 1) % 3 == 0) ? DG.FLOAT_NULL : molecularWeight(sequence.get(i)));
+    t.columns.addNewFloat('Salt mass').init((i: number) => parseNumber(salt.get(i)) * equivalents.get(i));
+    t.columns.addNewCalculated('Batch MW', '${Cpd MW} + ${Salt mass}', DG.COLUMN_TYPE.FLOAT, false);
+
+    addColumnsPressed = true;
+    return newDf = t;
+  }
+
+  const columnsOrder = ["Chemistry", "Number", "Type", "Chemistry Name", "Internal compound ID", "IDP", "Sequence", "Compound Name",
+    "Compound Comments", "Salt", "Equivalents", "Purity", "Cpd MW", "Salt mass", "Batch MW", "Source", "ICD", "Owner"];
+  let newDf: DG.DataFrame;
+  let addColumnsPressed = false;
+
+  let d = ui.div([
+    ui.icons.edit(() => {
+      d.innerHTML = '';
+      d.append(
+        ui.link('Add Columns', async () => {
+          await addColumns(table);
+          grok.shell.tableView(table.name).grid.columns.setOrder(columnsOrder);
+        }, 'Add columns: Compound Name, Compound Components, Cpd MW, Salt mass, Batch MW', ''),
+        ui.button('Save SD file', () => saveTableAsSdFile(addColumnsPressed ? newDf : table))
+      );
+      let view = grok.shell.getTableView(table.name);
+      let typeCol = view.grid.col('Type')!;
+      let saltCol = view.grid.col('Salt')!;
+      saltCol.cellType = 'html';
+      typeCol.cellType = 'html';
+      view.grid.onCellPrepare(function (gc: DG.GridCell) {
+        if (gc.isTableCell) {
+          if (gc.gridColumn.name == 'Type')
+            gc.style.element = ui.choiceInput('', gc.cell.value, ['AS', 'SS', 'Duplex']).root;
+          else if (gc.gridColumn.name == 'Salt')
+            gc.style.element = ui.choiceInput('', gc.cell.value, ['Sodium (+1)', 'Sodium (+2)']).root;
+        }
+      });
+
+      table.onDataChanged.subscribe((_) => {
+        if (table.currentCol.name == 'IDP' && typeof table.currentCell.value != 'number')
+          grok.shell.error('Value should be numeric');
+      });
+    })
+  ]);
+  grok.shell.v.setRibbonPanels([[d]]);
+}