@datagrok/sequence-translator 0.0.6 → 0.0.8

package/src/salts.ts

@@ -0,0 +1,2 @@
+export const SALTS_CSV = `CHARGE,DISPLAY,MOLWEIGHT
+  ,no Data Added,100`;

package/src/structures-works/converters.ts

@@ -0,0 +1,288 @@
+//name: asoGapmersNucleotidesToBioSpring
+//input: string nucleotides {semType: DNA nucleotides}
+//output: string result {semType: BioSpring / Gapmers}
+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*'};
+  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);
+}
+
+//name: asoGapmersNucleotidesToGcrs
+//input: string nucleotides {semType: DNA nucleotides}
+//output: string result {semType: GCRS / Gapmers}
+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'};
+  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);
+}
+
+//name: asoGapmersBioSpringToNucleotides
+//input: string nucleotides {semType: BioSpring / Gapmers}
+//output: string result {semType: DNA nucleotides}
+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): 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',
+  };
+  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++;
+      return (count == 4) ? obj[x].slice(0, -3) + 'ps' : (count == 14) ? obj[x].slice(0, -2) + 'nps' : obj[x];
+    });
+}
+
+
+//name: asoGapmersGcrsToBioSpring
+//input: string nucleotides {semType: GCRS / Gapmers}
+//output: string result {semType: BioSpring / Gapmers}
+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];});
+}
+
+//name: asoGapmersGcrsToNucleotides
+//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'};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|moe|5m|n|ps|U)/g, function(x: string) {return obj[x];});
+}
+
+//name: siRnaBioSpringToNucleotides
+//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', '*': ''};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|1|2|3|4|5|6|7|8|\*)/g,
+    function(x: string) {return obj[x];});
+}
+
+//name: siRnaBioSpringToAxolabs
+//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'};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|1|2|3|4|5|6|7|8|\*)/g,
+    function(x: string) {return obj[x];});
+}
+
+
+//name: siRnaBioSpringToGcrs
+//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'};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|1|2|3|4|5|6|7|8|\*)/g,
+    function(x: string) {return obj[x];});
+}
+
+//name: siRnaAxolabsToGcrs
+//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',
+  };
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|Uf|Af|Cf|Gf|u|a|c|g|s)/g,
+    function(x: string) {return obj[x];});
+}
+
+//name: siRnaAxolabsToBioSpring
+//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': '*',
+  };
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|Uf|Af|Cf|Gf|u|a|c|g|s)/g,
+    function(x: string) {return obj[x];});
+}
+
+//name: siRnaAxolabsToNucleotides
+//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': '',
+  };
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|Uf|Af|Cf|Gf|u|a|c|g|s)/g,
+    function(x: string) {return obj[x];});
+}
+
+
+//name: siRnaGcrsToNucleotides
+//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': '',
+  };
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|fU|fA|fC|fG|mU|mA|mC|mG|ps)/g,
+    function(x: string) {return obj[x];});
+}
+
+//name: siRnaGcrsToBioSpring
+//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': '*',
+  };
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|fU|fA|fC|fG|mU|mA|mC|mG|ps)/g,
+    function(x: string) {return obj[x];});
+}
+
+//name: siRnaGcrsToAxolabs
+//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',
+  };
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|fU|fA|fC|fG|mU|mA|mC|mG|ps)/g,
+    function(x: string) {return obj[x];});
+}
+
+//name: siRnaNucleotideToBioSpringSenseStrand
+//input: string nucleotides {semType: RNA nucleotides}
+//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'};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function(x: string) {
+    count++;
+    if (count < 2) return objForLeftEdge[x];
+    if (count > nucleotides.length - 3) return objForRightEdge[x];
+    return (count % 2 == 0) ? objForEvenIndices[x] : objForOddIndices[x];
+  });
+}
+
+//name: siRnaNucleotidesToGcrs
+//input: string nucleotides {semType: RNA nucleotides}
+//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'};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function(x: string) {
+    count++;
+    if (count < 2) return objForLeftEdge[x];
+    if (count > nucleotides.length - 3) return objForRightEdge[x];
+    return (count % 2 == 0) ? objForEvenIndices[x] : objForOddIndices[x];
+  });
+}
+
+//name: siRnaNucleotideToAxolabsSenseStrand
+//input: string nucleotides {semType: RNA nucleotides}
+//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'};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function(x: string) {
+    count++;
+    if (count < 2) return objForLeftEdge[x];
+    if (count == 6 || (count > 7 && count < 11)) return objForSomeIndices[x];
+    if (count == nucleotides.length - 1) return 'a';
+    return obj[x];
+  });
+}
+
+//name: siRnaNucleotideToAxolabsAntisenseStrand
+//input: string nucleotides {semType: RNA nucleotides}
+//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'};
+  return nucleotides.replace(/(\(invabasic\)|\(GalNAc-2-JNJ\)|A|U|G|C)/g, function(x: string) {
+    count++;
+    if (count > 19 && count < 22) return objForSmallLinkages[x];
+    if (count == 0) return 'us';
+    if (count == 1) return objForBigLinkages[x];
+    return (count == 5 || count == 7 || count == 8 || count == 13 || count == 15) ? objForSomeIndices[x] : obj[x];
+  });
+}
+
+//name: gcrsToNucleotides
+//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',
+  };
+  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];});
+}
+
+//name: gcrsToMermade12
+//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',
+  };
+  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];});
+}

