@datagrok/sequence-translator 1.9.4 → 1.9.6

package/dist/vendors-node_modules_datagrok-libraries_bio_src_monomer-works_seq-to-molfile-worker_js.js

@@ -0,0 +1,827 @@
+var sequencetranslator;
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/helm/consts.js":
+/*!*****************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/helm/consts.js ***!
+  \*****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   HelmTypes: () => (/* reexport safe */ _datagrok_libraries_js_draw_lite_src_types_org__WEBPACK_IMPORTED_MODULE_0__.HelmTypes)
+/* harmony export */ });
+/* harmony import */ var _datagrok_libraries_js_draw_lite_src_types_org__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @datagrok-libraries/js-draw-lite/src/types/org */ "./node_modules/@datagrok-libraries/js-draw-lite/src/types/org.js");
+
+
+//# sourceMappingURL=consts.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/monomer-works/consts.js":
+/*!**************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/monomer-works/consts.js ***!
+  \**************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   monomerWorksConsts: () => (/* binding */ monomerWorksConsts)
+/* harmony export */ });
+const monomerWorksConsts = {
+    // constants for parsing molfile V2000
+    V2K_RGP_SHIFT: 8,
+    V2K_RGP_LINE: 'M  RGP',
+    V2K_A_LINE: 'A  ',
+    // constants for parsing/reconstruction of molfile V3000
+    V3K_COUNTS_SHIFT: 14,
+    V3K_IDX_SHIFT: 7,
+    V3K_HEADER_FIRST_LINE: '\nDatagrok macromolecule handler\n\n',
+    V3K_HEADER_SECOND_LINE: '  0  0  0  0  0  0            999 V3000\n',
+    V3K_BEGIN_CTAB_BLOCK: 'M  V30 BEGIN CTAB\n',
+    V3K_END_CTAB_BLOCK: 'M  V30 END CTAB\n',
+    V3K_BEGIN_COUNTS_LINE: 'M  V30 COUNTS ',
+    V3K_COUNTS_LINE_ENDING: ' 0 0 0\n',
+    V3K_BEGIN_ATOM_BLOCK: 'M  V30 BEGIN ATOM\n',
+    V3K_END_ATOM_BLOCK: 'M  V30 END ATOM\n',
+    V3K_BEGIN_BOND_BLOCK: 'M  V30 BEGIN BOND\n',
+    V3K_END_BOND_BLOCK: 'M  V30 END BOND\n',
+    V3K_BOND_CONFIG: ' CFG=',
+    V3K_BEGIN_DATA_LINE: 'M  V30 ',
+    V3K_END: 'M  END',
+    PRECISION_FACTOR: 10000, // HELMCoreLibrary has 4 significant digits after decimal point in atom coordinates
+    // symbols for the corresponding monomers in HELM library
+    DEOXYRIBOSE: { polymerType: "RNA" /* PolymerTypes.RNA */, symbol: 'd' },
+    RIBOSE: { polymerType: "RNA" /* PolymerTypes.RNA */, symbol: 'r' },
+    PHOSPHATE: { polymerType: "RNA" /* PolymerTypes.RNA */, symbol: 'p' },
+    OXYGEN: 'O',
+    HYDROGEN: 'H',
+};
+//# sourceMappingURL=consts.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/monomer-works/monomer-works.js":
+/*!*********************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/monomer-works/monomer-works.js ***!
+  \*********************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MonomerWorks: () => (/* binding */ MonomerWorks),
+/* harmony export */   helmTypeToPolymerType: () => (/* binding */ helmTypeToPolymerType)
+/* harmony export */ });
+/* harmony import */ var _helm_consts__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../helm/consts */ "./node_modules/@datagrok-libraries/bio/src/helm/consts.js");
+
+class MonomerWorks {
+    //private molfileConverter: IMolfileConverter;
+    constructor(monomerLib /*, molfileConverter: IMolfileConverter*/) {
+        this.monomerLib = monomerLib;
+        //this.molfileConverter = molfileConverter;
+    }
+    //types according to Monomer possible
+    getCappedRotatedMonomer(monomerType, monomerName) {
+        // TODO: Check type of monomerType arg
+        const monomer = this.monomerLib.getMonomer(monomerType, monomerName);
+        if (monomer)
+            return monomer.molfile; //TODO cap
+        return null;
+    }
+}
+function helmTypeToPolymerType(helmType) {
+    let polymerType = undefined;
+    switch (helmType) {
+        case _helm_consts__WEBPACK_IMPORTED_MODULE_0__.HelmTypes.BASE:
+        case _helm_consts__WEBPACK_IMPORTED_MODULE_0__.HelmTypes.SUGAR: // r - ribose, d - deoxyribose
+        case _helm_consts__WEBPACK_IMPORTED_MODULE_0__.HelmTypes.LINKER: // p - phosphate
+        case _helm_consts__WEBPACK_IMPORTED_MODULE_0__.HelmTypes.NUCLEOTIDE:
+        // @ts-ignore
+        case 'nucleotide':
+            polymerType = "RNA" /* PolymerTypes.RNA */;
+            break;
+        case _helm_consts__WEBPACK_IMPORTED_MODULE_0__.HelmTypes.AA:
+            polymerType = "PEPTIDE" /* PolymerTypes.PEPTIDE */;
+            break;
+        case _helm_consts__WEBPACK_IMPORTED_MODULE_0__.HelmTypes.CHEM:
+            polymerType = "CHEM" /* PolymerTypes.CHEM */;
+            break;
+        case _helm_consts__WEBPACK_IMPORTED_MODULE_0__.HelmTypes.BLOB:
+            polymerType = "BLOB" /* PolymerTypes.BLOB */;
+            break;
+        default:
+            polymerType = "PEPTIDE" /* PolymerTypes.PEPTIDE */;
+            console.warn(`Unexpected HelmType '${helmType}'`);
+    }
+    return polymerType;
+}
+//# sourceMappingURL=monomer-works.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/monomer-works/to-atomic-level-utils.js":
+/*!*****************************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/monomer-works/to-atomic-level-utils.js ***!
+  \*****************************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getFormattedMonomerLib: () => (/* binding */ getFormattedMonomerLib),
+/* harmony export */   keepPrecision: () => (/* binding */ keepPrecision),
+/* harmony export */   monomerSeqToMolfile: () => (/* binding */ monomerSeqToMolfile)
+/* harmony export */ });
+/* harmony import */ var _consts__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./consts */ "./node_modules/@datagrok-libraries/bio/src/monomer-works/consts.js");
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./types */ "./node_modules/@datagrok-libraries/bio/src/monomer-works/types.js");
+/* harmony import */ var _utils_const__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/const */ "./node_modules/@datagrok-libraries/bio/src/utils/const.js");
+/* harmony import */ var _utils_macromolecule_consts__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/macromolecule/consts */ "./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/consts.js");
+/* harmony import */ var _monomer_works__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./monomer-works */ "./node_modules/@datagrok-libraries/bio/src/monomer-works/monomer-works.js");
+/* eslint-disable max-len */
+
+
+
+
+
+/** Get a mapping of peptide symbols to HELM monomer library objects with selected fields.
+ * @param {IMonomerLib} monomerLib - Monomer library
+ * @param {HELM_POLYMER_TYPE} polymerType - Polymer type
+ * @param {ALPHABET} alphabet - Alphabet of the column
+ * @return {Map<string, any>} - Mapping of peptide symbols to HELM monomer library objects with selected fields*/
+function getFormattedMonomerLib(monomerLib, polymerType, alphabet) {
+    const map = new Map();
+    for (const monomerSymbol of monomerLib.getMonomerSymbolsByType(polymerType)) {
+        const it = monomerLib.getMonomer(polymerType, monomerSymbol);
+        if (polymerType === "RNA" /* HELM_POLYMER_TYPE.RNA */ &&
+            (it["monomerType" /* HELM_FIELDS.MONOMER_TYPE */] === "Branch" /* HELM_MONOMER_TYPE.BRANCH */ ||
+                alphabet === _utils_macromolecule_consts__WEBPACK_IMPORTED_MODULE_3__.ALPHABET.DNA && it["symbol" /* HELM_FIELDS.SYMBOL */] === _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.DEOXYRIBOSE.symbol ||
+                alphabet === _utils_macromolecule_consts__WEBPACK_IMPORTED_MODULE_3__.ALPHABET.RNA && it["symbol" /* HELM_FIELDS.SYMBOL */] === _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.RIBOSE.symbol ||
+                it["symbol" /* HELM_FIELDS.SYMBOL */] === _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.PHOSPHATE.symbol) ||
+            polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */ &&
+                it["monomerType" /* HELM_FIELDS.MONOMER_TYPE */] !== "Branch" /* HELM_MONOMER_TYPE.BRANCH */) {
+            const monomerObject = {};
+            _utils_const__WEBPACK_IMPORTED_MODULE_2__.HELM_CORE_FIELDS.forEach((field) => {
+                //@ts-ignore
+                monomerObject[field] = it[field];
+            });
+            map.set(it["symbol" /* HELM_FIELDS.SYMBOL */], monomerObject);
+        }
+    }
+    return map;
+}
+/** Translate a sequence of monomer symbols into Molfile V3000
+ * @param {string[]} monomerSeq - Sequence of monomer symbols (canonical)
+ * @param {Map<string, MolGraph>} monomersDict - Mapping of monomer symbols to MolGraph objects
+ * @param {ALPHABET} alphabet - Alphabet of the column
+ * @param {PolymerType} polymerType - Polymer type
+ * @return {string} - Molfile V3000*/
+function monomerSeqToMolfile(monomerSeq, monomersDict, alphabet, polymerType) {
+    if (monomerSeq.length === 0) {
+        // throw new Error('monomerSeq is empty');
+        return _types__WEBPACK_IMPORTED_MODULE_1__.MolfileWithMap.createEmpty();
+    }
+    // define atom and bond counts, taking into account the bond type
+    const getAtomAndBondCounts = getResultingAtomBondCounts;
+    const { atomCount, bondCount, needsCapping } = getAtomAndBondCounts(monomerSeq, monomersDict, alphabet, polymerType);
+    // create arrays to store lines of the resulting molfile
+    const molfileAtomBlock = new Array(atomCount);
+    const molfileBondBlock = new Array(bondCount);
+    let addMonomerToMolblock;
+    let sugar = null;
+    let phosphate = null;
+    if (polymerType === "PEPTIDE" /* HELM_POLYMER_TYPE.PEPTIDE */)
+        addMonomerToMolblock = addAminoAcidToMolblock;
+    else { // nucleotides
+        addMonomerToMolblock = addNucleotideToMolblock;
+        sugar = (alphabet === _utils_macromolecule_consts__WEBPACK_IMPORTED_MODULE_3__.ALPHABET.DNA) ? (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.DEOXYRIBOSE) : (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.RIBOSE);
+        phosphate = (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.PHOSPHATE);
+    }
+    const v = {
+        i: 0,
+        nodeShift: 0,
+        bondShift: 0,
+        backbonePositionShift: new Array(2).fill(0),
+        branchPositionShift: new Array(2).fill(0),
+        backboneAttachNode: 0,
+        branchAttachNode: 0,
+        flipFactor: 1,
+    };
+    const LC = {
+        sugar: sugar,
+        phosphate: phosphate,
+        seqLength: monomerSeq.length,
+        atomCount: atomCount,
+        bondCount: bondCount,
+    };
+    const monomers = new _types__WEBPACK_IMPORTED_MODULE_1__.MonomerMap();
+    const steabsCollection = [];
+    let nAtoms = 0;
+    for (v.i = 0; v.i < LC.seqLength; ++v.i) {
+        const seqMonomer = monomerSeq[v.i];
+        if (seqMonomer.symbol === _utils_macromolecule_consts__WEBPACK_IMPORTED_MODULE_3__.GAP_SYMBOL)
+            continue;
+        const monomer = (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, { symbol: seqMonomer.symbol, polymerType: (0,_monomer_works__WEBPACK_IMPORTED_MODULE_4__.helmTypeToPolymerType)(seqMonomer.biotype) });
+        const mAtomFirst = v.nodeShift;
+        const mBondFirst = v.bondShift;
+        addMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v, LC);
+        //adding stereo atoms to array for further STEABS block generation
+        monomer.stereoAtoms?.forEach((i) => steabsCollection.push(i + nAtoms));
+        nAtoms += monomer.atoms.x.length;
+        const mAtomCount = v.nodeShift - mAtomFirst;
+        const mAtomList = new Array(mAtomCount);
+        for (let maI = 0; maI < mAtomCount; ++maI)
+            mAtomList[maI] = mAtomFirst + maI;
+        const mBondCount = v.bondShift - mBondFirst;
+        const mBondList = new Array(mBondCount);
+        for (let mbI = 0; mbI < mBondCount; ++mbI)
+            mBondList[mbI] = mBondFirst + mbI;
+        monomers.set(v.i, {
+            biotype: seqMonomer.biotype,
+            symbol: seqMonomer.symbol,
+            atoms: mAtomList, bonds: mBondList
+        });
+    }
+    // if the last monomer needs to be capped, add the terminal OH to the resulting molfile
+    if (needsCapping)
+        capResultingMolblock(molfileAtomBlock, molfileBondBlock, v, LC);
+    const molfileCountsLine = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_BEGIN_COUNTS_LINE + atomCount + ' ' + bondCount + _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_COUNTS_LINE_ENDING;
+    // todo: possible optimization may be achieved by replacing .join('') with +=
+    // since counterintuitively joining an array into a new string is reportedly
+    // slower than using += as below
+    let result = '';
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_HEADER_FIRST_LINE;
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_HEADER_SECOND_LINE;
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_BEGIN_CTAB_BLOCK;
+    result += molfileCountsLine;
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_BEGIN_ATOM_BLOCK;
+    result += molfileAtomBlock.join('');
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_END_ATOM_BLOCK;
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_BEGIN_BOND_BLOCK;
+    result += molfileBondBlock.join('');
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_END_BOND_BLOCK;
+    if (steabsCollection.length > 0)
+        result += getCollectionBlock(steabsCollection);
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_END_CTAB_BLOCK;
+    result += _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_END;
+    // return molfileParts.join('');
+    return { molfile: result, monomers: monomers };
+}
+function getCollectionBlock(collection) {
+    //one row in STEABS block can be no longer than 80 symbols
+    //maxSymbols = 80 symbols minus ' -\n' (4 symbols)
+    const maxSymbols = 76;
+    const rowsArray = [];
+    let newCollectionRow = `M  V30 MDLV30/STEABS ATOMS=(${collection.length}`;
+    for (let i = 0; i < collection.length; i++) {
+        const updatedRow = `${newCollectionRow} ${collection[i]}`;
+        if (updatedRow.length > maxSymbols) {
+            rowsArray.push(`${newCollectionRow} -\n`);
+            newCollectionRow = `M  V30 ${collection[i]}`;
+        }
+        else
+            newCollectionRow = updatedRow;
+        //in case last atom was added - close the block
+        if (i === collection.length - 1)
+            rowsArray.push(`${newCollectionRow})\n`);
+    }
+    return `M  V30 BEGIN COLLECTION\n${rowsArray.join('')}M  V30 END COLLECTION\n`;
+}
+/** Cap the resulting (after sewing up all the monomers) molfile with 'O'
+ * @param {string[]} molfileAtomBlock - Array of lines of the resulting molfile atom block
+ * @param {string[]} molfileBondBlock - Array of lines of the resulting molfile bond block
+ * @param {LoopVariables} v - Loop variables
+ * @param {LoopConstants} LC - Loop constants*/
+function capResultingMolblock(molfileAtomBlock, molfileBondBlock, v, LC) {
+    // add terminal oxygen
+    const atomIdx = v.nodeShift + 1;
+    molfileAtomBlock[LC.atomCount] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_BEGIN_DATA_LINE + atomIdx + ' ' +
+        _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.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[LC.bondCount] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_BEGIN_DATA_LINE + v.bondShift + ' ' +
+        1 + ' ' + firstAtom + ' ' + secondAtom + '\n';
+}
+function addAminoAcidToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v) {
+    v.flipFactor = (-1) ** (v.i % 2); // to flip every even monomer over OX
+    addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v);
+}
+function addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v) {
+    // todo: remove these comments to the docstrings of the corr. functions
+    // construnct the lines of V3K molfile atom block
+    fillAtomLines(monomer, molfileAtomBlock, v);
+    // construct the lines of V3K molfile bond block
+    fillBondLines(monomer, molfileBondBlock, v);
+    // peptide bond
+    fillChainExtendingBond(monomer, molfileBondBlock, v);
+    // update branch variables if necessary
+    if (monomer.meta.branchShift !== null && monomer.meta.terminalNodes.length > 2)
+        updateBranchVariables(monomer, v);
+    // update loop variables
+    updateChainExtendingVariables(monomer, v);
+}
+function addNucleotideToMolblock(nucleobase, molfileAtomBlock, molfileBondBlock, v, LC) {
+    // construnct the lines of V3K molfile atom block corresponding to phosphate
+    // and sugar
+    if (v.i === 0)
+        addBackboneMonomerToMolblock(LC.sugar, molfileAtomBlock, molfileBondBlock, v);
+    else {
+        for (const monomer of [LC.phosphate, LC.sugar])
+            addBackboneMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v);
+    }
+    addBranchMonomerToMolblock(nucleobase, molfileAtomBlock, molfileBondBlock, v);
+}
+function addBranchMonomerToMolblock(monomer, molfileAtomBlock, molfileBondBlock, v) {
+    fillBranchAtomLines(monomer, molfileAtomBlock, v);
+    fillBondLines(monomer, molfileBondBlock, v);
+    fillBackboneToBranchBond(monomer, molfileBondBlock, v);
+    // C-N bond
+    const bondIdx = v.bondShift;
+    const firstAtom = v.branchAttachNode;
+    const secondAtom = monomer.meta.terminalNodes[0] + v.nodeShift;
+    molfileBondBlock[bondIdx - 1] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.V3K_BEGIN_DATA_LINE + bondIdx + ' ' +
+        1 + ' ' + firstAtom + ' ' + secondAtom + '\n';
+    // update loop variables
+    v.bondShift += monomer.bonds.atomPairs.length + 1;
+    v.nodeShift += monomer.atoms.atomTypes.length;
+}
+function updateChainExtendingVariables(monomer, v) {
+    v.backboneAttachNode = v.nodeShift + monomer.meta.terminalNodes[1];
+    v.bondShift += monomer.bonds.atomPairs.length + 1;
+    v.nodeShift += monomer.atoms.atomTypes.length;
+    v.backbonePositionShift[0] += monomer.meta.backboneShift?.[0] ?? 0; // todo: non-null check
+    v.backbonePositionShift[1] += v.flipFactor * (monomer.meta.backboneShift?.[1] ?? 0);
+}
+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] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.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] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.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] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.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] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.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] = _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.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)
+ * @param {string[]}monomerSeq - the sequence of monomers
+ * @param {Map<string, MolGraph>}monomersDict - the dictionary of monomers
+ * @param {ALPHABET}alphabet - the alphabet of the monomers
+ * @param {HELM_POLYMER_TYPE}polymerType - the type of polymer
+ * @return {{atomCount: number, bondCount: number}} - the atom/bond counts*/
+function getResultingAtomBondCounts(monomerSeq, monomersDict, alphabet, polymerType) {
+    let atomCount = 0;
+    let bondCount = 0;
+    let monomerCount = 0;
+    let needsCapping = true;
+    let lastMonomerGraph = null;
+    // sum up all the atoms/nodes provided by the sequence
+    for (const seqMonomer of monomerSeq) {
+        if (seqMonomer.symbol === _utils_macromolecule_consts__WEBPACK_IMPORTED_MODULE_3__.GAP_SYMBOL)
+            continue; // Skip for gap/empty monomer in MSA
+        if (seqMonomer.symbol == '*')
+            throw new Error(`Gap canonical symbol is '', not '*`);
+        lastMonomerGraph = (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, { symbol: seqMonomer.symbol, polymerType: (0,_monomer_works__WEBPACK_IMPORTED_MODULE_4__.helmTypeToPolymerType)(seqMonomer.biotype) });
+        atomCount += lastMonomerGraph.atoms.x.length;
+        bondCount += lastMonomerGraph.bonds.bondTypes.length;
+        monomerCount++;
+    }
+    // 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 += monomerCount;
+        // if the last monomer is something like NH2, which only has R1, there is no need to cap it
+        if (monomerCount > 0) {
+            if ((lastMonomerGraph?.meta?.rNodes?.length ?? 0) < 2) {
+                needsCapping = false;
+                atomCount -= 1; // remove the last atom (the terminal 'O')
+                bondCount -= 1; // remove the last bond (the terminal C-OH)
+            }
+        }
+    }
+    else { // nucleotides
+        const sugar = (alphabet === _utils_macromolecule_consts__WEBPACK_IMPORTED_MODULE_3__.ALPHABET.DNA) ?
+            (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.DEOXYRIBOSE) : (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.RIBOSE);
+        const phosphate = (0,_types__WEBPACK_IMPORTED_MODULE_1__.getMolGraph)(monomersDict, _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.PHOSPHATE);
+        // add phosphate per each pair of nucleobase symbols
+        atomCount += (monomerSeq.length - 1) * phosphate.atoms.x.length;
+        // add sugar per each nucleobase symbol
+        atomCount += monomerSeq.length * sugar.atoms.x.length;
+        // add the leftmost cap group 'OH' (i.e. 'O')
+        atomCount += 1;
+        // add bonds from phosphate monomers
+        bondCount += (monomerSeq.length - 1) * phosphate.bonds.bondTypes.length;
+        // add bonds from sugar monomers
+        bondCount += monomerSeq.length * sugar.bonds.bondTypes.length;
+        // exclude the first chain-extending bond O-P (absent, no 'leftmost' phosphate)
+        bondCount -= 1;
+        // add chain-extending and branch bonds (O-P, C-O and C-N per each nucleotide)
+        bondCount += monomerSeq.length * 3;
+    }
+    return { atomCount, bondCount, needsCapping };
+}
+/** Keep precision upon floating point operations over atom coordinates
+ * @param {number}x - the floating point number
+ * @return {number} - the floating point number with the same precision
+ */
+function keepPrecision(x) {
+    return Math.round(_consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.PRECISION_FACTOR * x) / _consts__WEBPACK_IMPORTED_MODULE_0__.monomerWorksConsts.PRECISION_FACTOR;
+}
+//# sourceMappingURL=to-atomic-level-utils.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/monomer-works/types.js":
+/*!*************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/monomer-works/types.js ***!
+  \*************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MolfileWithMap: () => (/* binding */ MolfileWithMap),
+/* harmony export */   MonomerMap: () => (/* binding */ MonomerMap),
+/* harmony export */   getMolGraph: () => (/* binding */ getMolGraph),
+/* harmony export */   hasMolGraph: () => (/* binding */ hasMolGraph),
+/* harmony export */   setMolGraph: () => (/* binding */ setMolGraph)
+/* harmony export */ });
+function getMolGraph(dict, libKey) {
+    return dict[libKey.polymerType]?.[libKey.symbol];
+}
+function hasMolGraph(dict, libKey) {
+    return !!dict[libKey.polymerType]?.[libKey.symbol];
+}
+function setMolGraph(dict, libKey, value) {
+    let pt = dict[libKey.polymerType];
+    if (!pt)
+        pt = dict[libKey.polymerType] = {};
+    pt[libKey.symbol] = value;
+}
+class MonomerMap extends Map {
+    constructor(entries) {
+        super(entries);
+    }
+}
+/** @property monomers key - helm seq position, */
+class MolfileWithMap {
+    constructor(molfile, monomers) {
+        this.molfile = molfile;
+        this.monomers = monomers;
+    }
+    static createEmpty() { return new MolfileWithMap('', new MonomerMap(null)); }
+}
+//# sourceMappingURL=types.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/utils/const.js":
+/*!*****************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/utils/const.js ***!
+  \*****************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DEOXYRIBOSE_SYMBOL: () => (/* binding */ DEOXYRIBOSE_SYMBOL),
+/* harmony export */   DUMMY_MONOMER: () => (/* binding */ DUMMY_MONOMER),
+/* harmony export */   HELM_CORE_FIELDS: () => (/* binding */ HELM_CORE_FIELDS),
+/* harmony export */   HELM_WRAPPERS_REGEXP: () => (/* binding */ HELM_WRAPPERS_REGEXP),
+/* harmony export */   MONOMER_ENCODE_MAX: () => (/* binding */ MONOMER_ENCODE_MAX),
+/* harmony export */   MONOMER_ENCODE_MIN: () => (/* binding */ MONOMER_ENCODE_MIN),
+/* harmony export */   PHOSPHATE_SYMBOL: () => (/* binding */ PHOSPHATE_SYMBOL),
+/* harmony export */   RIBOSE_SYMBOL: () => (/* binding */ RIBOSE_SYMBOL),
+/* harmony export */   SDF_MONOMER_NAME: () => (/* binding */ SDF_MONOMER_NAME),
+/* harmony export */   jsonSdfMonomerLibDict: () => (/* binding */ jsonSdfMonomerLibDict)
+/* harmony export */ });
+// core fields of HELM library object used in toAtomicLevel function
+const HELM_CORE_FIELDS = [
+    "symbol" /* HELM_FIELDS.SYMBOL */,
+    "molfile" /* HELM_FIELDS.MOLFILE */,
+    "rgroups" /* HELM_FIELDS.RGROUPS */,
+    "name" /* HELM_FIELDS.NAME */,
+    // HELM_FIELDS.MONOMER_TYPE, // add if terminal monomers for PEPTIDEs to be
+    // supported
+];
+const SDF_MONOMER_NAME = 'MonomerName';
+// todo: ideally, keys should be expressed via constants
+const jsonSdfMonomerLibDict = {
+    'monomerType': null, // -> Backbone
+    'smiles': null,
+    'name': 'Name',
+    'author': null,
+    'molfile': 'molecule',
+    'naturalAnalog': 'MonomerNaturalAnalogCode',
+    'rgroups': 'MonomerCaps',
+    'createDate': null,
+    'id': null,
+    'polymerType': 'MonomerType',
+    'symbol': 'MonomerName'
+};
+const DUMMY_MONOMER = {
+    'monomerType': 'Backbone',
+    'smiles': '',
+    'name': '',
+    'author': 'Datagrok',
+    'molfile': '',
+    'naturalAnalog': '',
+    'rgroups': [],
+    'createDate': null,
+    'id': 0,
+    'polymerType': 'PEPTIDE',
+    'symbol': ''
+};
+// range of hex nubers used in PepSea library to endode monomers
+const MONOMER_ENCODE_MIN = 0x100;
+const MONOMER_ENCODE_MAX = 0x40A;
+const RIBOSE_SYMBOL = 'r';
+const DEOXYRIBOSE_SYMBOL = 'd';
+const PHOSPHATE_SYMBOL = 'p';
+const HELM_WRAPPERS_REGEXP = new RegExp(`[${RIBOSE_SYMBOL}${DEOXYRIBOSE_SYMBOL}]\\((\\w)\\)${PHOSPHATE_SYMBOL}?`, 'g');
+//# sourceMappingURL=const.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/consts.js":
+/*!********************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/consts.js ***!
+  \********************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ALPHABET: () => (/* binding */ ALPHABET),
+/* harmony export */   Alphabets: () => (/* binding */ Alphabets),
+/* harmony export */   BioTags: () => (/* binding */ TAGS),
+/* harmony export */   GAP_SYMBOL: () => (/* binding */ GAP_SYMBOL),
+/* harmony export */   GapOriginals: () => (/* binding */ GapOriginals),
+/* harmony export */   NOTATION: () => (/* binding */ NOTATION),
+/* harmony export */   TAGS: () => (/* binding */ TAGS),
+/* harmony export */   candidateAlphabets: () => (/* binding */ candidateAlphabets),
+/* harmony export */   helmPp1Re: () => (/* binding */ helmPp1Re),
+/* harmony export */   helmRe: () => (/* binding */ helmRe),
+/* harmony export */   monomerRe: () => (/* binding */ monomerRe),
+/* harmony export */   positionSeparator: () => (/* binding */ positionSeparator)
+/* harmony export */ });
+/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./types */ "./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/types.js");
+
+/** enum type to simplify setting "user-friendly" notation if necessary */
+var NOTATION;
+(function (NOTATION) {
+    NOTATION["FASTA"] = "fasta";
+    NOTATION["SEPARATOR"] = "separator";
+    NOTATION["HELM"] = "helm";
+    /* Requires notation handler */ NOTATION["CUSTOM"] = "custom";
+})(NOTATION || (NOTATION = {}));
+var ALPHABET;
+(function (ALPHABET) {
+    ALPHABET["DNA"] = "DNA";
+    ALPHABET["RNA"] = "RNA";
+    ALPHABET["PT"] = "PT";
+    /** Unknown */
+    ALPHABET["UN"] = "UN";
+})(ALPHABET || (ALPHABET = {}));
+var TAGS;
+(function (TAGS) {
+    TAGS["aligned"] = "aligned";
+    TAGS["alphabet"] = "alphabet";
+    TAGS["alphabetSize"] = ".alphabetSize";
+    TAGS["alphabetIsMultichar"] = ".alphabetIsMultichar";
+    TAGS["separator"] = "separator";
+    TAGS["isHelmCompatible"] = ".isHelmCompatible";
+    TAGS["positionNames"] = ".positionNames";
+    TAGS["positionLabels"] = ".positionLabels";
+    TAGS["regions"] = ".regions";
+    TAGS["positionShift"] = ".positionShift";
+    TAGS["selectedPosition"] = ".selectedPosition";
+})(TAGS || (TAGS = {}));
+
+const positionSeparator = ', ';
+const monomerRe = /(?:\[([A-Za-z0-9_\-,()]+)\])|([A-Za-z\-])/g;
+const helmRe = /(PEPTIDE1|DNA1|RNA1)\{([^}]+)}/g;
+const helmPp1Re = /\[([^\[\]]+)]/g;
+const Alphabets = new class {
+    constructor() {
+        this.fasta = {
+            peptide: new Set([
+                'G', 'L', 'Y', 'S', 'E', 'Q', 'D', 'N', 'F', 'A',
+                'K', 'R', 'H', 'C', 'V', 'P', 'W', 'I', 'M', 'T',
+            ]),
+            dna: new Set(['A', 'C', 'G', 'T']),
+            rna: new Set(['A', 'C', 'G', 'U']),
+        };
+    }
+}();
+const candidateAlphabets = [
+    new _types__WEBPACK_IMPORTED_MODULE_0__.CandidateType(ALPHABET.PT, Alphabets.fasta.peptide, 0.50),
+    new _types__WEBPACK_IMPORTED_MODULE_0__.CandidateType(ALPHABET.DNA, Alphabets.fasta.dna, 0.55),
+    new _types__WEBPACK_IMPORTED_MODULE_0__.CandidateType(ALPHABET.RNA, Alphabets.fasta.rna, 0.55),
+];
+/** Canonical gap symbol */
+const GAP_SYMBOL = '';
+const GapOriginals = {
+    [NOTATION.FASTA]: '-',
+    [NOTATION.SEPARATOR]: '',
+    [NOTATION.HELM]: '*',
+};
+//# sourceMappingURL=consts.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/types.js":
+/*!*******************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/utils/macromolecule/types.js ***!
+  \*******************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   CandidateSimType: () => (/* binding */ CandidateSimType),
+/* harmony export */   CandidateType: () => (/* binding */ CandidateType)
+/* harmony export */ });
+/** Alphabet candidate type */
+class CandidateType {
+    constructor(name, alphabet, cutoff) {
+        this.name = name;
+        this.alphabet = alphabet;
+        this.cutoff = cutoff;
+    }
+}
+/** Alphabet candidate similarity type */
+class CandidateSimType extends CandidateType {
+    constructor(candidate, freq, similarity) {
+        super(candidate.name, candidate.alphabet, candidate.cutoff);
+        this.freq = freq;
+        this.similarity = similarity;
+    }
+}
+//# sourceMappingURL=types.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@datagrok-libraries/js-draw-lite/src/types/org.js":
+/*!************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/js-draw-lite/src/types/org.js ***!
+  \************************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   HelmTypes: () => (/* binding */ HelmTypes)
+/* harmony export */ });
+var HelmTypes;
+(function (HelmTypes) {
+    HelmTypes["BASE"] = "HELM_BASE";
+    HelmTypes["SUGAR"] = "HELM_SUGAR";
+    HelmTypes["LINKER"] = "HELM_LINKER";
+    HelmTypes["AA"] = "HELM_AA";
+    HelmTypes["CHEM"] = "HELM_CHEM";
+    HelmTypes["BLOB"] = "HELM_BLOB";
+    HelmTypes["NUCLEOTIDE"] = "HELM_NUCLETIDE";
+})(HelmTypes || (HelmTypes = {}));
+//# sourceMappingURL=org.js.map
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+/*!*****************************************************************************************!*\
+  !*** ./node_modules/@datagrok-libraries/bio/src/monomer-works/seq-to-molfile-worker.js ***!
+  \*****************************************************************************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _to_atomic_level_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./to-atomic-level-utils */ "./node_modules/@datagrok-libraries/bio/src/monomer-works/to-atomic-level-utils.js");
+
+onmessage = (event) => {
+    const { seqList, monomersDict, alphabet, polymerType, start, end } = event.data;
+    const resMolList = new Array(end - start);
+    const molfileWarningList = new Array(0);
+    for (let rowI = start; rowI < end; ++rowI) {
+        try {
+            const seq = seqList[rowI];
+            resMolList[rowI - start] = (0,_to_atomic_level_utils__WEBPACK_IMPORTED_MODULE_0__.monomerSeqToMolfile)(seq, monomersDict, alphabet, polymerType);
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : err.toString();
+            const msg = `Cannot get molfile of row #${rowI}: ${errMsg}.`;
+            molfileWarningList.push(msg);
+        }
+    }
+    postMessage({ molfiles: resMolList, warnings: molfileWarningList });
+};
+//# sourceMappingURL=seq-to-molfile-worker.js.map
+sequencetranslator = __webpack_exports__;
+/******/ })()
+;
+//# sourceMappingURL=vendors-node_modules_datagrok-libraries_bio_src_monomer-works_seq-to-molfile-worker_js.js.map