molstar 3.3.1 → 3.6.0

package/lib/commonjs/mol-io/reader/mol/parser.js

@@ -194,8 +194,8 @@ function parseInternal(data) {
 }
 function parseMol(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse Mol', function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-        return (0, tslib_1.__generator)(this, function (_a) {
+    return mol_task_1.Task.create('Parse Mol', function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
             return [2 /*return*/, parseInternal(data)];
         });
     }); });

package/lib/commonjs/mol-io/reader/mol2/parser.js

@@ -78,9 +78,9 @@ function handleMolecule(state) {
     molecule.mol_comment = mol_comment;
 }
 function handleAtoms(state) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var tokenizer, molecule, initialTokenizerPosition, initialTokenizerLineNumber, firstLine, firstLineArray, columnCount, atom_idTokens, atom_nameTokens, xTokens, yTokens, zTokens, atom_typeTokens, subst_idTokens, subst_nameTokens, chargeTokens, status_bitTokens, undefFloat, undefInt, undefStr, length, linesAlreadyRead, ret;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     tokenizer = state.tokenizer, molecule = state.molecule;
@@ -175,9 +175,9 @@ function handleAtoms(state) {
     });
 }
 function handleBonds(state) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var tokenizer, molecule, initialTokenizerPosition, initialTokenizerLineNumber, firstLine, firstLineArray, columnCount, bond_idTokens, origin_bond_idTokens, target_bond_idTokens, bondTypeTokens, status_bitTokens, length, linesAlreadyRead, ret;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     tokenizer = state.tokenizer, molecule = state.molecule;
@@ -274,9 +274,9 @@ function handleCrysin(state) {
     };
 }
 function parseInternal(ctx, data, name) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var tokenizer, structures, state, atoms, bonds, crysin, result;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     tokenizer = (0, tokenizer_1.Tokenizer)(data);
