@datagrok/sequence-translator 1.2.1 → 1.2.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "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/plugins/mermade.ts

@@ -23,16 +23,16 @@ export async function getExternalAppViewFactories(): Promise<{[name: string]: ()
     let div: HTMLDivElement;
     try {
       div = await grok.functions.call(pluginName, data.parameters);
-    } catch (err) {
-      console.error(`Plugin ${pluginName} not loaded, error:`, err)
-      div = ui.divText('error loading');
-    }
-    const pluginUI = new ExternalPluginUI(data.tabName, div);
+      const pluginUI = new ExternalPluginUI(data.tabName, div);
 
-    // intentonally don't await for the promise
-    pluginUI.initView();
+      // intentonally don't await for the promise
+      pluginUI.initView();
 
-    result[data.tabName] = () => pluginUI.getView();
+      result[data.tabName] = () => pluginUI.getView();
+    } catch (err) {
+      console.warn(`Plugin ${pluginName} not loaded, reason:`, err)
+      continue;
+    }
   }
   return result;
 }

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

@@ -6,10 +6,10 @@ 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';
+} 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';

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,25 @@ export class StructureLayoutHandler {
       )
     );
 
+    const clearBlock = Object.fromEntries(
+      STRANDS.map(
+        (key) => {
+          const icon = ui.iconFA('eraser', () => {coloredInput[key].inputBase.value = ''});
+          ui.tooltip.bind(icon, `Clear ${key.toUpperCase()}`);
+          return [key, icon];
+        }
+      ));
+
     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

@@ -9,15 +9,15 @@ 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';
 

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}`;
-}