@datagrok/bio 1.5.3 → 1.5.6

package/src/utils/atomic-works.ts

@@ -0,0 +1,252 @@
+import * as OCL from 'openchemlib/full.js';
+
+export function getMacroMol(molBlocks: string[]): string {
+  for (let i = 0; i < molBlocks.length; i++)
+    molBlocks[i] = rotateBackboneV3000(molBlocks[i]);
+
+  return linkV3000(molBlocks);
+}
+
+function rotateBackboneV3000(molecule: string): string {
+  let molBlock = OCL.Molecule.fromMolfile(molecule).toMolfileV3();
+  const coordinates = extractAtomDataV3000(molBlock);
+  const natom = coordinates.atomIndex.length;
+
+  const indexFivePrime = coordinates.atomIndex.indexOf(1);
+  const indexThreePrime = coordinates.atomIndex.indexOf(natom);
+
+  const xCenter = (coordinates.x[indexThreePrime] + coordinates.x[indexFivePrime])/2;
+  const yCenter = (coordinates.y[indexThreePrime] + coordinates.y[indexFivePrime])/2;
+
+  //place to center
+  for (let i = 0; i < natom; i++) {
+    coordinates.x[i] -= xCenter;
+    coordinates.y[i] -= yCenter;
+  }
+
+  let angle = 0;
+  if (coordinates.x[indexFivePrime] == 0)
+    angle = coordinates.y[indexFivePrime] > coordinates.y[indexThreePrime] ? Math.PI/2 : 3*Math.PI/2;
+  else if (coordinates.y[indexFivePrime] == 0)
+    angle = coordinates.x[indexFivePrime] > coordinates.x[indexThreePrime] ? Math.PI : 0;
+  else {
+    const derivative = coordinates.y[indexFivePrime]/coordinates.x[indexFivePrime];
+    angle = derivative > 0 ? Math.PI - Math.atan(derivative) : Math.atan(derivative);
+  }
+
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+
+  for (let i = 0; i < natom; i++) {
+    const xAdd = coordinates.x[i];
+    coordinates.x[i] = xAdd*cos - coordinates.y[i]*sin;
+    coordinates.y[i] = xAdd*sin + coordinates.y[i]*cos;
+  }
+
+  //place to right
+  const xShift = coordinates.x[indexFivePrime];
+  for (let i = 0; i < natom; i++)
+    coordinates.x[i] -= xShift;
+
+  //rewrite molBlock
+  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+  index = molBlock.indexOf('\n', index);
+  let indexEnd = index;
+  for (let i = 0; i < natom; i++) {
+    index = molBlock.indexOf('V30', index) + 4;
+    index = molBlock.indexOf(' ', index) + 1;
+    index = molBlock.indexOf(' ', index) + 1;
+    indexEnd = molBlock.indexOf(' ', index) + 1;
+    indexEnd = molBlock.indexOf(' ', indexEnd);
+
+    molBlock = molBlock.slice(0, index) +
+      coordinates.x[i] + ' ' + coordinates.y[i] +
+      molBlock.slice(indexEnd);
+
+    index = molBlock.indexOf('\n', index) + 1;
+  }
+
+  return molBlock;
+}
+
+function extractAtomDataV3000(molBlock: string) {
+  const numbers = extractAtomsBondsNumbersV3000(molBlock);
+  let index = molBlock.indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+  index = molBlock.indexOf('\n', index);
+  let indexEnd = index;
+
+  const indexes: number[] = Array(numbers.natom);
+  const types: string[] = Array(numbers.natom);
+  const x: number[] = Array(numbers.natom);
+  const y: number[] = Array(numbers.natom);
+
+  for (let i = 0; i < numbers.natom; i++) {
+    index = molBlock.indexOf('V30', index) + 4;
+    indexEnd = molBlock.indexOf(' ', index);
+    indexes[i] = parseInt(molBlock.substring(index, indexEnd));
+
+    index = indexEnd + 1;
+    indexEnd = molBlock.indexOf(' ', index);
+    types[i] = molBlock.substring(index, indexEnd);
+
+    index = indexEnd + 1;
+    indexEnd = molBlock.indexOf(' ', index);
+    x[i] = parseFloat(molBlock.substring(index, indexEnd));
+
+    index = indexEnd + 1;
+    indexEnd = molBlock.indexOf(' ', index);
+    y[i] = parseFloat(molBlock.substring(index, indexEnd));
+
+    index = molBlock.indexOf('\n', index) + 1;
+  }
+
+  return {atomIndex: indexes, atomType: types, x: x, y: y};
+}
+
+function linkV3000(molBlocks: string[]): string {
+  let macroMolBlock = '\nDatagrok macromolecule handler\n\n';
+  macroMolBlock += '  0  0  0  0  0  0            999 V3000\n';
+  macroMolBlock += 'M  V30 BEGIN CTAB\n';
+  let atomBlock = '';
+  let bondBlock = '';
+  let collectionBlock = '';
+  const collection: number [] = [];
+  let natom = 0;
+  let nbond = 0;
+  let xShift = 0;
+
+  for (let i = 0; i < molBlocks.length; i++) {
+    molBlocks[i] = molBlocks[i].replaceAll('(-\nM  V30 ', '(')
+      .replaceAll('-\nM  V30 ', '').replaceAll(' )', ')');
+    const numbers = extractAtomsBondsNumbersV3000(molBlocks[i]);
+    const coordinates = extractAtomDataV3000(molBlocks[i]);
+
+    let indexAtoms = molBlocks[i].indexOf('M  V30 BEGIN ATOM'); // V3000 index for atoms coordinates
+    indexAtoms = molBlocks[i].indexOf('\n', indexAtoms);
+    let index = indexAtoms;
+    let indexEnd = indexAtoms;
+
+    for (let j = 0; j < numbers.natom; j++) {
+      if (coordinates.atomIndex[j] != 1 || i == 0) {
+        //rewrite atom number
+        index = molBlocks[i].indexOf('V30', index) + 4;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+        const atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+        molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+
+        //rewrite coordinates
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+
+        const totalShift = xShift - coordinates.x[0];
+        let coordinate = Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd)) + totalShift))/10000;
+        molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
+
+        index = molBlocks[i].indexOf(' ', index) + 1;
+        indexEnd = molBlocks[i].indexOf(' ', index);
+        coordinate = Math.round(10000*(parseFloat(molBlocks[i].substring(index, indexEnd))))/10000;
+        molBlocks[i] = molBlocks[i].slice(0, index) + coordinate + molBlocks[i].slice(indexEnd);
+
+        index = molBlocks[i].indexOf('\n', index) + 1;
+      } else {
+        index = molBlocks[i].indexOf('M  V30', index) - 1;
+        indexEnd = molBlocks[i].indexOf('\n', index + 1);
+        molBlocks[i] = molBlocks[i].slice(0, index) + molBlocks[i].slice(indexEnd);
+      }
+    }
+
+    const indexAtomsEnd = molBlocks[i].indexOf('M  V30 END ATOM');
+    atomBlock += molBlocks[i].substring(indexAtoms + 1, indexAtomsEnd);
+
+    let indexBonds = molBlocks[i].indexOf('M  V30 BEGIN BOND'); // V3000 index for bonds
+    indexBonds = molBlocks[i].indexOf('\n', indexBonds);
+    index = indexBonds;
+    indexEnd = indexBonds;
+
+    for (let j = 0; j < numbers.nbond; j++) {
+      //rewrite bond number
+      index = molBlocks[i].indexOf('V30', index) + 4;
+      indexEnd = molBlocks[i].indexOf(' ', index);
+      const bondNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + nbond;
+      molBlocks[i] = molBlocks[i].slice(0, index) + bondNumber + molBlocks[i].slice(indexEnd);
+
+      //rewrite atom pair in bond
+      index = molBlocks[i].indexOf(' ', index) + 1;
+      index = molBlocks[i].indexOf(' ', index) + 1;
+      indexEnd = molBlocks[i].indexOf(' ', index);
+      let atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+      index = molBlocks[i].indexOf(' ', index) + 1;
+      indexEnd = Math.min(molBlocks[i].indexOf('\n', index), molBlocks[i].indexOf(' ', index));
+      atomNumber = parseInt(molBlocks[i].substring(index, indexEnd)) + natom;
+      molBlocks[i] = molBlocks[i].slice(0, index) + atomNumber + molBlocks[i].slice(indexEnd);
+
+      index = molBlocks[i].indexOf('\n', index) + 1;
+    }
+
+    const indexBondEnd = molBlocks[i].indexOf('M  V30 END BOND');
+    bondBlock += molBlocks[i].substring(indexBonds + 1, indexBondEnd);
+
+    let indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=('); // V3000 index for collections
+
+    while (indexCollection != -1) {
+      indexCollection += 28;
+      const collectionEnd = molBlocks[i].indexOf(')', indexCollection);
+      const collectionEntries = molBlocks[i].substring(indexCollection, collectionEnd).split(' ').slice(1);
+      collectionEntries.forEach((e) => {
+        collection.push(parseInt(e) + natom);
+      });
+      indexCollection = collectionEnd;
+      indexCollection = molBlocks[i].indexOf('M  V30 MDLV30/STEABS ATOMS=(', indexCollection);
+    }
+
+    natom += numbers.natom - 1;
+    nbond += numbers.nbond;
+    xShift += coordinates.x[numbers.natom - 1] - coordinates.x[0];
+  }
+
+  const entries = 4;
+  const collNumber = Math.ceil(collection.length / entries);
+  collectionBlock += 'M  V30 MDLV30/STEABS ATOMS=(' + collection.length + ' -\n';
+  for (let i = 0; i < collNumber; i++) {
+    collectionBlock += 'M  V30 ';
+    const entriesCurrent = i + 1 == collNumber ? collection.length - (collNumber - 1)*entries : entries;
+    for (let j = 0; j < entriesCurrent; j++) {
+      collectionBlock += (j + 1 == entriesCurrent) ?
+        (i == collNumber - 1 ? collection[entries*i + j] + ')\n' : collection[entries*i + j] + ' -\n') :
+        collection[entries*i + j] + ' ';
+    }
+  }
+
+  //generate file
+  natom++;
+  macroMolBlock += 'M  V30 COUNTS ' + natom + ' ' + nbond + ' 0 0 0\n';
+  macroMolBlock += 'M  V30 BEGIN ATOM\n';
+  macroMolBlock += atomBlock;
+  macroMolBlock += 'M  V30 END ATOM\n';
+  macroMolBlock += 'M  V30 BEGIN BOND\n';
+  macroMolBlock += bondBlock;
+  macroMolBlock += 'M  V30 END BOND\n';
+  macroMolBlock += 'M  V30 BEGIN COLLECTION\n';
+  macroMolBlock += collectionBlock;
+  macroMolBlock += 'M  V30 END COLLECTION\n';
+  macroMolBlock += 'M  V30 END CTAB\n';
+  macroMolBlock += 'M  END\n';
+
+  return macroMolBlock;
+}
+
+function extractAtomsBondsNumbersV3000(molBlock: string): {natom: number, nbond: number} {
+  molBlock = molBlock.replaceAll('\r', ''); //equalize old and new sdf standards
+  let index = molBlock.indexOf('COUNTS') + 7; // V3000 index for atoms and bonds number
+  let indexEnd = molBlock.indexOf(' ', index);
+
+  const atomsNumber = parseInt(molBlock.substring(index, indexEnd));
+  index = indexEnd + 1;
+  indexEnd = molBlock.indexOf(' ', index);
+  const bondsNumber = parseInt(molBlock.substring(index, indexEnd));
+
+  return {natom: atomsNumber, nbond: bondsNumber};
+}
+

