molstar 2.3.9 → 3.0.0-dev.10

package/lib/commonjs/mol-io/reader/sdf/parser-v3-util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2021-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Jason Pattle <jpattle@exscientia.co.uk>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
+ */
+import { MolFile } from '../mol/parser';
+import { Tokenizer } from '../common/text/tokenizer';
+export declare function isV3(versionLine: string): boolean;
+export declare function handleCountsV3(tokenizer: Tokenizer): {
+    atomCount: number;
+    bondCount: number;
+};
+export declare function handleAtomsV3(tokenizer: Tokenizer, atomCount: number): MolFile['atoms'];
+export declare function handleBondsV3(tokenizer: Tokenizer, bondCount: number): MolFile['bonds'];

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

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Copyright (c) 2021-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Jason Pattle <jpattle@exscientia.co.uk>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBondsV3 = exports.handleAtomsV3 = exports.handleCountsV3 = exports.isV3 = void 0;
+var db_1 = require("../../../mol-data/db");
+var tokenizer_1 = require("../common/text/tokenizer");
+var token_1 = require("../common/text/column/token");
+function isV3(versionLine) {
+    return versionLine.trim().endsWith('V3000');
+}
+exports.isV3 = isV3;
+function handleCountsV3(tokenizer) {
+    var atomCount = tokenizer_1.TokenBuilder.create(tokenizer.data, 1);
+    var bondCount = tokenizer_1.TokenBuilder.create(tokenizer.data, 1);
+    tokenizer_1.Tokenizer.eatLine(tokenizer); // BEGIN CTAB
+    skipSingleValue(tokenizer); // M
+    skipSingleValue(tokenizer); // V30
+    skipSingleValue(tokenizer); // COUNTS
+    addSingleValue(tokenizer, atomCount);
+    addSingleValue(tokenizer, bondCount);
+    tokenizer_1.Tokenizer.eatLine(tokenizer);
+    return {
+        atomCount: (0, token_1.TokenColumnProvider)(atomCount)(db_1.Column.Schema.int).value(0),
+        bondCount: (0, token_1.TokenColumnProvider)(bondCount)(db_1.Column.Schema.int).value(0)
+    };
+}
+exports.handleCountsV3 = handleCountsV3;
+function handleAtomsV3(tokenizer, atomCount) {
+    var x = tokenizer_1.TokenBuilder.create(tokenizer.data, atomCount * 2);
+    var y = tokenizer_1.TokenBuilder.create(tokenizer.data, atomCount * 2);
+    var z = tokenizer_1.TokenBuilder.create(tokenizer.data, atomCount * 2);
+    var type_symbol = tokenizer_1.TokenBuilder.create(tokenizer.data, atomCount * 2);
+    for (var i = 0; i < atomCount; ++i) {
+        tokenizer_1.Tokenizer.markLine(tokenizer);
+        skipSingleValue(tokenizer); // M
+        skipSingleValue(tokenizer); // V30
+        skipSingleValue(tokenizer); // Index
+        var position = tokenizer.position;
+        addSingleValue(tokenizer, type_symbol);
+        addSingleValue(tokenizer, x);
+        addSingleValue(tokenizer, y);
+        addSingleValue(tokenizer, z);
+        tokenizer.position = position;
+    }
+    tokenizer_1.Tokenizer.eatLine(tokenizer); // Previous Line
+    tokenizer_1.Tokenizer.eatLine(tokenizer); // END ATOM
+    return {
+        count: atomCount,
+        x: (0, token_1.TokenColumnProvider)(x)(db_1.Column.Schema.float),
+        y: (0, token_1.TokenColumnProvider)(y)(db_1.Column.Schema.float),
+        z: (0, token_1.TokenColumnProvider)(z)(db_1.Column.Schema.float),
+        type_symbol: (0, token_1.TokenColumnProvider)(type_symbol)(db_1.Column.Schema.str),
+        /* No support for formal charge parsing in V3000 molfiles at the moment,
+        so all charges default to 0.*/
+        formal_charge: db_1.Column.ofConst(0, atomCount, db_1.Column.Schema.int)
+    };
+}
+exports.handleAtomsV3 = handleAtomsV3;
+function handleBondsV3(tokenizer, bondCount) {
+    var atomIdxA = tokenizer_1.TokenBuilder.create(tokenizer.data, bondCount * 2);
+    var atomIdxB = tokenizer_1.TokenBuilder.create(tokenizer.data, bondCount * 2);
+    var order = tokenizer_1.TokenBuilder.create(tokenizer.data, bondCount * 2);
+    for (var i = 0; i < bondCount; ++i) {
+        tokenizer_1.Tokenizer.markLine(tokenizer);
+        skipSingleValue(tokenizer); // M
+        skipSingleValue(tokenizer); // V30
+        skipSingleValue(tokenizer); // Index
+        var position = tokenizer.position;
+        addSingleValue(tokenizer, order);
+        addSingleValue(tokenizer, atomIdxA);
+        addSingleValue(tokenizer, atomIdxB);
+        tokenizer.position = position;
+    }
+    tokenizer_1.Tokenizer.eatLine(tokenizer); // Previous Line
+    tokenizer_1.Tokenizer.eatLine(tokenizer); // END BOND
+    return {
+        count: bondCount,
+        atomIdxA: (0, token_1.TokenColumnProvider)(atomIdxA)(db_1.Column.Schema.float),
+        atomIdxB: (0, token_1.TokenColumnProvider)(atomIdxB)(db_1.Column.Schema.float),
+        order: (0, token_1.TokenColumnProvider)(order)(db_1.Column.Schema.float),
+    };
+}
+exports.handleBondsV3 = handleBondsV3;
+function skipSingleValue(tokenizer) {
+    tokenizer_1.Tokenizer.skipWhitespace(tokenizer);
+    tokenizer_1.Tokenizer.eatValue(tokenizer);
+}
+function addSingleValue(tokenizer, tokens) {
+    var valueStart = tokenizer.position;
+    tokenizer_1.Tokenizer.skipWhitespace(tokenizer);
+    tokenizer_1.Tokenizer.eatValue(tokenizer);
+    tokenizer_1.Tokenizer.trim(tokenizer, valueStart, tokenizer.position);
+    tokenizer_1.TokenBuilder.addUnchecked(tokens, tokenizer.tokenStart, tokenizer.tokenEnd);
+}
+//# sourceMappingURL=parser-v3-util.js.map

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

