molstar 3.0.1 → 3.0.2

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

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaccharideCompIdMap = exports.MonosaccharidesColorTable = exports.SaccharidesSnfgMap = exports.UnknownSaccharideComponent = exports.getSaccharideShape = exports.getSaccharideName = exports.SaccharideColors = void 0;
+var color_1 = require("../../../../mol-util/color");
+exports.SaccharideColors = (0, color_1.ColorMap)({
+    Blue: 0x0090bc,
+    Green: 0x00a651,
+    Yellow: 0xffd400,
+    Orange: 0xf47920,
+    Pink: 0xf69ea1,
+    Purple: 0xa54399,
+    LightBlue: 0x8fcce9,
+    Brown: 0xa17a4d,
+    Red: 0xed1c24,
+    Secondary: 0xf1ece1
+});
+var SaccharideTypeNameMap = (_a = {},
+    _a[0 /* Hexose */] = 'Hexose',
+    _a[1 /* HexNAc */] = 'HexNAc',
+    _a[2 /* Hexosamine */] = 'Hexosamine',
+    _a[3 /* Hexuronate */] = 'Hexuronate',
+    _a[4 /* Deoxyhexose */] = 'Deoxyhexose',
+    _a[5 /* DeoxyhexNAc */] = 'DeoxyhexNAc',
+    _a[6 /* DiDeoxyhexose */] = 'Di-deoxyhexose',
+    _a[7 /* Pentose */] = 'Pentose',
+    _a[8 /* Deoxynonulosonate */] = 'Deoxynonulosonate',
+    _a[9 /* DiDeoxynonulosonate */] = 'Di-deoxynonulosonate',
+    _a[10 /* Unknown */] = 'Unknown',
+    _a[11 /* Assigned */] = 'Assigned',
+    _a);
+function getSaccharideName(type) {
+    return SaccharideTypeNameMap[type];
+}
+exports.getSaccharideName = getSaccharideName;
+var SaccharideTypeShapeMap = (_b = {},
+    _b[0 /* Hexose */] = 0 /* FilledSphere */,
+    _b[1 /* HexNAc */] = 1 /* FilledCube */,
+    _b[2 /* Hexosamine */] = 2 /* CrossedCube */,
+    _b[3 /* Hexuronate */] = 3 /* DividedDiamond */,
+    _b[4 /* Deoxyhexose */] = 4 /* FilledCone */,
+    _b[5 /* DeoxyhexNAc */] = 5 /* DevidedCone */,
+    _b[6 /* DiDeoxyhexose */] = 6 /* FlatBox */,
+    _b[7 /* Pentose */] = 7 /* FilledStar */,
+    _b[8 /* Deoxynonulosonate */] = 8 /* FilledDiamond */,
+    _b[9 /* DiDeoxynonulosonate */] = 9 /* FlatDiamond */,
+    _b[10 /* Unknown */] = 10 /* FlatHexagon */,
+    _b[11 /* Assigned */] = 11 /* Pentagon */,
+    _b);
+function getSaccharideShape(type, ringMemberCount) {
+    if (type === 10 /* Unknown */) {
+        if (ringMemberCount === 4)
+            return 12 /* DiamondPrism */;
+        else if (ringMemberCount === 5)
+            return 13 /* PentagonalPrism */;
+        else if (ringMemberCount === 6)
+            return 14 /* HexagonalPrism */;
+        else if (ringMemberCount === 7)
+            return 15 /* HeptagonalPrism */;
+        else
+            return 10 /* FlatHexagon */;
+    }
+    else {
+        return SaccharideTypeShapeMap[type];
+    }
+}
+exports.getSaccharideShape = getSaccharideShape;
+exports.UnknownSaccharideComponent = {
+    abbr: 'Unk',
+    name: 'Unknown',
+    color: exports.SaccharideColors.Secondary,
+    type: 10 /* Unknown */
+};
+var Monosaccharides = [
+    { abbr: 'Glc', name: 'Glucose', color: exports.SaccharideColors.Blue, type: 0 /* Hexose */ },
+    { abbr: 'Man', name: 'Mannose', color: exports.SaccharideColors.Green, type: 0 /* Hexose */ },
+    { abbr: 'Gal', name: 'Galactose', color: exports.SaccharideColors.Yellow, type: 0 /* Hexose */ },
+    { abbr: 'Gul', name: 'Gulose', color: exports.SaccharideColors.Orange, type: 0 /* Hexose */ },
+    { abbr: 'Alt', name: 'Altrose', color: exports.SaccharideColors.Pink, type: 0 /* Hexose */ },
+    { abbr: 'All', name: 'Allose', color: exports.SaccharideColors.Purple, type: 0 /* Hexose */ },
+    { abbr: 'Tal', name: 'Talose', color: exports.SaccharideColors.LightBlue, type: 0 /* Hexose */ },
+    { abbr: 'Ido', name: 'Idose', color: exports.SaccharideColors.Brown, type: 0 /* Hexose */ },
+    { abbr: 'GlcNAc', name: 'N-Acetyl Glucosamine', color: exports.SaccharideColors.Blue, type: 1 /* HexNAc */ },
+    { abbr: 'ManNAc', name: 'N-Acetyl Mannosamine', color: exports.SaccharideColors.Green, type: 1 /* HexNAc */ },
+    { abbr: 'GalNAc', name: 'N-Acetyl Galactosamine', color: exports.SaccharideColors.Yellow, type: 1 /* HexNAc */ },
+    { abbr: 'GulNAc', name: 'N-Acetyl Gulosamine', color: exports.SaccharideColors.Orange, type: 1 /* HexNAc */ },
+    { abbr: 'AltNAc', name: 'N-Acetyl Altrosamine', color: exports.SaccharideColors.Pink, type: 1 /* HexNAc */ },
+    { abbr: 'AllNAc', name: 'N-Acetyl Allosamine', color: exports.SaccharideColors.Purple, type: 1 /* HexNAc */ },
+    { abbr: 'TalNAc', name: 'N-Acetyl Talosamine', color: exports.SaccharideColors.LightBlue, type: 1 /* HexNAc */ },
+    { abbr: 'IdoNAc', name: 'N-Acetyl Idosamine', color: exports.SaccharideColors.Brown, type: 1 /* HexNAc */ },
+    { abbr: 'GlcN', name: 'Glucosamine', color: exports.SaccharideColors.Blue, type: 2 /* Hexosamine */ },
+    { abbr: 'ManN', name: 'Mannosamine', color: exports.SaccharideColors.Green, type: 2 /* Hexosamine */ },
+    { abbr: 'GalN', name: 'Galactosamine', color: exports.SaccharideColors.Yellow, type: 2 /* Hexosamine */ },
+    { abbr: 'GulN', name: 'Gulosamine', color: exports.SaccharideColors.Orange, type: 2 /* Hexosamine */ },
+    { abbr: 'AltN', name: 'Altrosamine', color: exports.SaccharideColors.Pink, type: 2 /* Hexosamine */ },
+    { abbr: 'AllN', name: 'Allosamine', color: exports.SaccharideColors.Purple, type: 2 /* Hexosamine */ },
+    { abbr: 'TalN', name: 'Talosamine', color: exports.SaccharideColors.LightBlue, type: 2 /* Hexosamine */ },
+    { abbr: 'IdoN', name: 'Idosamine', color: exports.SaccharideColors.Brown, type: 2 /* Hexosamine */ },
+    { abbr: 'GlcA', name: 'Glucuronic Acid', color: exports.SaccharideColors.Blue, type: 3 /* Hexuronate */ },
+    { abbr: 'ManA', name: 'Mannuronic Acid', color: exports.SaccharideColors.Green, type: 3 /* Hexuronate */ },
+    { abbr: 'GalA', name: 'Galacturonic Acid', color: exports.SaccharideColors.Yellow, type: 3 /* Hexuronate */ },
+    { abbr: 'GulA', name: 'Guluronic Acid', color: exports.SaccharideColors.Orange, type: 3 /* Hexuronate */ },
+    { abbr: 'AltA', name: 'Altruronic Acid', color: exports.SaccharideColors.Pink, type: 3 /* Hexuronate */ },
+    { abbr: 'AllA', name: 'Alluronic Acid', color: exports.SaccharideColors.Purple, type: 3 /* Hexuronate */ },
+    { abbr: 'TalA', name: 'Taluronic Acid', color: exports.SaccharideColors.LightBlue, type: 3 /* Hexuronate */ },
+    { abbr: 'IdoA', name: 'Iduronic Acid', color: exports.SaccharideColors.Brown, type: 3 /* Hexuronate */ },
+    { abbr: 'Qui', name: 'Quinovose', color: exports.SaccharideColors.Blue, type: 4 /* Deoxyhexose */ },
+    { abbr: 'Rha', name: 'Rhamnose', color: exports.SaccharideColors.Green, type: 4 /* Deoxyhexose */ },
+    { abbr: '6dGul', name: '6-Deoxy Gulose', color: exports.SaccharideColors.Orange, type: 4 /* Deoxyhexose */ },
+    { abbr: '6dAlt', name: '6-Deoxy Altrose', color: exports.SaccharideColors.Pink, type: 4 /* Deoxyhexose */ },
+    { abbr: '6dTal', name: '6-Deoxy Talose', color: exports.SaccharideColors.LightBlue, type: 4 /* Deoxyhexose */ },
+    { abbr: 'Fuc', name: 'Fucose', color: exports.SaccharideColors.Red, type: 4 /* Deoxyhexose */ },
+    { abbr: 'QuiNAc', name: 'N-Acetyl Quinovosamine', color: exports.SaccharideColors.Blue, type: 5 /* DeoxyhexNAc */ },
+    { abbr: 'RhaNAc', name: 'N-Acetyl Rhamnosamine', color: exports.SaccharideColors.Green, type: 5 /* DeoxyhexNAc */ },
+    { abbr: '6dAltNAc', name: 'N-Acetyl 6-Deoxy Altrosamine', color: exports.SaccharideColors.Pink, type: 5 /* DeoxyhexNAc */ },
+    { abbr: '6dTalNAc', name: 'N-Acetyl 6-Deoxy Talosamine', color: exports.SaccharideColors.LightBlue, type: 5 /* DeoxyhexNAc */ },
+    { abbr: 'FucNAc', name: 'N-Acetyl Fucosamine', color: exports.SaccharideColors.Red, type: 5 /* DeoxyhexNAc */ },
+    { abbr: 'Oli', name: 'Olivose', color: exports.SaccharideColors.Blue, type: 6 /* DiDeoxyhexose */ },
+    { abbr: 'Tyv', name: 'Tyvelose', color: exports.SaccharideColors.Green, type: 6 /* DiDeoxyhexose */ },
+    { abbr: 'Abe', name: 'Abequose', color: exports.SaccharideColors.Orange, type: 6 /* DiDeoxyhexose */ },
+    { abbr: 'Par', name: 'Paratose', color: exports.SaccharideColors.Pink, type: 6 /* DiDeoxyhexose */ },
+    { abbr: 'Dig', name: 'Digitoxose', color: exports.SaccharideColors.Purple, type: 6 /* DiDeoxyhexose */ },
+    { abbr: 'Col', name: 'Colitose', color: exports.SaccharideColors.LightBlue, type: 6 /* DiDeoxyhexose */ },
+    { abbr: 'Ara', name: 'Arabinose', color: exports.SaccharideColors.Green, type: 7 /* Pentose */ },
+    { abbr: 'Lyx', name: 'Lyxose', color: exports.SaccharideColors.Yellow, type: 7 /* Pentose */ },
+    { abbr: 'Xyl', name: 'Xylose', color: exports.SaccharideColors.Orange, type: 7 /* Pentose */ },
+    { abbr: 'Rib', name: 'Ribose', color: exports.SaccharideColors.Pink, type: 7 /* Pentose */ },
+    { abbr: 'Kdn', name: 'Keto-Deoxy Nonulonic Acid', color: exports.SaccharideColors.Green, type: 8 /* Deoxynonulosonate */ },
+    { abbr: 'Neu5Ac', name: 'N-Acetyl Neuraminic Acid', color: exports.SaccharideColors.Purple, type: 8 /* Deoxynonulosonate */ },
+    { abbr: 'Neu5Gc', name: 'N-Glycolyl Neuraminic Acid', color: exports.SaccharideColors.LightBlue, type: 8 /* Deoxynonulosonate */ },
+    { abbr: 'Neu', name: 'Neuraminic Acid', color: exports.SaccharideColors.Brown, type: 8 /* Deoxynonulosonate */ },
+    { abbr: 'Sia', name: 'Sialic acid', color: exports.SaccharideColors.Red, type: 8 /* Deoxynonulosonate */ },
+    { abbr: 'Pse', name: 'Pseudaminic Acid', color: exports.SaccharideColors.Green, type: 9 /* DiDeoxynonulosonate */ },
+    { abbr: 'Leg', name: 'Legionaminic Acid', color: exports.SaccharideColors.Yellow, type: 9 /* DiDeoxynonulosonate */ },
+    { abbr: 'Aci', name: 'Acinetaminic Acid', color: exports.SaccharideColors.Pink, type: 9 /* DiDeoxynonulosonate */ },
+    { abbr: '4eLeg', name: '4-Epilegionaminic Acid', color: exports.SaccharideColors.LightBlue, type: 9 /* DiDeoxynonulosonate */ },
+    { abbr: 'Bac', name: 'Bacillosamine', color: exports.SaccharideColors.Blue, type: 10 /* Unknown */ },
+    { abbr: 'LDmanHep', name: 'L-Glycero-D-Manno Heptose', color: exports.SaccharideColors.Green, type: 10 /* Unknown */ },
+    { abbr: 'Kdo', name: 'Keto-Deoxy Octulonic Acid', color: exports.SaccharideColors.Yellow, type: 10 /* Unknown */ },
+    { abbr: 'Dha', name: '3-Deoxy Lyxo-Heptulosaric Acid', color: exports.SaccharideColors.Orange, type: 10 /* Unknown */ },
+    { abbr: 'DDmanHep', name: 'D-Glycero-D-Manno-Heptose', color: exports.SaccharideColors.Pink, type: 10 /* Unknown */ },
+    { abbr: 'MurNAc', name: 'N-Acetyl Muramic Acid', color: exports.SaccharideColors.Purple, type: 10 /* Unknown */ },
+    { abbr: 'MurNGc', name: 'N-Glycolyl Muramic Acid', color: exports.SaccharideColors.LightBlue, type: 10 /* Unknown */ },
+    { abbr: 'Mur', name: 'Muramic Acid', color: exports.SaccharideColors.Brown, type: 10 /* Unknown */ },
+    { abbr: 'Api', name: 'Apicose', color: exports.SaccharideColors.Green, type: 11 /* Assigned */ },
+    { abbr: 'Fru', name: 'Fructose', color: exports.SaccharideColors.Green, type: 11 /* Assigned */ },
+    { abbr: 'Tag', name: 'Tagatose', color: exports.SaccharideColors.Yellow, type: 11 /* Assigned */ },
+    { abbr: 'Sor', name: 'Sorbose', color: exports.SaccharideColors.Orange, type: 11 /* Assigned */ },
+    { abbr: 'Psi', name: 'Psicose', color: exports.SaccharideColors.Pink, type: 11 /* Assigned */ },
+];
+exports.SaccharidesSnfgMap = (function () {
+    var map = new Map();
+    for (var i = 0, il = Monosaccharides.length; i < il; ++i) {
+        var saccharide = Monosaccharides[i];
+        map.set(saccharide.abbr, saccharide);
+    }
+    return map;
+})();
+exports.MonosaccharidesColorTable = [
+    ['Glc-family', exports.SaccharideColors.Blue],
+    ['Man-family', exports.SaccharideColors.Green],
+    ['Gal-family', exports.SaccharideColors.Yellow],
+    ['Gul-family', exports.SaccharideColors.Orange],
+    ['Alt-family', exports.SaccharideColors.Pink],
+    ['All-family', exports.SaccharideColors.Purple],
+    ['Tal-family', exports.SaccharideColors.LightBlue],
+    ['Ido-family', exports.SaccharideColors.Brown],
+    ['Fuc-family', exports.SaccharideColors.Red],
+    ['Generic/Unknown/Secondary', exports.SaccharideColors.Secondary],
+];
+var CommonSaccharideNames = {
+    // Hexose
+    Glc: [
+        'GLC', 'BGC', 'Z8T',
+        'TRE',
+        'MLR', // tri-saccharide but homomer
+    ],
+    Man: ['MAN', 'BMA'],
+    Gal: ['GLA', 'GAL', 'GZL', 'GXL', 'GIV'],
+    Gul: ['4GL', 'GL0', 'GUP', 'Z8H'],
+    Alt: ['Z6H', '3MK', 'SHD'],
+    All: ['AFD', 'ALL', 'WOO', 'Z2D'],
+    Tal: ['ZEE', 'A5C', 'SDY'],
+    Ido: ['ZCD', 'Z0F', '4N2'],
+    // HexNAc
+    GlcNAc: ['NDG', 'NAG', 'NGZ'],
+    ManNAc: ['BM3', 'BM7'],
+    GalNAc: ['A2G', 'NGA', 'YYQ'],
+    GulNAc: ['LXB'],
+    AltNAc: [],
+    AllNAc: ['NAA'],
+    TalNAc: [],
+    IdoNAc: ['LXZ', 'HSQ'],
+    // Hexosamine
+    GlcN: ['PA1', 'GCS'],
+    ManN: ['95Z'],
+    GalN: ['X6X', '1GN'],
+    GulN: [],
+    AltN: [],
+    AllN: [],
+    TalN: [],
+    IdoN: [],
+    // Hexuronate
+    GlcA: ['GCU', 'BDP'],
+    ManA: ['MAV', 'BEM'],
+    GalA: ['ADA', 'GTR', 'GTK'],
+    GulA: ['LGU'],
+    AltA: [],
+    AllA: [],
+    TalA: ['X1X', 'X0X'],
+    IdoA: ['IDR'],
+    // Deoxyhexose
+    Qui: ['G6D', 'YYK'],
+    Rha: ['RAM', 'RM4', 'XXR'],
+    '6dGul': ['66O'],
+    '6dAlt': [],
+    '6dTal': [],
+    Fuc: ['FUC', 'FUL', 'FCA', 'FCB', 'GYE'],
+    // DeoxyhexNAc
+    QuiNAc: ['Z9W'],
+    RhaNAc: [],
+    '6dAltNAc': [],
+    '6dTalNAc': [],
+    FucNAc: ['49T'],
+    // Di-deoxyhexose
+    Oli: ['DDA', 'RAE', 'Z5J'],
+    Tyv: ['TYV'],
+    Abe: ['ABE'],
+    Par: ['PZU'],
+    Dig: ['Z3U'],
+    Col: [],
+    // Pentose
+    Ara: ['64K', 'ARA', 'ARB', 'AHR', 'FUB', 'BXY', 'BXX', 'SEJ'],
+    Lyx: ['LDY', 'Z4W'],
+    Xyl: ['XYS', 'XYP', 'XYZ', 'HSY', 'LXC'],
+    Rib: ['YYM', 'RIP', 'RIB', 'BDR', '0MK', 'Z6J', '32O'],
+    // Deoxynonulosonate
+    Kdn: ['KDM', 'KDN'],
+    Neu5Ac: ['SIA', 'SLB'],
+    Neu5Gc: ['NGC', 'NGE'],
+    Neu: [],
+    Sia: [],
+    // Di-deoxynonulosonate
+    Pse: [],
+    Leg: [],
+    Aci: [],
+    '4eLeg': [],
+    // Unknown
+    Bac: [],
+    LDmanHep: ['GMH'],
+    Kdo: ['KDO'],
+    Dha: [],
+    DDmanHep: ['289'],
+    MurNAc: ['MUB', 'AMU'],
+    MurNGc: [],
+    Mur: ['1S4', 'MUR'],
+    // Assigned
+    Api: ['XXM'],
+    Fru: ['BDF', 'Z9N', 'FRU', 'LFR'],
+    Tag: ['T6T'],
+    Sor: ['SOE', 'UEA'],
+    Psi: ['PSV', 'SF6', 'SF9', 'TTV'],
+};
+var UnknownSaccharideNames = [
+    'NGZ',
+    'LAT',
+    'PUF', 'GDA', '9WJ', // via updated CCD
+];
+/**
+ * From http://glycam.org/docs/othertoolsservice/2016/06/09/3d-snfg-list-of-residue-names/#CHARMM
+ */
+var CharmmSaccharideNames = {
+    Glc: ['AGLC', 'BGLC'],
+    GlcNAc: ['AGLCNA', 'BGLCNA', 'BGLCN0'],
+    GlcA: ['AGLCA', 'BGLCA', 'BGLCA0'],
+    Man: ['AMAN', 'BMAN'],
+    Rha: ['ARHM', 'BRHM'],
+    Ara: ['AARB', 'BARB'],
+    Gal: ['AGAL', 'BGAL'],
+    GalNAc: ['AGALNA', 'BGALNA'],
+    Gul: ['AGUL', 'BGUL'],
+    Alt: ['AALT', 'BALT'],
+    All: ['AALL', 'BALL'],
+    Tal: ['ATAL', 'BTAL'],
+    Ido: ['AIDO', 'BIDO'],
+    IdoA: ['AIDOA', 'BIDOA'],
+    Fuc: ['AFUC', 'BFUC'],
+    Lyx: ['ALYF', 'BLYF'],
+    Xyl: ['AXYL', 'BXYL', 'AXYF', 'BXYF'],
+    Rib: ['ARIB', 'BRIB'],
+    Fru: ['AFRU', 'BFRU'],
+    Neu5Ac: ['ANE5AC', 'BNE5AC'],
+};
+exports.SaccharideCompIdMap = (function () {
+    var map = new Map();
+    for (var i = 0, il = Monosaccharides.length; i < il; ++i) {
+        var saccharide = Monosaccharides[i];
+        var common = CommonSaccharideNames[saccharide.abbr];
+        if (common) {
+            for (var j = 0, jl = common.length; j < jl; ++j) {
+                map.set(common[j], saccharide);
+            }
+        }
+        var charmm = CharmmSaccharideNames[saccharide.abbr];
+        if (charmm) {
+            for (var j = 0, jl = charmm.length; j < jl; ++j) {
+                map.set(charmm[j], saccharide);
+            }
+        }
+    }
+    for (var i = 0, il = UnknownSaccharideNames.length; i < il; ++i) {
+        map.set(UnknownSaccharideNames[i], exports.UnknownSaccharideComponent);
+    }
+    return map;
+})();
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Copyright (c) 2018-2020 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.EmptyCarbohydrates = void 0;
+var EmptyArray = [];
+exports.EmptyCarbohydrates = {
+    links: EmptyArray,
+    terminalLinks: EmptyArray,
+    elements: EmptyArray,
+    partialElements: EmptyArray,
+    getElementIndices: function () { return EmptyArray; },
+    getLinkIndices: function () { return EmptyArray; },
+    getTerminalLinkIndices: function () { return EmptyArray; },
+};
+//# sourceMappingURL=data.js.map

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

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Copyright (c) 2019 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.Bundle = void 0;
+var int_1 = require("../../../../mol-data/int");
+var structure_1 = require("../structure");
+var util_1 = require("../../../../mol-data/util");
+var sorted_ranges_1 = require("../../../../mol-data/int/sorted-ranges");
+var loci_1 = require("./loci");
+var builder_1 = require("../../../../mol-script/language/builder");
+var query_1 = require("../../query");
+var Bundle;
+(function (Bundle) {
+    Bundle.Empty = { hash: -1, elements: [] };
+    function fromSubStructure(parent, structure) {
+        return fromLoci(query_1.StructureSelection.toLociWithSourceUnits(query_1.StructureSelection.Singletons(parent, structure)));
+    }
+    Bundle.fromSubStructure = fromSubStructure;
+    function fromSelection(selection) {
+        return fromLoci(query_1.StructureSelection.toLociWithSourceUnits(selection));
+    }
+    Bundle.fromSelection = fromSelection;
+    function fromLoci(loci) {
+        var _elements = [];
+        for (var _i = 0, _a = loci.elements; _i < _a.length; _i++) {
+            var e = _a[_i];
+            var unit = e.unit, indices = e.indices;
+            if (int_1.OrderedSet.size(indices) === 0)
+                continue;
+            var ranges = [];
+            var set = [];
+            if (int_1.OrderedSet.isInterval(indices)) {
+                if (int_1.OrderedSet.size(indices) === 1) {
+                    set.push(int_1.Interval.min(indices));
+                }
+                else {
+                    ranges.push(int_1.Interval.min(indices), int_1.Interval.max(indices));
+                }
+            }
+            else {
+                var i = 0;
+                var len = indices.length;
+                while (i < len) {
+                    var start = i;
+                    i++;
+                    while (i < len && indices[i - 1] + 1 === indices[i])
+                        i++;
+                    var end = i;
+                    if (end - start > 2) {
+                        ranges.push(indices[start], indices[end - 1]);
+                    }
+                    else {
+                        for (var j = start; j < end; j++) {
+                            set[set.length] = indices[j];
+                        }
+                    }
+                }
+            }
+            _elements.push({
+                unit: unit,
+                set: int_1.SortedArray.ofSortedArray(set),
+                ranges: sorted_ranges_1.SortedRanges.ofSortedRanges(ranges)
+            });
+        }
+        var elementGroups = new Map();
+        for (var i = 0, il = _elements.length; i < il; ++i) {
+            var e = _elements[i];
+            var key = (0, util_1.hash2)((0, util_1.hashFnv32a)(e.ranges), (0, util_1.hashFnv32a)(e.set));
+            if (elementGroups.has(key)) {
+                var groupedUnits = elementGroups.get(key).groupedUnits;
+                if (groupedUnits.has(e.unit.invariantId)) {
+                    groupedUnits.get(e.unit.invariantId).push(e.unit.id);
+                }
+                else {
+                    groupedUnits.set(e.unit.invariantId, [e.unit.id]);
+                }
+            }
+            else {
+                var groupedUnits = new Map();
+                groupedUnits.set(e.unit.invariantId, [e.unit.id]);
+                elementGroups.set(key, { groupedUnits: groupedUnits, set: e.set, ranges: e.ranges });
+            }
+        }
+        var elements = [];
+        elementGroups.forEach(function (e) {
+            var groupedUnits = [];
+            e.groupedUnits.forEach(function (g) { return groupedUnits.push(int_1.SortedArray.ofUnsortedArray(g)); });
+            groupedUnits.sort(function (a, b) { return a[0] - b[0]; }); // sort by first unit id of each group
+            elements.push({ groupedUnits: groupedUnits, set: e.set, ranges: e.ranges });
+        });
+        return { hash: loci.structure.hashCode, elements: elements };
+    }
+    Bundle.fromLoci = fromLoci;
+    function getUnitsFromIds(unitIds, structure) {
+        var units = [];
+        for (var i = 0, il = unitIds.length; i < il; ++i) {
+            var unitId = unitIds[i];
+            if (structure.unitMap.has(unitId))
+                units.push(structure.unitMap.get(unitId));
+        }
+        return units;
+    }
+    function toLoci(bundle, structure) {
+        if (bundle.hash !== -1 && bundle.hash !== structure.hashCode) {
+            new Error('Bundle not compatible with given structure');
+        }
+        var elements = [];
+        for (var _i = 0, _a = bundle.elements; _i < _a.length; _i++) {
+            var e = _a[_i];
+            var _loop_1 = function (g) {
+                var units = getUnitsFromIds(g, structure);
+                if (units.length === 0)
+                    return "continue";
+                var indices = void 0;
+                if (e.ranges.length === 0) {
+                    indices = e.set;
+                }
+                else if (e.set.length === 0) {
+                    if (e.ranges.length === 2) {
+                        indices = int_1.Interval.ofRange(e.ranges[0], e.ranges[1]);
+                    }
+                    else {
+                        var _indices_1 = new Int32Array(sorted_ranges_1.SortedRanges.size(e.ranges));
+                        sorted_ranges_1.SortedRanges.forEach(e.ranges, function (v, i) { return _indices_1[i] = v; });
+                        indices = int_1.SortedArray.ofSortedArray(_indices_1);
+                    }
+                }
+                else {
+                    var rangesSize = sorted_ranges_1.SortedRanges.size(e.ranges);
+                    var _indices_2 = new Int32Array(e.set.length + rangesSize);
+                    sorted_ranges_1.SortedRanges.forEach(e.ranges, function (v, i) { return _indices_2[i] = v; });
+                    _indices_2.set(e.set, rangesSize);
+                    indices = int_1.SortedArray.ofUnsortedArray(_indices_2); // requires sort
+                }
+                for (var _d = 0, units_1 = units; _d < units_1.length; _d++) {
+                    var unit = units_1[_d];
+                    elements.push({ unit: unit, indices: indices });
+                }
+            };
+            for (var _b = 0, _c = e.groupedUnits; _b < _c.length; _b++) {
+                var g = _c[_b];
+                _loop_1(g);
+            }
+        }
+        return (0, loci_1.Loci)(structure, elements);
+    }
+    Bundle.toLoci = toLoci;
+    function toStructure(bundle, parent) {
+        if (bundle.hash !== -1 && bundle.hash !== parent.hashCode) {
+            new Error('Bundle not compatible with given structure');
+        }
+        var units = [];
+        for (var _i = 0, _a = bundle.elements; _i < _a.length; _i++) {
+            var e = _a[_i];
+            var _loop_2 = function (g) {
+                var _units = getUnitsFromIds(g, parent);
+                if (_units.length === 0)
+                    return "continue";
+                var ue = _units[0].elements; // the elements are grouped by unit.invariantId
+                var rangesSize = sorted_ranges_1.SortedRanges.size(e.ranges);
+                var setSize = e.set.length;
+                var _indices = new Int32Array(setSize + rangesSize);
+                var indices = void 0;
+                if (rangesSize === 0) {
+                    for (var i = 0, il = setSize; i < il; ++i) {
+                        _indices[i] = ue[e.set[i]];
+                    }
+                    indices = int_1.SortedArray.ofSortedArray(_indices);
+                }
+                else if (setSize === 0) {
+                    sorted_ranges_1.SortedRanges.forEach(e.ranges, function (v, i) { return _indices[i] = ue[v]; });
+                    indices = int_1.SortedArray.ofSortedArray(_indices);
+                }
+                else {
+                    if (int_1.SortedArray.min(e.set) > sorted_ranges_1.SortedRanges.max(e.ranges)) {
+                        sorted_ranges_1.SortedRanges.forEach(e.ranges, function (v, i) { return _indices[i] = ue[v]; });
+                        for (var i = 0, il = setSize; i < il; ++i) {
+                            _indices[i + rangesSize] = ue[e.set[i]];
+                        }
+                        indices = int_1.SortedArray.ofSortedArray(_indices);
+                    }
+                    else if (sorted_ranges_1.SortedRanges.min(e.ranges) > int_1.SortedArray.max(e.set)) {
+                        for (var i = 0, il = setSize; i < il; ++i) {
+                            _indices[i] = ue[e.set[i]];
+                        }
+                        sorted_ranges_1.SortedRanges.forEach(e.ranges, function (v, i) { return _indices[i + setSize] = ue[v]; });
+                        indices = int_1.SortedArray.ofSortedArray(_indices);
+                    }
+                    else {
+                        sorted_ranges_1.SortedRanges.forEach(e.ranges, function (v, i) { return _indices[i] = ue[v]; });
+                        for (var i = 0, il = setSize; i < il; ++i) {
+                            _indices[i + rangesSize] = ue[e.set[i]];
+                        }
+                        indices = int_1.SortedArray.ofUnsortedArray(_indices); // requires sort
+                    }
+                }
+                for (var _d = 0, _units_1 = _units; _d < _units_1.length; _d++) {
+                    var unit = _units_1[_d];
+                    units.push(unit.getChild(indices));
+                }
+            };
+            for (var _b = 0, _c = e.groupedUnits; _b < _c.length; _b++) {
+                var g = _c[_b];
+                _loop_2(g);
+            }
+        }
+        return structure_1.Structure.create(units, { parent: parent });
+    }
+    Bundle.toStructure = toStructure;
+    function elementToExpression(e) {
+        return builder_1.MolScriptBuilder.internal.generator.bundleElement({
+            groupedUnits: builder_1.MolScriptBuilder.core.type.list(e.groupedUnits.map(function (u) { return builder_1.MolScriptBuilder.core.type.list(u); })),
+            ranges: builder_1.MolScriptBuilder.core.type.list(e.ranges),
+            set: builder_1.MolScriptBuilder.core.type.list(e.set),
+        });
+    }
+    function toExpression(bundle) {
+        return builder_1.MolScriptBuilder.internal.generator.bundle({
+            elements: builder_1.MolScriptBuilder.core.type.list(bundle.elements.map(elementToExpression))
+        });
+    }
+    Bundle.toExpression = toExpression;
+    function areEqual(a, b) {
+        if (a.elements.length !== b.elements.length)
+            return false;
+        for (var i = 0, il = a.elements.length; i < il; ++i) {
+            var elementA = a.elements[i], elementB = b.elements[i];
+            if (elementA.groupedUnits.length !== elementB.groupedUnits.length)
+                return false;
+            for (var j = 0, jl = elementB.groupedUnits.length; j < jl; ++j) {
+                if (!int_1.SortedArray.areEqual(elementA.groupedUnits[j], elementB.groupedUnits[j]))
+                    return false;
+            }
+            if (!int_1.SortedArray.areEqual(elementA.set, elementB.set))
+                return false;
+            if (!sorted_ranges_1.SortedRanges.areEqual(elementA.ranges, elementB.ranges))
+                return false;
+        }
+        return true;
+    }
+    Bundle.areEqual = areEqual;
+})(Bundle = exports.Bundle || (exports.Bundle = {}));
+//# sourceMappingURL=bundle.js.map

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

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Copyright (c) 2017-2019 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>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./location"), exports);
+(0, tslib_1.__exportStar)(require("./loci"), exports);
+(0, tslib_1.__exportStar)(require("./bundle"), exports);
+(0, tslib_1.__exportStar)(require("./stats"), exports);
+(0, tslib_1.__exportStar)(require("./util"), exports);
+//# sourceMappingURL=element.js.map

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

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Copyright (c) 2017-2020 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>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Location = void 0;
+var linear_algebra_1 = require("../../../../mol-math/linear-algebra");
+var Location;
+(function (Location) {
+    function create(structure, unit, element) {
+        return {
+            kind: 'element-location',
+            structure: structure,
+            unit: unit,
+            element: element || 0
+        };
+    }
+    Location.create = create;
+    function clone(l) {
+        return create(l.structure, l.unit, l.element);
+    }
+    Location.clone = clone;
+    function set(a, structure, unit, element) {
+        if (structure)
+            a.structure = structure;
+        if (unit)
+            a.unit = unit;
+        if (element !== undefined)
+            a.element = element;
+        return a;
+    }
+    Location.set = set;
+    function copy(out, a) {
+        out.unit = a.unit;
+        out.element = a.element;
+        return out;
+    }
+    Location.copy = copy;
+    function is(x) {
+        return !!x && x.kind === 'element-location';
+    }
+    Location.is = is;
+    function areEqual(a, b) {
+        return a.unit === b.unit && a.element === b.element;
+    }
+    Location.areEqual = areEqual;
+    var pA = linear_algebra_1.Vec3.zero(), pB = linear_algebra_1.Vec3.zero();
+    function distance(a, b) {
+        a.unit.conformation.position(a.element, pA);
+        b.unit.conformation.position(b.element, pB);
+        return linear_algebra_1.Vec3.distance(pA, pB);
+    }
+    Location.distance = distance;
+    function residueIndex(l) {
+        return l.unit.model.atomicHierarchy.residueAtomSegments.index[l.element];
+    }
+    Location.residueIndex = residueIndex;
+    function chainIndex(l) {
+        return l.unit.model.atomicHierarchy.chainAtomSegments.index[l.element];
+    }
+    Location.chainIndex = chainIndex;
+})(Location || (Location = {}));
+exports.Location = Location;
+//# sourceMappingURL=location.js.map