package/src/utils/convert.ts

@@ -1,11 +1,21 @@
 import * as DG from 'datagrok-api/dg';
 import * as ui from 'datagrok-api/ui';
+import {NotationConverter} from './notation-converter';
 
+/**
+ * Converts notations of a Macromolecule column
+ *
+ * @param {DG.column} col Column with 'Macromolecule' semantic type
+ */
 export function convert(col: DG.Column): void {
   const current = col.tags[DG.TAGS.UNITS];
   //TODO: read all notations
-  const notations = ['fasta:SEQ:NT', 'fasta:SEQ:PT', 'fasta:SEQ.MSA:NT', 'fasta:SEQ.MSA:PT', 'HELM'];
-  const choices = ui.choiceInput('convert to', '', notations.filter((e) => e !== current));
+  const units = [
+    'fasta',
+    'separator',
+    'HELM'
+  ];
+  const choices = ui.choiceInput('convert to', '', units.filter((e) => e !== current));
 
   ui.dialog('Convert sequence')
     .add(
@@ -17,7 +27,9 @@ export function convert(col: DG.Column): void {
     )
     .onOK(() => {
       //TODO: create new converted column
-      //col.dataFrame.columns.add();
+      const converter = new NotationConverter(col, choices.value!);
+      const newColumn = converter.convert();
+      col.dataFrame.columns.add(newColumn);
     })
     .show();
 }

package/src/utils/multiple-sequence-alignment.ts

@@ -29,12 +29,12 @@ function _fastaToStrings(fasta: string): string[] {
 /**
  * Runs Aioli environment with kalign tool.
  *
- * @param {DG.Column} col Column with sequences.
+ * @param {DG.Column} srcCol Column with sequences.
  * @param {boolean} isAligned Whether the column is aligned.
  * @return {Promise<DG.Column>} Aligned sequences.
  */
-export async function runKalign(col: DG.Column, isAligned = false) : Promise<DG.Column> {
-  let sequences = col.toList();
+export async function runKalign(srcCol: DG.Column, isAligned = false): Promise<DG.Column> {
+  let sequences = srcCol.toList();
 
   if (isAligned)
     sequences = sequences.map((v: string, _) => AlignedSequenceEncoder.clean(v).replace(/\-/g, ''));
@@ -55,15 +55,20 @@ export async function runKalign(col: DG.Column, isAligned = false) : Promise<DG.
   console.warn(output);
 
   const aligned = _fastaToStrings(buf).slice(0, sequences.length);
-  const alignedCol = DG.Column.fromStrings(`msa(${col.name})`, aligned);
-  alignedCol.setTag(DG.TAGS.UNITS, '');
-  alignedCol.semType = C.SEM_TYPES.Macro_Molecule;
-  return alignedCol;
+  const tgtCol = DG.Column.fromStrings(`msa(${srcCol.name})`, aligned);
+
+  // units
+  const srcUnits = srcCol.getTag(DG.TAGS.UNITS);
+  const tgtUnits = srcUnits.split(':').map((p, i) => i == 1 ? p + '.MSA' : p).join(':');
+
+  tgtCol.setTag(DG.TAGS.UNITS, tgtUnits);
+  tgtCol.semType = C.SEM_TYPES.Macro_Molecule;
+  return tgtCol;
 }
 
 export async function testMSAEnoughMemory(col: DG.Column): Promise<void> {
   const sequencesCount = col.length;
-  const delta = sequencesCount/100;
+  const delta = sequencesCount / 100;
 
   for (let i = delta; i < sequencesCount; i += delta) {
     try {

package/src/utils/notation-converter.ts

@@ -0,0 +1,131 @@
+import * as DG from 'datagrok-api/dg';
+
+// export const enum NOTATION {
+//   // these values can be changed to "user-friendly" ones later on
+//   FASTA = 'fasta',
+//   SEPARATOR = 'separator',
+//   HELM = 'helm'
+// }
+
+export class NotationConverter {
+  private _sourceColumn: DG.Column; // the column to be converted
+  private _currentUnits: string; // units of the form fasta:SEQ:NT, etc.
+  private _sourceNotation: string; // current notation (without :SEQ:NT, etc.)
+  private _targetNotation: string;
+
+  private get sourceColumn(): DG.Column { return this._sourceColumn; }
+  private get currentUnits(): string { return this._currentUnits; }
+  private get sourceNotation(): string { return this._sourceNotation; }
+  private get targetNotation(): string { return this._targetNotation; }
+
+  // these values can be changed to "user-friendly" ones later on
+  private _fasta = 'fasta';
+  private _separator = 'separator';
+  private _helm = 'helm';
+
+  public isFasta(): boolean { return this.sourceNotation == this._fasta; }
+  public isSeparator(): boolean { return this.sourceNotation == this._separator; }
+  public isHelm(): boolean { return this.sourceNotation == this._helm; }
+
+  private determineSourceNotation() : string {
+    if (this.currentUnits.toLowerCase().startsWith('fasta'))
+      return 'fasta';
+    else if (this.currentUnits.toLowerCase().startsWith('separator'))
+      return 'separator';
+    else
+      // TODO: handle possible exceptions
+      return 'HELM';
+  }
+
+  private convertFastaToSeparator(): DG.Column {
+    // TODO: implementation
+    const len = this.sourceColumn.length;
+    const newColName = 'converted';
+    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('fasta2sep'));
+    newColumn.semType = 'Macromolecule';
+    return newColumn;
+  }
+
+  private convertFastaToHelm(): DG.Column {
+    // TODO: implementation
+    const len = this.sourceColumn.length;
+    const newColName = 'converted';
+    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('fasta2helm'));
+    newColumn.semType = 'Macromolecule';
+    return newColumn;
+  }
+
+  private convertSeparatorToFasta(): DG.Column {
+    // TODO: implementation
+    const len = this.sourceColumn.length;
+    const newColName = 'converted';
+    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('sep2fasta'));
+    newColumn.semType = 'Macromolecule';
+    return newColumn;
+  }
+
+  private convertSeparatorToHelm(): DG.Column {
+    // TODO: implementation
+    const len = this.sourceColumn.length;
+    const newColName = 'converted';
+    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('sep2helm'));
+    newColumn.semType = 'Macromolecule';
+    return newColumn;
+  }
+
+  private convertHelmToFasta(): DG.Column {
+    // TODO: implementation
+    const len = this.sourceColumn.length;
+    const newColName = 'converted';
+    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('helm2fasta'));
+    newColumn.semType = 'Macromolecule';
+    return newColumn;
+  }
+
+  private convertHelmToSeparator(): DG.Column {
+    // TODO: implementation
+    const len = this.sourceColumn.length;
+    const newColName = 'converted';
+    const newColumn = DG.Column.fromList('string', newColName, new Array(len).fill('helm2sep'));
+    newColumn.semType = 'Macromolecule';
+    return newColumn;
+  }
+
+  // TODO: write the bodies of converter methods
+  public convert() : DG.Column {
+    if (
+      this.sourceNotation == this._fasta &&
+      this.targetNotation == this._separator
+    )
+      return this.convertFastaToSeparator();
+    else if (
+      this.sourceNotation == this._fasta &&
+      this.targetNotation == this._helm
+    )
+      return this.convertFastaToHelm();
+    else if (
+      this.sourceNotation == this._separator &&
+      this.targetNotation == this._fasta
+    )
+      return this.convertSeparatorToFasta();
+    else if (
+      this.sourceNotation == this._separator &&
+      this.targetNotation == this._helm
+    )
+      return this.convertSeparatorToHelm();
+    else if (
+      this.sourceNotation == this._helm &&
+      this.targetNotation == this._fasta
+    )
+      return this.convertHelmToFasta();
+    else
+      return this.convertHelmToSeparator();
+  }
+
+  public constructor(col: DG.Column, target: string) {
+    this._sourceColumn = col;
+    this._currentUnits = this._sourceColumn.tags[DG.TAGS.UNITS];
+    this._sourceNotation = this.determineSourceNotation();
+    this._targetNotation = target;
+  }
+}

package/src/utils/sequence-space.ts

@@ -18,9 +18,9 @@ export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<
     const sepFinal = sep ? sep === '.' ? '\\\.' : sep : '-';
     const regex = new RegExp(sepFinal, 'g');
     if (Object.keys(AvailableMetrics['String']).includes(spaceParams.similarityMetric))
-      preparedData = spaceParams.seqCol.toList().map((v) => v.replace(regex, '')) as string[];
+      preparedData = spaceParams.seqCol.toList().map((v: string) => v.replace(regex, '')) as string[];
     else
-      preparedData = spaceParams.seqCol.toList().map((v) => v.replace(regex, '')) as string[];
+      preparedData = spaceParams.seqCol.toList().map((v: string) => v.replace(regex, '')) as string[];
   } else {
     preparedData = spaceParams.seqCol.toList();
   }