package/src/structures-works/from-monomers.ts

@@ -0,0 +1,73 @@
+import {map, stadardPhosphateLinkSmiles, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS} from './map';
+import {isValidSequence} from './sequence-codes-tools';
+
+export function sequenceToSmiles(sequence: string, inverted: boolean = false): string {
+  const obj = getObjectWithCodesAndSmiles(sequence);
+  let codes = sortByStringLengthInDescendingOrder(Object.keys(obj));
+  let i = 0;
+  let smiles = '';
+  const codesList = [];
+  const links = ['s', 'ps', '*'];
+  const includesStandardLinkAlready = ['e', 'h', /*'g',*/ 'f', 'i', 'l', 'k', 'j'];
+  const dropdowns = Object.keys(MODIFICATIONS);
+  codes = codes.concat(dropdowns);
+  while (i < sequence.length) {
+    const code = codes.find((s: string) => s == sequence.slice(i, i + s.length))!;
+    i += code.length;
+    inverted ? codesList.unshift(code) : codesList.push(code);
+  }
+  for (let i = 0; i < codesList.length; i++) {
+    if (dropdowns.includes(codesList[i])) {
+      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]) ||
+        includesStandardLinkAlready.includes(codesList[i]) ||
+        (i < codesList.length - 1 && links.includes(codesList[i + 1]))
+      )
+        smiles += obj[codesList[i]];
+      else
+        smiles += obj[codesList[i]] + stadardPhosphateLinkSmiles;
+    }
+  }
+  smiles = smiles.replace(/OO/g, 'O');
+  return (
+    (
+      links.includes(codesList[codesList.length - 1]) &&
+      codesList.length > 1 &&
+      !includesStandardLinkAlready.includes(codesList[codesList.length - 2])
+    ) ||
+    dropdowns.includes(codesList[codesList.length - 1]) ||
+    includesStandardLinkAlready.includes(codesList[codesList.length - 1])
+  ) ?
+    smiles :
+    smiles.slice(0, smiles.length - stadardPhosphateLinkSmiles.length + 1);
+}
+
+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 (const 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;
+}
+
+function sortByStringLengthInDescendingOrder(array: string[]): string[] {
+  return array.sort(function(a: string, b: string) {return b.length - a.length;});
+}

package/src/{save-sense-antisense.ts → structures-works/save-sense-antisense.ts}

@@ -1,22 +1,22 @@
 import * as ui from 'datagrok-api/ui';
