molstar 3.3.1 → 3.4.0

package/lib/commonjs/mol-io/common/netcdf/reader.js

@@ -0,0 +1,459 @@
+"use strict";
+/**
+ * Copyright (c) 2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * Adapted from https://github.com/cheminfo-js/netcdfjs
+ * MIT License, Copyright (c) 2016 cheminfo
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetcdfReader = void 0;
+var io_buffer_1 = require("../io-buffer");
+/**
+ * Throws a non-valid NetCDF exception if the statement it's true
+ */
+function notNetcdf(statement, reason) {
+    if (statement) {
+        throw new TypeError('Not a valid NetCDF v3.x file: ' + reason);
+    }
+}
+/**
+ * Moves 1, 2, or 3 bytes to next 4-byte boundary
+ */
+function padding(buffer) {
+    if ((buffer.offset % 4) !== 0) {
+        buffer.skip(4 - (buffer.offset % 4));
+    }
+}
+/**
+ * Reads the name
+ */
+function readName(buffer) {
+    // Read name
+    var nameLength = buffer.readUint32();
+    var name = buffer.readChars(nameLength);
+    // validate name
+    // TODO
+    // Apply padding
+    padding(buffer);
+    return name;
+}
+var types = {
+    BYTE: 1,
+    CHAR: 2,
+    SHORT: 3,
+    INT: 4,
+    FLOAT: 5,
+    DOUBLE: 6
+};
+/**
+ * Parse a number into their respective type
+ */
+function num2str(type) {
+    switch (Number(type)) {
+        case types.BYTE:
+            return 'byte';
+        case types.CHAR:
+            return 'char';
+        case types.SHORT:
+            return 'short';
+        case types.INT:
+            return 'int';
+        case types.FLOAT:
+            return 'float';
+        case types.DOUBLE:
+            return 'double';
+        default:
+            return 'undefined';
+    }
+}
+/**
+ * Parse a number type identifier to his size in bytes
+ */
+function num2bytes(type) {
+    switch (Number(type)) {
+        case types.BYTE:
+            return 1;
+        case types.CHAR:
+            return 1;
+        case types.SHORT:
+            return 2;
+        case types.INT:
+            return 4;
+        case types.FLOAT:
+            return 4;
+        case types.DOUBLE:
+            return 8;
+        default:
+            return -1;
+    }
+}
+/**
+ * Reverse search of num2str
+ */
+function str2num(type) {
+    switch (String(type)) {
+        case 'byte':
+            return types.BYTE;
+        case 'char':
+            return types.CHAR;
+        case 'short':
+            return types.SHORT;
+        case 'int':
+            return types.INT;
+        case 'float':
+            return types.FLOAT;
+        case 'double':
+            return types.DOUBLE;
+        default:
+            return -1;
+    }
+}
+/**
+ * Auxiliary function to read numeric data
+ */
+function readNumber(size, bufferReader) {
+    if (size !== 1) {
+        var numbers = new Array(size);
+        for (var i = 0; i < size; i++) {
+            numbers[i] = bufferReader();
+        }
+        return numbers;
+    }
+    else {
+        return bufferReader();
+    }
+}
+/**
+ * Given a type and a size reads the next element
+ */
+function readType(buffer, type, size) {
+    switch (type) {
+        case types.BYTE:
+            return buffer.readBytes(size);
+        case types.CHAR:
+            return trimNull(buffer.readChars(size));
+        case types.SHORT:
+            return readNumber(size, buffer.readInt16.bind(buffer));
+        case types.INT:
+            return readNumber(size, buffer.readInt32.bind(buffer));
+        case types.FLOAT:
+            return readNumber(size, buffer.readFloat32.bind(buffer));
+        case types.DOUBLE:
+            return readNumber(size, buffer.readFloat64.bind(buffer));
+        default:
+            notNetcdf(true, 'non valid type ' + type);
+            return undefined;
+    }
+}
+/**
+ * Removes null terminate value
+ */
+function trimNull(value) {
+    if (value.charCodeAt(value.length - 1) === 0) {
+        return value.substring(0, value.length - 1);
+    }
+    return value;
+}
+// const STREAMING = 4294967295;
+/**
+ * Read data for the given non-record variable
+ */
+function nonRecord(buffer, variable) {
+    // variable type
+    var type = str2num(variable.type);
+    // size of the data
+    var size = variable.size / num2bytes(type);
+    // iterates over the data
+    var data = new Array(size);
+    for (var i = 0; i < size; i++) {
+        data[i] = readType(buffer, type, 1);
+    }
+    return data;
+}
+/**
+ * Read data for the given record variable
+ */
+function record(buffer, variable, recordDimension) {
+    // variable type
+    var type = str2num(variable.type);
+    var width = variable.size ? variable.size / num2bytes(type) : 1;
+    // size of the data
+    // TODO streaming data
+    var size = recordDimension.length;
+    // iterates over the data
+    var data = new Array(size);
+    var step = recordDimension.recordStep;
+    for (var i = 0; i < size; i++) {
+        var currentOffset = buffer.offset;
+        data[i] = readType(buffer, type, width);
+        buffer.seek(currentOffset + step);
+    }
+    return data;
+}
+// Grammar constants
+var ZERO = 0;
+var NC_DIMENSION = 10;
+var NC_VARIABLE = 11;
+var NC_ATTRIBUTE = 12;
+/**
+ * Read the header of the file
+ * Returns object with the fields:
+ *  - `recordDimension`: Number with the length of record dimension
+ *  - `dimensions`: List of dimensions
+ *  - `globalAttributes`: List of global attributes
+ *  - `variables`: List of variables
+ */
+function header(buffer, version) {
+    // Length of record dimension
+    // sum of the varSize's of all the record variables.
+    var header = { recordDimension: { length: buffer.readUint32() } };
+    // Version
+    header.version = version;
+    // List of dimensions
+    var dimList = dimensionsList(buffer);
+    header.recordDimension.id = dimList.recordId;
+    header.recordDimension.name = dimList.recordName;
+    header.dimensions = dimList.dimensions;
+    // List of global attributes
+    header.globalAttributes = attributesList(buffer);
+    // List of variables
+    var variables = variablesList(buffer, dimList.recordId, version);
+    header.variables = variables.variables;
+    header.recordDimension.recordStep = variables.recordStep;
+    return header;
+}
+/**
+ * List of dimensions
+ */
+function dimensionsList(buffer) {
+    var dimensions, recordId, recordName;
+    var dimList = buffer.readUint32();
+    if (dimList === ZERO) {
+        notNetcdf((buffer.readUint32() !== ZERO), 'wrong empty tag for list of dimensions');
+        return [];
+    }
+    else {
+        notNetcdf((dimList !== NC_DIMENSION), 'wrong tag for list of dimensions');
+        // Length of dimensions
+        var dimensionSize = buffer.readUint32();
+        dimensions = new Array(dimensionSize);
+        for (var dim = 0; dim < dimensionSize; dim++) {
+            // Read name
+            var name_1 = readName(buffer);
+            // Read dimension size
+            var size = buffer.readUint32();
+            if (size === 0) {
+                recordId = dim;
+                recordName = name_1;
+            }
+            dimensions[dim] = {
+                name: name_1,
+                size: size
+            };
+        }
+        return {
+            dimensions: dimensions,
+            recordId: recordId,
+            recordName: recordName
+        };
+    }
+}
+/**
+ * List of attributes
+ */
+function attributesList(buffer) {
+    var attributes;
+    var gAttList = buffer.readUint32();
+    if (gAttList === ZERO) {
+        notNetcdf((buffer.readUint32() !== ZERO), 'wrong empty tag for list of attributes');
+        return [];
+    }
+    else {
+        notNetcdf((gAttList !== NC_ATTRIBUTE), 'wrong tag for list of attributes');
+        // Length of attributes
+        var attributeSize = buffer.readUint32();
+        attributes = new Array(attributeSize);
+        for (var gAtt = 0; gAtt < attributeSize; gAtt++) {
+            // Read name
+            var name_2 = readName(buffer);
+            // Read type
+            var type = buffer.readUint32();
+            notNetcdf(((type < 1) || (type > 6)), 'non valid type ' + type);
+            // Read attribute
+            var size = buffer.readUint32();
+            var value = readType(buffer, type, size);
+            // Apply padding
+            padding(buffer);
+            attributes[gAtt] = {
+                name: name_2,
+                type: num2str(type),
+                value: value
+            };
+        }
+    }
+    return attributes;
+}
+/**
+ * List of variables
+ */
+function variablesList(buffer, recordId, version) {
+    var varList = buffer.readUint32();
+    var recordStep = 0;
+    var variables;
+    if (varList === ZERO) {
+        notNetcdf((buffer.readUint32() !== ZERO), 'wrong empty tag for list of variables');
+        return [];
+    }
+    else {
+        notNetcdf((varList !== NC_VARIABLE), 'wrong tag for list of variables');
+        // Length of variables
+        var variableSize = buffer.readUint32();
+        variables = new Array(variableSize);
+        for (var v = 0; v < variableSize; v++) {
+            // Read name
+            var name_3 = readName(buffer);
+            // Read dimensionality of the variable
+            var dimensionality = buffer.readUint32();
+            // Index into the list of dimensions
+            var dimensionsIds = new Array(dimensionality);
+            for (var dim = 0; dim < dimensionality; dim++) {
+                dimensionsIds[dim] = buffer.readUint32();
+            }
+            // Read variables size
+            var attributes = attributesList(buffer);
+            // Read type
+            var type = buffer.readUint32();
+            notNetcdf(((type < 1) && (type > 6)), 'non valid type ' + type);
+            // Read variable size
+            // The 32-bit varSize field is not large enough to contain the
+            // size of variables that require more than 2^32 - 4 bytes,
+            // so 2^32 - 1 is used in the varSize field for such variables.
+            var varSize = buffer.readUint32();
+            // Read offset
+            var offset = buffer.readUint32();
+            if (version === 2) {
+                notNetcdf((offset > 0), 'offsets larger than 4GB not supported');
+                offset = buffer.readUint32();
+            }
+            // Count amount of record variables
+            if (dimensionsIds[0] === recordId) {
+                recordStep += varSize;
+            }
+            variables[v] = {
+                name: name_3,
+                dimensions: dimensionsIds,
+                attributes: attributes,
+                type: num2str(type),
+                size: varSize,
+                offset: offset,
+                record: (dimensionsIds[0] === recordId)
+            };
+        }
+    }
+    return {
+        variables: variables,
+        recordStep: recordStep
+    };
+}
+/**
+ * Reads a NetCDF v3.x file
+ * https://www.unidata.ucar.edu/software/netcdf/docs/file_format_specifications.html
+ */
+var NetcdfReader = /** @class */ (function () {
+    function NetcdfReader(data) {
+        var buffer = new io_buffer_1.IOBuffer(data);
+        buffer.setBigEndian();
+        // Validate that it's a NetCDF file
+        notNetcdf((buffer.readChars(3) !== 'CDF'), 'should start with CDF');
+        // Check the NetCDF format
+        var version = buffer.readByte();
+        notNetcdf((version > 2), 'unknown version');
+        // Read the header
+        this.header = header(buffer, version);
+        this.buffer = buffer;
+    }
+    Object.defineProperty(NetcdfReader.prototype, "version", {
+        /**
+         * Version for the NetCDF format
+         */
+        get: function () {
+            if (this.header.version === 1) {
+                return 'classic format';
+            }
+            else {
+                return '64-bit offset format';
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetcdfReader.prototype, "recordDimension", {
+        get: function () {
+            return this.header.recordDimension;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetcdfReader.prototype, "dimensions", {
+        get: function () {
+            return this.header.dimensions;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetcdfReader.prototype, "globalAttributes", {
+        get: function () {
+            return this.header.globalAttributes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(NetcdfReader.prototype, "variables", {
+        get: function () {
+            return this.header.variables;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Checks if a variable is available
+     * @param {string|object} variableName - Name of the variable to check
+     * @return {Boolean} - Variable existence
+     */
+    NetcdfReader.prototype.hasDataVariable = function (variableName) {
+        return this.header.variables && this.header.variables.findIndex(function (val) { return val.name === variableName; }) !== -1;
+    };
+    /**
+     * Retrieves the data for a given variable
+     * @param {string|object} variableName - Name of the variable to search or variable object
+     * @return {Array} - List with the variable values
+     */
+    NetcdfReader.prototype.getDataVariable = function (variableName) {
+        var _a;
+        var variable;
+        if (typeof variableName === 'string') {
+            // search the variable
+            variable = (_a = this.header.variables) === null || _a === void 0 ? void 0 : _a.find(function (val) { return val.name === variableName; });
+        }
+        else {
+            variable = variableName;
+        }
+        // throws if variable not found
+        if (variable === undefined)
+            throw new Error('variable not found');
+        // go to the offset position
+        this.buffer.seek(variable.offset);
+        if (variable.record) {
+            // record variable case
+            return record(this.buffer, variable, this.header.recordDimension);
+        }
+        else {
+            // non-record variable case
+            return nonRecord(this.buffer, variable);
+        }
+    };
+    return NetcdfReader;
+}());
+exports.NetcdfReader = NetcdfReader;

package/lib/commonjs/mol-io/common/typed-array.js

@@ -64,8 +64,8 @@ function createTypedArrayBufferContext(size, type) {
 }
 exports.createTypedArrayBufferContext = createTypedArrayBufferContext;
 function readTypedArray(ctx, file, position, byteCount, valueByteOffset, littleEndian) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-        return (0, tslib_1.__generator)(this, function (_a) {
+    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*/, file.readBuffer(position, ctx.readBuffer, byteCount, valueByteOffset)];
                 case 1:

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

@@ -13,9 +13,9 @@ var file_handle_1 = require("../../common/file-handle");
 var simple_buffer_1 = require("../../../mol-io/common/simple-buffer");
 var typed_array_1 = require("../../../mol-io/common/typed-array");
 function readCcp4Header(file) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var headerSize, buffer, MAP, MACHST, littleEndian, modeLE, readInt, readFloat, header;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     headerSize = 1024;
@@ -88,9 +88,9 @@ function readCcp4Header(file) {
 }
 exports.readCcp4Header = readCcp4Header;
 function readCcp4Slices(header, buffer, file, byteOffset, length, littleEndian) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var valueByteOffset, int8, b1, b0, j, jl;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     if (!isMapmode2to0(header)) return [3 /*break*/, 2];
@@ -142,9 +142,9 @@ function getCcp4DataOffset(header) {
 }
 exports.getCcp4DataOffset = getCcp4DataOffset;
 function parseInternal(file, size, ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var _a, header, littleEndian, offset, dataType, valueType, count, elementByteSize, byteCount, buffer, result;
-        return (0, tslib_1.__generator)(this, function (_b) {
+        return tslib_1.__generator(this, function (_b) {
             switch (_b.label) {
                 case 0: return [4 /*yield*/, ctx.update({ message: 'Parsing CCP4/MRC/MAP file...' })];
                 case 1:
@@ -168,9 +168,9 @@ function parseInternal(file, size, ctx) {
 }
 function parseFile(file, size) {
     var _this = this;
-    return mol_task_1.Task.create('Parse CCP4/MRC/MAP', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+    return mol_task_1.Task.create('Parse CCP4/MRC/MAP', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var _a, _b, e_1;
-        return (0, tslib_1.__generator)(this, function (_c) {
+        return tslib_1.__generator(this, function (_c) {
             switch (_c.label) {
                 case 0:
                     _c.trys.push([0, 2, , 3]);

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

@@ -7,7 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCifBinary = void 0;
 var tslib_1 = require("tslib");
-var Data = (0, tslib_1.__importStar)(require("../data-model"));
+var Data = tslib_1.__importStar(require("../data-model"));
 var field_1 = require("./field");
 var result_1 = require("../../result");
 var decode_1 = require("../../../common/msgpack/decode");
@@ -43,9 +43,9 @@ function Category(data) {
 }
 function parseCifBinary(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse BinaryCIF', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+    return mol_task_1.Task.create('Parse BinaryCIF', function (ctx) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var minVersion, unpacked, file;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             minVersion = [0, 3];
             try {
                 unpacked = (0, decode_1.decodeMsgPack)(data);

package/lib/commonjs/mol-io/reader/cif/data-model.js

@@ -34,7 +34,7 @@ function CifSaveFrame(categoryNames, categories, header) {
 }
 exports.CifSaveFrame = CifSaveFrame;
 function CifCategory(name, rowCount, fieldNames, fields) {
-    return { rowCount: rowCount, name: name, fieldNames: (0, tslib_1.__spreadArray)([], fieldNames, true), getField: function (name) { return fields[name]; } };
+    return { rowCount: rowCount, name: name, fieldNames: tslib_1.__spreadArray([], fieldNames, true), getField: function (name) { return fields[name]; } };
 }
 exports.CifCategory = CifCategory;
 (function (CifCategory) {

package/lib/commonjs/mol-io/reader/cif/schema/mmcif-extras.js

@@ -20,8 +20,8 @@ exports.mmCIF_residueId_schema = {
     auth_seq_id: mmcif_1.mmCIF_Schema.atom_site.auth_seq_id,
     auth_asym_id: mmcif_1.mmCIF_Schema.atom_site.auth_asym_id
 };
-exports.mmCIF_chemCompBond_schema = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mmcif_1.mmCIF_Schema.chem_comp_bond), { 
+exports.mmCIF_chemCompBond_schema = tslib_1.__assign(tslib_1.__assign({}, mmcif_1.mmCIF_Schema.chem_comp_bond), { 
     /** Indicates if the bond entry was taken from the protonation variant dictionary */
     molstar_protonation_variant: db_1.Column.Schema.Str() });
 /** Has `type` extended with 'Ion' and 'Lipid' */
-exports.mmCIF_chemComp_schema = (0, tslib_1.__assign)((0, tslib_1.__assign)({}, mmcif_1.mmCIF_Schema.chem_comp), { type: db_1.Column.Schema.Aliased(db_1.Column.Schema.str) });
+exports.mmCIF_chemComp_schema = tslib_1.__assign(tslib_1.__assign({}, mmcif_1.mmCIF_Schema.chem_comp), { type: db_1.Column.Schema.Aliased(db_1.Column.Schema.str) });

package/lib/commonjs/mol-io/reader/cif/schema/mmcif.d.ts

@@ -4872,7 +4872,7 @@ export declare const mmCIF_Schema: {
          * The name of the database containing reference information about
          * this entity or biological unit.
          */
-        db_name: Schema.Aliased<"Other" | "UNP" | "GB" | "OrthoDB" | "NCBI" | "JGI">;
+        db_name: Schema.Aliased<"GB" | "Other" | "UNP" | "OrthoDB" | "NCBI" | "JGI">;
         /**
          * The code for this entity or biological unit or for a closely
          * related entity or biological unit in the named database.

package/lib/commonjs/mol-io/reader/cif/schema.js

@@ -11,7 +11,7 @@ var tslib_1 = require("tslib");
 var db_1 = require("../../../mol-data/db");
 var linear_algebra_1 = require("../../../mol-math/linear-algebra");
 var mol_util_1 = require("../../../mol-util");
-var Data = (0, tslib_1.__importStar)(require("./data-model"));
+var Data = tslib_1.__importStar(require("./data-model"));
 var FieldPath;
 (function (FieldPath) {
     function canonical(path) {
@@ -200,7 +200,7 @@ function createTable(key, schema, frame, aliases) {
         cat = {
             rowCount: rowCount,
             name: key,
-            fieldNames: (0, tslib_1.__spreadArray)([], fieldNames, true),
+            fieldNames: tslib_1.__spreadArray([], fieldNames, true),
             getField: function (name) {
                 return fields_1[name];
             }

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

@@ -25,7 +25,7 @@ var tslib_1 = require("tslib");
  * - Similarly, things like punctuation (\', ..) are left to be processed by the user if needed.
  *
  */
-var Data = (0, tslib_1.__importStar)(require("../data-model"));
+var Data = tslib_1.__importStar(require("../data-model"));
 var tokenizer_1 = require("../../common/text/tokenizer");
 var result_1 = require("../../result");
 var mol_task_1 = require("../../../../mol-task");
@@ -553,9 +553,9 @@ function updateLoopChunk(ctx, state) {
  * Reads a loop.
  */
 function handleLoop(tokenizer, ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var loopLine, name, isFlat, fieldNames, rowCountEstimate, tokens, fieldCount, i, state, rowCount, i, fields, fields, i;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     loopLine = tokenizer.lineNumber;
@@ -631,9 +631,9 @@ function result(data) {
  * @returns CifParserResult wrapper of the result.
  */
 function parseInternal(data, runtimeCtx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
         var dataBlocks, tokenizer, blockHeader, blockCtx, saveFrames, saveCtx, saveFrame, saveHeader, token, cat, cat;
-        return (0, tslib_1.__generator)(this, function (_a) {
+        return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     dataBlocks = [];
@@ -719,8 +719,8 @@ function parseInternal(data, runtimeCtx) {
 }
 function parseCifText(data) {
     var _this = this;
-    return mol_task_1.Task.create('Parse CIF', 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 CIF', 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/cif.js

@@ -32,4 +32,4 @@ exports.CIF = {
         densityServer: function (frame) { return (0, schema_1.toDatabase)(density_server_1.DensityServer_Data_Schema, frame); },
     }
 };
-(0, tslib_1.__exportStar)(require("./cif/data-model"), exports);
+tslib_1.__exportStar(require("./cif/data-model"), exports);

package/lib/commonjs/mol-io/reader/common/text/tokenizer.js

@@ -118,9 +118,9 @@ exports.Tokenizer = Tokenizer;
     /** Advance the state by the given number of lines and return line starts/ends as tokens. */
     function readLinesAsync(state, count, ctx, initialLineCount) {
         if (initialLineCount === void 0) { initialLineCount = 100000; }
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
             var length, lineTokens, linesAlreadyRead;
-            return (0, tslib_1.__generator)(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         length = state.length;
@@ -161,9 +161,9 @@ exports.Tokenizer = Tokenizer;
     }
     function readAllLinesAsync(data, ctx, chunkSize) {
         if (chunkSize === void 0) { chunkSize = 100000; }
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
             var state, tokens;
-            return (0, tslib_1.__generator)(this, function (_a) {
+            return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         state = Tokenizer(data);

package/lib/commonjs/mol-io/reader/csv/data-model.js

@@ -14,6 +14,6 @@ function CsvFile(table) {
 }
 exports.CsvFile = CsvFile;
 function CsvTable(rowCount, columnNames, columns) {
-    return { rowCount: rowCount, columnNames: (0, tslib_1.__spreadArray)([], columnNames, true), getColumn: function (name) { return columns[name]; } };
+    return { rowCount: rowCount, columnNames: tslib_1.__spreadArray([], columnNames, true), getColumn: function (name) { return columns[name]; } };
 }
 exports.CsvTable = CsvTable;