@@ -1,14 +1,16 @@
 /**
- * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Sebastian Bittrich <sebastian.bittrich@rcsb.org>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author Jason Pattle <jpattle@exscientia.co.uk>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
  */
 import { Column } from '../../../mol-data/db';
 import { MolFile } from '../mol/parser';
 import { Task } from '../../../mol-task';
 import { ReaderResult as Result } from '../result';
-/** http://c4.cabrillo.edu/404/ctfile.pdf - page 41 */
+/** http://c4.cabrillo.edu/404/ctfile.pdf - page 41 & 79 */
 export interface SdfFileCompound {
     readonly molFile: MolFile;
     readonly dataItems: {

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

@@ -1,9 +1,11 @@
 "use strict";
 /**
- * Copyright (c) 2020-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Sebastian Bittrich <sebastian.bittrich@rcsb.org>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author Jason Pattle <jpattle@exscientia.co.uk>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSdf = void 0;
@@ -14,6 +16,7 @@ var mol_task_1 = require("../../../mol-task");
 var result_1 = require("../result");
 var tokenizer_1 = require("../common/text/tokenizer");
 var token_1 = require("../common/text/column/token");
+var parser_v3_util_1 = require("./parser-v3-util");
 var delimiter = '$$$$';
 function handleDataItems(tokenizer) {
     var dataHeader = tokenizer_1.TokenBuilder.create(tokenizer.data, 32);
@@ -49,12 +52,19 @@ function handleDataItems(tokenizer) {
         data: (0, token_1.TokenColumnProvider)(data)(db_1.Column.Schema.str)
     };
 }
+function handleCountsV2(countsAndVersion) {
+    return {
+        atomCount: +countsAndVersion.substr(0, 3),
+        bondCount: +countsAndVersion.substr(3, 3)
+    };
+}
 function handleMolFile(tokenizer) {
     var title = tokenizer_1.Tokenizer.readLine(tokenizer).trim();
     var program = tokenizer_1.Tokenizer.readLine(tokenizer).trim();
     var comment = tokenizer_1.Tokenizer.readLine(tokenizer).trim();
-    var counts = tokenizer_1.Tokenizer.readLine(tokenizer);
-    var atomCount = +counts.substr(0, 3), bondCount = +counts.substr(3, 3);
+    var countsAndVersion = tokenizer_1.Tokenizer.readLine(tokenizer);
+    var molIsV3 = (0, parser_v3_util_1.isV3)(countsAndVersion);
+    var _a = molIsV3 ? (0, parser_v3_util_1.handleCountsV3)(tokenizer) : handleCountsV2(countsAndVersion), atomCount = _a.atomCount, bondCount = _a.bondCount;
     if (Number.isNaN(atomCount) || Number.isNaN(bondCount)) {
         // try to skip to next molecule
         while (tokenizer.position < tokenizer.length) {
@@ -64,11 +74,18 @@ function handleMolFile(tokenizer) {
         }
         return;
     }
-    var atoms = (0, parser_1.handleAtoms)(tokenizer, atomCount);
-    var bonds = (0, parser_1.handleBonds)(tokenizer, bondCount);
+    /* No support for formal charge parsing in V3000 molfiles at the moment,
+    so all charges default to 0.*/
+    var nullFormalCharges = {
+        atomIdx: db_1.Column.ofConst(0, atomCount, db_1.Column.Schema.int),
+        charge: db_1.Column.ofConst(0, atomCount, db_1.Column.Schema.int)
+    };
+    var atoms = molIsV3 ? (0, parser_v3_util_1.handleAtomsV3)(tokenizer, atomCount) : (0, parser_1.handleAtoms)(tokenizer, atomCount);
+    var bonds = molIsV3 ? (0, parser_v3_util_1.handleBondsV3)(tokenizer, bondCount) : (0, parser_1.handleBonds)(tokenizer, bondCount);
+    var formalCharges = molIsV3 ? nullFormalCharges : (0, parser_1.handlePropertiesBlock)(tokenizer);
     var dataItems = handleDataItems(tokenizer);
     return {
-        molFile: { title: title, program: program, comment: comment, atoms: atoms, bonds: bonds },
+        molFile: { title: title, program: program, comment: comment, atoms: atoms, bonds: bonds, formalCharges: formalCharges },
         dataItems: dataItems
     };
 }

package/lib/commonjs/mol-math/geometry/gaussian-density/gpu.js

@@ -13,7 +13,7 @@ var int_1 = require("../../../mol-data/int");
 var linear_algebra_1 = require("../../linear-algebra");
 var mol_util_1 = require("../../../mol-util");
 var renderable_1 = require("../../../mol-gl/renderable");
-var float_packing_1 = require("../../../mol-util/float-packing");
+var number_packing_1 = require("../../../mol-util/number-packing");
 var shader_code_1 = require("../../../mol-gl/shader-code");
 var render_item_1 = require("../../../mol-gl/webgl/render-item");
 var schema_1 = require("../../../mol-gl/renderable/schema");
@@ -378,7 +378,7 @@ function fieldFromTexture2d(ctx, texture, dim, texDim) {
             for (var ix = 0; ix < dx; ++ix) {
                 var idx = 4 * (tmpCol * dx + (iy + tmpRow) * width + ix);
                 data[j] = image[idx + 3] / 255;
-                idData[j] = (0, float_packing_1.decodeFloatRGB)(image[idx], image[idx + 1], image[idx + 2]);
+                idData[j] = (0, number_packing_1.unpackRGBToInt)(image[idx], image[idx + 1], image[idx + 2]);
                 j++;
             }
         }

package/lib/commonjs/mol-math/geometry/symmetry-operator.js

@@ -25,8 +25,9 @@ var SymmetryOperator;
         var suffix = getSuffix(info);
         if (mat4_1.Mat4.isIdentity(matrix))
             return { name: name, assembly: assembly, matrix: matrix, inverse: mat4_1.Mat4.identity(), isIdentity: true, hkl: _hkl, spgrOp: spgrOp, ncsId: ncsId, suffix: suffix };
-        if (!mat4_1.Mat4.isRotationAndTranslation(matrix, SymmetryOperator.RotationTranslationEpsilon))
-            throw new Error("Symmetry operator (".concat(name, ") must be a composition of rotation and translation."));
+        if (!mat4_1.Mat4.isRotationAndTranslation(matrix, SymmetryOperator.RotationTranslationEpsilon)) {
+            console.warn("Symmetry operator (".concat(name, ") should be a composition of rotation and translation."));
+        }
         return { name: name, assembly: assembly, matrix: matrix, inverse: mat4_1.Mat4.invert((0, mat4_1.Mat4)(), matrix), isIdentity: false, hkl: _hkl, spgrOp: spgrOp, ncsId: ncsId, suffix: suffix };
     }
     SymmetryOperator.create = create;