@@ -309,8 +309,8 @@ function parseInternal(ctx, data, name) {
 }
 function parseMol2(data, name) {
     var _this = this;
-    return mol_task_1.Task.create('Parse MOL2', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-        return (0, tslib_1.__generator)(this, function (_a) {
+    return mol_task_1.Task.create('Parse MOL2', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, parseInternal(ctx, data, name)];
                 case 1: return [2 /*return*/, _a.sent()];

package/lib/commonjs/mol-io/reader/nctraj/parser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Task } from '../../../mol-task';
+import { ReaderResult as Result } from '../result';
+export interface NctrajFile {
+    coordinates: number[][];
+    velocities?: number[][];
+    forces?: number[][];
+    cell_lengths?: number[][];
+    cell_angles?: number[][];
+    time?: number[];
+    timeOffset: number;
+    deltaTime: number;
+}
+export declare function parseNctraj(data: Uint8Array): Task<Result<NctrajFile>>;

package/lib/commonjs/mol-io/reader/nctraj/parser.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNctraj = void 0;
+var tslib_1 = require("tslib");
+var mol_task_1 = require("../../../mol-task");
+var reader_1 = require("../../common/netcdf/reader");
+var result_1 = require("../result");
+function parseInternal(data) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var nc, f, _i, _a, c, velocities, _b, _c, v, forces, _d, _e, f_1, cell_lengths, _f, _g, l, cell_angles, _h, _j, a, time, _k, _l, t;
+        return tslib_1.__generator(this, function (_m) {
+            nc = new reader_1.NetcdfReader(data);
+            f = {
+                coordinates: [],
+                time: [],
+                timeOffset: 0,
+                deltaTime: 1
+            };
+            for (_i = 0, _a = nc.getDataVariable('coordinates'); _i < _a.length; _i++) {
+                c = _a[_i];
+                f.coordinates.push(c);
+            }
+            if (nc.hasDataVariable('velocities')) {
+                velocities = [];
+                for (_b = 0, _c = nc.getDataVariable('velocities'); _b < _c.length; _b++) {
+                    v = _c[_b];
+                    velocities.push(v);
+                }
+                f.velocities = velocities;
+            }
+            if (nc.hasDataVariable('forces')) {
+                forces = [];
+                for (_d = 0, _e = nc.getDataVariable('forces'); _d < _e.length; _d++) {
+                    f_1 = _e[_d];
+                    forces.push(f_1);
+                }
+                f.forces = forces;
+            }
+            if (nc.hasDataVariable('cell_lengths')) {
+                cell_lengths = [];
+                for (_f = 0, _g = nc.getDataVariable('cell_lengths'); _f < _g.length; _f++) {
+                    l = _g[_f];
+                    cell_lengths.push(l);
+                }
+                f.cell_lengths = cell_lengths;
+            }
+            if (nc.hasDataVariable('cell_angles')) {
+                cell_angles = [];
+                for (_h = 0, _j = nc.getDataVariable('cell_angles'); _h < _j.length; _h++) {
+                    a = _j[_h];
+                    cell_angles.push(a);
+                }
+                f.cell_angles = cell_angles;
+            }
+            if (nc.hasDataVariable('time')) {
+                time = [];
+                for (_k = 0, _l = nc.getDataVariable('time'); _k < _l.length; _k++) {
+                    t = _l[_k];
+                    time.push(t);
+                }
+                f.time = time;
+            }
+            if (f.time) {
+                if (f.time.length >= 1) {
+                    f.timeOffset = f.time[0];
+                }
+                if (f.time.length >= 2) {
+                    f.deltaTime = f.time[1] - f.time[0];
+                }
+            }
+            return [2 /*return*/, f];
+        });
+    });
+}
+function parseNctraj(data) {
+    var _this = this;
+    return mol_task_1.Task.create('Parse NCTRAJ', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        var file, e_1;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    ctx.update({ canAbort: true, message: 'Parsing trajectory...' });
+                    return [4 /*yield*/, parseInternal(data)];
+                case 1:
+                    file = _a.sent();
+                    return [2 /*return*/, result_1.ReaderResult.success(file)];
+                case 2:
+                    e_1 = _a.sent();
+                    return [2 /*return*/, result_1.ReaderResult.error('' + e_1)];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); });
+}
+exports.parseNctraj = parseNctraj;

package/lib/commonjs/mol-io/reader/obj/parser.js

