molstar 3.3.1 → 3.4.0

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 {};

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

@@ -0,0 +1,303 @@
+"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.parseTop = 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");
+// https://manual.gromacs.org/2021-current/reference-manual/file-formats.html#top
+var AtomsSchema = {
+    nr: db_1.Column.Schema.Int(),
+    type: db_1.Column.Schema.Str(),
+    resnr: db_1.Column.Schema.Int(),
+    residu: db_1.Column.Schema.Str(),
+    atom: db_1.Column.Schema.Str(),
+    cgnr: db_1.Column.Schema.Int(),
+    charge: db_1.Column.Schema.Float(),
+    mass: db_1.Column.Schema.Float(),
+};
+var BondsSchema = {
+    ai: db_1.Column.Schema.Int(),
+    aj: db_1.Column.Schema.Int(),
+};
+var MoleculesSchema = {
+    compound: db_1.Column.Schema.Str(),
+    molCount: db_1.Column.Schema.Int(),
+};
+var readLine = tokenizer_1.Tokenizer.readLine, markLine = tokenizer_1.Tokenizer.markLine, skipWhitespace = tokenizer_1.Tokenizer.skipWhitespace, markStart = tokenizer_1.Tokenizer.markStart, eatValue = tokenizer_1.Tokenizer.eatValue, eatLine = tokenizer_1.Tokenizer.eatLine;
+function State(tokenizer, runtimeCtx) {
+    return {
+        tokenizer: tokenizer,
+        runtimeCtx: runtimeCtx,
+    };
+}
+var reField = /\[ (.+) \]/;
+var reWhitespace = /\s+/;
+function handleMoleculetype(state) {
+    var tokenizer = state.tokenizer;
+    var molName = undefined;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        if (molName !== undefined)
+            throw new Error('more than one molName');
+        var line = readLine(tokenizer);
+        molName = line.split(reWhitespace)[0];
+    }
+    if (molName === undefined)
+        throw new Error('missing molName');
+    return molName;
+}
+function handleAtoms(state) {
+    var tokenizer = state.tokenizer;
+    var nr = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var type = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var resnr = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var residu = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var atom = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var cgnr = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var charge = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var mass = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        for (var j = 0; j < 8; ++j) {
+            skipWhitespace(tokenizer);
+            markStart(tokenizer);
+            eatValue(tokenizer);
+            switch (j) {
+                case 0:
+                    tokenizer_1.TokenBuilder.add(nr, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 1:
+                    tokenizer_1.TokenBuilder.add(type, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 2:
+                    tokenizer_1.TokenBuilder.add(resnr, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 3:
+                    tokenizer_1.TokenBuilder.add(residu, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 4:
+                    tokenizer_1.TokenBuilder.add(atom, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 5:
+                    tokenizer_1.TokenBuilder.add(cgnr, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 6:
+                    tokenizer_1.TokenBuilder.add(charge, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 7:
+                    tokenizer_1.TokenBuilder.add(mass, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+            }
+        }
+        // ignore any extra columns
+        markLine(tokenizer);
+    }
+    return db_1.Table.ofColumns(AtomsSchema, {
+        nr: (0, token_1.TokenColumnProvider)(nr)(db_1.Column.Schema.int),
+        type: (0, token_1.TokenColumnProvider)(type)(db_1.Column.Schema.str),
+        resnr: (0, token_1.TokenColumnProvider)(resnr)(db_1.Column.Schema.int),
+        residu: (0, token_1.TokenColumnProvider)(residu)(db_1.Column.Schema.str),
+        atom: (0, token_1.TokenColumnProvider)(atom)(db_1.Column.Schema.str),
+        cgnr: (0, token_1.TokenColumnProvider)(cgnr)(db_1.Column.Schema.int),
+        charge: (0, token_1.TokenColumnProvider)(charge)(db_1.Column.Schema.float),
+        mass: (0, token_1.TokenColumnProvider)(mass)(db_1.Column.Schema.float),
+    });
+}
+function handleBonds(state) {
+    var tokenizer = state.tokenizer;
+    var ai = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var aj = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        for (var j = 0; j < 2; ++j) {
+            skipWhitespace(tokenizer);
+            markStart(tokenizer);
+            eatValue(tokenizer);
+            switch (j) {
+                case 0:
+                    tokenizer_1.TokenBuilder.add(ai, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 1:
+                    tokenizer_1.TokenBuilder.add(aj, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+            }
+        }
+        // ignore any extra columns
+        markLine(tokenizer);
+    }
+    return db_1.Table.ofColumns(BondsSchema, {
+        ai: (0, token_1.TokenColumnProvider)(ai)(db_1.Column.Schema.int),
+        aj: (0, token_1.TokenColumnProvider)(aj)(db_1.Column.Schema.int),
+    });
+}
+function handleSystem(state) {
+    var tokenizer = state.tokenizer;
+    var system = undefined;
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        if (system !== undefined)
+            throw new Error('more than one system');
+        system = readLine(tokenizer).trim();
+    }
+    if (system === undefined)
+        throw new Error('missing system');
+    return system;
+}
+function handleMolecules(state) {
+    var tokenizer = state.tokenizer;
+    var compound = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    var molCount = tokenizer_1.TokenBuilder.create(tokenizer.data, 64);
+    while (tokenizer.tokenEnd < tokenizer.length) {
+        skipWhitespace(tokenizer);
+        if (tokenizer.position >= tokenizer.length)
+            break;
+        var c = tokenizer.data[tokenizer.position];
+        if (c === '[')
+            break;
+        if (c === ';' || c === '*') {
+            markLine(tokenizer);
+            continue;
+        }
+        for (var j = 0; j < 2; ++j) {
+            skipWhitespace(tokenizer);
+            markStart(tokenizer);
+            eatValue(tokenizer);
+            switch (j) {
+                case 0:
+                    tokenizer_1.TokenBuilder.add(compound, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+                case 1:
+                    tokenizer_1.TokenBuilder.add(molCount, tokenizer.tokenStart, tokenizer.tokenEnd);
+                    break;
+            }
+        }
+        // ignore any extra columns
+        eatLine(tokenizer);
+        markStart(tokenizer);
+    }
+    return db_1.Table.ofColumns(MoleculesSchema, {
+        compound: (0, token_1.TokenColumnProvider)(compound)(db_1.Column.Schema.str),
+        molCount: (0, token_1.TokenColumnProvider)(molCount)(db_1.Column.Schema.int),
+    });
+}
+function parseInternal(data, ctx) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        function addMol() {
+            if (currentMolName && currentCompound.atoms) {
+                result.compounds[currentMolName] = currentCompound;
+                currentCompound = {};
+                currentMolName = '';
+            }
+        }
+        var t, state, result, prevPosition, currentCompound, currentMolName, line, fieldMatch, fieldName;
+        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;
+                    result.compounds = {};
+                    currentCompound = {};
+                    currentMolName = '';
+                    _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 || line[0] === '*' || line[0] === ';') {
+                        return [3 /*break*/, 1];
+                    }
+                    if (line.startsWith('#include')) {
+                        throw new Error('#include statements not allowed');
+                    }
+                    if (line.startsWith('[')) {
+                        fieldMatch = line.match(reField);
+                        if (fieldMatch === null)
+                            throw new Error('expected field name');
+                        fieldName = fieldMatch[1];
+                        if (fieldName === 'moleculetype') {
+                            addMol();
+                            currentMolName = handleMoleculetype(state);
+                        }
+                        else if (fieldName === 'atoms') {
+                            currentCompound.atoms = handleAtoms(state);
+                        }
+                        else if (fieldName === 'bonds') {
+                            currentCompound.bonds = handleBonds(state);
+                        }
+                        else if (fieldName === 'system') {
+                            result.system = handleSystem(state);
+                        }
+                        else if (fieldName === 'molecules') {
+                            addMol(); // add the last compound
+                            result.molecules = handleMolecules(state);
+                        }
+                        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 parseTop(data) {
+    var _this = this;
+    return mol_task_1.Task.create('Parse TOP', 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.parseTop = parseTop;

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

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Adapted from NGL.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+import { Task } from '../../../mol-task';
+import { ReaderResult as Result } from '../result';
+export interface TrrFile {
+    frames: {
+        count: number;
+        x: Float32Array;
+        y: Float32Array;
+        z: Float32Array;
+    }[];
+    boxes: number[][];
+    times: number[];
+    timeOffset: number;
+    deltaTime: number;
+}
+export declare function parseTrr(data: Uint8Array): Task<Result<TrrFile>>;

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

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Adapted from NGL.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTrr = void 0;
+var tslib_1 = require("tslib");
+var mol_task_1 = require("../../../mol-task");
+var result_1 = require("../result");
+function parseInternal(data) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var dv, f, coordinates, boxes, times, offset, versionSize, boxSize, virSize, presSize, coordSize, velocitySize, forceSize, natoms, floatSize, natoms3, box, i, i, x, y, z, i, tmp, i, value, frameCoords, i;
+        return tslib_1.__generator(this, function (_a) {
+            dv = new DataView(data.buffer);
+            f = {
+                frames: [],
+                boxes: [],
+                times: [],
+                timeOffset: 0,
+                deltaTime: 0
+            };
+            coordinates = f.frames;
+            boxes = f.boxes;
+            times = f.times;
+            offset = 0;
+            while (true) {
+                // const magicnum = dv.getInt32(offset)
+                // const i1 = dv.getFloat32(offset + 4)
+                offset += 8;
+                versionSize = dv.getInt32(offset);
+                offset += 4;
+                offset += versionSize;
+                boxSize = dv.getInt32(offset + 8);
+                virSize = dv.getInt32(offset + 12);
+                presSize = dv.getInt32(offset + 16);
+                coordSize = dv.getInt32(offset + 28);
+                velocitySize = dv.getInt32(offset + 32);
+                forceSize = dv.getInt32(offset + 36);
+                natoms = dv.getInt32(offset + 40);
+                // const step = dv.getInt32(offset + 44)
+                // const nre = dv.getInt32(offset + 48)
+                offset += 52;
+                floatSize = boxSize / 9;
+                natoms3 = natoms * 3;
+                // let lambda
+                if (floatSize === 8) {
+                    times.push(dv.getFloat64(offset));
+                    // lambda = dv.getFloat64(offset + 8)
+                }
+                else {
+                    times.push(dv.getFloat32(offset));
+                    // lambda = dv.getFloat32(offset + 4)
+                }
+                offset += 2 * floatSize;
+                if (boxSize) {
+                    box = new Float32Array(9);
+                    if (floatSize === 8) {
+                        for (i = 0; i < 9; ++i) {
+                            box[i] = dv.getFloat64(offset) * 10;
+                            offset += 8;
+                        }
+                    }
+                    else {
+                        for (i = 0; i < 9; ++i) {
+                            box[i] = dv.getFloat32(offset) * 10;
+                            offset += 4;
+                        }
+                    }
+                    boxes.push(box);
+                }
+                // ignore, unused
+                offset += virSize;
+                // ignore, unused
+                offset += presSize;
+                if (coordSize) {
+                    x = new Float32Array(natoms);
+                    y = new Float32Array(natoms);
+                    z = new Float32Array(natoms);
+                    if (floatSize === 8) {
+                        for (i = 0; i < natoms; ++i) {
+                            x[i] = dv.getFloat64(offset) * 10;
+                            y[i] = dv.getFloat64(offset + 8) * 10;
+                            z[i] = dv.getFloat64(offset + 16) * 10;
+                            offset += 24;
+                        }
+                    }
+                    else {
+                        tmp = new Uint32Array(data.buffer, offset, natoms3);
+                        for (i = 0; i < natoms3; ++i) {
+                            value = tmp[i];
+                            tmp[i] = (((value & 0xFF) << 24) | ((value & 0xFF00) << 8) |
+                                ((value >> 8) & 0xFF00) | ((value >> 24) & 0xFF));
+                        }
+                        frameCoords = new Float32Array(data.buffer, offset, natoms3);
+                        for (i = 0; i < natoms; ++i) {
+                            x[i] = frameCoords[i * 3] * 10;
+                            y[i] = frameCoords[i * 3 + 1] * 10;
+                            z[i] = frameCoords[i * 3 + 2] * 10;
+                            offset += 12;
+                        }
+                    }
+                    coordinates.push({ count: natoms, x: x, y: y, z: z });
+                }
+                // ignore, unused
+                offset += velocitySize;
+                // ignore, unused
+                offset += forceSize;
+                if (offset >= data.byteLength)
+                    break;
+            }
+            if (times.length >= 1) {
+                f.timeOffset = times[0];
+            }
+            if (times.length >= 2) {
+                f.deltaTime = times[1] - times[0];
+            }
+            return [2 /*return*/, f];
+        });
+    });
+}
+function parseTrr(data) {
+    var _this = this;
+    return mol_task_1.Task.create('Parse TRR', 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.parseTrr = parseTrr;

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

@@ -141,9 +141,9 @@ function undefinedError() {
     throw new Error('(xdrfile error) Undefined error.');
 }
 function parseInternal(ctx, data) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var dv, f, coordinates, boxes, times, minMaxInt, sizeint, bitsizeint, sizesmall, thiscoord, prevcoord, offset, buf, frameCoords, natoms, box, i, i, lfp, lsize, precision, bitsize, smallidx, tmpIdx, smaller, smallnum, adz, invPrecision, run_1, i, flag, isSmaller, k, tmpSwap, c;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     dv = new DataView(data.buffer, data.byteOffset);
@@ -354,9 +354,9 @@ function parseInternal(ctx, data) {
 }
 function parseXtc(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse XTC', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+    return mol_task_1.Task.create('Parse XTC', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var file, e_1;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     _a.trys.push([0, 2, , 3]);

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

@@ -51,8 +51,8 @@ function parseInternal(data) {
 }
 function parseXyz(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/writer/cif/encoder.js

@@ -10,6 +10,7 @@ exports.Encoder = exports.Category = exports.Field = void 0;
 var tslib_1 = require("tslib");
 var iterator_1 = require("../../../mol-data/iterator");
 var binary_cif_1 = require("../../common/binary-cif");
+var type_helpers_1 = require("../../../mol-util/type-helpers");
 var Field;
 (function (Field) {
     function str(name, value, params) {
@@ -199,7 +200,7 @@ function columnTensorValue(k) {
     }
     return function (i, d) {
         var _a;
-        return (_a = d[k].schema.space).get.apply(_a, (0, tslib_1.__spreadArray)([d[k].value(i)], coords, false));
+        return (_a = d[k].schema.space).get.apply(_a, tslib_1.__spreadArray([d[k].value(i)], coords, false));
     };
 }
 function columnValueKind(k) {
@@ -262,7 +263,7 @@ function cifFieldsFromTableSchema(schema) {
             fields.push.apply(fields, getTensorDefinitions(k, t.space));
         }
         else {
-            throw new Error("Unknown valueType ".concat(t.valueType));
+            (0, type_helpers_1.assertUnreachable)(t.valueType);
         }
     }
     return fields;

package/lib/commonjs/mol-io/writer/cif.js

@@ -10,7 +10,7 @@ exports.CifWriter = void 0;
 var tslib_1 = require("tslib");
 var text_1 = require("./cif/encoder/text");
 var binary_1 = require("./cif/encoder/binary");
-var _Encoder = (0, tslib_1.__importStar)(require("./cif/encoder"));
+var _Encoder = tslib_1.__importStar(require("./cif/encoder"));
 var binary_cif_1 = require("../common/binary-cif");
 var CifWriter;
 (function (CifWriter) {

package/lib/commonjs/mol-io/writer/ligand-encoder.js

@@ -9,7 +9,7 @@ exports.LigandEncoder = void 0;
 var tslib_1 = require("tslib");
 var mol_util_1 = require("../../mol-util");
 function Atom(partial) {
-    return (0, tslib_1.__assign)({}, partial);
+    return tslib_1.__assign({}, partial);
 }
 var LigandEncoder = /** @class */ (function () {
     function LigandEncoder(encoder, metaInformation, hydrogens) {

package/lib/commonjs/mol-io/writer/mol/encoder.js

@@ -13,7 +13,7 @@ var ligand_encoder_1 = require("../ligand-encoder");
 // specification: http://c4.cabrillo.edu/404/ctfile.pdf
 // SDF wraps MOL and allows for multiple molecules per file as well as additional properties
 var MolEncoder = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(MolEncoder, _super);
+    tslib_1.__extends(MolEncoder, _super);
     function MolEncoder(encoder, metaInformation, hydrogens, terminator) {
         if (terminator === void 0) { terminator = ''; }
         var _this = _super.call(this, encoder, metaInformation, hydrogens) || this;

package/lib/commonjs/mol-io/writer/mol2/encoder.js

@@ -16,7 +16,7 @@ var types_1 = require("../../../mol-model/structure/model/types");
 var NON_METAL_ATOMS = 'H D B C N O F Si P S Cl As Se Br Te I At He Ne Ar Kr Xe Rn'.split(' ');
 // specification: http://chemyang.ccnu.edu.cn/ccb/server/AIMMS/mol2.pdf
 var Mol2Encoder = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(Mol2Encoder, _super);
+    tslib_1.__extends(Mol2Encoder, _super);
     function Mol2Encoder(encoder, metaInformation, hydrogens) {
         var _this = _super.call(this, encoder, metaInformation, hydrogens) || this;
         _this.out = mol_util_1.StringBuilder.create();