package/lib/commonjs/mol-math/linear-algebra/3d/quat.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -70,6 +70,14 @@ declare namespace Quat {
     function fromArray(a: Quat, array: NumberArray, offset: number): Quat;
     function copy(out: Quat, a: Quat): Quat;
     function set(out: Quat, x: number, y: number, z: number, w: number): Quat;
+    /**
+     * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+     */
+    function exactEquals(a: Quat, b: Quat): boolean;
+    /**
+     * Returns whether or not the quaternions have approximately the same elements in the same position.
+     */
+    function equals(a: Quat, b: Quat): boolean;
     function add(out: Quat, a: Quat, b: Quat): Quat;
     function normalize(out: Quat, a: Quat): Quat;
     function rotationTo(out: Quat, a: Vec3, b: Vec3): Quat;

package/lib/commonjs/mol-math/linear-algebra/3d/quat.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2017-2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -315,6 +315,25 @@ exports.Quat = Quat;
         return out;
     }
     Quat.set = set;
+    /**
+     * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)
+     */
+    function exactEquals(a, b) {
+        return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+    }
+    Quat.exactEquals = exactEquals;
+    /**
+     * Returns whether or not the quaternions have approximately the same elements in the same position.
+     */
+    function equals(a, b) {
+        var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+        var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+        return (Math.abs(a0 - b0) <= common_1.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
+            Math.abs(a1 - b1) <= common_1.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
+            Math.abs(a2 - b2) <= common_1.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&
+            Math.abs(a3 - b3) <= common_1.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)));
+    }
+    Quat.equals = equals;
     function add(out, a, b) {
         out[0] = a[0] + b[0];
         out[1] = a[1] + b[1];

package/lib/commonjs/mol-math/linear-algebra/3d/vec3.d.ts

@@ -138,6 +138,12 @@ declare namespace Vec3 {
      * Computes the dihedral angles of 4 points, reports in radians.
      */
     function dihedralAngle(a: Vec3, b: Vec3, c: Vec3, d: Vec3): number;
+    /**
+     * @param inclination in radians [0, PI]
+     * @param azimuth in radians [0, 2 * PI]
+     * @param radius [0, +Inf]
+     */
+    function directionFromSpherical(out: Vec3, inclination: number, azimuth: number, radius: number): Vec3;
     /**
      * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
      */

package/lib/commonjs/mol-math/linear-algebra/3d/vec3.js

@@ -469,6 +469,15 @@ exports.Vec3 = Vec3;
         return dot(tmp_dh_cb, tmp_dh_cross) > 0 ? _angle : -_angle;
     }
     Vec3.dihedralAngle = dihedralAngle;
+    /**
+     * @param inclination in radians [0, PI]
+     * @param azimuth in radians [0, 2 * PI]
+     * @param radius [0, +Inf]
+     */
+    function directionFromSpherical(out, inclination, azimuth, radius) {
+        return Vec3.set(out, radius * Math.cos(azimuth) * Math.sin(inclination), radius * Math.sin(azimuth) * Math.sin(inclination), radius * Math.cos(inclination));
+    }
+    Vec3.directionFromSpherical = directionFromSpherical;
     /**
      * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
      */

package/lib/commonjs/mol-model/loci.d.ts

@@ -54,56 +54,56 @@ declare namespace Loci {
     export function getPrincipalAxes(loci: Loci): PrincipalAxes | undefined;
     const Granularity: {
         element: (loci: Loci) => Loci;
-        residue: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
-            kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        residue: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
-        chain: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
+        chain: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
-        entity: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
+        entity: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
-        model: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
+        model: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
-        operator: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
+        operator: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
-        structure: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
+        structure: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | Volume.Loci;
-        elementInstances: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci;
+        elementInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
-        residueInstances: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
+        residueInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
-        chainInstances: (loci: Loci) => Volume.Isosurface.Loci | Volume.Cell.Loci | {
+        } | {
             kind: "empty-loci";
-        } | StructureElement.Loci | Structure.Loci | Bond.Loci | {
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
+        chainInstances: (loci: Loci) => StructureElement.Loci | Structure.Loci | Bond.Loci | Volume.Loci | Volume.Isosurface.Loci | Volume.Cell.Loci | {
             kind: "every-loci";
-        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci | Volume.Loci;
+        } | {
+            kind: "empty-loci";
+        } | DataLoci<unknown, unknown> | Shape.Loci | ShapeGroup.Loci;
     };
     export type Granularity = keyof typeof Granularity;
-    export const GranularityOptions: ["model" | "structure" | "residue" | "entity" | "chain" | "element" | "operator" | "elementInstances" | "residueInstances" | "chainInstances", string][];
+    export const GranularityOptions: ["element" | "operator" | "residue" | "entity" | "model" | "structure" | "chain" | "elementInstances" | "residueInstances" | "chainInstances", string][];
     /** Exclude `Instances` granularity kinds */
-    export function simpleGranularity(granularity: Granularity): "model" | "structure" | "residue" | "entity" | "chain" | "element" | "operator" | "elementInstances" | "residueInstances" | "chainInstances";
+    export function simpleGranularity(granularity: Granularity): "element" | "operator" | "residue" | "entity" | "model" | "structure" | "chain" | "elementInstances" | "residueInstances" | "chainInstances";
     export function applyGranularity(loci: Loci, granularity: Granularity): Loci;
     /**
      * Converts structure related loci to StructureElement.Loci and applies

package/lib/commonjs/mol-model/shape/shape.d.ts

@@ -38,7 +38,7 @@ export declare namespace Shape {
     function getTheme(shape: Shape): Theme;
     function groupIterator(shape: Shape): LocationIterator;
     function createTransform(transforms: Mat4[], transformData?: TransformData): TransformData;
-    function createRenderObject<G extends Geometry>(shape: Shape<G>, props: PD.Values<Geometry.Params<G>>): import("../../mol-gl/render-object").GraphicsRenderObject<"text" | "mesh" | "points" | "spheres" | "cylinders" | "lines" | "direct-volume" | "image" | "texture-mesh">;
+    function createRenderObject<G extends Geometry>(shape: Shape<G>, props: PD.Values<Geometry.Params<G>>): import("../../mol-gl/render-object").GraphicsRenderObject<"text" | "image" | "points" | "spheres" | "cylinders" | "lines" | "mesh" | "direct-volume" | "texture-mesh">;
     interface Loci {
         readonly kind: 'shape-loci';
         readonly shape: Shape;

package/lib/commonjs/mol-model/structure/model/model.d.ts

@@ -124,6 +124,7 @@ export declare namespace Model {
     function hasProtein(model: Model): boolean;
     function hasNucleic(model: Model): boolean;
     function isFromPdbArchive(model: Model): boolean;
+    function hasPdbId(model: Model): boolean;
     function hasSecondaryStructure(model: Model): boolean;
     function hasCrystalSymmetry(model: Model): boolean;
     function isFromXray(model: Model): boolean;

package/lib/commonjs/mol-model/structure/model/model.js

@@ -204,13 +204,23 @@ var Model;
         if (!mmcif_1.MmcifFormat.is(model.sourceData))
             return false;
         var db = model.sourceData.data.db;
-        return (db.database_2.database_id.isDefined ||
-            // 4 character PDB id
-            model.entryId.match(/^[1-9][a-z0-9]{3,3}$/i) !== null ||
+        for (var i = 0, il = db.database_2.database_id.rowCount; i < il; ++i) {
+            if (db.database_2.database_id.value(i) === 'PDB')
+                return true;
+        }
+        return false;
+    }
+    Model.isFromPdbArchive = isFromPdbArchive;
+    function hasPdbId(model) {
+        if (!mmcif_1.MmcifFormat.is(model.sourceData))
+            return false;
+        return (
+        // 4 character PDB id
+        model.entryId.match(/^[1-9][a-z0-9]{3,3}$/i) !== null ||
             // long PDB id
             model.entryId.match(/^pdb_[0-9]{4,4}[1-9][a-z0-9]{3,3}$/i) !== null);
     }
-    Model.isFromPdbArchive = isFromPdbArchive;
+    Model.hasPdbId = hasPdbId;
     function hasSecondaryStructure(model) {
         if (!mmcif_1.MmcifFormat.is(model.sourceData))
             return false;
@@ -307,7 +317,7 @@ var Model;
         var db = model.sourceData.data.db;
         return hasDensityMap(model) || (
         // check if from pdb archive but missing relevant meta data
-        isFromPdbArchive(model) && (!db.exptl.method.isDefined ||
+        hasPdbId(model) && (!db.exptl.method.isDefined ||
             (isFromXray(model) && (!db.pdbx_database_status.status_code_sf.isDefined ||
                 db.pdbx_database_status.status_code_sf.valueKind(0) === 2 /* Unknown */)) ||
             (isFromEm(model) && (!db.pdbx_database_related.db_name.isDefined))));

package/lib/commonjs/mol-model/structure/model/properties/atomic/hierarchy.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -181,6 +181,11 @@ export interface AtomicIndex {
      * @returns first found index or -1 if none of the given atoms are present.
      */
     findAtomsOnResidue(residueIndex: ResidueIndex, label_atom_ids: Set<string>): ElementIndex;
+    /**
+     * Find element index of an atom on a given residue.
+     * @returns index or -1 if the atom is not present.
+     */
+    findElementOnResidue(residueIndex: ResidueIndex, type_symbol: ElementSymbol): ElementIndex;
 }
 export declare namespace AtomicIndex {
     interface ChainLabelKey {

package/lib/commonjs/mol-model/structure/model/properties/atomic/hierarchy.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>

package/lib/commonjs/mol-model/structure/model/properties/utils/atomic-derived.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */

package/lib/commonjs/mol-model/structure/model/properties/utils/atomic-derived.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -57,6 +57,9 @@ function getAtomicDerivedData(data, segments, index, chemicalComponentMap) {
         if (traceIndex === -1) {
             var coarseAtomId = (0, util_1.getAtomIdForAtomRole)(polyType, 'coarseBackbone');
             traceIndex = index.findAtomsOnResidue(i, coarseAtomId);
+            if (traceIndex === -1 && (0, types_1.isPolymer)(molType)) {
+                traceIndex = index.findElementOnResidue(i, (0, types_1.ElementSymbol)('C'));
+            }
         }
         traceElementIndex[i] = traceIndex;
         var directionFromAtomId = (0, util_1.getAtomIdForAtomRole)(polyType, 'directionFrom');

package/lib/commonjs/mol-model/structure/model/properties/utils/atomic-index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>

package/lib/commonjs/mol-model/structure/model/properties/utils/atomic-index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Copyright (c) 2017-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -43,6 +43,7 @@ function createMapping(entities, data, segments) {
         label_atom_id: data.atoms.label_atom_id,
         auth_atom_id: data.atoms.auth_atom_id,
         label_alt_id: data.atoms.label_alt_id,
+        type_symbol: data.atoms.type_symbol,
         chain_index_entity_index: new Int32Array(data.chains._rowCount),
         entity_index_label_asym_id: new Map(),
         chain_index_label_seq_id: new Map(),
@@ -151,6 +152,9 @@ var Index = /** @class */ (function () {
     Index.prototype.findAtomsOnResidue = function (rI, label_atom_ids) {
         return findAtomByNames(this.residueOffsets[rI], this.residueOffsets[rI + 1], this.map.label_atom_id, label_atom_ids);
     };
+    Index.prototype.findElementOnResidue = function (rI, type_symbol) {
+        return findAtomByElement(this.residueOffsets[rI], this.residueOffsets[rI + 1], this.map.type_symbol, type_symbol);
+    };
     return Index;
 }());
 function findAtomByName(start, end, data, atomName) {
@@ -174,6 +178,13 @@ function findAtomByNameAndAltLoc(start, end, nameData, altLocData, atomName, alt
     }
     return -1;
 }
+function findAtomByElement(start, end, data, typeSymbol) {
+    for (var i = start; i < end; i++) {
+        if (data.value(i) === typeSymbol)
+            return i;
+    }
+    return -1;
+}
 function getAtomicIndex(data, entities, segments) {
     var map = createMapping(entities, data, segments);
     var _a = data.residues, label_seq_id = _a.label_seq_id, auth_seq_id = _a.auth_seq_id, pdbx_PDB_ins_code = _a.pdbx_PDB_ins_code;

package/lib/commonjs/mol-model/structure/model/types.js

@@ -268,6 +268,15 @@ function getMoleculeType(compType, compId) {
             // trust our saccharide table more than given 'non-polymer' or 'other' component type
             return 9 /* Saccharide */;
         }
+        else if (exports.AminoAcidNames.has(compId)) {
+            return 5 /* Protein */;
+        }
+        else if (exports.RnaBaseNames.has(compId)) {
+            return 6 /* RNA */;
+        }
+        else if (exports.DnaBaseNames.has(compId)) {
+            return 7 /* DNA */;
+        }
         else {
             return 1 /* Other */;
         }