@@ -31,13 +31,13 @@ export async function sequenceSpace(spaceParams: ISequenceSpaceParams): Promise<
     spaceParams.similarityMetric as StringMetrics | BitArrayMetrics,
     spaceParams.options);
   const cols: DG.Column[] = spaceParams.embedAxesNames.map(
-    (name, index) => DG.Column.fromFloat32Array(name, sequenceSpaceResult.embedding[index]));
+    (name: string, index: number) => DG.Column.fromFloat32Array(name, sequenceSpaceResult.embedding[index]));
   return {distance: sequenceSpaceResult.distance, coordinates: new DG.ColumnList(cols)};
 }
 
 
 export function getEmbeddingColsNames(df: DG.DataFrame) {
   const axes = ['Embed_X', 'Embed_Y'];
-  const colNameInd = df.columns.names().filter((it) => it.includes(axes[0])).length + 1;
+  const colNameInd = df.columns.names().filter((it: string) => it.includes(axes[0])).length + 1;
   return axes.map((it) => `${it}_${colNameInd}`);
 }

package/src/utils/split-to-monomers.ts

@@ -0,0 +1,8 @@
+/* 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';
+
+export function splitToMonomers() {
+
+}

package/src/utils/utils.ts

@@ -0,0 +1,40 @@
+import * as DG from 'datagrok-api/dg';
+import { WebLogo, SplitterFunc } from '@datagrok-libraries/bio/src/viewers/web-logo';
+import * as grok from 'datagrok-api/grok';
+
+export const HELM_CORE_LIB_MONOMER_COL = 'symbol';
+export const HELM_CORE_LIB_MOLFILE_COL = 'molfile';
+export const HELM_CORE_LIB_FILENAME = '/samples/HELMCoreLibrary.json';
+
+export function getMolfilesFromSeq(col: DG.Column, monomersLib: DG.DataFrame): string[][] | null {
+    const units = col.tags[DG.TAGS.UNITS];
+    const sep = col.getTag('separator');
+    const splitterFunc: SplitterFunc = WebLogo.getSplitter(units, sep);
+    const monomersDict = createMomomersMolDict(monomersLib);
+    const molFiles = [];
+    for (let i = 0; i < col.length; ++i) {
+        const monomers = splitterFunc(col.get(i));
+        const molFilesForSeq = [];
+        for (let j = 0; j < monomers.length; ++j) {
+            if (monomers[j]) {
+                if (!monomersDict[monomers[j]]) {
+                    grok.shell.warning(`Monomer ${monomers[j]} is missing in HELM library. Structure cannot be created`);
+                    return null;
+                }
+                molFilesForSeq.push(monomersDict[monomers[j]])
+            }
+        }
+        molFiles.push(molFilesForSeq);
+    }
+    return molFiles;
+  }
+
+export function createMomomersMolDict(lib: DG.DataFrame): {[key: string]: string} {
+    const dict: {[key: string]: string} = {};
+    const monmersCol = lib.col(HELM_CORE_LIB_MONOMER_COL);
+    const molCol = lib.col(HELM_CORE_LIB_MOLFILE_COL);
+    for (let i = 0; i < lib.rowCount; ++i) {
+        dict[monmersCol!.get(i)] = molCol!.get(i);
+    }
+    return dict;
+}

package/tsconfig.json

@@ -6,7 +6,7 @@
       // "incremental": true,                         /* Enable incremental compilation */
       "target": "es6",                                /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
       "module": "es2020",                             /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
-      "lib": ["es2020", "dom"],                       /* Specify library files to be included in the compilation. */
+      "lib": ["es2020", "dom", "ES2021.String"],                       /* Specify library files to be included in the compilation. */
       // "allowJs": true,                             /* Allow javascript files to be compiled. */
       // "checkJs": true,                             /* Report errors in .js files. */
       // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */