@datagrok-libraries/bio 5.32.3 → 5.32.4

package/src/monomer-works/to-atomic-level.js

@@ -1,137 +1,71 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as grok from 'datagrok-api/grok';
 import * as DG from 'datagrok-api/dg';
-import { HELM_CORE_FIELDS, } from '../utils/const';
-import { getSplitter } from '../utils/macromolecule/utils';
 import { NotationConverter } from '../utils/notation-converter';
-import { errorToConsole } from '@datagrok-libraries/utils/src/to-console';
 import { UnitsHandler } from '../utils/units-handler';
-// constants for parsing molfile V2000
-const V2K_RGP_SHIFT = 8;
-const V2K_RGP_LINE = 'M  RGP';
-const V2K_A_LINE = 'A  ';
-// constants for parsing/reconstruction of molfile V3000
-const V3K_COUNTS_SHIFT = 14;
-const V3K_IDX_SHIFT = 7;
-const V3K_HEADER_FIRST_LINE = '\nDatagrok macromolecule handler\n\n';
-const V3K_HEADER_SECOND_LINE = '  0  0  0  0  0  0            999 V3000\n';
-const V3K_BEGIN_CTAB_BLOCK = 'M  V30 BEGIN CTAB\n';
-const V3K_END_CTAB_BLOCK = 'M  V30 END CTAB\n';
-const V3K_BEGIN_COUNTS_LINE = 'M  V30 COUNTS ';
-const V3K_COUNTS_LINE_ENDING = ' 0 0 0\n';
-const V3K_BEGIN_ATOM_BLOCK = 'M  V30 BEGIN ATOM\n';
-const V3K_END_ATOM_BLOCK = 'M  V30 END ATOM\n';
-const V3K_BEGIN_BOND_BLOCK = 'M  V30 BEGIN BOND\n';
-const V3K_END_BOND_BLOCK = 'M  V30 END BOND\n';
-const V3K_BOND_CONFIG = ' CFG=';
-const V3K_BEGIN_DATA_LINE = 'M  V30 ';
-const V3K_END = 'M  END';
-const PRECISION_FACTOR = 10000; // HELMCoreLibrary has 4 significant digits after decimal point in atom coordinates
-// symbols for the corresponding monomers in HELM library
-const DEOXYRIBOSE = 'd';
-const RIBOSE = 'r';
-const PHOSPHATE = 'p';
-const OXYGEN = 'O';
-const HYDROGEN = 'H';
+import { getFormattedMonomerLib, keepPrecision } from './to-atomic-level-utils';
+import { seqToMolFileWorker } from './seq-to-molfile';
+import { monomerWorksConsts as C } from './consts';
+import { errorToConsole } from '@datagrok-libraries/utils';
+import { getSplitter } from '../utils/macromolecule';
 // todo: verify that all functions have return types