@@ -11,9 +11,9 @@ var result_1 = require("../result");
 var mol_task_1 = require("../../../mol-task");
 var mesh_1 = require("../../../mol-geo/geometry/mesh/mesh");
 function parseInternal(data, ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var mesh;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             mesh = mesh_1.Mesh.createEmpty();
             // Mesh.computeNormalsImmediate(mesh)
             return [2 /*return*/, result_1.ReaderResult.success(mesh)];
@@ -22,8 +22,8 @@ function parseInternal(data, ctx) {
 }
 function parse(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse OBJ', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-        return (0, tslib_1.__generator)(this, function (_a) {
+    return mol_task_1.Task.create('Parse OBJ', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, parseInternal(data, ctx)];
                 case 1: return [2 /*return*/, _a.sent()];

package/lib/commonjs/mol-io/reader/pdb/parser.js

@@ -14,10 +14,10 @@ var tokenizer_1 = require("../common/text/tokenizer");
 function parsePDB(data, id, isPdbqt) {
     var _this = this;
     if (isPdbqt === void 0) { isPdbqt = false; }
-    return mol_task_1.Task.create('Parse PDB', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+    return mol_task_1.Task.create('Parse PDB', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var _a, _b;
         var _c;
-        return (0, tslib_1.__generator)(this, function (_d) {
+        return tslib_1.__generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
                     _b = (_a = result_1.ReaderResult).success;

package/lib/commonjs/mol-io/reader/ply/parser.js

@@ -224,9 +224,9 @@ function parseListElement(state, spec) {
     });
 }
 function parseInternal(data, ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var state, elements, elementSpecs, comments, elementNames, result;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             state = State(data, ctx);
             ctx.update({ message: 'Parsing...', current: 0, max: data.length });
             parseHeader(state);
@@ -240,8 +240,8 @@ function parseInternal(data, ctx) {
 }
 function parsePly(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse PLY', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-        return (0, tslib_1.__generator)(this, function (_a) {
+    return mol_task_1.Task.create('Parse PLY', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, parseInternal(data, ctx)];
                 case 1: return [2 /*return*/, _a.sent()];

package/lib/commonjs/mol-io/reader/prmtop/parser.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Task } from '../../../mol-task';
+import { ReaderResult as Result } from '../result';
+import { Column } from '../../../mol-data/db';
+declare const Pointers: {
+    NATOM: string;
+    NTYPES: string;
+    NBONH: string;
+    MBONA: string;
+    NTHETH: string;
+    MTHETA: string;
+    NPHIH: string;
+    MPHIA: string;
+    NHPARM: string;
+    NPARM: string;
+    NNB: string;
+    NRES: string;
+    NBONA: string;
+    NTHETA: string;
+    NPHIA: string;
+    NUMBND: string;
+    NUMANG: string;
+    NPTRA: string;
+    NATYP: string;
+    NPHB: string;
+    IFPERT: string;
+    NBPER: string;
+    NGPER: string;
+    NDPER: string;
+    MBPER: string;
+    MGPER: string;
+    MDPER: string;
+    IFBOX: string;
+    NMXRS: string;
+    IFCAP: string;
+    NUMEXTRA: string;
+    NCOPY: string;
+};
+declare type PointerName = keyof typeof Pointers;
+export interface PrmtopFile {
+    readonly version: string;
+    readonly title: ReadonlyArray<string>;
+    readonly pointers: Readonly<Record<PointerName, number>>;
+    readonly atomName: Column<string>;
+    readonly charge: Column<number>;
+    readonly mass: Column<number>;
+    readonly residueLabel: Column<string>;
+    readonly residuePointer: Column<number>;
+    readonly bondsIncHydrogen: Column<number>;
+    readonly bondsWithoutHydrogen: Column<number>;
+    readonly radii: Column<number>;
+}
+export declare function parsePrmtop(data: string): Task<Result<PrmtopFile>>;
+export {};

package/lib/commonjs/mol-io/reader/prmtop/parser.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrmtop = void 0;
+var tslib_1 = require("tslib");
+var mol_task_1 = require("../../../mol-task");
+var tokenizer_1 = require("../common/text/tokenizer");
+var result_1 = require("../result");
+var token_1 = require("../common/text/column/token");
+var db_1 = require("../../../mol-data/db");
+// http://ambermd.org/prmtop.pdf
+// https://ambermd.org/FileFormats.php#topology
+var Pointers = {
+    'NATOM': '', 'NTYPES': '', 'NBONH': '', 'MBONA': '', 'NTHETH': '', 'MTHETA': '',
+    'NPHIH': '', 'MPHIA': '', 'NHPARM': '', 'NPARM': '', 'NNB': '', 'NRES': '',
+    'NBONA': '', 'NTHETA': '', 'NPHIA': '', 'NUMBND': '', 'NUMANG': '', 'NPTRA': '',
+    'NATYP': '', 'NPHB': '', 'IFPERT': '', 'NBPER': '', 'NGPER': '', 'NDPER': '',
+    'MBPER': '', 'MGPER': '', 'MDPER': '', 'IFBOX': '', 'NMXRS': '', 'IFCAP': '',
+    'NUMEXTRA': '', 'NCOPY': '',
+};
+var PointersNames = Object.keys(Pointers);
+var readLine = tokenizer_1.Tokenizer.readLine, markLine = tokenizer_1.Tokenizer.markLine, trim = tokenizer_1.Tokenizer.trim;
+function State(tokenizer, runtimeCtx) {
+    return {
+        tokenizer: tokenizer,
+        runtimeCtx: runtimeCtx,
+    };
+}
+function handleTitle(state) {
+    var tokenizer = state.tokenizer;
+    var title = [];
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        if (tokenizer.data[tokenizer.position] === '%')
+            break;
+        var line = readLine(tokenizer).trim();
+        if (line)
+            title.push(line);
+    }
+    return title;
+}
+function handlePointers(state) {
+    var tokenizer = state.tokenizer;
+    var pointers = Object.create(null);
+    PointersNames.forEach(function (name) { pointers[name] = 0; });
+    var curIdx = 0;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        if (tokenizer.data[tokenizer.position] === '%')
+            break;
+        var line = readLine(tokenizer);
+        var n = Math.min(curIdx + 10, 32);
+        for (var i = 0; curIdx < n; ++i, ++curIdx) {
+            pointers[PointersNames[curIdx]] = parseInt(line.substring(i * 8, i * 8 + 8).trim());
+        }
+    }
+    return pointers;
+}
+function handleTokens(state, count, countPerLine, itemSize) {
+    var tokenizer = state.tokenizer;
+    var tokens = tokenizer_1.TokenBuilder.create(tokenizer.data, count * 2);
+    var curIdx = 0;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        if (tokenizer.data[tokenizer.position] === '%')
+            break;
+        tokenizer.tokenStart = tokenizer.position;
+        var n = Math.min(curIdx + countPerLine, count);
+        for (var i = 0; curIdx < n; ++i, ++curIdx) {
+            var p = tokenizer.position;
+            trim(tokenizer, tokenizer.position, tokenizer.position + itemSize);
+            tokenizer_1.TokenBuilder.addUnchecked(tokens, tokenizer.tokenStart, tokenizer.tokenEnd);
+            tokenizer.position = p + itemSize;
+        }
+        markLine(tokenizer);
+    }
+    return tokens;
+}
+function parseInternal(data, ctx) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var t, state, result, prevPosition, line, flag, formatLine, tokens, tokens, tokens, tokens, tokens, tokens, tokens, tokens;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    t = (0, tokenizer_1.Tokenizer)(data);
+                    state = State(t, ctx);
+                    result = Object.create(null);
+                    prevPosition = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(t.tokenEnd < t.length)) return [3 /*break*/, 4];
+                    if (!(t.position - prevPosition > 100000 && ctx.shouldUpdate)) return [3 /*break*/, 3];
+                    prevPosition = t.position;
+                    return [4 /*yield*/, ctx.update({ current: t.position, max: t.length })];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    line = readLine(state.tokenizer).trim();
+                    if (line.startsWith('%VERSION')) {
+                        result.version = line.substring(8).trim();
+                    }
+                    else if (line.startsWith('%FLAG')) {
+                        flag = line.substring(5).trim();
+                        formatLine = readLine(state.tokenizer).trim();
+                        if (!formatLine.startsWith('%FORMAT'))
+                            throw new Error('expected %FORMAT');
+                        if (flag === 'TITLE') {
+                            result.title = handleTitle(state);
+                        }
+                        else if (flag === 'POINTERS') {
+                            result.pointers = handlePointers(state);
+                        }
+                        else if (flag === 'ATOM_NAME') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 20, 4);
+                            result.atomName = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.str);
+                        }
+                        else if (flag === 'CHARGE') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 5, 16);
+                            result.charge = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.float);
+                        }
+                        else if (flag === 'MASS') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 5, 16);
+                            result.mass = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.float);
+                        }
+                        else if (flag === 'RESIDUE_LABEL') {
+                            tokens = handleTokens(state, result.pointers['NRES'], 20, 4);
+                            result.residueLabel = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.str);
+                        }
+                        else if (flag === 'RESIDUE_POINTER') {
+                            tokens = handleTokens(state, result.pointers['NRES'], 10, 8);
+                            result.residuePointer = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.int);
+                        }
+                        else if (flag === 'BONDS_INC_HYDROGEN') {
+                            tokens = handleTokens(state, result.pointers['NBONH'] * 3, 10, 8);
+                            result.bondsIncHydrogen = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.int);
+                        }
+                        else if (flag === 'BONDS_WITHOUT_HYDROGEN') {
+                            tokens = handleTokens(state, result.pointers['NBONA'] * 3, 10, 8);
+                            result.bondsWithoutHydrogen = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.int);
+                        }
+                        else if (flag === 'RADII') {
+                            tokens = handleTokens(state, result.pointers['NATOM'], 5, 16);
+                            result.radii = (0, token_1.TokenColumnProvider)(tokens)(db_1.Column.Schema.float);
+                        }
+                        else {
+                            while (t.tokenEnd < t.length) {
+                                if (t.data[t.position] === '%')
+                                    break;
+                                markLine(t);
+                            }
+                        }
+                    }
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, result_1.ReaderResult.success(result)];
+            }
+        });
+    });
+}
+function parsePrmtop(data) {
+    var _this = this;
+    return mol_task_1.Task.create('Parse PRMTOP', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, parseInternal(data, ctx)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    }); });
+}
+exports.parsePrmtop = parsePrmtop;

