@datagrok/sequence-translator 1.2.2 → 1.2.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "author": {
     "name": "Alexey Choposky",
     "email": "achopovsky@datagrok.ai"

package/src/model/parsing-validation/format-handler.ts

@@ -0,0 +1,147 @@
+/* Do not change these import lines to match external modules in webpack configuration */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {codesToHelmDictionary} from '../data-loading-utils/json-loader';
+import {CodesInfo} from '../data-loading-utils/types';
+import {DEFAULT_FORMATS} from '../const';
+import {GROUP_TYPE, PHOSPHATE_SYMBOL} from '../translator-app/const';
+
+const inverseLengthComparator = (a: string, b: string) => b.length - a.length;
+
+export class FormatHandler {
+  constructor() {
+    this.formats = this.getFormats();
+  }
+
+  /** Includes all formats except HELM (the "default" one)  */
+  private formats: string[];
+
+  /** All format names except HELM (the "default" one)  */
+  getFormatNames(): string[] {
+    return this.formats.sort();
+  };
+
+  getCodesByFormat(format: string): string[] {
+    this.validateFormat(format);
+
+    if (this.isHelm(format))
+      throw new Error(`Codes cannot be obtained for HELM`);
+    return this.getFormatCodes(format);
+  }
+
+  getHelmToFormatDict(format: string): {[key: string]: string} {
+    this.validateFormat(format);
+
+    const codesInfoObject = codesToHelmDictionary[format] as CodesInfo;
+    const dict = getHelmToCodeDict(codesInfoObject);
+    return dict;
+  }
+
+  getFormatToHelmDict(format: string): {[key: string]: string} {
+    this.validateFormat(format);
+
+    const codesInfoObject = codesToHelmDictionary[format] as CodesInfo;
+    const dict = Object.assign({}, ...Object.values(codesInfoObject)) as {[code: string]: string};
+    return dict;
+  }
+
+  /** Get helm codes for the specified format  */
+  getTargetFormatHelmCodes(format: string): string[] {
+    this.validateFormat(format);
+
+    const dict = this.getHelmToFormatDict(format);
+    const helmCodes = Object.keys(dict).sort(inverseLengthComparator);
+    return helmCodes;
+  }
+
+  getTargetFormatHelmCodesRegExp(format: string): RegExp {
+    this.validateFormat(format);
+
+    const helmCodes = this.getTargetFormatHelmCodes(format);
+    const helmRegExp = new RegExp(getRegExpPattern(helmCodes) + '|.', 'g');
+    return helmRegExp;
+  }
+
+  getFormatRegExp(format: string): RegExp {
+    this.validateFormat(format);
+
+    if (this.isHelm(format))
+      throw new Error(`Helm RegExp can be built for non-HELM target formats`);
+    return this.getNonHelmFormatRegExp(format);
+  }
+
+  getPhosphateHelmCodesRegExp(format: string): RegExp {
+    this.validateFormat(format);
+
+    const codesInfoObject = codesToHelmDictionary[format] as CodesInfo;
+    const phosphateHELMCodes = Array.from(
+      new Set(Object.values(codesInfoObject[GROUP_TYPE.LINKAGE]))
+    ).sort(inverseLengthComparator);
+    const phosphateHELMPattern = getRegExpPattern(phosphateHELMCodes);
+    const phosphateRegExp = new RegExp(`${PHOSPHATE_SYMBOL}\.(${phosphateHELMPattern})`, 'g');
+    return phosphateRegExp;
+  }
+
+  isValidFormat(format: string): boolean {
+    return this.formats.includes(format);
+  }
+
+  private getFormats(): string[] {
+    return Object.keys(codesToHelmDictionary);
+  }
+
+  private validateFormat(format: string) {
+    if (!this.isValidFormat(format))
+      throw new Error(`Invalid format: ${format}`);
+  }
+
+  private isHelm(format: string): boolean {
+    return format === DEFAULT_FORMATS.HELM;
+  }
+
+  private getFormatCodes(format: string): string[] {
+    const dict = this.getFormatToHelmDict(format);
+    const formatCodes = Object.keys(dict).sort(inverseLengthComparator);
+    return formatCodes;
+  }
+  
+  private getNonHelmFormatRegExp(format: string): RegExp {
+    const formatCodes = this.getCodesByFormat(format);
+    const formatRegExp = new RegExp(getRegExpPattern(formatCodes) + '|\\([^()]*\\)|.', 'g'); // the added group before '|.' is to avoid mismatch inside parenths
+    return formatRegExp;
+  }
+}
+
+export function getRegExpPattern(arr: string[]): string {
+  const negativeLookBehind = '(?<!\\([^()]*)'; // not '(' followed by non-parenths
+  const negativeLookAhead = '(?![^()]*\\))';  // not ')' preceded by non-parenths
+  const escaped = arr.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+    .map((key) => {
+    if (!key.includes('(') && !key.includes(')'))
+      return `${negativeLookBehind}${key}${negativeLookAhead}`;
+    return key;
+  });
+  const result =  escaped.join('|');
+  return result;
+}
+
+function getHelmToCodeDict(infoObj: CodesInfo) {
+  const result: {[key: string]: string | string[]} = {};
+  Object.values(infoObj).forEach((obj: {[code: string]: string}) => {
+    Object.entries(obj).forEach(([code, helm]) => {
+      const key = helm.replace(/\)p/g, ')').replace(/\]p/g, ']');
+      if (result[key] === undefined) {
+        result[key] = [code];
+      } else {
+        (result[key] as string[]).push(code);
+      }
+    })
+  });
+  Object.entries(result).forEach(([key, value]) => {
+    const sorted = (value as string[]).sort(inverseLengthComparator);
+    result[key] = sorted[0] as string;
+  })
+  return result as {[key: string]: string};
+}