-/** Convert Macromolecule column into Molecule column storing molfile V3000 with the help of a monomer library  */
-export function _toAtomicLevel(df, seqCol, monomerLib) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // todo: remove this from the library
-        if (DG.Func.find({ package: 'Chem', name: 'getRdKitModule' }).length === 0) {
-            const msg = 'Transformation to atomic level requires the package "Chem" installed.';
-            return { col: null, warnings: [msg] };
-        }
-        if (seqCol.semType !== DG.SEMTYPE.MACROMOLECULE) {
-            const msg = `Only the ${DG.SEMTYPE.MACROMOLECULE} columns can be converted to atomic level, ` +
-                `the chosen column has semType '${seqCol.semType}'`;
-            return { col: null, warnings: [msg] };
-        }
-        let srcCol = seqCol;
-        const seqUh = UnitsHandler.getOrCreate(seqCol);
-        // convert 'helm' to 'separator' units
-        if (seqUh.isHelm()) {
-            const converter = new NotationConverter(seqCol);
-            srcCol = converter.convert("separator" /* NOTATION.SEPARATOR */, '.');
-            srcCol.name = seqCol.name; // Replace converted col name 'separator(<original>)' to '<original>';
-        }
-        const srcUh = UnitsHandler.getOrCreate(srcCol);
-        const alphabet = srcUh.alphabet;
-        // determine the polymer type according to HELM specifications
-        let polymerType;
-        // todo: an exception from dart comes before this check if the alphabet is UN
-        if (alphabet === "PT" /* ALPHABET.PT */ || alphabet === "UN" /* ALPHABET.UN */) {
-            polymerType = "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */;
-        }
-        else if (alphabet === "RNA" /* ALPHABET.RNA */ || alphabet === "DNA" /* ALPHABET.DNA */) {
-            polymerType = "RNA" /* HELM_POLYMER_TYPE.RNA */;
-        }
-        else {
-            const msg = `Unexpected column's '${srcCol.name}' alphabet '${alphabet}'.`;
-            return { col: null, warnings: [msg] };
-        }
-        const monomerSequencesArray = getMonomerSequencesArray(srcCol);
-        const monomersDict = yield getMonomersDictFromLib(monomerSequencesArray, monomerLib, polymerType, alphabet);
-        const srcColLength = srcCol.length;
-        const molfileList = new Array(srcColLength);
-        const molfileWarningList = new Array(0);
-        for (let rowI = 0; rowI < srcColLength; ++rowI) {
-            try {
-                const monomerSeq = monomerSequencesArray[rowI];
-                molfileList[rowI] = monomerSeqToMolfile(monomerSeq, monomersDict, alphabet, polymerType);
-            }
-            catch (err) {
-                const errMsg = err instanceof Error ? err.message : err.toString();
-                const msg = `Cannot get molfile of row #${rowI}: ${errMsg}.`;
-                molfileWarningList.push(msg);
-            }
-        }
-        if (molfileWarningList.length > 0.05 * srcColLength)
-            throw new Error('Too many errors getting molfiles.');
-        // exclude name collisions
-        const name = `molfile(${srcCol.name})`;
-        const resColName = df.columns.getUnusedName(name);
-        const resCol = DG.Column.fromStrings(resColName, molfileList);
-        resCol.semType = DG.SEMTYPE.MOLECULE;
-        resCol.setTag(DG.TAGS.UNITS, DG.UNITS.Molecule.MOLBLOCK);
-        return { col: resCol, warnings: molfileWarningList };
-    });
-}
-/** Get a mapping of peptide symbols to HELM monomer library
- * objects with selected fields.
- */
-function getFormattedMonomerLib(monomerLib, polymerType, alphabet) {
-    const map = new Map();
-    for (const monomerSymbol of monomerLib.getMonomerSymbolsByType(polymerType)) {
-        const it = monomerLib.getMonomer(polymerType, monomerSymbol);
-        if (polymerType === "RNA" /* HELM_POLYMER_TYPE.RNA */ &&
-            (it["monomerType" /* HELM_FIELDS.MONOMER_TYPE */] === "Branch" /* HELM_MONOMER_TYPE.BRANCH */ ||
-                alphabet === "DNA" /* ALPHABET.DNA */ && it["symbol" /* HELM_FIELDS.SYMBOL */] === DEOXYRIBOSE ||
-                alphabet === "RNA" /* ALPHABET.RNA */ && it["symbol" /* HELM_FIELDS.SYMBOL */] === RIBOSE ||
-                it["symbol" /* HELM_FIELDS.SYMBOL */] === PHOSPHATE) ||
-            polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */ &&
-                it["monomerType" /* HELM_FIELDS.MONOMER_TYPE */] !== "Branch" /* HELM_MONOMER_TYPE.BRANCH */) {
-            const monomerObject = {};
-            HELM_CORE_FIELDS.forEach((field) => {
-                //@ts-ignore
-                monomerObject[field] = it[field];
-            });
-            map.set(it["symbol" /* HELM_FIELDS.SYMBOL */], monomerObject);
-        }
+/** Convert Macromolecule column into Molecule column storing molfile V3000 with the help of a monomer library
+ * @param {DG.DataFrame} df - DataFrame containing the column to be converted
+ * @param {DG.Column} seqCol - Column containing the macromolecule sequence
+ * @param {IMonomerLib} monomerLib - Monomer library
+*/
+export async function _toAtomicLevel(df, seqCol, monomerLib) {
+    // todo: remove this from the library
+    if (DG.Func.find({ package: 'Chem', name: 'getRdKitModule' }).length === 0) {
+        const msg = 'Transformation to atomic level requires the package "Chem" installed.';
+        return { col: null, warnings: [msg] };
+    }
+    if (seqCol.semType !== DG.SEMTYPE.MACROMOLECULE) {
+        const msg = `Only the ${DG.SEMTYPE.MACROMOLECULE} columns can be converted to atomic level, ` +
+            `the chosen column has semType '${seqCol.semType}'`;
+        return { col: null, warnings: [msg] };
+    }
+    let srcCol = seqCol;
+    const seqUh = UnitsHandler.getOrCreate(seqCol);
+    // convert 'helm' to 'separator' units
+    if (seqUh.isHelm()) {
+        const converter = new NotationConverter(seqCol);
+        srcCol = converter.convert("separator" /* NOTATION.SEPARATOR */, '.');
+        srcCol.name = seqCol.name; // Replace converted col name 'separator(<original>)' to '<original>';
+    }
+    const srcUh = UnitsHandler.getOrCreate(srcCol);
+    const alphabet = srcUh.alphabet;
+    // determine the polymer type according to HELM specifications
+    let polymerType;
+    // todo: an exception from dart comes before this check if the alphabet is UN
+    if (alphabet === "PT" /* ALPHABET.PT */ || alphabet === "UN" /* ALPHABET.UN */) {
+        polymerType = "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */;
+    }
+    else if (alphabet === "RNA" /* ALPHABET.RNA */ || alphabet === "DNA" /* ALPHABET.DNA */) {
+        polymerType = "RNA" /* HELM_POLYMER_TYPE.RNA */;
     }
-    return map;
-}
-/** Get jagged array of monomer symbols for the dataframe  */
-function getMonomerSequencesArray(macroMolCol) {
+    else {
+        const msg = `Unexpected column's '${srcCol.name}' alphabet '${alphabet}'.`;
+        return { col: null, warnings: [msg] };
+    }
+    const monomerSequencesArray = getMonomerSequencesArray(srcCol);
+    const monomersDict = await getMonomersDictFromLib(monomerSequencesArray, monomerLib, polymerType, alphabet);
+    const srcColLength = srcCol.length;
+    const { molfileList, molfileWarningList } = await seqToMolFileWorker(monomerSequencesArray, monomersDict, alphabet, polymerType, srcColLength);
+    if (molfileWarningList.length > 0.05 * srcColLength)
+        throw new Error('Too many errors getting molfiles.');
+    // exclude name collisions
+    const name = `molfile(${srcCol.name})`;
+    const resColName = df.columns.getUnusedName(name);
+    const resCol = DG.Column.fromStrings(resColName, molfileList);
+    resCol.semType = DG.SEMTYPE.MOLECULE;
+    resCol.setTag(DG.TAGS.UNITS, DG.UNITS.Molecule.MOLBLOCK);
+    return { col: resCol, warnings: molfileWarningList };
+}
+/** Get jagged array of monomer symbols for the dataframe
+ * @param {DG.Column} macroMolCol - Column with macro-molecules
+ * @return {string[]} - Jagged array of monomer symbols for the dataframe */
+export function getMonomerSequencesArray(macroMolCol) {
     const columnLength = macroMolCol.length;
     const result = new Array(columnLength);
     // split the string into monomers
@@ -147,53 +81,53 @@ function getMonomerSequencesArray(macroMolCol) {
 }
 /** Get a mapping of monomer symbols to MolGraph objects. Notice, the
  * transformation from molfile V2000 to V3000 takes place,
- * with the help of async function call from Chem (RdKit module) */
-function getMonomersDictFromLib(monomerSequencesArray, monomerLib, polymerType, alphabet) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // todo: exception - no gaps, no empty string monomers
-        const formattedMonomerLib = getFormattedMonomerLib(monomerLib, polymerType, alphabet);
-        const monomersDict = new Map();
-        const moduleRdkit = yield grok.functions.call('Chem:getRdKitModule');
-        const pointerToBranchAngle = {
-            value: null
-        };
-        // this must NOT be placed after translating monomer sequences
-        // because adding branch monomers for nucleobases relies on these data
-        if (polymerType === "RNA" /* HELM_POLYMER_TYPE.RNA */) {
-            const symbols = (alphabet === "RNA" /* ALPHABET.RNA */) ?
-                [RIBOSE, PHOSPHATE] : [DEOXYRIBOSE, PHOSPHATE];
-            for (const sym of symbols)
+ * with the help of async function call from Chem (RdKit module)
+ * @param {string[]} monomerSequencesArray - Jagged array of monomer symbols for the dataframe
+ * @param {IMonomerLib} monomerLib - Monomer library
+ * @param {HELM_POLYMER_TYPE} polymerType - Polymer type
+ * @param {ALPHABET} alphabet - Alphabet
+ * @return {Map<string, MolGraph>} - Mapping of monomer symbols to MolGraph objects*/
+export async function getMonomersDictFromLib(monomerSequencesArray, monomerLib, polymerType, alphabet) {
+    // todo: exception - no gaps, no empty string monomers
+    const formattedMonomerLib = getFormattedMonomerLib(monomerLib, polymerType, alphabet);
+    const monomersDict = new Map();
+    const moduleRdkit = await grok.functions.call('Chem:getRdKitModule');
+    const pointerToBranchAngle = {
+        value: null
+    };
+    // this must NOT be placed after translating monomer sequences
+    // because adding branch monomers for nucleobases relies on these data
+    if (polymerType === "RNA" /* HELM_POLYMER_TYPE.RNA */) {
+        const symbols = (alphabet === "RNA" /* ALPHABET.RNA */) ?
+            [C.RIBOSE, C.PHOSPHATE] : [C.DEOXYRIBOSE, C.PHOSPHATE];
+        for (const sym of symbols)
+            addMonomerToDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType, pointerToBranchAngle);
+    }
+    for (let rowI = 0; rowI < monomerSequencesArray.length; ++rowI) {
+        const monomerSeq = monomerSequencesArray[rowI];
+        for (const sym of monomerSeq) {
+            if (sym === '')
+                continue; // Skip gap/empty monomer for MSA
+            try {
                 addMonomerToDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType, pointerToBranchAngle);
-        }
-        for (let rowI = 0; rowI < monomerSequencesArray.length; ++rowI) {
-            const monomerSeq = monomerSequencesArray[rowI];
-            for (const sym of monomerSeq) {
-                if (sym === '')
-                    continue; // Skip gap/empty monomer for MSA
-                try {
-                    addMonomerToDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType, pointerToBranchAngle);
-                }
-                catch (err) {
-                    const errTxt = errorToConsole(err);
-                    console.error(`bio lib: getMonomersDictFromLib() sym='${sym}', error:\n` + errTxt);
-                    const errMsg = `Сan't get monomer '${sym}' from library: ${errTxt}`; // Text for Datagrok error baloon
-                    throw new Error(errMsg);
-                }
+            }
+            catch (err) {
+                const errTxt = errorToConsole(err);
+                console.error(`bio lib: getMonomersDictFromLib() sym='${sym}', error:\n` + errTxt);
+                const errMsg = `Сan't get monomer '${sym}' from library: ${errTxt}`; // Text for Datagrok error baloon
+                throw new Error(errMsg);
             }
         }
-        return monomersDict;
-    });
-}
-function getAngleBetweenSugarBranchAndOY(molGraph) {
-    const x = molGraph.atoms.x;
-    const y = molGraph.atoms.y;
-    const rNode = molGraph.meta.rNodes[2] - 1;
-    const terminalNode = molGraph.meta.terminalNodes[2] - 1;
-    const xShift = x[rNode] - x[terminalNode];
-    const yShift = y[rNode] - y[terminalNode];
-    return Math.atan(yShift / xShift) + Math.PI / 2;
+    }
+    return monomersDict;
 }