-import {sequenceToSmiles} from './package';
+import {sequenceToSmiles} from '../structures-works/from-monomers';
 import * as OCL from 'openchemlib/full.js';
 
 export function saveSenseAntiSense() {
   const ssInput = ui.textInput('Sense Strand 5\' ->3\'', '');
   const asInput = ui.textInput('Anti Sense 3\' ->5\'', '');
-  const saveOption = ui.switchInput('save as one entity', false);
+  const saveOption = ui.switchInput('save as one entity', true);
   const saveBtn = ui.button('Save SDF', () => {
     const smiSS = sequenceToSmiles(ssInput.value);
     const smiAS = sequenceToSmiles(asInput.value, true);
     let result: string;
     if (saveOption.value)
-      result = `${OCL.Molecule.fromSmiles(smiSS + '.' + smiAS).toMolfile()}\n\n$$$$\n`;
+      result = `${OCL.Molecule.fromSmiles(smiSS + '.' + smiAS).toMolfileV3()}\n\n$$$$\n`;
     else {
       result =
-      `${OCL.Molecule.fromSmiles(smiSS).toMolfile()}\n` +
+      `${OCL.Molecule.fromSmiles(smiSS).toMolfileV3()}\n` +
       `>  <Sequence>\nSense Strand\n\n$$$$\n` +
-      `${OCL.Molecule.fromSmiles(smiAS).toMolfile()}\n` +
+      `${OCL.Molecule.fromSmiles(smiAS).toMolfileV3()}\n` +
       `>  <Sequence>\nAnti Sense\n\n$$$$\n`;
     }
 

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

@@ -0,0 +1,236 @@
+import {map, SYNTHESIZERS, TECHNOLOGIES, MODIFICATIONS} from './map';
+import {asoGapmersNucleotidesToBioSpring, asoGapmersNucleotidesToGcrs,
+  asoGapmersBioSpringToNucleotides, asoGapmersBioSpringToGcrs, asoGapmersGcrsToNucleotides,
+  asoGapmersGcrsToBioSpring, gcrsToMermade12, siRnaNucleotideToBioSpringSenseStrand,
+  siRnaNucleotideToAxolabsSenseStrand, siRnaNucleotidesToGcrs, siRnaBioSpringToNucleotides,
+  siRnaBioSpringToAxolabs, siRnaBioSpringToGcrs, siRnaAxolabsToNucleotides,
+  siRnaAxolabsToBioSpring, siRnaAxolabsToGcrs, siRnaGcrsToNucleotides,
+  siRnaGcrsToBioSpring, siRnaGcrsToAxolabs, gcrsToNucleotides} from './converters';
+
+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
+} {
+  const possibleSynthesizers = getListOfPossibleSynthesizersByFirstMatchedCode(sequence);
+  if (possibleSynthesizers.length == 0)
+    return {indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null};
+
+  let outputIndices = Array(possibleSynthesizers.length).fill(0);
+
+  const firstUniqueCharacters = ['r', 'd'];
+  const nucleotides = ['A', 'U', 'T', 'C', 'G'];
+
+  possibleSynthesizers.forEach((synthesizer, synthesizerIndex) => {
+    const codes = getAllCodesOfSynthesizer(synthesizer);
+    while (outputIndices[synthesizerIndex] < sequence.length) {
+      const matchedCode = codes
+        .find((c) => c == sequence.slice(outputIndices[synthesizerIndex], outputIndices[synthesizerIndex] + 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])
+      ) break;
+
+      if ( // for mistake pattern 'ArA'
+        firstUniqueCharacters.includes(sequence[outputIndices[synthesizerIndex] + 1]) &&
+        nucleotides.includes(sequence[outputIndices[synthesizerIndex]])
+      ) {
+        outputIndices[synthesizerIndex]++;
+        break;
+      }
+
+      outputIndices[synthesizerIndex] += matchedCode.length;
+    }
+  });
+
+  const indexOfExpectedSythesizer = Math.max(...outputIndices);
+  const indexOfFirstNotValidCharacter = (indexOfExpectedSythesizer == sequence.length) ? -1 : indexOfExpectedSythesizer;
+  const expectedSynthesizer = possibleSynthesizers[outputIndices.indexOf(indexOfExpectedSythesizer)];
+  if (indexOfFirstNotValidCharacter != -1) {
+    return {
+      indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
+      expectedSynthesizer: expectedSynthesizer,
+      expectedTechnology: null,
+    };
+  }
+
+  const possibleTechnologies = getListOfPossibleTechnologiesByFirstMatchedCode(sequence, expectedSynthesizer);
+  if (possibleTechnologies.length == 0)
+    return {indexOfFirstNotValidCharacter: 0, expectedSynthesizer: null, expectedTechnology: null};
+
+  outputIndices = Array(possibleTechnologies.length).fill(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));
+
+      if (matchedCode == null)
+        break;
+
+      if ( // for mistake pattern 'rAA'
+        outputIndices[technologyIndex] > 1 &&
+        nucleotides.includes(sequence[outputIndices[technologyIndex]]) &&
+        firstUniqueCharacters.includes(sequence[outputIndices[technologyIndex] - 2])
+      ) break;
+
+      if ( // for mistake pattern 'ArA'
+        firstUniqueCharacters.includes(sequence[outputIndices[technologyIndex] + 1]) &&
+        nucleotides.includes(sequence[outputIndices[technologyIndex]])
+      ) {
+        outputIndices[technologyIndex]++;
+        break;
+      }
+
+      outputIndices[technologyIndex] += matchedCode.length;
+    }
+  });
+
+  const indexOfExpectedTechnology = Math.max(...outputIndices);
+  const expectedTechnology = possibleTechnologies[outputIndices.indexOf(indexOfExpectedTechnology)];
+
+  return {
+    indexOfFirstNotValidCharacter: indexOfFirstNotValidCharacter,
+    expectedSynthesizer: expectedSynthesizer,
+    expectedTechnology: expectedTechnology,
+  };
+}
+
+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));
+}
+
+function getListOfPossibleSynthesizersByFirstMatchedCode(sequence: string): 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++) {
+      if (sequence[i] == ')' && i != sequence.length - 1) {
+        start = i + 1;
+        break;
+      }
+    }
+    if (codes.some((s: string) => s == sequence.slice(start, start + s.length)))
+      synthesizers.push(synthesizer);
+  });
+  return synthesizers;
+}
+
+function getListOfPossibleTechnologiesByFirstMatchedCode(sequence: string, synthesizer: string): 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)))
+      technologies.push(technology);
+  });
+  return technologies;
+}
+
+export function convertSequence(text: string) {
+  text = text.replace(/\s/g, '');
+  const seq = text;
+  const output = isValidSequence(seq);
+  if (output.indexOfFirstNotValidCharacter != -1) {
+    return {
+      // type: '',
+      indexOfFirstNotValidCharacter: JSON.stringify(output),
+      Error: undefinedInputSequence,
+    };
+  }
+  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.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.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.ASO_GAPMERS) {
+    return {
+      type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.ASO_GAPMERS,
+      Nucleotides: asoGapmersGcrsToNucleotides(seq),
+      BioSpring: asoGapmersGcrsToBioSpring(seq),
+      Mermade12: gcrsToMermade12(seq),
+      GCRS: seq,
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.RAW_NUCLEOTIDES && output.expectedTechnology == TECHNOLOGIES.RNA) {
+    return {
+      type: SYNTHESIZERS.RAW_NUCLEOTIDES + ' ' + TECHNOLOGIES.RNA,
+      Nucleotides: seq,
+      BioSpring: siRnaNucleotideToBioSpringSenseStrand(seq),
+      Axolabs: siRnaNucleotideToAxolabsSenseStrand(seq),
+      GCRS: siRnaNucleotidesToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.BIOSPRING && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+    return {
+      type: SYNTHESIZERS.BIOSPRING + ' ' + TECHNOLOGIES.SI_RNA,
+      Nucleotides: siRnaBioSpringToNucleotides(seq),
+      BioSpring: seq,
+      Axolabs: siRnaBioSpringToAxolabs(seq),
+      GCRS: siRnaBioSpringToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.AXOLABS && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+    return {
+      type: SYNTHESIZERS.AXOLABS + ' ' + TECHNOLOGIES.SI_RNA,
+      Nucleotides: siRnaAxolabsToNucleotides(seq),
+      BioSpring: siRnaAxolabsToBioSpring(seq),
+      Axolabs: seq,
+      GCRS: siRnaAxolabsToGcrs(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS && output.expectedTechnology == TECHNOLOGIES.SI_RNA) {
+    return {
+      type: SYNTHESIZERS.GCRS + ' ' + TECHNOLOGIES.SI_RNA,
+      Nucleotides: siRnaGcrsToNucleotides(seq),
+      BioSpring: siRnaGcrsToBioSpring(seq),
+      Axolabs: siRnaGcrsToAxolabs(seq),
+      MM12: gcrsToMermade12(seq),
+      GCRS: seq,
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.GCRS) {
+    return {
+      type: SYNTHESIZERS.GCRS,
+      Nucleotides: gcrsToNucleotides(seq),
+      GCRS: seq,
+      Mermade12: gcrsToMermade12(seq),
+    };
+  }
+  if (output.expectedSynthesizer == SYNTHESIZERS.MERMADE_12) {
+    return {
+      type: SYNTHESIZERS.MERMADE_12,
+      Nucleotides: noTranslationTableAvailable,
+      GCRS: noTranslationTableAvailable,
+      Mermade12: seq,
+    };
+  }
+  return {
+    type: undefinedInputSequence,
+    Nucleotides: undefinedInputSequence,
+  };
+}

package/src/tests/smiles-tests.ts

@@ -1,5 +1,5 @@
 import {category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {sequenceToSmiles} from '../package';
+import {sequenceToSmiles} from '../structures-works/from-monomers';
 
 category('sequence-translator', () => {
   test('AGGTCCTCTTGACTTAGGCC', async () => {