@datagrok-libraries/bio 5.9.7 → 5.9.11

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

@@ -0,0 +1,1111 @@
+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';
+import { NotationConverter } from '../utils/notation-converter';
+// 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\n';
+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';
+// 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, macroMolCol, 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;
+        }
+        if (macroMolCol.semType !== DG.SEMTYPE.MACROMOLECULE) {
+            grok.shell.warning(`Only the ${DG.SEMTYPE.MACROMOLECULE} columns can be converted to atomic
+      level, the chosen column has semType ${macroMolCol.semType}`);
+            return;
+        }
+        // convert 'helm' to 'separator' units
+        if (macroMolCol.getTag(DG.TAGS.UNITS) === "helm" /* NOTATION.HELM */) {
+            const converter = new NotationConverter(macroMolCol);
+            const separator = '/';
+            macroMolCol = converter.convert("separator" /* NOTATION.SEPARATOR */, separator);
+        }
+        const alphabet = macroMolCol.getTag("alphabet" /* TAGS.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 */) {
+            polymerType = "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */;
+        }
+        else if (alphabet === "RNA" /* ALPHABET.RNA */ || alphabet === "DNA" /* ALPHABET.DNA */) {
+            polymerType = "RNA" /* HELM_POLYMER_TYPE.RNA */;
+        }
+        else {
+            grok.shell.warning(`Only PT, DNA and RNA alphabets are supported, while the selected column has ${polymerType} alphabet`);
+            return;
+        }
+        const monomerSequencesArray = getMonomerSequencesArray(macroMolCol);
+        // todo: consider separately backbone, terminal, branch monomer types
+        const monomersDict = yield getMonomersDict(monomerSequencesArray, monomersLibList, polymerType, alphabet);
+        const columnLength = macroMolCol.length;
+        const reconstructed = new Array(columnLength);
+        for (let row = 0; row < columnLength; ++row) {
+            const monomerSeq = monomerSequencesArray[row];
+            reconstructed[row] = monomerSeqToMolfile(monomerSeq, monomersDict, alphabet, polymerType);
+            console.log(reconstructed[row]);
+        }
+        // exclude name collisions
+        const name = 'molfile(' + macroMolCol.name + ')';
+        const newColName = df.columns.getUnusedName(name);
+        const newCol = DG.Column.fromStrings(newColName, reconstructed);
+        newCol.semType = DG.SEMTYPE.MOLECULE;
+        newCol.setTag(DG.TAGS.UNITS, DG.UNITS.Molecule.MOLBLOCK);
+        df.columns.add(newCol, true);
+        yield grok.data.detectSemanticTypes(df);
+    });
+}
+/* Get a mapping of peptide symbols to HELM monomer library objects with
+ * selectted fields  */
+function getFormattedMonomerLib(monomersLibList, polymerType, alphabet) {
+    const map = new Map();
+    monomersLibList.forEach((it) => {
+        if (it["polymerType" /* HELM_FIELDS.POLYMER_TYPE */] === polymerType) {
+            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) => {
+                    monomerObject[field] = it[field];
+                });
+                map.set(it["symbol" /* HELM_FIELDS.SYMBOL */], monomerObject);
+            }
+        }
+    });
+    return map;
+}
+/* Get jagged array of monomer symbols for the dataframe  */
+function getMonomerSequencesArray(macroMolCol) {
+    const columnLength = macroMolCol.length;
+    const result = new Array(columnLength);
+    // split the string into monomers
+    const colUnits = macroMolCol.getTag(DG.TAGS.UNITS);
+    const separator = macroMolCol.getTag("separator" /* TAGS.separator */);
+    const splitterFunc = getSplitter(colUnits, separator);
+    for (let row = 0; row < columnLength; ++row) {
+        const macroMolecule = macroMolCol.get(row);
+        // todo: handle the exception case when macroMolecule is null
+        result[row] = macroMolecule ? splitterFunc(macroMolecule) : [];
+    }
+    return result;
+}
+/* Get a mapping of monomer symbols to MolGraph objects */
+function getMonomersDict(monomerSequencesArray, monomersLibList, polymerType, alphabet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // todo: exception - no gaps, no empty string monomers
+        const formattedMonomerLib = getFormattedMonomerLib(monomersLibList, polymerType, alphabet);
+        const monomersDict = new Map();
+        const moduleRdkit = yield grok.functions.call('Chem:getRdKitModule');
+        // add deoxyribose/ribose and phosphate for nucleotide sequences
+        if (polymerType === "RNA" /* HELM_POLYMER_TYPE.RNA */) {
+            const symbols = (alphabet === "RNA" /* ALPHABET.RNA */) ?
+                [RIBOSE, PHOSPHATE] : [DEOXYRIBOSE, PHOSPHATE];
+            for (const sym of symbols)
+                updateMonomersDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType);
+        }
+        for (let row = 0; row < monomerSequencesArray.length; ++row) {
+            const monomerSeq = monomerSequencesArray[row];
+            for (const sym of monomerSeq)
+                updateMonomersDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType);
+        }
+        // console.log(monomersDict);
+        return monomersDict;
+    });
+}
+/* Adds MolGraph object for 'sym' to the monomers dict when necessary  */
+function updateMonomersDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType) {
+    if (!monomersDict.has(sym)) {
+        const monomerData = getMolGraph(sym, formattedMonomerLib, moduleRdkit, polymerType);
+        if (monomerData)
+            monomersDict.set(sym, monomerData);
+        else
+            throw new Error(`Monomer with symbol '${sym}' is absent the monomer library`);
+        // todo: handle exception
+    }
+}
+/* Construct the MolGraph object for specified monomerSymbol: the associated
+ * graph is adjusted in XY plane and filled with default R-groups */
+function getMolGraph(monomerSymbol, formattedMonomerLib, moduleRdkit, polymerType // todo: specify type for moduleRdkit
+) {
+    if (!formattedMonomerLib.has(monomerSymbol)) {
+        return null;
+    }
+    else {
+        const libObject = formattedMonomerLib.get(monomerSymbol);
+        const capGroups = parseCapGroups(libObject["rgroups" /* HELM_FIELDS.RGROUPS */]);
+        const capGroupIdxMap = parseCapGroupIdxMap(libObject["molfile" /* HELM_FIELDS.MOLFILE */]);
+        const molfileV3K = convertMolfileToV3K(removeRGroupLines(libObject["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 };
+        if (polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */) {
+            adjustPeptideMonomerGraph(monomerGraph);
+        }
+        else { // nucleotides
+            if (monomerSymbol === RIBOSE || monomerSymbol === DEOXYRIBOSE)
+                adjustSugarMonomerGraph(monomerGraph);
+            else if (monomerSymbol === PHOSPHATE)
+                adjustPhosphateMonomerGraph(monomerGraph);
+            else
+                adjustBaseMonomerGraph(monomerGraph);
+        }
+        // remove the 'rightmost' chain-extending r-group node in the backbone
+        if (polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */) {
+            setShifts(monomerGraph, polymerType);
+            removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);
+        }
+        else { // nucleotides
+            if (monomerSymbol === RIBOSE || monomerSymbol === DEOXYRIBOSE) {
+                // remove R2
+                removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);
+                // set terminalNode2 (oxygen) as new R2
+                monomerGraph.meta.rNodes[1] = monomerGraph.meta.terminalNodes[1];
+                setTerminalNodes(monomerGraph.bonds, monomerGraph.meta); // set terminal nodes anew
+                setShifts(monomerGraph, polymerType);
+                // remove 'new' R2 (oxygen)
+                removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);
+                // remove R1
+                removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[0]);
+                // remove the branching r-group
+                removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[2]);
+            }
+            else if (monomerSymbol === 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);
+                removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);
+            }
+            else { // nucleobases
+                removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[0]);
+            }
+        }
+        removeHydrogen(monomerGraph);
+        return monomerGraph;
+    }
+}
+// todo: doc
+function getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap) {
+    const meta = {
+        backboneShift: null,
+        branchShift: null,
+        terminalNodes: [],
+        rNodes: [],
+    };
+    substituteCapGroups(atoms, capGroups, capGroupIdxMap);
+    setRNodes(capGroupIdxMap, meta);
+    setTerminalNodes(bonds, meta);
+    return meta;
+}
+/* Parse element symbols for R-groups from the HELM monomer library R-groups
+ * field  */
+export function parseCapGroups(rGroupObjList) {
+    // specifically for HELMCoreLibrary
+    // considered only monoatomic rgroups
+    // supposing that elements in rGroupObjList are sorted w.r.t. the rgroups idx
+    // todo: possible generalizations
+    const capGroupsArray = [];
+    for (const obj of rGroupObjList) {
+        let capGroup = obj["capGroupSmiles" /* RGROUP_FIELDS.CAP_GROUP_SMILES */];
+        // in some cases the smiles field is written with uppercase
+        if (!capGroup)
+            capGroup = obj["capGroupSMILES" /* RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE */];
+        // todo: verify that there are no multi-element cap groups, or consider how to
+        // transform them
+        capGroup = capGroup.replace(/(\[|\]|\*|:|\d)/g, '');
+        if (capGroup.length > 1) // todo: check if such cases are possible, remove if not
+            throw new Error('Default cap group has length more than one');
+        capGroupsArray.push(capGroup);
+    }
+    return capGroupsArray;
+}
+/* Substitute the cap group elements instead of R# */
+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
+}
+//todo: doc
+function setRNodes(capGroupIdxMap, meta) {
+    meta.rNodes = Array.from(capGroupIdxMap.keys());
+    for (let i = 0; i < meta.rNodes.length; i++) {
+        for (const j of [1, 2]) { // 1 and 2 by def. correspond to 'left/rightmost' r-nodes
+            // swap the values if necessary, so that the "leftmost" r-node is at 0,
+            // and the 'rightmost', at 1
+            if (capGroupIdxMap.get(meta.rNodes[i]) === j) {
+                const tmp = meta.rNodes[j - 1];
+                meta.rNodes[j - 1] = meta.rNodes[i];
+                meta.rNodes[i] = tmp;
+            }
+        }
+    }
+}
+//todo: doc
+function setTerminalNodes(bonds, meta) {
+    const rNodes = meta.rNodes;
+    meta.terminalNodes = new Array(rNodes.length).fill(0);
+    const terminalNodes = meta.terminalNodes;
+    const atomPairs = bonds.atomPairs;
+    let i = 0;
+    let j = 0;
+    while ((i < atomPairs.length) && j < terminalNodes.length) {
+        // rNodes array is sorted so that its 0th and 1st elements (if both
+        // present) correspond to the chain extending (i.e. not branching) r-groups
+        for (let k = 0; k < terminalNodes.length; ++k) {
+            for (let l = 0; l < 2; ++l) {
+                if (atomPairs[i][l] === rNodes[k]) {
+                    terminalNodes[k] = atomPairs[i][(l + 1) % 2];
+                    if (rNodes.length > 2) {
+                    }
+                    ++j;
+                }
+            }
+        }
+        ++i;
+    }
+}
+//todo: doc
+function setShifts(molGraph, polymerType) {
+    if (molGraph.meta.rNodes.length > 1) {
+        molGraph.meta.backboneShift = [
+            keepPrecision(molGraph.atoms.x[molGraph.meta.rNodes[1] - 1] -
+                molGraph.atoms.x[molGraph.meta.terminalNodes[0] - 1]),
+            keepPrecision(molGraph.atoms.y[molGraph.meta.rNodes[1] - 1] -
+                molGraph.atoms.y[molGraph.meta.terminalNodes[0] - 1]),
+        ];
+    }
+    if (polymerType === "RNA" /* HELM_POLYMER_TYPE.RNA */ && molGraph.meta.rNodes.length > 2) {
+        molGraph.meta.branchShift = [
+            keepPrecision(molGraph.atoms.x[molGraph.meta.rNodes[2] - 1] -
+                molGraph.atoms.x[molGraph.meta.terminalNodes[0] - 1]),
+            keepPrecision(molGraph.atoms.y[molGraph.meta.rNodes[2] - 1] -
+                molGraph.atoms.y[molGraph.meta.terminalNodes[0] - 1]),
+        ];
+    }
+}
+/* Helper function necessary to build a correct V3000 molfile out of V2000 with
+ * specified r-groups*/
+function removeRGroupLines(molfileV2K) {
+    let begin = molfileV2K.indexOf(V2K_A_LINE, 0);
+    if (begin === -1)
+        begin = molfileV2K.indexOf(V2K_RGP_LINE);
+    const end = molfileV2K.indexOf(V3K_END, begin);
+    return molfileV2K.substring(0, begin) + molfileV2K.substring(end);
+}
+/* V2000 to V3000 converter  */
+function convertMolfileToV3K(molfileV2K, moduleRdkit) {
+    // todo: type of moduleRdkit
+    // todo: consider the use of standard Chem converter (relies on creation of moduleRdkit on each iteration, though)
+    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) {
+    // todo: consider the case when there is no simple leftmost/rightmost choice
+    // todo: consider the case when there are multiple consequent M  RGP lines,
+    // like in HELMCoreLibrary nucleotides
+    const bondTypes = new Array(bondCount);
+    const atomPairs = new Array(bondCount);
+    const bondConfiguration = new Map();
+    const kwargs = new Map();
+    let begin = molfileV3K.indexOf(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;
+        end = molfileV3K.indexOf(' ', begin);
+        for (let k = 0; k < 3; ++k) {
+            begin = end + 1;
+            end = Math.min(molfileV3K.indexOf('\n', begin), molfileV3K.indexOf(' ', begin));
+            parsedValues[k] = parseInt(molfileV3K.slice(begin, end));
+        }
+        bondTypes[i] = parsedValues[0];
+        atomPairs[i] = parsedValues.slice(1);
+        // parse keyword arguments
+        const endOfLine = molfileV3K.indexOf('\n', begin);
+        let lineRemainder = molfileV3K.slice(end, endOfLine);
+        let beginCfg = lineRemainder.indexOf(V3K_BOND_CONFIG);
+        if (beginCfg !== -1) {
+            beginCfg = lineRemainder.indexOf('=', beginCfg) + 1;
+            let endCfg = lineRemainder.indexOf(' ', beginCfg);
+            if (endCfg === -1)
+                endCfg = lineRemainder.length;
+            const bondConfig = parseInt(lineRemainder.slice(beginCfg, endCfg));
+            bondConfiguration.set(i, bondConfig);
+            const removedSubstring = V3K_BOND_CONFIG + bondConfig.toString();
+            lineRemainder = lineRemainder.replace(removedSubstring, '');
+        }
+        if (!lineRemainder)
+            kwargs.set(i, lineRemainder);
+    }
+    return {
+        bondTypes: bondTypes,
+        atomPairs: atomPairs,
+        bondConfiguration: bondConfiguration,
+        kwargs: kwargs,
+    };
+}
+/* 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) {
+    const capGroupIdxMap = new Map();
+    // parse A-lines (RNA)
+    let begin = molfileV2K.indexOf(V2K_A_LINE, 0);
+    let end = begin;
+    while (begin !== -1) {
+        // parse the rNode to which the cap group is attached
+        end = molfileV2K.indexOf('\n', begin);
+        const rNode = parseInt(molfileV2K.substring(begin, end).replace(/^A\s+/, ''));
+        // parse the capGroup index
+        begin = molfileV2K.indexOf('R', end);
+        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);
+    }
+    // parse RGP lines (may be more than one in RNA monomers)
+    begin = molfileV2K.indexOf(V2K_RGP_LINE, 0);
+    end = molfileV2K.indexOf('\n', begin);
+    while (begin !== -1) {
+        begin += V2K_RGP_SHIFT;
+        end = molfileV2K.indexOf('\n', begin);
+        const rgpStringParsed = molfileV2K.substring(begin, end)
+            .replaceAll(/\s+/g, ' ')
+            .split(' ');
+        const rgpIndicesArray = rgpStringParsed.map((el) => parseInt(el))
+            .slice(1); // slice from 1 because the 1st value is the number of pairs in the line
+        for (let i = 0; i < rgpIndicesArray.length; i += 2) {
+            // notice: there may be conflicting cap group definitions, like 3-O-Methylribose (2,5 connectivity)
+            // (the last monomer in HELMCoreLibrary)
+            // there the indices of cap groups are self-contradictory
+            // todo: clarify why such situations occur in principle
+            if (capGroupIdxMap.has(rgpIndicesArray[i]) && capGroupIdxMap.get(rgpIndicesArray[i]) !== rgpIndicesArray[i + 1])
+                throw new Error(`r-group index ${rgpIndicesArray[i]} has already been added with a different value`);
+            else
+                capGroupIdxMap.set(rgpIndicesArray[i], rgpIndicesArray[i + 1]);
+        }
+        begin = molfileV2K.indexOf(V2K_RGP_LINE, end);
+    }
+    return capGroupIdxMap;
+}
+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 end = molfileV3K.indexOf(' ', begin);
+    const numOfAtoms = parseInt(molfileV3K.substring(begin, end));
+    // parse bond count
+    begin = end + 1;
+    end = molfileV3K.indexOf(' ', begin);
+    const numOfBonds = parseInt(molfileV3K.substring(begin, end));
+    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 */
+function parseAtomBlock(molfileV3K, atomCount) {
+    const atomTypes = new Array(atomCount);
+    const x = new Array(atomCount);
+    const y = new Array(atomCount);
+    const kwargs = new Array(atomCount);
+    let begin = molfileV3K.indexOf(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;
+        end = molfileV3K.indexOf(' ', begin); // skip the idx row
+        // parse atom type
+        begin = end + 1;
+        end = molfileV3K.indexOf(' ', begin);
+        atomTypes[i] = molfileV3K.substring(begin, end);
+        // parse X and Y coordinates of the atom
+        const coordinate = new Array(2);
+        for (let k = 0; k < 2; ++k) {
+            begin = end + 1;
+            end = molfileV3K.indexOf(' ', begin);
+            coordinate[k] = parseFloat(molfileV3K.substring(begin, end));
+        }
+        x[i] = coordinate[0];
+        y[i] = coordinate[1];
+        // parse the remaining possible keyword arguments
+        begin = end;
+        end = molfileV3K.indexOf('\n', begin) + 1;
+        kwargs[i] = molfileV3K.slice(begin, end);
+        begin = end;
+    }
+    return {
+        atomTypes: atomTypes,
+        x: x,
+        y: y,
+        kwargs: kwargs,
+    };
+}
+/* Remove hydrogen nodes */
+function removeHydrogen(monomerGraph) {
+    let i = 0;
+    while (i < monomerGraph.atoms.atomTypes.length) {
+        if (monomerGraph.atoms.atomTypes[i] === HYDROGEN) {
+            removeNodeAndBonds(monomerGraph, i + 1); // i + 1 because molfile node indexing starts from 1
+            --i;
+            // monomerGraph.atoms.atomTypes[i] = 'Li';
+        }
+        ++i;
+    }
+}
+/* Remove node 'removedNode' and the associated bonds. Notice, numeration of
+ * nodes in molfiles starts from 1, not 0 */
+function removeNodeAndBonds(monomerGraph, removedNode) {
+    if (typeof removedNode !== 'undefined') {
+        const removedNodeIdx = removedNode - 1;
+        const atoms = monomerGraph.atoms;
+        const bonds = monomerGraph.bonds;
+        const meta = monomerGraph.meta;
+        // remove the node from atoms
+        atoms.atomTypes.splice(removedNodeIdx, 1);
+        atoms.x.splice(removedNodeIdx, 1);
+        atoms.y.splice(removedNodeIdx, 1);
+        atoms.kwargs.splice(removedNodeIdx, 1);
+        // update the values of terminal and r-group nodes if necessary
+        for (let i = 0; i < meta.terminalNodes.length; ++i) {
+            if (meta.terminalNodes[i] > removedNode)
+                --meta.terminalNodes[i];
+            else if (meta.terminalNodes[i] === removedNode)
+                meta.terminalNodes[i] = -1; // sentinel to mark the value as removed
+        }
+        for (let i = 0; i < meta.rNodes.length; ++i) {
+            if (meta.rNodes[i] > removedNode)
+                --meta.rNodes[i];
+            else if (meta.rNodes[i] === removedNode)
+                meta.rNodes[i] = -1; // sentinel to mark the value as removed
+        }
+        // update indices of atoms in bonds
+        let i = 0;
+        while (i < bonds.atomPairs.length) {
+            const firstAtom = bonds.atomPairs[i][0];
+            const secondAtom = bonds.atomPairs[i][1];
+            if (firstAtom === removedNode || secondAtom === removedNode) {
+                bonds.atomPairs.splice(i, 1);
+                bonds.bondTypes.splice(i, 1);
+                if (bonds.bondConfiguration.has(i))
+                    bonds.bondConfiguration.delete(i);
+                if (bonds.kwargs.has(i))
+                    bonds.kwargs.delete(i);
+                --i;
+            }
+            else {
+                bonds.atomPairs[i][0] = (firstAtom > removedNode) ? firstAtom - 1 : firstAtom;
+                bonds.atomPairs[i][1] = (secondAtom > removedNode) ? secondAtom - 1 : secondAtom;
+            }
+            ++i;
+        }
+        // update bondConfiguration and kwargs keys
+        let keys = Array.from(bonds.bondConfiguration.keys());
+        keys.forEach((key) => {
+            if (bonds.bondConfiguration.has(key) && key > removedNodeIdx) {
+                const value = bonds.bondConfiguration.get(key);
+                bonds.bondConfiguration.delete(key);
+                bonds.bondConfiguration.set(key - 1, value);
+            }
+        });
+        keys = Array.from(bonds.kwargs.keys());
+        keys.forEach((key) => {
+            if (bonds.kwargs.has(key) && key > removedNodeIdx) {
+                const value = bonds.kwargs.get(key);
+                bonds.kwargs.delete(key);
+                bonds.kwargs.set(key - 1, value);
+            }
+        });
+    }
+}
+// todo: rewrite description
+/* Adjust the (peptide) monomer graph so that it has standard form  */
+function adjustPeptideMonomerGraph(monomer) {
+    const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1
+    const nodeTwoIdx = monomer.meta.rNodes[0] - 1;
+    const x = monomer.atoms.x;
+    const y = monomer.atoms.y;
+    // place nodeOne at origin
+    shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);
+    // angle is measured between OY and the rotated node
+    const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);
+    // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY
+    rotateCenteredGraph(monomer.atoms, -angle);
+    if (x[monomer.meta.rNodes[1] - 1] < 0)
+        flipMonomerAroundOY(monomer);
+    const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);
+    // flip carboxyl and R if necessary
+    flipCarboxylAndRadical(monomer, doubleBondedOxygen);
+    // flip hydroxyl group with double-bound O inside carboxyl group if necessary
+    flipHydroxilGroup(monomer, doubleBondedOxygen);
+}
+function adjustPhosphateMonomerGraph(monomer) {
+    const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1
+    const nodeTwoIdx = monomer.meta.rNodes[0] - 1;
+    const x = monomer.atoms.x;
+    const y = monomer.atoms.y;
+    // place nodeOne at origin
+    shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);
+    // // angle is measured between OY and the rotated node
+    // const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);
+    // // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY
+    // rotateCenteredGraph(monomer.atoms, -angle);
+    // if (x[monomer.meta.rNodes[1] - 1] < 0)
+    //   flipMonomerAroundOY(monomer);
+    // const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);
+    // // flip carboxyl and R if necessary
+    // flipCarboxylAndRadical(monomer, doubleBondedOxygen);
+    // // flip hydroxyl group with double-bound O inside carboxyl group if necessary
+    // flipHydroxilGroup(monomer, doubleBondedOxygen);
+}
+function adjustSugarMonomerGraph(monomer) {
+    const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1
+    const nodeTwoIdx = monomer.meta.rNodes[0] - 1;
+    const x = monomer.atoms.x;
+    const y = monomer.atoms.y;
+    // place nodeOne at origin
+    shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);
+    // // angle is measured between OY and the rotated node
+    // const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);
+    // // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY
+    // rotateCenteredGraph(monomer.atoms, -angle);
+    // if (x[monomer.meta.rNodes[1] - 1] < 0)
+    //   flipMonomerAroundOY(monomer);
+    // const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);
+    // // flip carboxyl and R if necessary
+    // flipCarboxylAndRadical(monomer, doubleBondedOxygen);
+    // // flip hydroxyl group with double-bound O inside carboxyl group if necessary
+    // flipHydroxilGroup(monomer, doubleBondedOxygen);
+}
+function adjustBaseMonomerGraph(monomer) {
+    const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1
+    const nodeTwoIdx = monomer.meta.rNodes[0] - 1;
+    const x = monomer.atoms.x;
+    const y = monomer.atoms.y;
+    // place nodeOne at origin
+    shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);
+    // // angle is measured between OY and the rotated node
+    // const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);
+    // // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY
+    // rotateCenteredGraph(monomer.atoms, -angle);
+    // if (x[monomer.meta.rNodes[1] - 1] < 0)
+    //   flipMonomerAroundOY(monomer);
+    // const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);
+    // // flip carboxyl and R if necessary
+    // flipCarboxylAndRadical(monomer, doubleBondedOxygen);
+    // // flip hydroxyl group with double-bound O inside carboxyl group if necessary
+    // flipHydroxilGroup(monomer, doubleBondedOxygen);
+}
+/* Flip carboxyl group with the radical in a peptide monomer in case the
+ * carboxyl group is in the lower half-plane */
+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 &&
+        monomer.atoms.y[doubleBondedOxygen - 1] < 0) {
+        flipMonomerAroundOX(monomer);
+        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) */
+function findAngleWithOY(x, y) {
+    let angle;
+    if (x === 0) {
+        angle = y > 0 ? 0 : Math.PI;
+    }
+    else if (y === 0) {
+        angle = x > 0 ? -Math.PI / 2 : Math.PI / 2;
+    }
+    else {
+        const tan = y / x;
+        const atan = Math.atan(tan);
+        angle = (x < 0) ? Math.PI / 2 + atan : -Math.PI / 2 + atan;
+    }
+    return angle;
+}
+/* Finds angle between OX and the ray joining origin with (x, y) */
+function findAngleWithOX(x, y) {
+    return findAngleWithOY(x, y) + Math.PI / 2;
+}
+/*  Rotate the graph around the origin by 'angle' */
+function rotateCenteredGraph(atoms, angle) {
+    if (angle !== 0) {
+        const x = atoms.x;
+        const y = atoms.y;
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        for (let i = 0; i < x.length; ++i) {
+            const tmp = x[i];
+            x[i] = keepPrecision(tmp * cos - y[i] * sin);
+            y[i] = keepPrecision(tmp * sin + y[i] * cos);
+        }
+    }
+}
+/* Flip monomer graph around OX axis preserving stereometry */
+function flipMonomerAroundOX(monomer) {
+    flipMolGraph(monomer, true);
+}
+/* Flip monomer graph around OY axis preserving stereometry */
+function flipMonomerAroundOY(monomer) {
+    flipMolGraph(monomer, false);
+}
+/* Flip graph around a specified axis: 'true' corresponds to OX, 'false' to OY */
+function flipMolGraph(molGraph, axis) {
+    if (axis) { // flipping around OX
+        const y = molGraph.atoms.y;
+        for (let i = 0; i < y.length; i++)
+            y[i] = -y[i];
+    }
+    else { // flipping around OY
+        const x = molGraph.atoms.x;
+        for (let i = 0; i < x.length; i++)
+            x[i] = -x[i];
+    }
+    // preserve the stereometry
+    const orientation = molGraph.bonds.bondConfiguration;
+    for (const [key, value] of orientation) {
+        const newValue = value === 1 ? 3 : 1;
+        orientation.set(key, newValue);
+    }
+}
+/* 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  */
+function flipHydroxilGroup(monomer, doubleBondedOxygen) {
+    const x = monomer.atoms.x;
+    // -1 below because indexing of nodes in molfiles starts from 1, unlike arrays
+    if (x[monomer.meta.rNodes[1] - 1] > x[doubleBondedOxygen - 1])
+        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  */
+function findDoubleBondedCarbonylOxygen(monomer) {
+    const bondsMap = constructBondsMap(monomer);
+    let doubleBondedOxygen = 0;
+    let i = 0;
+    // 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])
+            doubleBondedOxygen = node;
+        i++;
+    }
+    return doubleBondedOxygen;
+}
+/* Swap the Cartesian coordinates of the two specified nodes in MolGraph  */
+function swapNodes(monomer, nodeOne, nodeTwo) {
+    const nodeOneIdx = nodeOne - 1;
+    const nodeTwoIdx = nodeTwo - 1;
+    const x = monomer.atoms.x;
+    const y = monomer.atoms.y;
+    const tmpX = x[nodeOneIdx];
+    const tmpY = y[nodeOneIdx];
+    x[nodeOneIdx] = x[nodeTwoIdx];
+    y[nodeOneIdx] = y[nodeTwoIdx];
+    x[nodeTwoIdx] = tmpX;
+    y[nodeTwoIdx] = tmpY;
+}
+// todo: doc
+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);
+            else
+                map.set(key, new Array(1).fill(value));
+        }
+    }
+    return map;
+}
+/* Shift molGraph in the XOY plane  */
+function shiftCoordinates(molGraph, xShift, yShift) {
+    const x = molGraph.atoms.x;
+    const y = molGraph.atoms.y;
+    for (let i = 0; i < x.length; ++i) {
+        x[i] = keepPrecision(x[i] + xShift);
+        if (typeof yShift !== 'undefined')
+            y[i] = keepPrecision(y[i] + yShift);
+    }
+}
+/* Translate a sequence of monomer symbols into Molfile V3000 */
+function monomerSeqToMolfile(monomerSeq, monomersDict, alphabet, polymerType) {
+    // todo: handle the case when the polymer is empty
+    if (monomerSeq.length === 0)
+        throw new Error('monomerSeq is empty');
+    // define atom and bond counts, taking into account the bond type
+    const { atomCount, bondCount } = getResultingAtomBondCounts(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;
+    let capMolblock;
+    let nodeShiftInitValue;
+    let bondShiftInitValue;
+    let sugar = null;
+    let phosphate = null;
+    if (polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */) {
+        addMonomerToMolblock = addAminoAcidToMolblock;
+        capMolblock = capPeptideMolblock;
+        nodeShiftInitValue = bondShiftInitValue = 0;
+    }
+    else { // nucleotides
+        addMonomerToMolblock = addNucleotideToMolblock;
+        capMolblock = capPeptideMolblock; // todo: cleanup & refactor
+        nodeShiftInitValue = 0;
+        bondShiftInitValue = 0;
+        sugar = (alphabet === "DNA" /* ALPHABET.DNA */) ? monomersDict.get(DEOXYRIBOSE) : monomersDict.get(RIBOSE);
+        phosphate = monomersDict.get(PHOSPHATE);
+    }
+    const v = {
+        i: 0,
+        nodeShift: nodeShiftInitValue,
+        bondShift: bondShiftInitValue,
+        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);
+    }
+    capMolblock(molfileAtomBlock, molfileBondBlock, v, C);
+    const molfileCountsLine = V3K_BEGIN_COUNTS_LINE + atomCount + ' ' + bondCount + V3K_COUNTS_LINE_ENDING;
+    // todo: optimize concatenation using Alexander's hint
+    const molfileParts = [
+        V3K_HEADER_FIRST_LINE,
+        V3K_HEADER_SECOND_LINE,
+        V3K_BEGIN_CTAB_BLOCK,
+        molfileCountsLine,
+        V3K_BEGIN_ATOM_BLOCK,
+        molfileAtomBlock.join(''),
+        V3K_END_ATOM_BLOCK,
+        V3K_BEGIN_BOND_BLOCK,
+        molfileBondBlock.join(''),
+        V3K_END_BOND_BLOCK,
+        V3K_END_CTAB_BLOCK,
+        V3K_END,
+    ];
+    return molfileParts.join('');
+}
+// todo: doc
+function capPeptideMolblock(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';
+}
+// todo: doc
+function addAminoAcidToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C) {
+    v.flipFactor = Math.pow((-1), (v.i % 2)); // to flip every even monomer over OX
+    addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C);
+}
+function addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C) {
+    // 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, C);
+}
+// todo: doc
+function addNucleotideToMolblock(nucleobase, molfileAtomBlock, molfileBondBlock, v, C) {
+    // construnct the lines of V3K molfile atom block corresponding to phosphate
+    // and sugar
+    for (const monomer of [C.phosphate, C.sugar])
+        addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C);
+    addBranchMonomerToMolblock(nucleobase, molfileAtomBlock, molfileBondBlock, v, C);
+}
+function addBranchMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C) {
+    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, C) {
+    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) {
+        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 and sugar per each nucleobase symbol
+        atomCount += monomerSeq.length * (phosphate.atoms.x.length + sugar.atoms.x.length);
+        // add the leftmost cap group 'OH' (i.e. 'O') to the first phosphate
+        atomCount += 1;
+        // add bonds from phosphate and sugar
+        bondCount += monomerSeq.length * (phosphate.bonds.bondTypes.length + sugar.bonds.bondTypes.length);
+        // 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) {
+    // counts line
+    const atomType = molGraph.atoms.atomTypes;
+    const x = molGraph.atoms.x;
+    const y = molGraph.atoms.y;
+    const atomKwargs = molGraph.atoms.kwargs;
+    const bondType = molGraph.bonds.bondTypes;
+    const atomPair = molGraph.bonds.atomPairs;
+    const bondKwargs = molGraph.bonds.kwargs;
+    const bondConfig = molGraph.bonds.bondConfiguration;
+    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;
+    // atom block
+    let molfileAtomBlock = '';
+    for (let i = 0; i < atomCount; ++i) {
+        const atomIdx = i + 1;
+        const coordinate = [x[i].toString(), y[i].toString()];
+        // format coordinates so that they have 6 digits after decimal point
+        // for (let k = 0; k < 2; ++k) {
+        //   const formatted = coordinate[k].toString().split('.');
+        //   if (formatted.length === 1)
+        //     formatted.push('0');
+        //   formatted[1] = formatted[1].padEnd(V3K_ATOM_COORDINATE_PRECISION, '0');
+        //   coordinate[k] = formatted.join('.');
+        // }
+        const atomLine = V3K_BEGIN_DATA_LINE + atomIdx + ' ' + atomType[i] + ' ' +
+            coordinate[0] + ' ' + coordinate[1] + ' ' + atomKwargs[i];
+        molfileAtomBlock += atomLine;
+    }
+    // bond block
+    let molfileBondBlock = '';
+    for (let i = 0; i < bondCount; ++i) {
+        const bondIdx = i + 1;
+        const firstAtom = atomPair[i][0];
+        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] + ' ' +
+            firstAtom + ' ' + secondAtom + bondCfg + kwargs + '\n';
+        molfileBondBlock += bondLine;
+    }
+    const molfileParts = [
+        V3K_HEADER_FIRST_LINE,
+        V3K_HEADER_SECOND_LINE,
+        V3K_BEGIN_CTAB_BLOCK,
+        molfileCountsLine,
+        V3K_BEGIN_ATOM_BLOCK,
+        molfileAtomBlock,
+        V3K_END_ATOM_BLOCK,
+        V3K_BEGIN_BOND_BLOCK,
+        molfileBondBlock,
+        V3K_END_BOND_BLOCK,
+        V3K_END_CTAB_BLOCK,
+        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;
+    });
+}
+/* Get the V3K molfile corresponding to the capped Monomer (default cap groups)  */
+export function capPeptideMonomer(monomer) {
+    const funcList = DG.Func.find({ package: 'Chem', name: 'getRdKitModule' });
+    const moduleRdkit = funcList[0].apply();
+    const capGroups = parseCapGroups(monomer["rgroups" /* HELM_FIELDS.RGROUPS */]);
+    const capGroupIdxMap = parseCapGroupIdxMap(monomer["molfile" /* HELM_FIELDS.MOLFILE */]);
+    const molfileV3K = convertMolfileToV3K(removeRGroupLines(monomer["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 };
+    adjustPeptideMonomerGraph(monomerGraph);
+    const molfile = convertMolGraphToMolfileV3K(monomerGraph);
+    return molfile;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"to-atomic-level.js","sourceRoot":"","sources":["to-atomic-level.ts"],"names":[],"mappings":"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","sourcesContent":["/* Do not change these import lines to match external modules in webpack configuration */\nimport * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\nimport {HELM_FIELDS, HELM_CORE_FIELDS, HELM_POLYMER_TYPE, HELM_MONOMER_TYPE, RGROUP_FIELDS} from '../utils/const';\nimport {ALPHABET, getSplitter, NOTATION, SplitterFunc, TAGS} from '../utils/macromolecule';\nimport {UnitsHandler} from '../utils/units-handler';\nimport {NotationConverter} from '../utils/notation-converter';\nimport {Monomer} from '../types';\n\n// constants for parsing molfile V2000\nconst V2K_RGP_SHIFT = 8;\nconst V2K_RGP_LINE = 'M  RGP';\nconst V2K_A_LINE = 'A  ';\n\n// constants for parsing/reconstruction of molfile V3000\nconst V3K_COUNTS_SHIFT = 14;\nconst V3K_IDX_SHIFT = 7;\nconst V3K_HEADER_FIRST_LINE = '\\nDatagrok macromolecule handler\\n\\n';\nconst V3K_HEADER_SECOND_LINE = '  0  0  0  0  0  0            999 V3000\\n';\nconst V3K_BEGIN_CTAB_BLOCK = 'M  V30 BEGIN CTAB\\n';\nconst V3K_END_CTAB_BLOCK = 'M  V30 END CTAB\\n';\nconst V3K_BEGIN_COUNTS_LINE = 'M  V30 COUNTS ';\nconst V3K_COUNTS_LINE_ENDING = ' 0 0 0\\n';\nconst V3K_BEGIN_ATOM_BLOCK = 'M  V30 BEGIN ATOM\\n';\nconst V3K_END_ATOM_BLOCK = 'M  V30 END ATOM\\n';\nconst V3K_BEGIN_BOND_BLOCK = 'M  V30 BEGIN BOND\\n';\nconst V3K_END_BOND_BLOCK = 'M  V30 END BOND\\n';\nconst V3K_BOND_CONFIG = ' CFG=';\nconst V3K_BEGIN_DATA_LINE = 'M  V30 ';\nconst V3K_END = 'M  END\\n';\n\nconst PRECISION_FACTOR = 10_000; // HELMCoreLibrary has 4 significant digits after decimal point in atom coordinates\n\n// symbols for the corresponding monomers in HELM library\nconst DEOXYRIBOSE = 'd';\nconst RIBOSE = 'r';\nconst PHOSPHATE = 'p';\n\nconst OXYGEN = 'O';\nconst HYDROGEN = 'H';\n\n/* Stores necessary data about atoms of a monomer parsed from Molfile */\ntype Atoms = {\n  /* element symbols for monomer's atoms */\n  atomTypes: string[],\n  /* Cartesian coordiantes of monomer's atoms */\n  x: number[], // todo: convert to Float32\n  y: number[],\n  /* V3K atom line may contain keyword args */\n  kwargs: string[],\n}\n\n/* Stores necessary data about bonds of a monomer parsed from Molfile */\ntype Bonds = {\n  /* bond types for all lines of Molfile bond block */\n  bondTypes: number[], // todo: convert to Ind32\n  /* Indices of all atom pairs, indexing starting from 1  */\n  atomPairs: number[][],\n  /* If a bond has CFG=... keyword argument, it is parsed and sotred as a\n   * value of the map, with the key being the bond's index  */\n  bondConfiguration: Map<number, number>,\n  /* V3K bond line may contain keyword args */\n  kwargs: Map<number, string>,\n}\n\n/* Metadata associated with the monomer necessary to restore the resulting\n * molfile  */\ntype MonomerMetadata = {\n  /* terminal nodes: 0-th corresponds to the \"leftmost\" one, 1st, to the \"rightmost\",\n   * e.g. N-terminus and C-terminus in peptides */\n  terminalNodes: number[],\n  /* r-group nodes: 0-th corresponds to the \"leftmost\" one, 1st, to the \"rightmost\" */\n  rNodes: number[],\n  /* shift from the origin to the next backbone, null for branch monomers */\n  backboneShift: number[] | null,\n  /* shift from the origin to the next branch, null for branch monomers */\n  branchShift: number[] | null\n}\n\ntype MolGraph = {\n  atoms: Atoms,\n  bonds: Bonds,\n  meta: MonomerMetadata,\n}\n\n/* Helper structure wrapping common arguments to several functions */\ntype LoopVariables = {\n  i: number,\n  nodeShift: number,\n  bondShift: number,\n  backbonePositionShift: number[],\n  backboneAttachNode: number; // node to which the next backbone is attached\n  branchPositionShift: number[],\n  branchAttachNode: number,\n  flipFactor: number,\n  // todo: should we consider representations other than planar?\n}\n\n/* Helper structure wrapping common arguments to several functions */\ntype LoopConstants = {\n  sugar: MolGraph | null,\n  phosphate: MolGraph | null,\n  seqLength: number,\n  atomCount: number,\n  bondCount: number,\n}\n\n// todo: verify that all functions have return types\n\n/* Convert Macromolecule column into Molecule column storing molfile V3000 with the help of a monomer library  */\nexport async function _toAtomicLevel(\n  df: DG.DataFrame, macroMolCol: DG.Column<string>, monomersLibList: any[]\n): Promise<void> {\n  if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'}).length === 0) {\n    grok.shell.warning('Transformation to atomic level requires package \"Chem\" installed.');\n    return;\n  }\n\n  if (macroMolCol.semType !== DG.SEMTYPE.MACROMOLECULE) {\n    grok.shell.warning(\n      `Only the ${DG.SEMTYPE.MACROMOLECULE} columns can be converted to atomic\n      level, the chosen column has semType ${macroMolCol.semType}`\n    );\n    return;\n  }\n\n  // convert 'helm' to 'separator' units\n  if (macroMolCol.getTag(DG.TAGS.UNITS) === NOTATION.HELM) {\n    const converter = new NotationConverter(macroMolCol);\n    const separator = '/';\n    macroMolCol = converter.convert(NOTATION.SEPARATOR, separator);\n  }\n\n  const alphabet = macroMolCol.getTag(TAGS.alphabet);\n\n  // determine the polymer type according to HELM specifications\n  let polymerType;\n  // todo: an exception from dart comes before this check if the alphabet is UN\n  if (alphabet === ALPHABET.PT) {\n    polymerType = HELM_POLYMER_TYPE.PEPTIDE;\n  } else if (alphabet === ALPHABET.RNA || alphabet === ALPHABET.DNA) {\n    polymerType = HELM_POLYMER_TYPE.RNA;\n  } else {\n    grok.shell.warning(\n      `Only PT, DNA and RNA alphabets are supported, while the selected column has ${polymerType} alphabet`\n    );\n    return;\n  }\n\n  const monomerSequencesArray: string[][] = getMonomerSequencesArray(macroMolCol);\n  // todo: consider separately backbone, terminal, branch monomer types\n  const monomersDict = await getMonomersDict(monomerSequencesArray, monomersLibList, polymerType, alphabet);\n  const columnLength = macroMolCol.length;\n  const reconstructed: string[] = new Array(columnLength);\n  for (let row = 0; row < columnLength; ++row) {\n    const monomerSeq = monomerSequencesArray[row];\n    reconstructed[row] = monomerSeqToMolfile(monomerSeq, monomersDict, alphabet, polymerType);\n    console.log(reconstructed[row]);\n  }\n\n  // exclude name collisions\n  const name = 'molfile(' + macroMolCol.name + ')';\n  const newColName = df.columns.getUnusedName(name);\n  const newCol = DG.Column.fromStrings(newColName, reconstructed);\n\n  newCol.semType = DG.SEMTYPE.MOLECULE;\n  newCol.setTag(DG.TAGS.UNITS, DG.UNITS.Molecule.MOLBLOCK);\n  df.columns.add(newCol, true);\n  await grok.data.detectSemanticTypes(df);\n}\n\n/* Get a mapping of peptide symbols to HELM monomer library objects with\n * selectted fields  */\nfunction getFormattedMonomerLib(\n  monomersLibList: any[], polymerType: HELM_POLYMER_TYPE, alphabet: ALPHABET\n): Map<string, any> {\n  const map = new Map<string, any>();\n  monomersLibList.forEach(\n    (it) => {\n      if (it[HELM_FIELDS.POLYMER_TYPE] === polymerType) {\n        if (\n          polymerType === HELM_POLYMER_TYPE.RNA &&\n          (it[HELM_FIELDS.MONOMER_TYPE] === HELM_MONOMER_TYPE.BRANCH ||\n            alphabet === ALPHABET.DNA && it[HELM_FIELDS.SYMBOL] === DEOXYRIBOSE ||\n            alphabet === ALPHABET.RNA && it[HELM_FIELDS.SYMBOL] === RIBOSE ||\n            it[HELM_FIELDS.SYMBOL] === PHOSPHATE) ||\n          polymerType === HELM_POLYMER_TYPE.PEPTIDE &&\n          it[HELM_FIELDS.MONOMER_TYPE] !== HELM_MONOMER_TYPE.BRANCH\n        ) {\n          const monomerObject: { [key: string]: any } = {};\n          HELM_CORE_FIELDS.forEach((field) => {\n            monomerObject[field] = it[field];\n          });\n          map.set(it[HELM_FIELDS.SYMBOL], monomerObject);\n        }\n      }\n    });\n  return map;\n}\n\n/* Get jagged array of monomer symbols for the dataframe  */\nfunction getMonomerSequencesArray(macroMolCol: DG.Column<string>): string[][] {\n  const columnLength = macroMolCol.length;\n  const result: string[][] = new Array(columnLength);\n\n  // split the string into monomers\n  const colUnits = macroMolCol.getTag(DG.TAGS.UNITS);\n  const separator = macroMolCol.getTag(TAGS.separator);\n  const splitterFunc: SplitterFunc = getSplitter(colUnits, separator);\n\n  for (let row = 0; row < columnLength; ++row) {\n    const macroMolecule = macroMolCol.get(row);\n    // todo: handle the exception case when macroMolecule is null\n    result[row] = macroMolecule ? splitterFunc(macroMolecule) : [];\n  }\n  return result;\n}\n\n/* Get a mapping of monomer symbols to MolGraph objects */\nasync function getMonomersDict(\n  monomerSequencesArray: string[][], monomersLibList: any[], polymerType: HELM_POLYMER_TYPE, alphabet: ALPHABET\n): Promise<Map<string, MolGraph>> {\n  // todo: exception - no gaps, no empty string monomers\n  const formattedMonomerLib = getFormattedMonomerLib(monomersLibList, polymerType, alphabet);\n  const monomersDict = new Map<string, MolGraph>();\n\n  const moduleRdkit = await grok.functions.call('Chem:getRdKitModule');\n\n  // add deoxyribose/ribose and phosphate for nucleotide sequences\n  if (polymerType === HELM_POLYMER_TYPE.RNA) {\n    const symbols = (alphabet === ALPHABET.RNA) ?\n      [RIBOSE, PHOSPHATE] : [DEOXYRIBOSE, PHOSPHATE];\n    for (const sym of symbols)\n      updateMonomersDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType);\n  }\n\n  for (let row = 0; row < monomerSequencesArray.length; ++row) {\n    const monomerSeq: string[] = monomerSequencesArray[row];\n    for (const sym of monomerSeq)\n      updateMonomersDict(monomersDict, sym, formattedMonomerLib, moduleRdkit, polymerType);\n  }\n  // console.log(monomersDict);\n\n  return monomersDict;\n}\n\n/* Adds MolGraph object for 'sym' to the monomers dict when necessary  */\nfunction updateMonomersDict(\n  monomersDict: Map<string, MolGraph>, sym: string,\n  formattedMonomerLib: Map<string, any>, moduleRdkit: any, polymerType: HELM_POLYMER_TYPE\n): void {\n  if (!monomersDict.has(sym)) {\n    const monomerData: MolGraph | null = getMolGraph(sym, formattedMonomerLib, moduleRdkit, polymerType);\n    if (monomerData)\n      monomersDict.set(sym, monomerData);\n    else\n      throw new Error(`Monomer with symbol '${sym}' is absent the monomer library`);\n    // todo: handle exception\n  }\n}\n\n/* Construct the MolGraph object for specified monomerSymbol: the associated\n * graph is adjusted in XY plane and filled with default R-groups */\nfunction getMolGraph(\n  monomerSymbol: string, formattedMonomerLib: Map<string, any>,\n  moduleRdkit: any, polymerType: HELM_POLYMER_TYPE // todo: specify type for moduleRdkit\n): MolGraph | null {\n  if (!formattedMonomerLib.has(monomerSymbol)) {\n    return null;\n  } else {\n    const libObject = formattedMonomerLib.get(monomerSymbol);\n    const capGroups = parseCapGroups(libObject[HELM_FIELDS.RGROUPS]);\n    const capGroupIdxMap = parseCapGroupIdxMap(libObject[HELM_FIELDS.MOLFILE]);\n    const molfileV3K = convertMolfileToV3K(removeRGroupLines(libObject[HELM_FIELDS.MOLFILE]), moduleRdkit);\n    const counts = parseAtomAndBondCounts(molfileV3K);\n\n    const atoms = parseAtomBlock(molfileV3K, counts.atomCount);\n    const bonds = parseBondBlock(molfileV3K, counts.bondCount);\n    const meta = getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap);\n\n    const monomerGraph: MolGraph = {atoms: atoms, bonds: bonds, meta: meta};\n\n    if (polymerType === HELM_POLYMER_TYPE.PEPTIDE) {\n      adjustPeptideMonomerGraph(monomerGraph);\n    } else { // nucleotides\n      if (monomerSymbol === RIBOSE || monomerSymbol === DEOXYRIBOSE)\n        adjustSugarMonomerGraph(monomerGraph);\n      else if (monomerSymbol === PHOSPHATE)\n        adjustPhosphateMonomerGraph(monomerGraph);\n      else\n        adjustBaseMonomerGraph(monomerGraph);\n    }\n\n    // remove the 'rightmost' chain-extending r-group node in the backbone\n    if (polymerType === HELM_POLYMER_TYPE.PEPTIDE) {\n      setShifts(monomerGraph, polymerType);\n      removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);\n    } else { // nucleotides\n      if (monomerSymbol === RIBOSE || monomerSymbol === DEOXYRIBOSE) {\n        // remove R2\n        removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);\n        // set terminalNode2 (oxygen) as new R2\n        monomerGraph.meta.rNodes[1] = monomerGraph.meta.terminalNodes[1];\n        setTerminalNodes(monomerGraph.bonds, monomerGraph.meta); // set terminal nodes anew\n        setShifts(monomerGraph, polymerType);\n        // remove 'new' R2 (oxygen)\n        removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);\n        // remove R1\n        removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[0]);\n        // remove the branching r-group\n        removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[2]);\n      } else if (monomerSymbol === PHOSPHATE) {\n        monomerGraph.meta.terminalNodes[0] = monomerGraph.meta.rNodes[0];\n        shiftCoordinates(\n          monomerGraph,\n          -monomerGraph.atoms.x[monomerGraph.meta.terminalNodes[0] - 1],\n          -monomerGraph.atoms.y[monomerGraph.meta.terminalNodes[0] - 1]\n        );\n        setShifts(monomerGraph, polymerType);\n        removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[1]);\n      } else { // nucleobases\n        removeNodeAndBonds(monomerGraph, monomerGraph.meta.rNodes[0]);\n      }\n    }\n    removeHydrogen(monomerGraph);\n\n    return monomerGraph;\n  }\n}\n\n// todo: doc\nfunction getMonomerMetadata(\n  atoms: Atoms, bonds: Bonds, capGroups: string[], capGroupIdxMap: Map<number, number>\n): MonomerMetadata {\n  const meta: MonomerMetadata = {\n    backboneShift: null,\n    branchShift: null,\n    terminalNodes: [],\n    rNodes: [],\n  };\n\n  substituteCapGroups(atoms, capGroups, capGroupIdxMap);\n  setRNodes(capGroupIdxMap, meta);\n  setTerminalNodes(bonds, meta);\n  return meta;\n}\n\n/* Parse element symbols for R-groups from the HELM monomer library R-groups\n * field  */\nexport function parseCapGroups(rGroupObjList: any[]): string[] {\n  // specifically for HELMCoreLibrary\n  // considered only monoatomic rgroups\n  // supposing that elements in rGroupObjList are sorted w.r.t. the rgroups idx\n  // todo: possible generalizations\n  const capGroupsArray: string[] = [];\n  for (const obj of rGroupObjList) {\n    let capGroup: string = obj[RGROUP_FIELDS.CAP_GROUP_SMILES];\n\n    // in some cases the smiles field is written with uppercase\n    if (!capGroup)\n      capGroup = obj[RGROUP_FIELDS.CAP_GROUP_SMILES_UPPERCASE];\n    // todo: verify that there are no multi-element cap groups, or consider how to\n    // transform them\n    capGroup = capGroup.replace(/(\\[|\\]|\\*|:|\\d)/g, '');\n    if (capGroup.length > 1) // todo: check if such cases are possible, remove if not\n      throw new Error('Default cap group has length more than one');\n    capGroupsArray.push(capGroup);\n  }\n  return capGroupsArray;\n}\n\n/* Substitute the cap group elements instead of R# */\nfunction substituteCapGroups(\n  atoms: Atoms, capGroups: string[], capGroupIdxMap: Map<number, number>\n): void {\n  for (const [node, capIdx] of capGroupIdxMap)\n    atoms.atomTypes[node - 1] = capGroups[capIdx - 1]; // -1 because molfile indexing starts from 1\n}\n\n//todo: doc\nfunction setRNodes(capGroupIdxMap: Map<number, number>, meta: MonomerMetadata): void {\n  meta.rNodes = Array.from(capGroupIdxMap.keys());\n  for (let i = 0; i < meta.rNodes.length; i++) {\n    for (const j of [1, 2]) { // 1 and 2 by def. correspond to 'left/rightmost' r-nodes\n      // swap the values if necessary, so that the \"leftmost\" r-node is at 0,\n      // and the 'rightmost', at 1\n      if (capGroupIdxMap.get(meta.rNodes[i]) === j) {\n        const tmp = meta.rNodes[j - 1];\n        meta.rNodes[j - 1] = meta.rNodes[i];\n        meta.rNodes[i] = tmp;\n      }\n    }\n  }\n}\n\n//todo: doc\nfunction setTerminalNodes(bonds: Bonds, meta: MonomerMetadata): void {\n  const rNodes = meta.rNodes;\n  meta.terminalNodes = new Array<number>(rNodes.length).fill(0);\n  const terminalNodes = meta.terminalNodes;\n  const atomPairs = bonds.atomPairs;\n  let i = 0;\n  let j = 0;\n  while ((i < atomPairs.length) && j < terminalNodes.length) {\n    // rNodes array is sorted so that its 0th and 1st elements (if both\n    // present) correspond to the chain extending (i.e. not branching) r-groups\n    for (let k = 0; k < terminalNodes.length; ++k) {\n      for (let l = 0; l < 2; ++l) {\n        if (atomPairs[i][l] === rNodes[k]) {\n          terminalNodes[k] = atomPairs[i][(l + 1) % 2];\n          if (rNodes.length > 2) {\n          }\n          ++j;\n        }\n      }\n    }\n    ++i;\n  }\n}\n\n//todo: doc\nfunction setShifts(molGraph: MolGraph, polymerType: HELM_POLYMER_TYPE): void {\n  if (molGraph.meta.rNodes.length > 1) {\n    molGraph.meta.backboneShift = [\n      keepPrecision(\n        molGraph.atoms.x[molGraph.meta.rNodes[1] - 1] -\n        molGraph.atoms.x[molGraph.meta.terminalNodes[0] - 1]\n      ),\n      keepPrecision(\n        molGraph.atoms.y[molGraph.meta.rNodes[1] - 1] -\n        molGraph.atoms.y[molGraph.meta.terminalNodes[0] - 1]\n      ),\n    ];\n  }\n\n  if (polymerType === HELM_POLYMER_TYPE.RNA && molGraph.meta.rNodes.length > 2) {\n    molGraph.meta.branchShift = [\n      keepPrecision(\n        molGraph.atoms.x[molGraph.meta.rNodes[2] - 1] -\n        molGraph.atoms.x[molGraph.meta.terminalNodes[0] - 1]\n      ),\n      keepPrecision(\n        molGraph.atoms.y[molGraph.meta.rNodes[2] - 1] -\n        molGraph.atoms.y[molGraph.meta.terminalNodes[0] - 1]\n      ),\n    ];\n  }\n}\n\n/* Helper function necessary to build a correct V3000 molfile out of V2000 with\n * specified r-groups*/\nfunction removeRGroupLines(molfileV2K: string): string {\n  let begin = molfileV2K.indexOf(V2K_A_LINE, 0);\n  if (begin === -1)\n    begin = molfileV2K.indexOf(V2K_RGP_LINE);\n  const end = molfileV2K.indexOf(V3K_END, begin);\n  return molfileV2K.substring(0, begin) + molfileV2K.substring(end);\n}\n\n/* V2000 to V3000 converter  */\nfunction convertMolfileToV3K(molfileV2K: string, moduleRdkit: any): string {\n  // todo: type of moduleRdkit\n  // todo: consider the use of standard Chem converter (relies on creation of moduleRdkit on each iteration, though)\n  const molObj = moduleRdkit.get_mol(molfileV2K);\n  const molfileV3K = molObj.get_v3Kmolblock();\n  molObj.delete();\n  return molfileV3K;\n}\n\n/* Parse V3000 bond block and construct the Bonds object */\nfunction parseBondBlock(molfileV3K: string, bondCount: number): Bonds {\n  // todo: consider the case when there is no simple leftmost/rightmost choice\n  // todo: consider the case when there are multiple consequent M  RGP lines,\n  // like in HELMCoreLibrary nucleotides\n\n  const bondTypes: number[] = new Array(bondCount);\n  const atomPairs: number[][] = new Array(bondCount);\n  const bondConfiguration = new Map<number, number>();\n  const kwargs = new Map<number, string>();\n\n  let begin = molfileV3K.indexOf(V3K_BEGIN_BOND_BLOCK);\n  begin = molfileV3K.indexOf('\\n', begin);\n  let end = begin;\n  for (let i = 0; i < bondCount; ++i) {\n    // parse bond type and atom pair\n    const parsedValues: number[] = new Array(3);\n    begin = molfileV3K.indexOf(V3K_BEGIN_DATA_LINE, end) + V3K_IDX_SHIFT;\n    end = molfileV3K.indexOf(' ', begin);\n    for (let k = 0; k < 3; ++k) {\n      begin = end + 1;\n      end = Math.min(molfileV3K.indexOf('\\n', begin), molfileV3K.indexOf(' ', begin));\n      parsedValues[k] = parseInt(molfileV3K.slice(begin, end));\n    }\n    bondTypes[i] = parsedValues[0];\n    atomPairs[i] = parsedValues.slice(1);\n\n    // parse keyword arguments\n    const endOfLine = molfileV3K.indexOf('\\n', begin);\n    let lineRemainder = molfileV3K.slice(end, endOfLine);\n    let beginCfg = lineRemainder.indexOf(V3K_BOND_CONFIG);\n    if (beginCfg !== -1) {\n      beginCfg = lineRemainder.indexOf('=', beginCfg) + 1;\n      let endCfg = lineRemainder.indexOf(' ', beginCfg);\n      if (endCfg === -1)\n        endCfg = lineRemainder.length;\n      const bondConfig = parseInt(lineRemainder.slice(beginCfg, endCfg));\n      bondConfiguration.set(i, bondConfig);\n      const removedSubstring = V3K_BOND_CONFIG + bondConfig.toString();\n      lineRemainder = lineRemainder.replace(removedSubstring, '');\n    }\n    if (!lineRemainder)\n      kwargs.set(i, lineRemainder);\n  }\n\n  return {\n    bondTypes: bondTypes,\n    atomPairs: atomPairs,\n    bondConfiguration: bondConfiguration,\n    kwargs: kwargs,\n  };\n}\n\n/* Constructs mapping of r-group nodes to default capGroups, all numeration starting from 1.\n * According to https://pubs.acs.org/doi/10.1021/ci3001925, R1 and R2 are the chain extending attachment points,\n * while R3 is the branching attachment point. */\nfunction parseCapGroupIdxMap(molfileV2K: string): Map<number, number> {\n  const capGroupIdxMap = new Map<number, number>();\n\n  // parse A-lines (RNA)\n  let begin = molfileV2K.indexOf(V2K_A_LINE, 0);\n  let end = begin;\n  while (begin !== -1) {\n    // parse the rNode to which the cap group is attached\n    end = molfileV2K.indexOf('\\n', begin);\n    const rNode = parseInt(molfileV2K.substring(begin, end).replace(/^A\\s+/, ''));\n\n    // parse the capGroup index\n    begin = molfileV2K.indexOf('R', end);\n    end = molfileV2K.indexOf('\\n', begin);\n    const capGroup = parseInt(molfileV2K.substring(begin, end).replace(/^R/, ''));\n    capGroupIdxMap.set(rNode, capGroup);\n\n    begin = molfileV2K.indexOf(V2K_A_LINE, end);\n  }\n\n  // parse RGP lines (may be more than one in RNA monomers)\n  begin = molfileV2K.indexOf(V2K_RGP_LINE, 0);\n  end = molfileV2K.indexOf('\\n', begin);\n  while (begin !== -1) {\n    begin += V2K_RGP_SHIFT;\n    end = molfileV2K.indexOf('\\n', begin);\n    const rgpStringParsed = molfileV2K.substring(begin, end)\n      .replaceAll(/\\s+/g, ' ')\n      .split(' ');\n    const rgpIndicesArray = rgpStringParsed.map((el) => parseInt(el))\n      .slice(1); // slice from 1 because the 1st value is the number of pairs in the line\n    for (let i = 0; i < rgpIndicesArray.length; i += 2) {\n      // notice: there may be conflicting cap group definitions, like 3-O-Methylribose (2,5 connectivity)\n      // (the last monomer in HELMCoreLibrary)\n      // there the indices of cap groups are self-contradictory\n      // todo: clarify why such situations occur in principle\n      if (capGroupIdxMap.has(rgpIndicesArray[i]) && capGroupIdxMap.get(rgpIndicesArray[i]) !== rgpIndicesArray[i + 1])\n        throw new Error(`r-group index ${rgpIndicesArray[i]} has already been added with a different value`);\n      else\n        capGroupIdxMap.set(rgpIndicesArray[i], rgpIndicesArray[i + 1]);\n    }\n\n    begin = molfileV2K.indexOf(V2K_RGP_LINE, end);\n  }\n\n  return capGroupIdxMap;\n}\n\nfunction parseAtomAndBondCounts(molfileV3K: string): { atomCount: number, bondCount: number } {\n  molfileV3K = molfileV3K.replaceAll('\\r', ''); // to handle old and new sdf standards\n\n  // parse atom count\n  let begin = molfileV3K.indexOf(V3K_BEGIN_COUNTS_LINE) + V3K_COUNTS_SHIFT;\n  let end = molfileV3K.indexOf(' ', begin);\n  const numOfAtoms = parseInt(molfileV3K.substring(begin, end));\n\n  // parse bond count\n  begin = end + 1;\n  end = molfileV3K.indexOf(' ', begin);\n  const numOfBonds = parseInt(molfileV3K.substring(begin, end));\n\n  return {atomCount: numOfAtoms, bondCount: numOfBonds};\n}\n\n/* Parse V3000 atom block and return Atoms object. NOTICE: only atomTypes, x, y\n * and kwargs fields are set in the return value, with other fields dummy */\nfunction parseAtomBlock(molfileV3K: string, atomCount: number): Atoms {\n  const atomTypes: string[] = new Array(atomCount);\n  const x: number[] = new Array(atomCount);\n  const y: number[] = new Array(atomCount);\n  const kwargs: string[] = new Array(atomCount);\n\n  let begin = molfileV3K.indexOf(V3K_BEGIN_ATOM_BLOCK); // V3000 atoms block\n  begin = molfileV3K.indexOf('\\n', begin);\n  let end = begin;\n\n  for (let i = 0; i < atomCount; i++) {\n    begin = molfileV3K.indexOf(V3K_BEGIN_DATA_LINE, begin) + V3K_IDX_SHIFT;\n    end = molfileV3K.indexOf(' ', begin); // skip the idx row\n\n    // parse atom type\n    begin = end + 1;\n    end = molfileV3K.indexOf(' ', begin);\n    atomTypes[i] = molfileV3K.substring(begin, end);\n\n    // parse X and Y coordinates of the atom\n    const coordinate: number[] = new Array(2);\n    for (let k = 0; k < 2; ++k) {\n      begin = end + 1;\n      end = molfileV3K.indexOf(' ', begin);\n      coordinate[k] = parseFloat(molfileV3K.substring(begin, end));\n    }\n    x[i] = coordinate[0];\n    y[i] = coordinate[1];\n\n    // parse the remaining possible keyword arguments\n    begin = end;\n    end = molfileV3K.indexOf('\\n', begin) + 1;\n    kwargs[i] = molfileV3K.slice(begin, end);\n\n    begin = end;\n  }\n\n  return {\n    atomTypes: atomTypes,\n    x: x,\n    y: y,\n    kwargs: kwargs,\n  };\n}\n\n/* Remove hydrogen nodes */\nfunction removeHydrogen(monomerGraph: MolGraph): void {\n  let i = 0;\n  while (i < monomerGraph.atoms.atomTypes.length) {\n    if (monomerGraph.atoms.atomTypes[i] === HYDROGEN) {\n      removeNodeAndBonds(monomerGraph, i + 1); // i + 1 because molfile node indexing starts from 1\n      --i;\n      // monomerGraph.atoms.atomTypes[i] = 'Li';\n    }\n    ++i;\n  }\n}\n\n/* Remove node 'removedNode' and the associated bonds. Notice, numeration of\n * nodes in molfiles starts from 1, not 0 */\nfunction removeNodeAndBonds(monomerGraph: MolGraph, removedNode?: number): void {\n  if (typeof removedNode !== 'undefined') {\n    const removedNodeIdx = removedNode - 1;\n    const atoms = monomerGraph.atoms;\n    const bonds = monomerGraph.bonds;\n    const meta = monomerGraph.meta;\n\n    // remove the node from atoms\n    atoms.atomTypes.splice(removedNodeIdx, 1);\n    atoms.x.splice(removedNodeIdx, 1);\n    atoms.y.splice(removedNodeIdx, 1);\n    atoms.kwargs.splice(removedNodeIdx, 1);\n\n    // update the values of terminal and r-group nodes if necessary\n    for (let i = 0; i < meta.terminalNodes.length; ++i) {\n      if (meta.terminalNodes[i] > removedNode)\n        --meta.terminalNodes[i];\n      else if (meta.terminalNodes[i] === removedNode)\n        meta.terminalNodes[i] = -1; // sentinel to mark the value as removed\n    }\n    for (let i = 0; i < meta.rNodes.length; ++i) {\n      if (meta.rNodes[i] > removedNode)\n        --meta.rNodes[i];\n      else if (meta.rNodes[i] === removedNode)\n        meta.rNodes[i] = -1; // sentinel to mark the value as removed\n    }\n\n    // update indices of atoms in bonds\n    let i = 0;\n    while (i < bonds.atomPairs.length) {\n      const firstAtom = bonds.atomPairs[i][0];\n      const secondAtom = bonds.atomPairs[i][1];\n      if (firstAtom === removedNode || secondAtom === removedNode) {\n        bonds.atomPairs.splice(i, 1);\n        bonds.bondTypes.splice(i, 1);\n        if (bonds.bondConfiguration.has(i))\n          bonds.bondConfiguration.delete(i);\n        if (bonds.kwargs.has(i))\n          bonds.kwargs.delete(i);\n        --i;\n      } else {\n        bonds.atomPairs[i][0] = (firstAtom > removedNode) ? firstAtom - 1 : firstAtom;\n        bonds.atomPairs[i][1] = (secondAtom > removedNode) ? secondAtom - 1 : secondAtom;\n      }\n      ++i;\n    }\n\n    // update bondConfiguration and kwargs keys\n    let keys = Array.from(bonds.bondConfiguration.keys());\n    keys.forEach((key) => {\n      if (bonds.bondConfiguration.has(key) && key > removedNodeIdx) {\n        const value = bonds.bondConfiguration.get(key)!;\n        bonds.bondConfiguration.delete(key);\n        bonds.bondConfiguration.set(key - 1, value);\n      }\n    });\n    keys = Array.from(bonds.kwargs.keys());\n    keys.forEach((key) => {\n      if (bonds.kwargs.has(key) && key > removedNodeIdx) {\n        const value = bonds.kwargs.get(key)!;\n        bonds.kwargs.delete(key);\n        bonds.kwargs.set(key - 1, value);\n      }\n    });\n  }\n}\n\n// todo: rewrite description\n/* Adjust the (peptide) monomer graph so that it has standard form  */\nfunction adjustPeptideMonomerGraph(monomer: MolGraph): void {\n  const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1\n  const nodeTwoIdx = monomer.meta.rNodes[0] - 1;\n  const x = monomer.atoms.x;\n  const y = monomer.atoms.y;\n\n  // place nodeOne at origin\n  shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);\n\n  // angle is measured between OY and the rotated node\n  const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);\n\n  // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY\n  rotateCenteredGraph(monomer.atoms, -angle);\n\n  if (x[monomer.meta.rNodes[1] - 1] < 0)\n    flipMonomerAroundOY(monomer);\n\n  const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);\n\n  // flip carboxyl and R if necessary\n  flipCarboxylAndRadical(monomer, doubleBondedOxygen);\n\n  // flip hydroxyl group with double-bound O inside carboxyl group if necessary\n  flipHydroxilGroup(monomer, doubleBondedOxygen);\n}\n\nfunction adjustPhosphateMonomerGraph(monomer: MolGraph): void {\n  const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1\n  const nodeTwoIdx = monomer.meta.rNodes[0] - 1;\n  const x = monomer.atoms.x;\n  const y = monomer.atoms.y;\n\n  // place nodeOne at origin\n  shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);\n\n  // // angle is measured between OY and the rotated node\n  // const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);\n\n  // // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY\n  // rotateCenteredGraph(monomer.atoms, -angle);\n\n  // if (x[monomer.meta.rNodes[1] - 1] < 0)\n  //   flipMonomerAroundOY(monomer);\n\n  // const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);\n\n  // // flip carboxyl and R if necessary\n  // flipCarboxylAndRadical(monomer, doubleBondedOxygen);\n\n  // // flip hydroxyl group with double-bound O inside carboxyl group if necessary\n  // flipHydroxilGroup(monomer, doubleBondedOxygen);\n}\n\nfunction adjustSugarMonomerGraph(monomer: MolGraph): void {\n  const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1\n  const nodeTwoIdx = monomer.meta.rNodes[0] - 1;\n  const x = monomer.atoms.x;\n  const y = monomer.atoms.y;\n\n  // place nodeOne at origin\n  shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);\n\n  // // angle is measured between OY and the rotated node\n  // const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);\n\n  // // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY\n  // rotateCenteredGraph(monomer.atoms, -angle);\n\n  // if (x[monomer.meta.rNodes[1] - 1] < 0)\n  //   flipMonomerAroundOY(monomer);\n\n  // const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);\n\n  // // flip carboxyl and R if necessary\n  // flipCarboxylAndRadical(monomer, doubleBondedOxygen);\n\n  // // flip hydroxyl group with double-bound O inside carboxyl group if necessary\n  // flipHydroxilGroup(monomer, doubleBondedOxygen);\n}\n\nfunction adjustBaseMonomerGraph(monomer: MolGraph): void {\n  const nodeOneIdx = monomer.meta.terminalNodes[0] - 1; // node indexing in molfiles starts from 1\n  const nodeTwoIdx = monomer.meta.rNodes[0] - 1;\n  const x = monomer.atoms.x;\n  const y = monomer.atoms.y;\n\n  // place nodeOne at origin\n  shiftCoordinates(monomer, -x[nodeOneIdx], -y[nodeOneIdx]);\n\n  // // angle is measured between OY and the rotated node\n  // const angle = findAngleWithOY(x[nodeTwoIdx], y[nodeTwoIdx]);\n\n  // // rotate the centered graph, so that 'nodeTwo' ends up on the positive ray of OY\n  // rotateCenteredGraph(monomer.atoms, -angle);\n\n  // if (x[monomer.meta.rNodes[1] - 1] < 0)\n  //   flipMonomerAroundOY(monomer);\n\n  // const doubleBondedOxygen = findDoubleBondedCarbonylOxygen(monomer);\n\n  // // flip carboxyl and R if necessary\n  // flipCarboxylAndRadical(monomer, doubleBondedOxygen);\n\n  // // flip hydroxyl group with double-bound O inside carboxyl group if necessary\n  // flipHydroxilGroup(monomer, doubleBondedOxygen);\n}\n\n/* Flip carboxyl group with the radical in a peptide monomer in case the\n * carboxyl group is in the lower half-plane */\nfunction flipCarboxylAndRadical(monomer: MolGraph, doubleBondedOxygen: number): void {\n  // verify that the carboxyl group is in the lower half-plane\n  if (monomer.atoms.y[monomer.meta.rNodes[1] - 1] < 0 &&\n    monomer.atoms.y[doubleBondedOxygen - 1] < 0) {\n    flipMonomerAroundOX(monomer);\n\n    rotateCenteredGraph(monomer.atoms,\n      -findAngleWithOX(\n        monomer.atoms.x[monomer.meta.terminalNodes[1] - 1],\n        monomer.atoms.y[monomer.meta.terminalNodes[1] - 1]\n      )\n    );\n  }\n}\n\n/* Finds angle between OY and the ray joining origin with (x, y) */\nfunction findAngleWithOY(x: number, y: number): number {\n  let angle;\n  if (x === 0) {\n    angle = y > 0 ? 0 : Math.PI;\n  } else if (y === 0) {\n    angle = x > 0 ? -Math.PI / 2 : Math.PI / 2;\n  } else {\n    const tan = y / x;\n    const atan = Math.atan(tan);\n    angle = (x < 0) ? Math.PI / 2 + atan : -Math.PI / 2 + atan;\n  }\n  return angle;\n}\n\n/* Finds angle between OX and the ray joining origin with (x, y) */\nfunction findAngleWithOX(x: number, y: number): number {\n  return findAngleWithOY(x, y) + Math.PI / 2;\n}\n\n/*  Rotate the graph around the origin by 'angle' */\nfunction rotateCenteredGraph(atoms: Atoms, angle: number): void {\n  if (angle !== 0) {\n    const x = atoms.x;\n    const y = atoms.y;\n\n    const cos = Math.cos(angle);\n    const sin = Math.sin(angle);\n\n    for (let i = 0; i < x.length; ++i) {\n      const tmp = x[i];\n      x[i] = keepPrecision(tmp * cos - y[i] * sin);\n      y[i] = keepPrecision(tmp * sin + y[i] * cos);\n    }\n  }\n}\n\n/* Flip monomer graph around OX axis preserving stereometry */\nfunction flipMonomerAroundOX(monomer: MolGraph): void {\n  flipMolGraph(monomer, true);\n}\n\n/* Flip monomer graph around OY axis preserving stereometry */\nfunction flipMonomerAroundOY(monomer: MolGraph): void {\n  flipMolGraph(monomer, false);\n}\n\n/* Flip graph around a specified axis: 'true' corresponds to OX, 'false' to OY */\nfunction flipMolGraph(molGraph: MolGraph, axis: boolean): void {\n  if (axis) { // flipping around OX\n    const y = molGraph.atoms.y;\n    for (let i = 0; i < y.length; i++)\n      y[i] = -y[i];\n  } else { // flipping around OY\n    const x = molGraph.atoms.x;\n    for (let i = 0; i < x.length; i++)\n      x[i] = -x[i];\n  }\n\n  // preserve the stereometry\n  const orientation = molGraph.bonds.bondConfiguration;\n  for (const [key, value] of orientation) {\n    const newValue = value === 1 ? 3 : 1;\n    orientation.set(key, newValue);\n  }\n}\n\n/* Flips double-bonded 'O' in carbonyl group with 'OH' in order for the monomers\n * to have standard representation simplifying their concatenation. The\n * monomer must already be adjusted with adjustPeptideMonomerGraph in order for this function to be implemented  */\nfunction flipHydroxilGroup(monomer: MolGraph, doubleBondedOxygen: number): void {\n  const x = monomer.atoms.x;\n  // -1 below because indexing of nodes in molfiles starts from 1, unlike arrays\n  if (x[monomer.meta.rNodes[1] - 1] > x[doubleBondedOxygen - 1])\n    swapNodes(monomer, doubleBondedOxygen, monomer.meta.rNodes[1]);\n}\n\n/* Determine the number of node (starting from 1) corresponding to the\n * double-bonded oxygen of the carbonyl group  */\nfunction findDoubleBondedCarbonylOxygen(monomer: MolGraph): number {\n  const bondsMap = constructBondsMap(monomer);\n  let doubleBondedOxygen = 0;\n  let i = 0;\n  // iterate over the nodes bonded to the carbon and find the double one\n  while (doubleBondedOxygen === 0) {\n    const node = bondsMap.get(monomer.meta.terminalNodes[1])![i];\n    if (monomer.atoms.atomTypes[node - 1] === OXYGEN && node !== monomer.meta.rNodes[1])\n      doubleBondedOxygen = node;\n    i++;\n  }\n  return doubleBondedOxygen;\n}\n\n/* Swap the Cartesian coordinates of the two specified nodes in MolGraph  */\nfunction swapNodes(monomer: MolGraph, nodeOne: number, nodeTwo: number): void {\n  const nodeOneIdx = nodeOne - 1;\n  const nodeTwoIdx = nodeTwo - 1;\n  const x = monomer.atoms.x;\n  const y = monomer.atoms.y;\n  const tmpX = x[nodeOneIdx];\n  const tmpY = y[nodeOneIdx];\n  x[nodeOneIdx] = x[nodeTwoIdx];\n  y[nodeOneIdx] = y[nodeTwoIdx];\n  x[nodeTwoIdx] = tmpX;\n  y[nodeTwoIdx] = tmpY;\n}\n\n// todo: doc\nfunction constructBondsMap(monomer: MolGraph): Map<number, Array<number>> {\n  const map = new Map<number, Array<number>>();\n  for (const atomPairs of monomer.bonds.atomPairs) {\n    for (let i = 0; i < 2; i++) {\n      const key = atomPairs[i];\n      const value = atomPairs[(i + 1) % 2];\n      if (map.has(key))\n        map.get(key)?.push(value);\n      else\n        map.set(key, new Array<number>(1).fill(value));\n    }\n  }\n  return map;\n}\n\n/* Shift molGraph in the XOY plane  */\nfunction shiftCoordinates(molGraph: MolGraph, xShift: number, yShift?: number): void {\n  const x = molGraph.atoms.x;\n  const y = molGraph.atoms.y;\n  for (let i = 0; i < x.length; ++i) {\n    x[i] = keepPrecision(x[i] + xShift);\n    if (typeof yShift !== 'undefined')\n      y[i] = keepPrecision(y[i] + yShift);\n  }\n}\n\n/* Translate a sequence of monomer symbols into Molfile V3000 */\nfunction monomerSeqToMolfile(\n  monomerSeq: string[], monomersDict: Map<string, MolGraph>, alphabet: ALPHABET, polymerType: HELM_POLYMER_TYPE\n): string {\n  // todo: handle the case when the polymer is empty\n  if (monomerSeq.length === 0)\n    throw new Error('monomerSeq is empty');\n\n  // define atom and bond counts, taking into account the bond type\n  const {atomCount, bondCount} = getResultingAtomBondCounts(monomerSeq, monomersDict, alphabet, polymerType);\n\n  // create arrays to store lines of the resulting molfile\n  const molfileAtomBlock = new Array<string>(atomCount);\n  const molfileBondBlock = new Array<string>(bondCount);\n\n  let addMonomerToMolblock;\n  let capMolblock;\n  let nodeShiftInitValue;\n  let bondShiftInitValue;\n  let sugar = null;\n  let phosphate = null;\n\n  if (polymerType === HELM_POLYMER_TYPE.PEPTIDE) {\n    addMonomerToMolblock = addAminoAcidToMolblock;\n    capMolblock = capPeptideMolblock;\n    nodeShiftInitValue = bondShiftInitValue = 0;\n  } else { // nucleotides\n    addMonomerToMolblock = addNucleotideToMolblock;\n    capMolblock = capPeptideMolblock; // todo: cleanup & refactor\n    nodeShiftInitValue = 0;\n    bondShiftInitValue = 0;\n    sugar = (alphabet === ALPHABET.DNA) ? monomersDict.get(DEOXYRIBOSE) : monomersDict.get(RIBOSE);\n    phosphate = monomersDict.get(PHOSPHATE);\n  }\n\n  const v: LoopVariables = {\n    i: 0,\n    nodeShift: nodeShiftInitValue,\n    bondShift: bondShiftInitValue,\n    backbonePositionShift: new Array<number>(2).fill(0),\n    branchPositionShift: new Array<number>(2).fill(0),\n    backboneAttachNode: 0,\n    branchAttachNode: 0,\n    flipFactor: 1,\n  };\n\n  const C: LoopConstants = {\n    sugar: sugar!,\n    phosphate: phosphate!,\n    seqLength: monomerSeq.length,\n    atomCount: atomCount,\n    bondCount: bondCount,\n  };\n\n  for (v.i = 0; v.i < C.seqLength; ++v.i) {\n    const monomer = monomersDict.get(monomerSeq[v.i])!;\n    addMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C);\n  }\n\n  capMolblock(molfileAtomBlock, molfileBondBlock, v, C);\n\n  const molfileCountsLine = V3K_BEGIN_COUNTS_LINE + atomCount + ' ' + bondCount + V3K_COUNTS_LINE_ENDING;\n\n  // todo: optimize concatenation using Alexander's hint\n  const molfileParts = [\n    V3K_HEADER_FIRST_LINE,\n    V3K_HEADER_SECOND_LINE,\n    V3K_BEGIN_CTAB_BLOCK,\n    molfileCountsLine,\n    V3K_BEGIN_ATOM_BLOCK,\n    molfileAtomBlock.join(''),\n    V3K_END_ATOM_BLOCK,\n    V3K_BEGIN_BOND_BLOCK,\n    molfileBondBlock.join(''),\n    V3K_END_BOND_BLOCK,\n    V3K_END_CTAB_BLOCK,\n    V3K_END,\n  ];\n\n  return molfileParts.join('');\n}\n\n// todo: doc\nfunction capPeptideMolblock(\n  molfileAtomBlock: string[], molfileBondBlock: string[],\n  v: LoopVariables, C: LoopConstants\n): void {\n  // add terminal oxygen\n  const atomIdx = v.nodeShift + 1;\n  molfileAtomBlock[C.atomCount] = V3K_BEGIN_DATA_LINE + atomIdx + ' ' +\n    OXYGEN + ' ' + keepPrecision(v.backbonePositionShift[0]) + ' ' +\n    v.flipFactor * keepPrecision(v.backbonePositionShift[1]) + ' ' + '0.000000 0' + '\\n';\n\n  // add terminal bond\n  const firstAtom = v.backboneAttachNode;\n  const secondAtom = atomIdx;\n  molfileBondBlock[C.bondCount] = V3K_BEGIN_DATA_LINE + v.bondShift + ' ' +\n    1 + ' ' + firstAtom + ' ' + secondAtom + '\\n';\n}\n\n// todo: doc\nfunction addAminoAcidToMolblock(monomer: MolGraph, molfileAtomBlock: string[],\n  molfileBondBlock: string[], v: LoopVariables, C: LoopConstants\n): void {\n  v.flipFactor = (-1) ** (v.i % 2); // to flip every even monomer over OX\n  addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, C);\n}\n\nfunction addBackboneMonomerToMolblock(\n  monomer: MolGraph, molfileAtomBlock: string[], molfileBondBlock: string[], v: LoopVariables, C: LoopConstants\n): void {\n  // todo: remove these comments to the docstrings of the corr. functions\n  // construnct the lines of V3K molfile atom block\n  fillAtomLines(monomer, molfileAtomBlock, v);\n\n  // construct the lines of V3K molfile bond block\n  fillBondLines(monomer, molfileBondBlock, v);\n\n  // peptide bond\n  fillChainExtendingBond(monomer, molfileBondBlock, v);\n\n  // update branch variables if necessary\n  if (monomer.meta.branchShift !== null && monomer.meta.terminalNodes.length > 2)\n    updateBranchVariables(monomer, v);\n\n  // update loop variables\n  updateChainExtendingVariables(monomer, v, C);\n}\n\n// todo: doc\nfunction addNucleotideToMolblock(\n  nucleobase: MolGraph, molfileAtomBlock: string[], molfileBondBlock: string[], v: LoopVariables, C: LoopConstants\n): void {\n  // construnct the lines of V3K molfile atom block corresponding to phosphate\n  // and sugar\n  for (const monomer of [C.phosphate, C.sugar])\n    addBackboneMonomerToMolblock(monomer!, molfileAtomBlock, molfileBondBlock, v, C);\n\n  addBranchMonomerToMolblock(nucleobase, molfileAtomBlock, molfileBondBlock, v, C);\n}\n\nfunction addBranchMonomerToMolblock(\n  monomer: MolGraph, molfileAtomBlock: string[], molfileBondBlock: string[], v: LoopVariables, C: LoopConstants\n): void {\n  fillBranchAtomLines(monomer, molfileAtomBlock, v);\n  fillBondLines(monomer, molfileBondBlock, v);\n  fillBackboneToBranchBond(monomer, molfileBondBlock, v);\n\n  // C-N bond\n  const bondIdx = v.bondShift;\n  const firstAtom = v.branchAttachNode;\n  const secondAtom = monomer.meta.terminalNodes[0] + v.nodeShift;\n  molfileBondBlock[bondIdx - 1] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +\n    1 + ' ' + firstAtom + ' ' + secondAtom + '\\n';\n\n  // update loop variables\n  v.bondShift += monomer.bonds.atomPairs.length + 1;\n  v.nodeShift += monomer.atoms.atomTypes.length;\n}\n\nfunction updateChainExtendingVariables(monomer: MolGraph, v: LoopVariables, C: LoopConstants): void {\n  v.backboneAttachNode = v.nodeShift + monomer.meta.terminalNodes[1];\n  v.bondShift += monomer.bonds.atomPairs.length + 1;\n\n  v.nodeShift += monomer.atoms.atomTypes.length;\n  v.backbonePositionShift[0] += monomer.meta.backboneShift![0]; // todo: non-null check\n  v.backbonePositionShift[1] += v.flipFactor * monomer.meta.backboneShift![1];\n}\n\nfunction updateBranchVariables(monomer: MolGraph, v: LoopVariables) {\n  v.branchAttachNode = v.nodeShift + monomer.meta.terminalNodes[2];\n  for (let i = 0; i < 2; ++i)\n    v.branchPositionShift[i] = v.backbonePositionShift[i] + monomer.meta.branchShift![i];\n}\n\nfunction fillAtomLines(monomer: MolGraph, molfileAtomBlock: string[], v: LoopVariables): void {\n  for (let j = 0; j < monomer.atoms.atomTypes.length; ++j) {\n    const atomIdx = v.nodeShift + j + 1;\n    molfileAtomBlock[v.nodeShift + j] = V3K_BEGIN_DATA_LINE + atomIdx + ' ' +\n      monomer.atoms.atomTypes[j] + ' ' +\n      keepPrecision(v.backbonePositionShift[0] + monomer.atoms.x[j]) + ' ' +\n      keepPrecision(v.backbonePositionShift[1] + v.flipFactor * monomer.atoms.y[j]) +\n      ' ' + monomer.atoms.kwargs[j];\n  }\n}\n\n// todo: remove as quickfix\nfunction fillBranchAtomLines(monomer: MolGraph, molfileAtomBlock: string[], v: LoopVariables): void {\n  for (let j = 0; j < monomer.atoms.atomTypes.length; ++j) {\n    const atomIdx = v.nodeShift + j + 1;\n    molfileAtomBlock[v.nodeShift + j] = V3K_BEGIN_DATA_LINE + atomIdx + ' ' +\n      monomer.atoms.atomTypes[j] + ' ' +\n      keepPrecision(v.branchPositionShift[0] + monomer.atoms.x[j]) + ' ' +\n      keepPrecision(v.branchPositionShift[1] + v.flipFactor * monomer.atoms.y[j]) +\n      ' ' + monomer.atoms.kwargs[j];\n  }\n}\n\nfunction fillBondLines(monomer: MolGraph, molfileBondBlock: string[], v: LoopVariables): void {\n  // construct the lines of V3K molfile bond block\n  for (let j = 0; j < monomer.bonds.atomPairs.length; ++j) {\n    const bondIdx = v.bondShift + j + 1;\n    const firstAtom = monomer.bonds.atomPairs[j][0] + v.nodeShift;\n    const secondAtom = monomer.bonds.atomPairs[j][1] + v.nodeShift;\n    let bondCfg = '';\n    if (monomer.bonds.bondConfiguration.has(j)) {\n      // flip orientation when necessary\n      let orientation = monomer.bonds.bondConfiguration.get(j);\n      if (v.flipFactor < 0)\n        orientation = (orientation === 1) ? 3 : 1;\n      bondCfg = ' CFG=' + orientation;\n    }\n    const kwargs = monomer.bonds.kwargs.has(j) ?\n      ' ' + monomer.bonds.kwargs.get(j) : '';\n    molfileBondBlock[v.bondShift + j] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +\n      monomer.bonds.bondTypes[j] + ' ' +\n      firstAtom + ' ' + secondAtom + bondCfg + kwargs + '\\n';\n  }\n}\n\nfunction fillChainExtendingBond(monomer: MolGraph, molfileBondBlock: string[], v: LoopVariables): void {\n  if (v.backboneAttachNode !== 0) {\n    const bondIdx = v.bondShift;\n    const firstAtom = v.backboneAttachNode;\n    const secondAtom = monomer.meta.terminalNodes[0] + v.nodeShift;\n    molfileBondBlock[v.bondShift - 1] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +\n      1 + ' ' + firstAtom + ' ' + secondAtom + '\\n';\n  }\n}\n\n// todo: remove\nfunction fillBackboneToBranchBond(branchMonomer: MolGraph, molfileBondBlock: string[], v: LoopVariables): void {\n  const bondIdx = v.bondShift;\n  const firstAtom = v.branchAttachNode;\n  const secondAtom = branchMonomer.meta.terminalNodes[0] + v.nodeShift;\n  molfileBondBlock[bondIdx - 1] = V3K_BEGIN_DATA_LINE + bondIdx + ' ' +\n    1 + ' ' + firstAtom + ' ' + secondAtom + '\\n';\n}\n\n/* Compute the atom/bond counts for the resulting molfile, depending on the\n * type of polymer (peptide/nucleotide) */\nfunction getResultingAtomBondCounts(\n  monomerSeq: string[], monomersDict: Map<string, MolGraph>,\n  alphabet: ALPHABET, polymerType: HELM_POLYMER_TYPE\n): { atomCount: number, bondCount: number } {\n  let atomCount = 0;\n  let bondCount = 0;\n\n  // sum up all the atoms/nodes provided by the sequence\n  for (const monomerSymbol of monomerSeq) {\n    const monomer = monomersDict.get(monomerSymbol)!;\n    atomCount += monomer.atoms.x.length;\n    bondCount += monomer.bonds.bondTypes.length;\n  }\n\n  // add extra values depending on the polymer type\n  if (polymerType === HELM_POLYMER_TYPE.PEPTIDE) {\n    // add the rightmost/terminating cap group 'OH' (i.e. 'O')\n    atomCount += 1;\n    // add chain-extending bonds (C-NH per each monomer pair and terminal C-OH)\n    bondCount += monomerSeq.length;\n  } else { // nucleotides\n    const sugar = (alphabet === ALPHABET.DNA) ?\n      monomersDict.get(DEOXYRIBOSE)! : monomersDict.get(RIBOSE)!;\n    const phosphate = monomersDict.get(PHOSPHATE)!;\n\n    // add phosphate and sugar per each nucleobase symbol\n    atomCount += monomerSeq.length * (phosphate.atoms.x.length + sugar.atoms.x.length);\n    // add the leftmost cap group 'OH' (i.e. 'O') to the first phosphate\n    atomCount += 1;\n\n    // add bonds from phosphate and sugar\n    bondCount += monomerSeq.length * (phosphate.bonds.bondTypes.length + sugar.bonds.bondTypes.length);\n\n    // add chain-extending and branch bonds (O-P, C-O and C-N per each nucleotide)\n    bondCount += monomerSeq.length * 3;\n  }\n\n  return {atomCount, bondCount};\n}\n\n/* Keep precision upon floating point operations over atom coordinates */\nfunction keepPrecision(x: number) {\n  return Math.round(PRECISION_FACTOR * x) / PRECISION_FACTOR;\n}\n\nfunction convertMolGraphToMolfileV3K(molGraph: MolGraph): string {\n  // counts line\n  const atomType = molGraph.atoms.atomTypes;\n  const x = molGraph.atoms.x;\n  const y = molGraph.atoms.y;\n  const atomKwargs = molGraph.atoms.kwargs;\n  const bondType = molGraph.bonds.bondTypes;\n  const atomPair = molGraph.bonds.atomPairs;\n  const bondKwargs = molGraph.bonds.kwargs;\n  const bondConfig = molGraph.bonds.bondConfiguration;\n  const atomCount = atomType.length;\n  const bondCount = molGraph.bonds.bondTypes.length;\n\n  // todo rewrite using constants\n  const molfileCountsLine = V3K_BEGIN_COUNTS_LINE + atomCount + ' ' + bondCount + V3K_COUNTS_LINE_ENDING;\n\n  // atom block\n  let molfileAtomBlock = '';\n  for (let i = 0; i < atomCount; ++i) {\n    const atomIdx = i + 1;\n    const coordinate = [x[i].toString(), y[i].toString()];\n\n    // format coordinates so that they have 6 digits after decimal point\n    // for (let k = 0; k < 2; ++k) {\n    //   const formatted = coordinate[k].toString().split('.');\n    //   if (formatted.length === 1)\n    //     formatted.push('0');\n    //   formatted[1] = formatted[1].padEnd(V3K_ATOM_COORDINATE_PRECISION, '0');\n    //   coordinate[k] = formatted.join('.');\n    // }\n\n    const atomLine = V3K_BEGIN_DATA_LINE + atomIdx + ' ' + atomType[i] + ' ' +\n      coordinate[0] + ' ' + coordinate[1] + ' ' + atomKwargs[i];\n    molfileAtomBlock += atomLine;\n  }\n\n  // bond block\n  let molfileBondBlock = '';\n  for (let i = 0; i < bondCount; ++i) {\n    const bondIdx = i + 1;\n    const firstAtom = atomPair[i][0];\n    const secondAtom = atomPair[i][1];\n    const kwargs = bondKwargs.has(i) ? ' ' + bondKwargs.get(i) : '';\n    const bondCfg = bondConfig.has(i) ? ' CFG=' + bondConfig.get(i) : '';\n    const bondLine = V3K_BEGIN_DATA_LINE + bondIdx + ' ' + bondType[i] + ' ' +\n      firstAtom + ' ' + secondAtom + bondCfg + kwargs + '\\n';\n    molfileBondBlock += bondLine;\n  }\n\n  const molfileParts = [\n    V3K_HEADER_FIRST_LINE,\n    V3K_HEADER_SECOND_LINE,\n    V3K_BEGIN_CTAB_BLOCK,\n    molfileCountsLine,\n    V3K_BEGIN_ATOM_BLOCK,\n    molfileAtomBlock,\n    V3K_END_ATOM_BLOCK,\n    V3K_BEGIN_BOND_BLOCK,\n    molfileBondBlock,\n    V3K_END_BOND_BLOCK,\n    V3K_END_CTAB_BLOCK,\n    V3K_END,\n  ];\n  const resultingMolfile = molfileParts.join('');\n  // console.log(resultingMolfile);\n\n  return resultingMolfile;\n}\n\nexport async function getSymbolToCappedMolfileMap(monomersLibList: any[]): Promise<Map<string, string> | undefined> {\n  if (DG.Func.find({package: 'Chem', name: 'getRdKitModule'}).length === 0) {\n    grok.shell.warning('Transformation to atomic level requires package \"Chem\" installed.');\n    return;\n  }\n\n  const symbolToCappedMolfileMap = new Map<string, string>();\n  const moduleRdkit = await grok.functions.call('Chem:getRdKitModule');\n\n  for (const monomerLibObject of monomersLibList) {\n    const monomerSymbol = monomerLibObject[HELM_FIELDS.SYMBOL];\n    const capGroups = parseCapGroups(monomerLibObject[HELM_FIELDS.RGROUPS]);\n    const capGroupIdxMap = parseCapGroupIdxMap(monomerLibObject[HELM_FIELDS.MOLFILE]);\n\n    const molfileV3K = convertMolfileToV3K(removeRGroupLines(monomerLibObject[HELM_FIELDS.MOLFILE]), moduleRdkit);\n    const counts = parseAtomAndBondCounts(molfileV3K);\n\n    const atoms = parseAtomBlock(molfileV3K, counts.atomCount);\n    const bonds = parseBondBlock(molfileV3K, counts.bondCount);\n    const meta = getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap);\n\n    const monomerGraph: MolGraph = {atoms: atoms, bonds: bonds, meta: meta};\n\n    removeHydrogen(monomerGraph);\n\n    const molfile = convertMolGraphToMolfileV3K(monomerGraph);\n    symbolToCappedMolfileMap.set(monomerSymbol, molfile);\n  }\n  return symbolToCappedMolfileMap;\n}\n\n/* Get the V3K molfile corresponding to the capped Monomer (default cap groups)  */\nexport function capPeptideMonomer(monomer: Monomer): string {\n  const funcList: DG.Func[] = DG.Func.find({package: 'Chem', name: 'getRdKitModule'});\n  const moduleRdkit = funcList[0].apply();\n  \n  const capGroups = parseCapGroups(monomer[HELM_FIELDS.RGROUPS]);\n  const capGroupIdxMap = parseCapGroupIdxMap(monomer[HELM_FIELDS.MOLFILE]);\n  const molfileV3K = convertMolfileToV3K(removeRGroupLines(monomer[HELM_FIELDS.MOLFILE]), moduleRdkit);\n  const counts = parseAtomAndBondCounts(molfileV3K);\n\n  const atoms = parseAtomBlock(molfileV3K, counts.atomCount);\n  const bonds = parseBondBlock(molfileV3K, counts.bondCount);\n  const meta = getMonomerMetadata(atoms, bonds, capGroups, capGroupIdxMap);\n\n  const monomerGraph: MolGraph = {atoms: atoms, bonds: bonds, meta: meta};\n\n  adjustPeptideMonomerGraph(monomerGraph);\n\n  const molfile = convertMolGraphToMolfileV3K(monomerGraph);\n  return molfile;\n}\n"]}