-/** Adds MolGraph object for 'sym' to the monomers dict when necessary  */
+/** Adds MolGraph object for 'sym' to the monomers dict when necessary
+ * @param {Map<string, MolGraph>} monomersDict - Monomers dictionary
+ * @param {string} sym - Monomer symbol
+ * @param {Map<string, any>} formattedMonomerLib - Formatted monomer library
+ * @param {any} moduleRdkit - RDKit module
+ * @param {HELM_POLYMER_TYPE} polymerType - Polymer type
+ * @param {NumberWrapper} pointerToBranchAngle - Pointer to branch angle*/
 function addMonomerToDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType, pointerToBranchAngle) {
     if (!monomersDict.has(sym)) {
         const monomerData = getMolGraph(sym, formattedMonomerLib, moduleRdkit, polymerType, pointerToBranchAngle);
@@ -205,7 +139,13 @@ function addMonomerToDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, p
     }
 }
 /** Construct the MolGraph object for specified monomerSymbol: the associated
- * graph is adjusted in XY plane and filled with default R-groups */
+ * graph is adjusted in XY plane and filled with default R-groups
+ * @param {string} monomerSymbol - Monomer symbol
+ * @param {Map<string, any>} formattedMonomerLib - Formatted monomer library
+ * @param {any} moduleRdkit - RDKit module
+ * @param {HELM_POLYMER_TYPE} polymerType - Polymer type
+ * @param {NumberWrapper} pointerToBranchAngle - Pointer to branch angle
+ * @return {MolGraph | null} - MolGraph object or null if monomerSymbol is absent in the library*/
 function getMolGraph(monomerSymbol, formattedMonomerLib, moduleRdkit, polymerType, pointerToBranchAngle) {
     if (!formattedMonomerLib.has(monomerSymbol)) {
         return null;
@@ -224,9 +164,9 @@ function getMolGraph(monomerSymbol, formattedMonomerLib, moduleRdkit, polymerTyp
             adjustPeptideMonomerGraph(monomerGraph);
         }
         else { // nucleotides
-            if (monomerSymbol === RIBOSE || monomerSymbol === DEOXYRIBOSE)
+            if (monomerSymbol === C.RIBOSE || monomerSymbol === C.DEOXYRIBOSE)
                 adjustSugarMonomerGraph(monomerGraph, pointerToBranchAngle);
-            else if (monomerSymbol === PHOSPHATE)
+            else if (monomerSymbol === C.PHOSPHATE)
                 adjustPhosphateMonomerGraph(monomerGraph);
             else
                 adjustBaseMonomerGraph(monomerGraph, pointerToBranchAngle);
@@ -244,7 +184,7 @@ function setShiftsAndTerminalNodes(polymerType, monomerGraph, monomerSymbol) {
         removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);
     }
     else { // nucleotides
-        if (monomerSymbol === RIBOSE || monomerSymbol === DEOXYRIBOSE) {
+        if (monomerSymbol === C.RIBOSE || monomerSymbol === C.DEOXYRIBOSE) {
             // remove R2
             removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);
             // set terminalNode2 (oxygen) as new R2
@@ -258,7 +198,7 @@ function setShiftsAndTerminalNodes(polymerType, monomerGraph, monomerSymbol) {
             // remove the branching r-group
             removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[2]);
         }
-        else if (monomerSymbol === PHOSPHATE) {
+        else if (monomerSymbol === C.PHOSPHATE) {
             monomerGraph.meta.terminalNodes[0] = monomerGraph.meta.rNodes[0];
             shiftCoordinates(monomerGraph, -monomerGraph.atoms.x[monomerGraph.meta.terminalNodes[0] - 1], -monomerGraph.atoms.y[monomerGraph.meta.terminalNodes[0] - 1]);
             setShifts(monomerGraph, polymerType);
@@ -269,7 +209,13 @@ function setShiftsAndTerminalNodes(polymerType, monomerGraph, monomerSymbol) {
         }
     }
 }
-// todo: sdoc
+/**
+ * Get monomer metadata object
+ * @param {Atoms} atoms - Atoms object
+ * @param {Bonds} bonds - Bonds object
+ * @param {string[]} capGroups - Cap groups
+ * @param {Map<number, number>} capGroupIdxMap - Cap group index map
+ * @return {MonomerMetadata}*/
 function getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap) {
     const meta = {
         backboneShift: null,
@@ -282,8 +228,9 @@ function getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap) {
     setTerminalNodes(bonds, meta);
     return meta;
 }
-/** Parse element symbols for R-groups from the HELM monomer library R-groups
- * field  */
+/** Parse element symbols for R-groups from the HELM monomer library R-group field
+ * @param {any[]} rGroupObjList - R-group object list
+ * @return {Map<number, number>} - Cap group index map*/
 export function parseCapGroups(rGroupObjList) {
     // specifically for HELMCoreLibrary
     // considered only monoatomic rgroups
@@ -299,7 +246,10 @@ export function parseCapGroups(rGroupObjList) {
     }
     return capGroupsArray;
 }
-/** Substitute the cap group elements instead of R# */
+/** Substitute the cap group elements instead of R#
+ * @param {Atoms} atoms - Atoms object
+ * @param {string[]} capGroups - Cap groups
+ * @param {Map<number, number>} capGroupIdxMap - Cap group index map*/
 function substituteCapGroups(atoms, capGroups, capGroupIdxMap) {
     for (const [node, capIdx] of capGroupIdxMap)
         atoms.atomTypes[node - 1] = capGroups[capIdx - 1]; // -1 because molfile indexing starts from 1
@@ -341,7 +291,9 @@ function setTerminalNodes(bonds, meta) {
         ++i;
     }
 }
-/** Sets shifts in 'meta' attribute of MolGraph  */
+/** Sets shifts in 'meta' attribute of MolGraph
+ * @param {MolGraph} molGraph - MolGraph object
+ * @param {HELM_POLYMER_TYPE} polymerType - Polymer type*/
 function setShifts(molGraph, polymerType) {
     if (molGraph.meta.rNodes.length > 1) {
         molGraph.meta.backboneShift = getShiftBetweenNodes(molGraph, molGraph.meta.rNodes[1] - 1, molGraph.meta.terminalNodes[0] - 1);
@@ -350,7 +302,11 @@ function setShifts(molGraph, polymerType) {
         molGraph.meta.branchShift = getShiftBetweenNodes(molGraph, molGraph.meta.rNodes[2] - 1, molGraph.meta.terminalNodes[0] - 1);
     }
 }
-/** Returns the pair [xShift, yShift] for specified node indices */
+/** Returns the pair [xShift, yShift] for specified node indices
+ * @param {MolGraph} molGraph - MolGraph object
+ * @param {number} rightNodeIdx - Right node index
+ * @param {number} leftNodeIdx - Left node index
+ * @return {number[]} - Shift between nodes*/
 function getShiftBetweenNodes(molGraph, rightNodeIdx, leftNodeIdx) {
     return [
         keepPrecision(molGraph.atoms.x[rightNodeIdx] -
@@ -360,35 +316,43 @@ function getShiftBetweenNodes(molGraph, rightNodeIdx, leftNodeIdx) {
     ];
 }
 /** Helper function necessary to build a correct V3000 molfile out of V2000 with
- * specified r-groups*/
+  * specified r-groups
+  * @param {string} molfileV2K - V2000 molfile
+  * @return {string} - V2000 molfile without R-group lines*/
 function removeRGroupLines(molfileV2K) {
-    let begin = molfileV2K.indexOf(V2K_A_LINE, 0);
+    let begin = molfileV2K.indexOf(C.V2K_A_LINE, 0);
     if (begin === -1)
-        begin = molfileV2K.indexOf(V2K_RGP_LINE);
-    const end = molfileV2K.indexOf(V3K_END, begin);
+        begin = molfileV2K.indexOf(C.V2K_RGP_LINE);
+    const end = molfileV2K.indexOf(C.V3K_END, begin);
     return molfileV2K.substring(0, begin) + molfileV2K.substring(end);
 }
-/** V2000 to V3000 converter  */
-function convertMolfileToV3K(molfileV2K, moduleRdkit) {
+/** V2000 to V3000 converter
+ * @param {string} molfileV2K - V2000 molfile
+ * @param {any} moduleRdkit - RDKit module
+ * @return {string} - V3000 molfile*/
+export function convertMolfileToV3K(molfileV2K, moduleRdkit) {
     // The standard Chem converter is not used here because it relies on creation of moduleRdkit on each iteration
     const molObj = moduleRdkit.get_mol(molfileV2K);
     const molfileV3K = molObj.get_v3Kmolblock();
     molObj.delete();
     return molfileV3K;
 }
-/** Parse V3000 bond block and construct the Bonds object */
-function parseBondBlock(molfileV3K, bondCount) {
+/** Parse V3000 bond block and construct the Bonds object
+ * @param {string} molfileV3K - V3000 molfile
+ * @param {number} bondCount - Number of bonds
+ * @return {Bonds} - Bonds object*/
+export function parseBondBlock(molfileV3K, bondCount) {
     const bondTypes = new Uint32Array(bondCount);
     const atomPairs = new Array(bondCount);
     const bondConfiguration = new Map();
     const kwargs = new Map();
-    let begin = molfileV3K.indexOf(V3K_BEGIN_BOND_BLOCK);
+    let begin = molfileV3K.indexOf(C.V3K_BEGIN_BOND_BLOCK);
     begin = molfileV3K.indexOf('\n', begin);
     let end = begin;
     for (let i = 0; i < bondCount; ++i) {
         // parse bond type and atom pair
         const parsedValues = new Array(3);
-        begin = molfileV3K.indexOf(V3K_BEGIN_DATA_LINE, end) + V3K_IDX_SHIFT;
+        begin = molfileV3K.indexOf(C.V3K_BEGIN_DATA_LINE, end) + C.V3K_IDX_SHIFT;
         end = molfileV3K.indexOf(' ', begin);
         for (let k = 0; k < 3; ++k) {
             begin = end + 1;
@@ -400,7 +364,7 @@ function parseBondBlock(molfileV3K, bondCount) {
         // parse keyword arguments
         const endOfLine = molfileV3K.indexOf('\n', begin);
         let lineRemainder = molfileV3K.slice(end, endOfLine);
-        let beginCfg = lineRemainder.indexOf(V3K_BOND_CONFIG);
+        let beginCfg = lineRemainder.indexOf(C.V3K_BOND_CONFIG);
         if (beginCfg !== -1) {
             beginCfg = lineRemainder.indexOf('=', beginCfg) + 1;
             let endCfg = lineRemainder.indexOf(' ', beginCfg);
@@ -408,7 +372,7 @@ function parseBondBlock(molfileV3K, bondCount) {
                 endCfg = lineRemainder.length;
             const bondConfig = parseInt(lineRemainder.slice(beginCfg, endCfg));
             bondConfiguration.set(i, bondConfig);
-            const removedSubstring = V3K_BOND_CONFIG + bondConfig.toString();
+            const removedSubstring = C.V3K_BOND_CONFIG + bondConfig.toString();
             lineRemainder = lineRemainder.replace(removedSubstring, '');
         }
         if (!lineRemainder)
@@ -422,12 +386,14 @@ function parseBondBlock(molfileV3K, bondCount) {
     };
 }
 /** Constructs mapping of r-group nodes to default capGroups, all numeration starting from 1.
- * According to https://pubs.acs.org/doi/10.1021/ci3001925, R1 and R2 are the chain extending attachment points,
- * while R3 is the branching attachment point. */
-function parseCapGroupIdxMap(molfileV2K) {
+  * According to https://pubs.acs.org/doi/10.1021/ci3001925, R1 and R2 are the chain extending attachment points,
+  * while R3 is the branching attachment point.
+  * @param {string} molfileV2K - V2000 molfile
+  * @return {Map<number, number>} - Map of r-group nodes to default capGroups*/
+export function parseCapGroupIdxMap(molfileV2K) {
     const capGroupIdxMap = new Map();
     // parse A-lines (RNA)
-    let begin = molfileV2K.indexOf(V2K_A_LINE, 0);
+    let begin = molfileV2K.indexOf(C.V2K_A_LINE, 0);
     let end = begin;
     while (begin !== -1) {
         // parse the rNode to which the cap group is attached
@@ -438,13 +404,13 @@ function parseCapGroupIdxMap(molfileV2K) {
         end = molfileV2K.indexOf('\n', begin);
         const capGroup = parseInt(molfileV2K.substring(begin, end).replace(/^R/, ''));
         capGroupIdxMap.set(rNode, capGroup);
-        begin = molfileV2K.indexOf(V2K_A_LINE, end);
+        begin = molfileV2K.indexOf(C.V2K_A_LINE, end);
     }
     // parse RGP lines (may be more than one in RNA monomers)
-    begin = molfileV2K.indexOf(V2K_RGP_LINE, 0);
+    begin = molfileV2K.indexOf(C.V2K_RGP_LINE, 0);
     end = molfileV2K.indexOf('\n', begin);
     while (begin !== -1) {
-        begin += V2K_RGP_SHIFT;
+        begin += C.V2K_RGP_SHIFT;
         end = molfileV2K.indexOf('\n', begin);
         const rgpStringParsed = molfileV2K.substring(begin, end)
             .replaceAll(/\s+/g, ' ')
@@ -458,14 +424,14 @@ function parseCapGroupIdxMap(molfileV2K) {
             else
                 capGroupIdxMap.set(rgpIndicesArray[i], rgpIndicesArray[i + 1]);
         }
-        begin = molfileV2K.indexOf(V2K_RGP_LINE, end);
+        begin = molfileV2K.indexOf(C.V2K_RGP_LINE, end);
     }
     return capGroupIdxMap;
 }
-function parseAtomAndBondCounts(molfileV3K) {
+export function parseAtomAndBondCounts(molfileV3K) {
     molfileV3K = molfileV3K.replaceAll('\r', ''); // to handle old and new sdf standards
     // parse atom count
-    let begin = molfileV3K.indexOf(V3K_BEGIN_COUNTS_LINE) + V3K_COUNTS_SHIFT;
+    let begin = molfileV3K.indexOf(C.V3K_BEGIN_COUNTS_LINE) + C.V3K_COUNTS_SHIFT;
     let end = molfileV3K.indexOf(' ', begin + 1);
     const numOfAtoms = parseInt(molfileV3K.substring(begin, end));
     // parse bond count
@@ -475,17 +441,20 @@ function parseAtomAndBondCounts(molfileV3K) {
     return { atomCount: numOfAtoms, bondCount: numOfBonds };
 }
 /** Parse V3000 atom block and return Atoms object. NOTICE: only atomTypes, x, y
- * and kwargs fields are set in the return value, with other fields dummy */
+  * and kwargs fields are set in the return value, with other fields dummy initialized.
+  * @param {string} molfileV3K - V3000 molfile
+  * @param {number} atomCount - number of atoms in the molecule
+  * @return {Atoms} - Atoms object */
 function parseAtomBlock(molfileV3K, atomCount) {
     const atomTypes = new Array(atomCount);
     const x = new Float32Array(atomCount);
     const y = new Float32Array(atomCount);
     const kwargs = new Array(atomCount);
-    let begin = molfileV3K.indexOf(V3K_BEGIN_ATOM_BLOCK); // V3000 atoms block
+    let begin = molfileV3K.indexOf(C.V3K_BEGIN_ATOM_BLOCK); // V3000 atoms block
     begin = molfileV3K.indexOf('\n', begin);
     let end = begin;
     for (let i = 0; i < atomCount; i++) {
-        begin = molfileV3K.indexOf(V3K_BEGIN_DATA_LINE, begin) + V3K_IDX_SHIFT;
+        begin = molfileV3K.indexOf(C.V3K_BEGIN_DATA_LINE, begin) + C.V3K_IDX_SHIFT;
         end = molfileV3K.indexOf(' ', begin); // skip the idx row
         // parse atom type
         begin = end + 1;
@@ -513,11 +482,12 @@ function parseAtomBlock(molfileV3K, atomCount) {
         kwargs: kwargs,
     };
 }
-/** Remove hydrogen nodes */
+/** Remove hydrogen nodes
+ * @param {MolGraph} monomerGraph - monomer graph*/
 function removeHydrogen(monomerGraph) {
     let i = 0;
     while (i < monomerGraph.atoms.atomTypes.length) {
-        if (monomerGraph.atoms.atomTypes[i] === HYDROGEN) {
+        if (monomerGraph.atoms.atomTypes[i] === C.HYDROGEN) {
             removeNodeAndBonds(monomerGraph, i + 1); // i + 1 because molfile node indexing starts from 1
             --i;
             // monomerGraph.atoms.atomTypes[i] = 'Li';
@@ -526,7 +496,9 @@ function removeHydrogen(monomerGraph) {
     }
 }
 /** Remove node 'removedNode' and the associated bonds. Notice, numeration of
- * nodes in molfiles starts from 1, not 0 */
+  * nodes in molfiles starts from 1, not 0
+  * @param {MolGraph} monomerGraph - monomer graph
+  * @param {number} removedNode - node to be removed*/
 function removeNodeAndBonds(monomerGraph, removedNode) {
     if (typeof removedNode !== 'undefined') {
         const removedNodeIdx = removedNode - 1;
@@ -604,7 +576,8 @@ function spliceTypedArray(TConstructor, typedArray, start, count) {
     }
     return result;
 }
-/** Adjust the peptide MolGraph to default/standardized position  */
+/** Adjust the peptide MolGraph to default/standardized position
+ * @param {MolGraph} monomer - monomer graph*/
 function adjustPeptideMonomerGraph(monomer) {
     const centeredNode = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1
     const rotatedNode = monomer.meta.rNodes[0] - 1;
@@ -686,10 +659,12 @@ function adjustBaseMonomerGraph(monomer, pointerToBranchAngle) {
     }
 }
 function getEuclideanDistance(p1, p2) {
-    return keepPrecision(Math.sqrt(Math.pow((p1.x - p2.x), 2) + Math.pow((p1.y - p2.y), 2)));
+    return keepPrecision(Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2));
 }
 /** Flip carboxyl group with the radical in a peptide monomer in case the
- * carboxyl group is in the lower half-plane */
+  * carboxyl group is in the lower half-plane
+  * @param {MolGraph}monomer - peptide monomer
+  * @param {number}doubleBondedOxygen - index of the double-bonded oxygen atom*/
 function flipCarboxylAndRadical(monomer, doubleBondedOxygen) {
     // verify that the carboxyl group is in the lower half-plane
     if (monomer.atoms.y[monomer.meta.rNodes[1] - 1] < 0 &&
@@ -698,7 +673,10 @@ function flipCarboxylAndRadical(monomer, doubleBondedOxygen) {
         rotateCenteredGraph(monomer.atoms, -findAngleWithOX(monomer.atoms.x[monomer.meta.terminalNodes[1] - 1], monomer.atoms.y[monomer.meta.terminalNodes[1] - 1]));
     }
 }
-/** Finds angle between OY and the ray joining origin with (x, y) */
+/** Finds angle between OY and the ray joining origin with (x, y)
+ * @param {number}x
+ * @param {number}y
+ * @return {number} angle in radians*/
 function findAngleWithOY(x, y) {
     let angle;
     if (x === 0) {
@@ -714,11 +692,17 @@ function findAngleWithOY(x, y) {
     }
     return angle;
 }
-/** Finds angle between OX and the ray joining origin with (x, y) */
+/** Finds angle between OX and the ray joining origin with (x, y)
+ * @param {number}x
+ * @param {number}y
+ * @return {number} angle in radians
+*/
 function findAngleWithOX(x, y) {
     return findAngleWithOY(x, y) + Math.PI / 2;
 }
-/**  Rotate the graph around the origin by 'angle' */
+/**  Rotate the graph around the origin by 'angle'
+ * @param {Atoms}atoms - atoms of the graph
+ * @param {number}angle - angle in radians*/
 function rotateCenteredGraph(atoms, angle) {
     if (angle !== 0) {
         const x = atoms.x;
@@ -732,15 +716,19 @@ function rotateCenteredGraph(atoms, angle) {
         }
     }
 }
-/** Flip monomer graph around OX axis preserving stereometry */
+/** Flip monomer graph around OX axis preserving stereometry
+ * @param {MolGraph}monomer - monomer graph*/
 function flipMonomerAroundOX(monomer) {
     flipMolGraph(monomer, true);
 }
-/** Flip monomer graph around OY axis preserving stereometry */
+/** Flip monomer graph around OY axis preserving stereometry
+ * @param {MolGraph}monomer - monomer graph*/
 function flipMonomerAroundOY(monomer) {
     flipMolGraph(monomer, false);
 }
-/** Flip graph around a specified axis: 'true' corresponds to OX, 'false' to OY */
+/** Flip graph around a specified axis: 'true' corresponds to OX, 'false' to OY
+ * @param {MolGraph}molGraph - graph to flip
+ * @param {boolean}axis - axis to flip around*/
 function flipMolGraph(molGraph, axis) {
     if (axis) { // flipping around OX
         const y = molGraph.atoms.y;
@@ -759,9 +747,20 @@ function flipMolGraph(molGraph, axis) {
         orientation.set(key, newValue);
     }
 }
+function getAngleBetweenSugarBranchAndOY(molGraph) {
+    const x = molGraph.atoms.x;
+    const y = molGraph.atoms.y;
+    const rNode = molGraph.meta.rNodes[2] - 1;
+    const terminalNode = molGraph.meta.terminalNodes[2] - 1;
+    const xShift = x[rNode] - x[terminalNode];
+    const yShift = y[rNode] - y[terminalNode];
+    return Math.atan(yShift / xShift) + Math.PI / 2;
+}
 /** Flips double-bonded 'O' in carbonyl group with 'OH' in order for the monomers
- * to have standard representation simplifying their concatenation. The
- * monomer must already be adjusted with adjustPeptideMonomerGraph in order for this function to be implemented  */
+  * to have standard representation simplifying their concatenation. The
+  * monomer must already be adjusted with adjustPeptideMonomerGraph in order for this function to be implemented
+  * @param {MolGraph}monomer - peptide monomer
+  * @param {number}doubleBondedOxygen - index of the double-bonded oxygen atom*/
 function flipHydroxilGroup(monomer, doubleBondedOxygen) {
     const x = monomer.atoms.x;
     // -1 below because indexing of nodes in molfiles starts from 1, unlike arrays
@@ -769,7 +768,9 @@ function flipHydroxilGroup(monomer, doubleBondedOxygen) {
         swapNodes(monomer, doubleBondedOxygen, monomer.meta.rNodes[1]);
 }
 /** Determine the number of node (starting from 1) corresponding to the
- * double-bonded oxygen of the carbonyl group  */
+   * double-bonded oxygen of the carbonyl group
+   * @param {MolGraph}monomer - peptide monomer
+   * @return {number} index of the double-bonded oxygen atom*/
 function findDoubleBondedCarbonylOxygen(monomer) {
     const bondsMap = constructBondsMap(monomer);
     let doubleBondedOxygen = 0;
@@ -777,13 +778,16 @@ function findDoubleBondedCarbonylOxygen(monomer) {
     // iterate over the nodes bonded to the carbon and find the double one
     while (doubleBondedOxygen === 0) {
         const node = bondsMap.get(monomer.meta.terminalNodes[1])[i];
-        if (monomer.atoms.atomTypes[node - 1] === OXYGEN && node !== monomer.meta.rNodes[1])
+        if (monomer.atoms.atomTypes[node - 1] === C.OXYGEN && node !== monomer.meta.rNodes[1])
             doubleBondedOxygen = node;
         i++;
     }
     return doubleBondedOxygen;
 }
-/** Swap the Cartesian coordinates of the two specified nodes in MolGraph  */
+/** Swap the Cartesian coordinates of the two specified nodes in MolGraph
+ * @param {MolGraph}monomer - monomer graph
+ * @param {number}nodeOne - index of the first node
+ * @param {number}nodeTwo - index of the second node*/
 function swapNodes(monomer, nodeOne, nodeTwo) {
     const nodeOneIdx = nodeOne - 1;
     const nodeTwoIdx = nodeTwo - 1;
@@ -796,23 +800,27 @@ function swapNodes(monomer, nodeOne, nodeTwo) {
     x[nodeTwoIdx] = tmpX;
     y[nodeTwoIdx] = tmpY;
 }
-/** Maps a node to the list of nodes bound to it */
+/** Maps a node to the list of nodes bound to it
+ * @param {MolGraph}monomer - monomer graph
+ * @return {Map<number, Array<number>>} map of nodes to the list of nodes bound to them*/
 function constructBondsMap(monomer) {
-    var _a;
     const map = new Map();
     for (const atomPairs of monomer.bonds.atomPairs) {
         for (let i = 0; i < 2; i++) {
             const key = atomPairs[i];
             const value = atomPairs[(i + 1) % 2];
             if (map.has(key))
-                (_a = map.get(key)) === null || _a === void 0 ? void 0 : _a.push(value);
+                map.get(key)?.push(value);
             else
                 map.set(key, new Array(1).fill(value));
         }
     }
     return map;
 }
-/** Shift molGraph in the XOY plane  */
+/** Shift molGraph in the XOY plane
+ * @param {MolGraph}molGraph - graph to shift
+ * @param {number}xShift - shift along X axis
+ * @param {number}yShift - shift along Y axis*/
 function shiftCoordinates(molGraph, xShift, yShift) {
     const x = molGraph.atoms.x;
     const y = molGraph.atoms.y;
@@ -822,245 +830,7 @@ function shiftCoordinates(molGraph, xShift, yShift) {
             y[i] = keepPrecision(y[i] + yShift);
     }
 }
-/** Translate a sequence of monomer symbols into Molfile V3000 */
-function monomerSeqToMolfile(monomerSeq, monomersDict, alphabet, polymerType) {
-    if (monomerSeq.length === 0) {
-        // throw new Error('monomerSeq is empty');
-        return '';
-    }
-    // define atom and bond counts, taking into account the bond type
-    const getAtomAndBondCounts = getResultingAtomBondCounts;
-    const { atomCount, bondCount } = getAtomAndBondCounts(monomerSeq, monomersDict, alphabet, polymerType);
-    // create arrays to store lines of the resulting molfile
-    const molfileAtomBlock = new Array(atomCount);
-    const molfileBondBlock = new Array(bondCount);
-    let addMonomerToMolblock; // todo: types?
-    let sugar = null;
-    let phosphate = null;
-    if (polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */) {
-        addMonomerToMolblock = addAminoAcidToMolblock;
-    }
-    else { // nucleotides
-        addMonomerToMolblock = addNucleotideToMolblock;
-        sugar = (alphabet === "DNA" /* ALPHABET.DNA */) ? monomersDict.get(DEOXYRIBOSE) : monomersDict.get(RIBOSE);
-        phosphate = monomersDict.get(PHOSPHATE);
-    }
-    const v = {
-        i: 0,
-        nodeShift: 0,
-        bondShift: 0,
-        backbonePositionShift: new Array(2).fill(0),
-        branchPositionShift: new Array(2).fill(0),
-        backboneAttachNode: 0,
-        branchAttachNode: 0,
-        flipFactor: 1,
-    };
-    const C = {
-        sugar: sugar,
-        phosphate: phosphate,
-        seqLength: monomerSeq.length,
-        atomCount: atomCount,
-        bondCount: bondCount,
-    };
-    for (v.i = 0; v.i < C.seqLength; ++v.i) {
-        const monomer = monomersDict.get(monomerSeq[v.i]);
-        addMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C);
-    }
-    capResultingMolblock(molfileAtomBlock, molfileBondBlock, v, C);
-    const molfileCountsLine = V3K_BEGIN_COUNTS_LINE + atomCount + ' ' + bondCount + V3K_COUNTS_LINE_ENDING;
-    // todo: possible optimization may be achieved by replacing .join('') with +=
-    // since counterintuitively joining an array into a new string is reportedly
-    // slower than using += as below
-    let result = '';
-    result += V3K_HEADER_FIRST_LINE;
-    result += V3K_HEADER_SECOND_LINE;
-    result += V3K_BEGIN_CTAB_BLOCK;
-    result += molfileCountsLine;
-    result += V3K_BEGIN_ATOM_BLOCK;
-    result += molfileAtomBlock.join('');
-    result += V3K_END_ATOM_BLOCK;
-    result += V3K_BEGIN_BOND_BLOCK;
-    result += molfileBondBlock.join('');
-    result += V3K_END_BOND_BLOCK;
-    result += V3K_END_CTAB_BLOCK;
-    result += V3K_END;
-    // return molfileParts.join('');
-    return result;
-}
-/** Cap the resulting (after sewing up all the monomers) molfile with 'O' */
-function capResultingMolblock(molfileAtomBlock, molfileBondBlock, v, C) {
-    // add terminal oxygen
-    const atomIdx = v.nodeShift + 1;
-    molfileAtomBlock[C.atomCount] = V3K_BEGIN_DATA_LINE + atomIdx + ' ' +
-        OXYGEN + ' ' + keepPrecision(v.backbonePositionShift[0]) + ' ' +
-        v.flipFactor * keepPrecision(v.backbonePositionShift[1]) + ' ' + '0.000000 0' + '\n';
-    // add terminal bond
-    const firstAtom = v.backboneAttachNode;
-    const secondAtom = atomIdx;
-    molfileBondBlock[C.bondCount] = V3K_BEGIN_DATA_LINE + v.bondShift + ' ' +
-        1 + ' ' + firstAtom + ' ' + secondAtom + '\n';
-}
-function addAminoAcidToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v) {
-    v.flipFactor = Math.pow((-1), (v.i % 2)); // to flip every even monomer over OX
-    addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v);
-}
-function addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v) {
-    // todo: remove these comments to the docstrings of the corr. functions
-    // construnct the lines of V3K molfile atom block
-    fillAtomLines(monomer, molfileAtomBlock, v);
-    // construct the lines of V3K molfile bond block
-    fillBondLines(monomer, molfileBondBlock, v);
-    // peptide bond
-    fillChainExtendingBond(monomer, molfileBondBlock, v);
-    // update branch variables if necessary
-    if (monomer.meta.branchShift !== null && monomer.meta.terminalNodes.length > 2)
-        updateBranchVariables(monomer, v);
-    // update loop variables
-    updateChainExtendingVariables(monomer, v);
-}
-function addNucleotideToMolblock(nucleobase, molfileAtomBlock, molfileBondBlock, v, C) {
-    // construnct the lines of V3K molfile atom block corresponding to phosphate
-    // and sugar
-    if (v.i === 0) {
-        addBackboneMonomerToMolblock(C.sugar, molfileAtomBlock, molfileBondBlock, v);
-    }
-    else {
-        for (const monomer of [C.phosphate, C.sugar])
-            addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v);
-    }
-    addBranchMonomerToMolblock(nucleobase, molfileAtomBlock, molfileBondBlock, v);
-}
-function addBranchMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v) {
-    fillBranchAtomLines(monomer, molfileAtomBlock, v);
-    fillBondLines(monomer, molfileBondBlock, v);
-    fillBackboneToBranchBond(monomer, molfileBondBlock, v);
-    // C-N bond
-    const bondIdx = v.bondShift;
-    const firstAtom = v.branchAttachNode;
-    const secondAtom = monomer.meta.terminalNodes[0] + v.nodeShift;
-    molfileBondBlock[bondIdx - 1] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +
-        1 + ' ' + firstAtom + ' ' + secondAtom + '\n';
-    // update loop variables
-    v.bondShift += monomer.bonds.atomPairs.length + 1;
-    v.nodeShift += monomer.atoms.atomTypes.length;
-}
-function updateChainExtendingVariables(monomer, v) {
-    v.backboneAttachNode = v.nodeShift + monomer.meta.terminalNodes[1];
-    v.bondShift += monomer.bonds.atomPairs.length + 1;
-    v.nodeShift += monomer.atoms.atomTypes.length;
-    v.backbonePositionShift[0] += monomer.meta.backboneShift[0]; // todo: non-null check
-    v.backbonePositionShift[1] += v.flipFactor * monomer.meta.backboneShift[1];
-}
-function updateBranchVariables(monomer, v) {
-    v.branchAttachNode = v.nodeShift + monomer.meta.terminalNodes[2];
-    for (let i = 0; i < 2; ++i)
-        v.branchPositionShift[i] = v.backbonePositionShift[i] + monomer.meta.branchShift[i];
-}
-function fillAtomLines(monomer, molfileAtomBlock, v) {
-    for (let j = 0; j < monomer.atoms.atomTypes.length; ++j) {
-        const atomIdx = v.nodeShift + j + 1;
-        molfileAtomBlock[v.nodeShift + j] = V3K_BEGIN_DATA_LINE + atomIdx + ' ' +
-            monomer.atoms.atomTypes[j] + ' ' +
-            keepPrecision(v.backbonePositionShift[0] + monomer.atoms.x[j]) + ' ' +
-            keepPrecision(v.backbonePositionShift[1] + v.flipFactor * monomer.atoms.y[j]) +
-            ' ' + monomer.atoms.kwargs[j];
-    }
-}
-// todo: remove as quickfix
-function fillBranchAtomLines(monomer, molfileAtomBlock, v) {
-    for (let j = 0; j < monomer.atoms.atomTypes.length; ++j) {
-        const atomIdx = v.nodeShift + j + 1;
-        molfileAtomBlock[v.nodeShift + j] = V3K_BEGIN_DATA_LINE + atomIdx + ' ' +
-            monomer.atoms.atomTypes[j] + ' ' +
-            keepPrecision(v.branchPositionShift[0] + monomer.atoms.x[j]) + ' ' +
-            keepPrecision(v.branchPositionShift[1] + v.flipFactor * monomer.atoms.y[j]) +
-            ' ' + monomer.atoms.kwargs[j];
-    }
-}
-function fillBondLines(monomer, molfileBondBlock, v) {
-    // construct the lines of V3K molfile bond block
-    for (let j = 0; j < monomer.bonds.atomPairs.length; ++j) {
-        const bondIdx = v.bondShift + j + 1;
-        const firstAtom = monomer.bonds.atomPairs[j][0] + v.nodeShift;
-        const secondAtom = monomer.bonds.atomPairs[j][1] + v.nodeShift;
-        let bondCfg = '';
-        if (monomer.bonds.bondConfiguration.has(j)) {
-            // flip orientation when necessary
-            let orientation = monomer.bonds.bondConfiguration.get(j);
-            if (v.flipFactor < 0)
-                orientation = (orientation === 1) ? 3 : 1;
-            bondCfg = ' CFG=' + orientation;
-        }
-        const kwargs = monomer.bonds.kwargs.has(j) ?
-            ' ' + monomer.bonds.kwargs.get(j) : '';
-        molfileBondBlock[v.bondShift + j] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +
-            monomer.bonds.bondTypes[j] + ' ' +
-            firstAtom + ' ' + secondAtom + bondCfg + kwargs + '\n';
-    }
-}
-function fillChainExtendingBond(monomer, molfileBondBlock, v) {
-    if (v.backboneAttachNode !== 0) {
-        const bondIdx = v.bondShift;
-        const firstAtom = v.backboneAttachNode;
-        const secondAtom = monomer.meta.terminalNodes[0] + v.nodeShift;
-        molfileBondBlock[v.bondShift - 1] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +
-            1 + ' ' + firstAtom + ' ' + secondAtom + '\n';
-    }
-}
-// todo: remove
-function fillBackboneToBranchBond(branchMonomer, molfileBondBlock, v) {
-    const bondIdx = v.bondShift;
-    const firstAtom = v.branchAttachNode;
-    const secondAtom = branchMonomer.meta.terminalNodes[0] + v.nodeShift;
-    molfileBondBlock[bondIdx - 1] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +
-        1 + ' ' + firstAtom + ' ' + secondAtom + '\n';
-}
-/** Compute the atom/bond counts for the resulting molfile, depending on the
- * type of polymer (peptide/nucleotide) */
-function getResultingAtomBondCounts(monomerSeq, monomersDict, alphabet, polymerType) {
-    let atomCount = 0;
-    let bondCount = 0;
-    // sum up all the atoms/nodes provided by the sequence
-    for (const monomerSymbol of monomerSeq) {
-        if (monomerSymbol === '')
-            continue; // Skip for gap/empty monomer in MSA
-        const monomer = monomersDict.get(monomerSymbol);
-        atomCount += monomer.atoms.x.length;
-        bondCount += monomer.bonds.bondTypes.length;
-    }
-    // add extra values depending on the polymer type
-    if (polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */) {
-        // add the rightmost/terminating cap group 'OH' (i.e. 'O')
-        atomCount += 1;
-        // add chain-extending bonds (C-NH per each monomer pair and terminal C-OH)
-        bondCount += monomerSeq.length;
-    }
-    else { // nucleotides
-        const sugar = (alphabet === "DNA" /* ALPHABET.DNA */) ?
-            monomersDict.get(DEOXYRIBOSE) : monomersDict.get(RIBOSE);
-        const phosphate = monomersDict.get(PHOSPHATE);
-        // add phosphate per each pair of nucleobase symbols
-        atomCount += (monomerSeq.length - 1) * phosphate.atoms.x.length;
-        // add sugar per each nucleobase symbol
-        atomCount += monomerSeq.length * sugar.atoms.x.length;
-        // add the leftmost cap group 'OH' (i.e. 'O')
-        atomCount += 1;
-        // add bonds from phosphate monomers
-        bondCount += (monomerSeq.length - 1) * phosphate.bonds.bondTypes.length;
-        // add bonds from sugar monomers
-        bondCount += monomerSeq.length * sugar.bonds.bondTypes.length;
-        // exclude the first chain-extending bond O-P (absent, no 'leftmost' phosphate)
-        bondCount -= 1;
-        // add chain-extending and branch bonds (O-P, C-O and C-N per each nucleotide)
-        bondCount += monomerSeq.length * 3;
-    }
-    return { atomCount, bondCount };
-}
-/** Keep precision upon floating point operations over atom coordinates */
-function keepPrecision(x) {
-    return Math.round(PRECISION_FACTOR * x) / PRECISION_FACTOR;
-}
-function convertMolGraphToMolfileV3K(molGraph) {
+export function convertMolGraphToMolfileV3K(molGraph) {
     // counts line
     const atomType = molGraph.atoms.atomTypes;
     const x = molGraph.atoms.x;
@@ -1073,7 +843,7 @@ function convertMolGraphToMolfileV3K(molGraph) {
     const atomCount = atomType.length;
     const bondCount = molGraph.bonds.bondTypes.length;
     // todo rewrite using constants
-    const molfileCountsLine = V3K_BEGIN_COUNTS_LINE + atomCount + ' ' + bondCount + V3K_COUNTS_LINE_ENDING;
+    const molfileCountsLine = C.V3K_BEGIN_COUNTS_LINE + atomCount + ' ' + bondCount + C.V3K_COUNTS_LINE_ENDING;
     // atom block
     let molfileAtomBlock = '';
     for (let i = 0; i < atomCount; ++i) {
@@ -1087,7 +857,7 @@ function convertMolGraphToMolfileV3K(molGraph) {
         //   formatted[1] = formatted[1].padEnd(V3K_ATOM_COORDINATE_PRECISION, '0');
         //   coordinate[k] = formatted.join('.');
         // }
-        const atomLine = V3K_BEGIN_DATA_LINE + atomIdx + ' ' + atomType[i] + ' ' +
+        const atomLine = C.V3K_BEGIN_DATA_LINE + atomIdx + ' ' + atomType[i] + ' ' +
             coordinate[0] + ' ' + coordinate[1] + ' ' + atomKwargs[i];
         molfileAtomBlock += atomLine;
     }
@@ -1099,54 +869,54 @@ function convertMolGraphToMolfileV3K(molGraph) {
         const secondAtom = atomPair[i][1];
         const kwargs = bondKwargs.has(i) ? ' ' + bondKwargs.get(i) : '';
         const bondCfg = bondConfig.has(i) ? ' CFG=' + bondConfig.get(i) : '';
-        const bondLine = V3K_BEGIN_DATA_LINE + bondIdx + ' ' + bondType[i] + ' ' +
+        const bondLine = C.V3K_BEGIN_DATA_LINE + bondIdx + ' ' + bondType[i] + ' ' +
             firstAtom + ' ' + secondAtom + bondCfg + kwargs + '\n';
         molfileBondBlock += bondLine;
     }
     const molfileParts = [
-        V3K_HEADER_FIRST_LINE,
-        V3K_HEADER_SECOND_LINE,
-        V3K_BEGIN_CTAB_BLOCK,
+        C.V3K_HEADER_FIRST_LINE,
+        C.V3K_HEADER_SECOND_LINE,
+        C.V3K_BEGIN_CTAB_BLOCK,
         molfileCountsLine,
-        V3K_BEGIN_ATOM_BLOCK,
+        C.V3K_BEGIN_ATOM_BLOCK,
         molfileAtomBlock,
-        V3K_END_ATOM_BLOCK,
-        V3K_BEGIN_BOND_BLOCK,
+        C.V3K_END_ATOM_BLOCK,
+        C.V3K_BEGIN_BOND_BLOCK,
         molfileBondBlock,
-        V3K_END_BOND_BLOCK,
-        V3K_END_CTAB_BLOCK,
-        V3K_END,
+        C.V3K_END_BOND_BLOCK,
+        C.V3K_END_CTAB_BLOCK,
+        C.V3K_END,
     ];
     const resultingMolfile = molfileParts.join('');
     // console.log(resultingMolfile);
     return resultingMolfile;
 }
-export function getSymbolToCappedMolfileMap(monomersLibList) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (DG.Func.find({ package: 'Chem', name: 'getRdKitModule' }).length === 0) {
-            grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
-            return;
-        }
-        const symbolToCappedMolfileMap = new Map();
-        const moduleRdkit = yield grok.functions.call('Chem:getRdKitModule');
-        for (const monomerLibObject of monomersLibList) {
-            const monomerSymbol = monomerLibObject["symbol" /* HELM_FIELDS.SYMBOL */];
-            const capGroups = parseCapGroups(monomerLibObject["rgroups" /* HELM_FIELDS.RGROUPS */]);
-            const capGroupIdxMap = parseCapGroupIdxMap(monomerLibObject["molfile" /* HELM_FIELDS.MOLFILE */]);
-            const molfileV3K = convertMolfileToV3K(removeRGroupLines(monomerLibObject["molfile" /* HELM_FIELDS.MOLFILE */]), moduleRdkit);
-            const counts = parseAtomAndBondCounts(molfileV3K);
-            const atoms = parseAtomBlock(molfileV3K, counts.atomCount);
-            const bonds = parseBondBlock(molfileV3K, counts.bondCount);
-            const meta = getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap);
-            const monomerGraph = { atoms: atoms, bonds: bonds, meta: meta };
-            removeHydrogen(monomerGraph);
-            const molfile = convertMolGraphToMolfileV3K(monomerGraph);
-            symbolToCappedMolfileMap.set(monomerSymbol, molfile);
-        }
-        return symbolToCappedMolfileMap;
-    });
+export async function getSymbolToCappedMolfileMap(monomersLibList) {
+    if (DG.Func.find({ package: 'Chem', name: 'getRdKitModule' }).length === 0) {
+        grok.shell.warning('Transformation to atomic level requires package "Chem" installed.');
+        return;
+    }
+    const symbolToCappedMolfileMap = new Map();
+    const moduleRdkit = await grok.functions.call('Chem:getRdKitModule');
+    for (const monomerLibObject of monomersLibList) {
+        const monomerSymbol = monomerLibObject["symbol" /* HELM_FIELDS.SYMBOL */];
+        const capGroups = parseCapGroups(monomerLibObject["rgroups" /* HELM_FIELDS.RGROUPS */]);
+        const capGroupIdxMap = parseCapGroupIdxMap(monomerLibObject["molfile" /* HELM_FIELDS.MOLFILE */]);
+        const molfileV3K = convertMolfileToV3K(removeRGroupLines(monomerLibObject["molfile" /* HELM_FIELDS.MOLFILE */]), moduleRdkit);
+        const counts = parseAtomAndBondCounts(molfileV3K);
+        const atoms = parseAtomBlock(molfileV3K, counts.atomCount);
+        const bonds = parseBondBlock(molfileV3K, counts.bondCount);
+        const meta = getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap);
+        const monomerGraph = { atoms: atoms, bonds: bonds, meta: meta };
+        removeHydrogen(monomerGraph);
+        const molfile = convertMolGraphToMolfileV3K(monomerGraph);
+        symbolToCappedMolfileMap.set(monomerSymbol, molfile);
+    }
+    return symbolToCappedMolfileMap;
 }
-/** Get the V3K molfile corresponding to the capped Monomer (default cap groups)  */
+/** Get the V3K molfile corresponding to the capped Monomer (default cap groups)
+ * @param {Monomer} monomer
+ * @return {string} V3K molfile*/
 export function capPeptideMonomer(monomer) {
     const funcList = DG.Func.find({ package: 'Chem', name: 'getRdKitModule' });
     const moduleRdkit = funcList[0].apply();