package/lib/commonjs/mol-io/reader/psf/parser.js

@@ -22,9 +22,9 @@ function State(tokenizer, runtimeCtx) {
     };
 }
 function handleAtoms(state, count) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var tokenizer, atomId, segmentName, residueId, residueName, atomName, atomType, charge, mass, position, line, isLammpsFull, n, length, linesAlreadyRead;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     tokenizer = state.tokenizer;
@@ -130,9 +130,9 @@ function handleAtoms(state, count) {
     });
 }
 function handleBonds(state, count) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var tokenizer, atomIdA, atomIdB, length, bondsAlreadyRead;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     tokenizer = state.tokenizer;
@@ -180,9 +180,9 @@ function parseTitle(state, count) {
     return title;
 }
 function parseInternal(data, ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var tokenizer, state, title, atoms, bonds, id, line, numTitle, numAtoms, numBonds, result;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     tokenizer = (0, tokenizer_1.Tokenizer)(data);
@@ -269,8 +269,8 @@ function parseInternal(data, ctx) {
 }
 function parsePsf(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse PSF', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-        return (0, tslib_1.__generator)(this, function (_a) {
+    return mol_task_1.Task.create('Parse PSF', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, parseInternal(data, ctx)];
                 case 1: return [2 /*return*/, _a.sent()];

package/lib/commonjs/mol-io/reader/sdf/parser.js

@@ -101,8 +101,8 @@ function parseInternal(data) {
 }
 function parseSdf(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse Sdf', function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-        return (0, tslib_1.__generator)(this, function (_a) {
+    return mol_task_1.Task.create('Parse Sdf', function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
             return [2 /*return*/, parseInternal(data)];
         });
     }); });

package/lib/commonjs/mol-io/reader/top/parser.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Task } from '../../../mol-task';
+import { ReaderResult as Result } from '../result';
+import { Column, Table } from '../../../mol-data/db';
+declare const AtomsSchema: {
+    nr: Column.Schema.Int;
+    type: Column.Schema.Str;
+    resnr: Column.Schema.Int;
+    residu: Column.Schema.Str;
+    atom: Column.Schema.Str;
+    cgnr: Column.Schema.Int;
+    charge: Column.Schema.Float;
+    mass: Column.Schema.Float;
+};
+declare const BondsSchema: {
+    ai: Column.Schema.Int;
+    aj: Column.Schema.Int;
+};
+declare const MoleculesSchema: {
+    compound: Column.Schema.Str;
+    molCount: Column.Schema.Int;
+};
+declare type Compound = {
+    atoms: Table<typeof AtomsSchema>;
+    bonds?: Table<typeof BondsSchema>;
+};
+export interface TopFile {
+    readonly system: string;
+    readonly molecules: Table<typeof MoleculesSchema>;
+    readonly compounds: Record<string, Compound>;
+}
+export declare function parseTop(data: string): Task<Result<TopFile>>;
+export {};