package/src/model/translator-app/format-converter.ts

@@ -0,0 +1,68 @@
+import * as DG from 'datagrok-api/dg';
+import {DEFAULT_FORMATS} from '../const';
+import {PHOSPHATE_SYMBOL, UNKNOWN_SYMBOL} from './const';
+import {FormatHandler, getRegExpPattern} from '../parsing-validation/format-handler';
+
+const HELM_WRAPPER = {
+  LEFT: 'RNA1{',
+  RIGHT: '}$$$$',
+};
+
+export class FormatConverter {
+  constructor(private readonly sequence: string, private readonly sourceFormat: string) { };
+
+  private formats = new FormatHandler();
+
+  convertTo(targetFormat: string): string {
+    const formats = this.formats.getFormatNames();
+
+    if (this.sourceFormat === DEFAULT_FORMATS.HELM && formats.includes(targetFormat))
+      return this.helmToFormat(this.sequence, targetFormat);
+    else if (formats.includes(this.sourceFormat) && targetFormat === DEFAULT_FORMATS.HELM)
+      return this.formatToHelm(this.sequence, this.sourceFormat);
+    else if ([this.sourceFormat, targetFormat].every((el) => formats.includes(el))) {
+      const helm = this.formatToHelm(this.sequence, this.sourceFormat);
+      return this.helmToFormat(helm, targetFormat);
+    }
+    else {
+      throw new Error (`ST: unsupported translation direction ${this.sourceFormat} -> ${targetFormat}`);
+    }
+  }
+
+  private helmToFormat(helmSequence: string, targetFormat: string): string {
+    const wrapperRegExp = new RegExp(getRegExpPattern(Object.values(HELM_WRAPPER)), 'g')
+    let result = helmSequence.replace(wrapperRegExp, '');
+
+    const dict = this.formats.getHelmToFormatDict(targetFormat);
+    const helmCodes = this.formats.getTargetFormatHelmCodes(targetFormat);
+    const helmRegExp = this.formats.getTargetFormatHelmCodesRegExp(targetFormat);
+
+    result = result.replace(helmRegExp, (match) => {
+      return helmCodes.includes(match) ? dict[match] :
+        (match === 'p' || match === '.') ? match : '?';
+    }).replace(/\?+/g, UNKNOWN_SYMBOL).replace(/p\.|\./g, '');
+    result = result.replace(/<empty>/g, '');
+    // remove double slash in LCMS codes
+    result = result.replace(/\/\//g, '/');
+    return result;
+  }
+
+  private formatToHelm(sequence: string, sourceFormat: string): string {
+    const dict = this.formats.getFormatToHelmDict(sourceFormat);
+    const formatCodes = this.formats.getCodesByFormat(sourceFormat);
+    const formatRegExp = this.formats.getFormatRegExp(sourceFormat);
+    const phosphateRegExp = this.formats.getPhosphateHelmCodesRegExp(sourceFormat);
+
+    let helm = sequence.replace(formatRegExp, (match) => {
+      const result = formatCodes.includes(match) ?  dict[match] + '.' : '?';
+      return result;
+    });
+    helm = helm.replace(/\?+/g, `${UNKNOWN_SYMBOL}.`);
+    helm = helm.slice(0, -1); // strip last dot
+    if (helm[helm.length - 1] === PHOSPHATE_SYMBOL)
+      helm = helm.slice(0, -1);
+    helm = helm.replace(phosphateRegExp, (match, group) => group);
+    helm = helm.replace(/<empty>/g, '');
+    return `${HELM_WRAPPER.LEFT + helm + HELM_WRAPPER.RIGHT}`;
+  }
+}

package/src/package.ts

@@ -8,13 +8,13 @@ import {LIB_PATH, DEFAULT_LIB_FILENAME} from './model/data-loading-utils/const';
 import {IMonomerLib} from '@datagrok-libraries/bio/src/types';
 import {getMonomerLibHelper, IMonomerLibHelper} from '@datagrok-libraries/bio/src/monomer-works/monomer-utils';
 import {getJsonData} from './model/data-loading-utils/json-loader';
-import {SequenceToMolfileConverter} from './model/sequence-to-structure-utils/sequence-to-molfile';
-import {linkStrandsV3000} from './model/sequence-to-structure-utils/mol-transformations';
+import {SequenceToMolfileConverter} from './model/structure-app/sequence-to-molfile';
+import {linkStrandsV3000} from './model/structure-app/mol-transformations';
 import {MonomerLibWrapper} from './model/monomer-lib/lib-wrapper';
 import {FormatDetector} from './model/parsing-validation/format-detector';
 import {SequenceValidator} from './model/parsing-validation/sequence-validator';
 import {demoOligoTranslatorUI, demoOligoPatternUI, demoOligoStructureUI} from './demo/demo-st-ui';
-import {FormatConverter} from './model/format-translation/format-converter';
+import {FormatConverter} from './model/translator-app/format-converter';
 import {APP} from './view/const/ui';
 import {getExternalAppViewFactories} from './plugins/mermade';
 

package/src/tests/formats-support.ts

@@ -8,7 +8,7 @@ import {DEFAULT_FORMATS} from '../model/const';
 import {getJsonData} from '../model/data-loading-utils/json-loader';
 import {formatsToHelm} from './const';
 import {SequenceValidator} from '../model/parsing-validation/sequence-validator';
-import {getTranslatedSequences} from '../model/format-translation/conversion-utils';
+import {getTranslatedSequences} from '../model/translator-app/conversion-utils';
 import {_package} from '../package';
 
 function getTranslationObject(sequence: string, format: string): {[format: string]: string} {

package/src/tests/formats-to-helm.ts

@@ -5,7 +5,7 @@ import * as DG from 'datagrok-api/dg';
 
 import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
 import {DEFAULT_FORMATS} from '../model/const';
-import {FormatConverter} from '../model/format-translation/format-converter';
+import {FormatConverter} from '../model/translator-app/format-converter';
 import {getJsonData} from '../model/data-loading-utils/json-loader';
 import {formatsToHelm} from './const';
 import {_package} from '../package';

package/src/tests/helm-to-nucleotides.ts

@@ -4,7 +4,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {before, category, expect, test} from '@datagrok-libraries/utils/src/test';
-import {getNucleotidesSequence} from '../model/format-translation/conversion-utils';
+import {getNucleotidesSequence} from '../model/translator-app/conversion-utils';
 import {getJsonData} from '../model/data-loading-utils/json-loader';
 import {helmToNucleotides} from './const';
 import {_package} from '../package';

package/src/view/apps/oligo-pattern.ts

@@ -5,11 +5,11 @@ import * as DG from 'datagrok-api/dg';
 
 import {axolabsStyleMap} from '../../model/data-loading-utils/json-loader';
 import {
-  DEFAULT_PTO, DEFAULT_SEQUENCE_LENGTH, MAX_SEQUENCE_LENGTH, USER_STORAGE_KEY, EXAMPLE_MIN_WIDTH, SS, AS, STRAND_NAME, STRANDS, TERMINAL, TERMINAL_KEYS, THREE_PRIME, FIVE_PRIME, JSON_FIELD as FIELD
-} from '../../model/axolabs/const';
-import {isOverhang} from '../../model/axolabs/helpers';
-import {generateExample, translateSequence, getShortName, isCurrentUserCreatedThisPattern, findDuplicates, addColumnWithIds, addColumnWithTranslatedSequences} from '../../model/axolabs/axolabs-tab';
-import {drawAxolabsPattern} from '../../model/axolabs/draw-svg';
+  DEFAULT_PTO, DEFAULT_SEQUENCE_LENGTH, MAX_SEQUENCE_LENGTH, USER_STORAGE_KEY, SS, AS, STRAND_NAME, STRANDS, TERMINAL, TERMINAL_KEYS, THREE_PRIME, FIVE_PRIME, JSON_FIELD as FIELD
+} from '../../model/pattern-app/const';
+import {isOverhang} from '../../model/pattern-app/helpers';
+import {generateExample, translateSequence, getShortName, isCurrentUserCreatedThisPattern, findDuplicates, addColumnWithIds, addColumnWithTranslatedSequences} from '../../model//pattern-app/oligo-pattern';
+import {drawAxolabsPattern} from '../../model/pattern-app/draw-svg';
 // todo: remove ts-ignore
 //@ts-ignore
 import * as svg from 'save-svg-as-png';
@@ -530,7 +530,6 @@ export class PatternLayoutHandler {
     const inputIdColumnDiv = ui.div([]);
     const svgDiv = ui.div([]);
     const asExampleDiv = ui.div([], 'ui-form ui-form-wide');
-    const appAxolabsDescription = ui.div([]);
     const loadPatternDiv = ui.div([]);
     const asModificationDiv = ui.form([]);
     const isEnumerateModificationsDiv = ui.divH([
@@ -678,7 +677,7 @@ export class PatternLayoutHandler {
       {backgroundColor: 'white'}), 'Download pattern as PNG image', '');
      
     const editPattern = ui.link('Edit pattern', ()=>{
-      ui.dialog('Edit patter')
+      ui.dialog('Edit pattern')
       .add(ui.divV([
         ui.h1('PTO'),
         ui.divH([
@@ -695,56 +694,6 @@ export class PatternLayoutHandler {
       .show()
     }, 'Edit pattern', '');  
 
-    const mainSection = ui.panel([
-      ui.block([
-        svgDiv,
-      ], {style: {overflowX: 'scroll'}}),
-      downloadButton,
-      isEnumerateModificationsDiv,
-      ui.div([
-        ui.div([
-          ui.divH([
-            ui.h1('Pattern options'),
-          ]),
-          ui.divH([
-            ui.block([
-              strandLengthInput[SS].root,
-              asLengthDiv,
-              sequenceBase.root,
-              comment.root,
-              loadPatternDiv,
-              saveAs.root,
-              ui.buttonsInput([
-                //savePatternButton,
-              ]),
-            ], 'ui-form'),
-            ui.block([
-              createAsStrand.root,
-              fullyPto.root,
-              firstPto[SS].root,
-              firstPto[AS].root,
-              terminalModification[SS][FIVE_PRIME].root,
-              terminalModification[SS][THREE_PRIME].root,
-              asModificationDiv,
-            ], 'ui-form'),
-          ]),
-        ], 'ui-form'),
-        inputsSection,
-        exampleSection,
-      ], {style: {flexWrap: 'wrap'}}),
-    ]);
-
-    const info = ui.info(
-      [
-        ui.divText('\n How to define new pattern:', {style: {'font-weight': 'bolder'}}),
-        ui.divText('1. Choose table and columns with sense and antisense strands'),
-        ui.divText('2. Choose lengths of both strands by editing checkboxes below'),
-        ui.divText('3. Choose basis and PTO status for each nucleotide'),
-        ui.divText('4. Set additional modifications for sequence edges'),
-        ui.divText('5. Press \'Convert Sequences\' button'),
-        ui.divText('This will add the result column(s) to the right of the table'),
-      ], 'Create and apply Axolabs translation patterns.',
-    );
     strandLengthInput[SS].addCaption('Length');
 
     return ui.splitH([

package/src/view/apps/oligo-structure.ts

@@ -10,10 +10,10 @@ import $ from 'cash-dom';
 import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
 
 import {highlightInvalidSubsequence} from '../utils/colored-input/input-painters';
-import {getLinkedMolfile, saveSdf} from '../../model/sequence-to-structure-utils/sdf-tab';
+import {getLinkedMolfile, saveSdf} from '../../model/structure-app/oligo-structure';
 import {ColoredTextInput} from '../utils/colored-input/colored-text-input';
 import {MoleculeImage} from '../utils/molecule-img';
-import {StrandData} from '../../model/sequence-to-structure-utils/sdf-tab';
+import {StrandData} from '../../model/structure-app/oligo-structure';
 
 const enum DIRECTION {
   STRAIGHT = '5′ → 3′',
@@ -63,10 +63,10 @@ export class StructureLayoutHandler {
     const bottomDiv = ui.divH([boolInputsAndButton, this.moleculeImgDiv]);
     $(bottomDiv).addClass('st-structure-bottom');
 
-    const sdfTabBody = ui.divV([tableLayout, bottomDiv]);
-    $(sdfTabBody).addClass('st-structure-body');
+    const layout = ui.divV([tableLayout, bottomDiv]);
+    $(layout).addClass('st-structure-body');
 
-    return sdfTabBody;
+    return layout;
   }
 
   private getBoolInputsAndButton(): HTMLDivElement {
@@ -123,15 +123,26 @@ export class StructureLayoutHandler {
       )
     );
 
+    const clearBlock = Object.fromEntries(
+      STRANDS.map(
+        (key) => {
+          const clearIcon = ui.icons.delete(() => { coloredInput[key].inputBase.value = '' });
+          const clearButton = ui.button(clearIcon, () => {});
+          ui.tooltip.bind(clearButton, `Clear ${key.toUpperCase()}`);
+          return [key, clearIcon];
+        }
+      ));
+
     const tableRows = STRANDS.map((strand) => {
       return {
         label: label[strand],
         textInput: coloredInput[strand].root,
+        clear: clearBlock[strand],
         choiceInput: directionChoiceInput[strand].root,
       };
     });
     const tableLayout = ui.table(
-      tableRows, (item) => [item.label, item.textInput, item.choiceInput]);
+      tableRows, (item) => [item.label, item.textInput, item.clear, item.choiceInput]);
     $(tableLayout).css('margin-top', '10px');
 
     for (const strand of STRANDS) {

package/src/view/apps/oligo-translator.ts

@@ -5,19 +5,18 @@ import * as DG from 'datagrok-api/dg';
 
 import * as rxjs from 'rxjs';
 import '../style/translator-app.css';
-import $ from 'cash-dom';
 
 import {highlightInvalidSubsequence} from '../utils/colored-input/input-painters';
 import {ColoredTextInput} from '../utils/colored-input/colored-text-input';
-import {SequenceToMolfileConverter} from '../../model/sequence-to-structure-utils/sequence-to-molfile';
-import {getTranslatedSequences} from '../../model/format-translation/conversion-utils';
+import {SequenceToMolfileConverter} from '../../model/structure-app/sequence-to-molfile';
+import {getTranslatedSequences} from '../../model/translator-app/conversion-utils';
 import {MoleculeImage} from '../utils/molecule-img';
 import {download} from '../../model/helpers';
 import {SEQUENCE_COPIED_MSG, SEQ_TOOLTIP_MSG} from '../const/oligo-translator';
 import {DEFAULT_AXOLABS_INPUT} from '../const/ui';
 import {FormatDetector} from '../../model/parsing-validation/format-detector';
 import {SequenceValidator} from '../../model/parsing-validation/sequence-validator';
-import {FormatConverter} from '../../model/format-translation/format-converter';
+import {FormatConverter} from '../../model/translator-app/format-converter';
 import {codesToHelmDictionary} from '../../model/data-loading-utils/json-loader';
 import {DEFAULT_FORMATS} from '../../model/const';
 
@@ -74,12 +73,19 @@ export class TranslatorLayoutHandler {
 
     const formatChoiceInput = ui.div([this.formatChoiceInput]);
 
+    const clearButton = ui.button(
+      ui.icons.delete(() => { sequenceColoredInput.inputBase.value = '' }),
+      () => {}
+    );
+    ui.tooltip.bind(clearButton, 'Clear input');
+
     const inputTableRow = {
       format: formatChoiceInput,
       textInput: sequenceColoredInput.root,
+      clearBtn: clearButton
     };
     const upperBlock = ui.table(
-      [inputTableRow], (item) => [item.format, item.textInput]
+      [inputTableRow], (item) => [item.format, item.textInput, item.clearBtn]
     );
     upperBlock.classList.add('st-translator-input-table');
 

package/src/view/style/translator-app.css

@@ -1,11 +1,11 @@
 /* Naming convention: class names should begin with st and app name to avoid naming collitions */
 .st-translator-input-table {
-  width: 100%;
+  /* width: 100%; */
+  margin-right: 20px;
 }
 
 .st-translator-input-table td:has(textarea) {
   width: 100%;
-  padding-right: 20px;
 }
 
 .st-translator-input-table td:has(select) {

package/src/view/utils/colored-input/colored-text-input.ts

@@ -22,7 +22,7 @@ export class ColoredTextInput {
     $(this.root).addClass('colored-text-input');
     if (resizeable) {
       // make input field automatically resizeable
-      this.textInputBase.onInput(
+      this.textInputBase.onChanged(
         () => {
           // necessary for the field to be squeezable, not only expandable
           $(this.textArea).css('height', 0);
@@ -34,7 +34,7 @@ export class ColoredTextInput {
     this.root.appendChild(this.highlights);
     this.colorize();
 
-    this.textInputBase.onInput(() => this.colorize());
+    this.textInputBase.onChanged(() => this.colorize());
   }
 
   private highlights: HTMLDivElement;

package/src/view/utils/draw-molecule.ts

@@ -6,7 +6,7 @@ import {errorToConsole} from '@datagrok-libraries/utils/src/to-console';
 
 import $ from 'cash-dom';
 
-import {extractAtomDataV3000} from '../../model/sequence-to-structure-utils/mol-transformations';
+import {extractAtomDataV3000} from '../../model/structure-app/mol-transformations';
 
 /** Draw molecule on the canvas and append it to the specified div, with the
  * option of zoom-in */

package/src/model/format-translation/format-converter.ts

@@ -1,109 +0,0 @@
-import * as DG from 'datagrok-api/dg';
-import {DEFAULT_FORMATS} from '../const';
-import {GROUP_TYPE, PHOSPHATE_SYMBOL, UNKNOWN_SYMBOL} from './const';
-import {CodesInfo} from '../data-loading-utils/types';
-import {codesToHelmDictionary} from '../data-loading-utils/json-loader';
-
-const HELM_WRAPPER = {
-  LEFT: 'RNA1{',
-  RIGHT: '}$$$$',
-};
-
-export class FormatConverter {
-  constructor(private readonly sequence: string, private readonly sourceFormat: string) { };
-
-  convertTo(targetFormat: string): string {
-    const formats = Object.keys(codesToHelmDictionary);
-
-    if (this.sourceFormat === DEFAULT_FORMATS.HELM && formats.includes(targetFormat))
-      return helmToFormat(this.sequence, targetFormat);
-    else if (formats.includes(this.sourceFormat) && targetFormat === DEFAULT_FORMATS.HELM)
-      return formatToHelm(this.sequence, this.sourceFormat);
-    else if ([this.sourceFormat, targetFormat].every((el) => formats.includes(el))) {
-      const helm = formatToHelm(this.sequence, this.sourceFormat);
-      return helmToFormat(helm, targetFormat);
-    }
-    else {
-      throw new Error (`ST: unsupported translation direction ${this.sourceFormat} -> ${targetFormat}`);
-    }
-  }
-}
-
-function getRegExpPattern(arr: string[]): string {
-  const negativeLookBehind = '(?<!\\([^()]*)'; // not '(' followed by non-parenths
-  const negativeLookAhead = '(?![^()]*\\))';  // not ')' preceded by non-parenths
-  const escaped = arr.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-    .map((key) => {
-    if (!key.includes('(') && !key.includes(')'))
-      return `${negativeLookBehind}${key}${negativeLookAhead}`;
-    return key;
-  });
-  const result =  escaped.join('|');
-  return result;
-}
-
-function sortCallback(a: string, b: string) {return b.length - a.length};
-
-function getHelmToCodeDict(infoObj: CodesInfo) {
-  const result: {[key: string]: string | string[]} = {};
-  Object.values(infoObj).forEach((obj: {[code: string]: string}) => {
-    Object.entries(obj).forEach(([code, helm]) => {
-      const key = helm.replace(/\)p/g, ')').replace(/\]p/g, ']');
-      if (result[key] === undefined) {
-        result[key] = [code];
-      } else {
-        (result[key] as string[]).push(code);
-      }
-    })
-  });
-  Object.entries(result).forEach(([key, value]) => {
-    const sorted = (value as string[]).sort(sortCallback);
-    result[key] = sorted[0] as string;
-  })
-  return result as {[key: string]: string};
-}
-
-function helmToFormat(helmSequence: string, targetFormat: string): string {
-  const codesInfoObject = codesToHelmDictionary[targetFormat] as CodesInfo;
-  const dict = getHelmToCodeDict(codesInfoObject);
-  const wrapperRegExp = new RegExp(getRegExpPattern(Object.values(HELM_WRAPPER)), 'g')
-  let result = helmSequence.replace(wrapperRegExp, '');
-
-  const helmCodes = Object.keys(dict)
-    .sort(sortCallback);
-  const helmRegExp = new RegExp(getRegExpPattern(helmCodes) + '|.', 'g');
-  result = result.replace(helmRegExp, (match) => {
-    return helmCodes.includes(match) ? dict[match] :
-      (match === 'p' || match === '.') ? match : '?';
-  }).replace(/\?+/g, UNKNOWN_SYMBOL).replace(/p\.|\./g, '');
-  result = result.replace(/<empty>/g, '');
-  // remove double slash in LCMS codes
-  result = result.replace(/\/\//g, '/');
-  return result;
-}
-
-function formatToHelm(sequence: string, sourceFormat: string): string {
-  const codesInfoObject = codesToHelmDictionary[sourceFormat] as CodesInfo;
-  const dict = Object.assign({}, ...Object.values(codesInfoObject)) as {[code: string]: string};
-
-  const formatCodes = Object.keys(dict).sort(sortCallback);
-  const formatRegExp = new RegExp(getRegExpPattern(formatCodes) + '|\\([^()]*\\)|.', 'g'); // the added group before '|.' is to avoid mismatch inside parenths
-
-  const phosphateHELMCodes = Array.from(
-    new Set(Object.values(codesInfoObject[GROUP_TYPE.LINKAGE]))
-  ).sort(sortCallback);
-  const phosphateHELMPattern = getRegExpPattern(phosphateHELMCodes);
-  const phosphateRegExp = new RegExp(`${PHOSPHATE_SYMBOL}\.(${phosphateHELMPattern})`, 'g');
-
-  let helm = sequence.replace(formatRegExp, (match) => {
-    const result = formatCodes.includes(match) ?  dict[match] + '.' : '?';
-    return result;
-  });
-  helm = helm.replace(/\?+/g, `${UNKNOWN_SYMBOL}.`);
-  helm = helm.slice(0, -1); // strip last dot
-  if (helm[helm.length - 1] === PHOSPHATE_SYMBOL)
-    helm = helm.slice(0, -1);
-  helm = helm.replace(phosphateRegExp, (match, group) => group);
-  helm = helm.replace(/<empty>/g, '');
-  return `${HELM_WRAPPER.LEFT + helm + HELM_WRAPPER.RIGHT}`;
-}