molstar 3.8.2 → 3.9.0

package/lib/mol-model-props/computed/interactions/refine.js

@@ -89,17 +89,17 @@ function hydrophobicRefiner(structure, interactions) {
         handleResidueContact(dist, edge, keyB, map, set);
     }
     var residueInterMap = new Map();
-    var setInterFiltered = function (i) { return contacts.edges[i].props.flag = 1 /* Filtered */; };
+    var setInterFiltered = function (i) { return contacts.edges[i].props.flag = 1 /* InteractionFlag.Filtered */; };
     var residueIntraMap;
     var setIntraFiltered;
     return {
-        isApplicable: function (type) { return type === 6 /* Hydrophobic */; },
+        isApplicable: function (type) { return type === 6 /* InteractionType.Hydrophobic */; },
         handleInterContact: function (index, infoA, infoB) {
             handleEdge(index, infoA, infoB, residueInterMap, setInterFiltered);
         },
         startUnit: function (unit, contacts, features) {
             residueIntraMap = new Map();
-            setIntraFiltered = function (i) { return contacts.edgeProps.flag[i] = 1 /* Filtered */; };
+            setIntraFiltered = function (i) { return contacts.edgeProps.flag[i] = 1 /* InteractionFlag.Filtered */; };
         },
         handleIntraContact: function (index, infoA, infoB) {
             handleEdge(index, infoA, infoB, residueIntraMap, setIntraFiltered);
@@ -113,34 +113,34 @@ function hydrophobicRefiner(structure, interactions) {
 function weakHydrogenBondsRefiner(structure, interactions) {
     var contacts = interactions.contacts;
     var hasHydrogenBond = function (infoA, infoB) {
-        var acc = infoA.types[infoA.feature] === 9 /* WeakHydrogenDonor */ ? infoB : infoA;
+        var acc = infoA.types[infoA.feature] === 9 /* FeatureType.WeakHydrogenDonor */ ? infoB : infoA;
         // check intra
         var eI = acc.members[acc.offsets[acc.feature]];
         var _a = interactions.unitsContacts.get(acc.unit.id), type = _a.edgeProps.type, _b = _a.elementsIndex, offsets = _b.offsets, indices = _b.indices;
         for (var i = offsets[eI], il = offsets[eI + 1]; i < il; ++i) {
-            if (type[indices[i]] === 4 /* HydrogenBond */)
+            if (type[indices[i]] === 4 /* InteractionType.HydrogenBond */)
                 return true;
         }
         // check inter
         var interIndices = contacts.getEdgeIndices(acc.feature, acc.unit.id);
         for (var i = 0, il = interIndices.length; i < il; ++i) {
-            if (contacts.edges[interIndices[i]].props.type === 4 /* HydrogenBond */)
+            if (contacts.edges[interIndices[i]].props.type === 4 /* InteractionType.HydrogenBond */)
                 return true;
         }
         return false;
     };
     return {
-        isApplicable: function (type) { return type === 8 /* WeakHydrogenBond */; },
+        isApplicable: function (type) { return type === 8 /* InteractionType.WeakHydrogenBond */; },
         handleInterContact: function (index, infoA, infoB) {
             if (hasHydrogenBond(infoA, infoB)) {
-                contacts.edges[index].props.flag = 1 /* Filtered */;
+                contacts.edges[index].props.flag = 1 /* InteractionFlag.Filtered */;
             }
         },
         startUnit: function () { },
         handleIntraContact: function (index, infoA, infoB) {
             if (hasHydrogenBond(infoA, infoB)) {
                 var flag = interactions.unitsContacts.get(infoA.unit.id).edgeProps.flag;
-                flag[index] = 1 /* Filtered */;
+                flag[index] = 1 /* InteractionFlag.Filtered */;
             }
         }
     };
@@ -160,7 +160,7 @@ function filterInter(types, index, infoA, infoB, contacts) {
                 for (var j = offsetsB[featureB], jl = offsetsB[featureB + 1]; j < jl; ++j) {
                     var bI = infoB.members[j];
                     if (contacts.getContactIndicesForElement(bI, infoB.unit).includes(cI)) {
-                        contacts.edges[index].props.flag = 1 /* Filtered */;
+                        contacts.edges[index].props.flag = 1 /* InteractionFlag.Filtered */;
                         return;
                     }
                 }
@@ -184,7 +184,7 @@ function filterIntra(types, index, infoA, infoB, contacts) {
                     var bI = infoB.members[j];
                     for (var l = offsets[bI], ll = offsets[bI + 1]; l < ll; ++l) {
                         if (cI === indices[l]) {
-                            flag[index] = 1 /* Filtered */;
+                            flag[index] = 1 /* InteractionFlag.Filtered */;
                             return;
                         }
                     }
@@ -200,13 +200,13 @@ function filterIntra(types, index, infoA, infoB, contacts) {
 function saltBridgeRefiner(structure, interactions) {
     var contacts = interactions.contacts;
     return {
-        isApplicable: function (type) { return type === 1 /* Ionic */; },
+        isApplicable: function (type) { return type === 1 /* InteractionType.Ionic */; },
         handleInterContact: function (index, infoA, infoB) {
-            filterInter([4 /* HydrogenBond */, 8 /* WeakHydrogenBond */], index, infoA, infoB, contacts);
+            filterInter([4 /* InteractionType.HydrogenBond */, 8 /* InteractionType.WeakHydrogenBond */], index, infoA, infoB, contacts);
         },
         startUnit: function () { },
         handleIntraContact: function (index, infoA, infoB) {
-            filterIntra([4 /* HydrogenBond */, 8 /* WeakHydrogenBond */], index, infoA, infoB, interactions.unitsContacts.get(infoA.unit.id));
+            filterIntra([4 /* InteractionType.HydrogenBond */, 8 /* InteractionType.WeakHydrogenBond */], index, infoA, infoB, interactions.unitsContacts.get(infoA.unit.id));
         }
     };
 }
@@ -217,13 +217,13 @@ function saltBridgeRefiner(structure, interactions) {
 function piStackingRefiner(structure, interactions) {
     var contacts = interactions.contacts;
     return {
-        isApplicable: function (type) { return type === 6 /* Hydrophobic */ || type === 2 /* CationPi */; },
+        isApplicable: function (type) { return type === 6 /* InteractionType.Hydrophobic */ || type === 2 /* InteractionType.CationPi */; },
         handleInterContact: function (index, infoA, infoB) {
-            filterInter([3 /* PiStacking */], index, infoA, infoB, contacts);
+            filterInter([3 /* InteractionType.PiStacking */], index, infoA, infoB, contacts);
         },
         startUnit: function () { },
         handleIntraContact: function (index, infoA, infoB) {
-            filterIntra([3 /* PiStacking */], index, infoA, infoB, interactions.unitsContacts.get(infoA.unit.id));
+            filterIntra([3 /* InteractionType.PiStacking */], index, infoA, infoB, interactions.unitsContacts.get(infoA.unit.id));
         }
     };
 }
@@ -234,13 +234,13 @@ function piStackingRefiner(structure, interactions) {
 function metalCoordinationRefiner(structure, interactions) {
     var contacts = interactions.contacts;
     return {
-        isApplicable: function (type) { return type === 1 /* Ionic */; },
+        isApplicable: function (type) { return type === 1 /* InteractionType.Ionic */; },
         handleInterContact: function (index, infoA, infoB) {
-            filterInter([7 /* MetalCoordination */], index, infoA, infoB, contacts);
+            filterInter([7 /* InteractionType.MetalCoordination */], index, infoA, infoB, contacts);
         },
         startUnit: function () { },
         handleIntraContact: function (index, infoA, infoB) {
-            filterIntra([7 /* MetalCoordination */], index, infoA, infoB, interactions.unitsContacts.get(infoA.unit.id));
+            filterIntra([7 /* InteractionType.MetalCoordination */], index, infoA, infoB, interactions.unitsContacts.get(infoA.unit.id));
         }
     };
 }

package/lib/mol-model-props/computed/representations/interactions-inter-unit-cylinder.js

@@ -41,7 +41,7 @@ function createInterUnitInteractionCylinderMesh(ctx, structure, theme, props, me
             Vec3.set(posB, fB.x[indexB], fB.y[indexB], fB.z[indexB]);
             Vec3.transformMat4(posB, posB, uB.conformation.operator.matrix);
         },
-        style: function (edgeIndex) { return 1 /* Dashed */; },
+        style: function (edgeIndex) { return 1 /* LinkStyle.Dashed */; },
         radius: function (edgeIndex) {
             var b = edges[edgeIndex];
             var fA = unitsFeatures.get(b.unitA);
@@ -55,7 +55,7 @@ function createInterUnitInteractionCylinderMesh(ctx, structure, theme, props, me
             return Math.min(sizeA, sizeB) * sizeFactor;
         },
         ignore: function (edgeIndex) {
-            if (edges[edgeIndex].props.flag === 1 /* Filtered */)
+            if (edges[edgeIndex].props.flag === 1 /* InteractionFlag.Filtered */)
                 return true;
             if (child) {
                 var b = edges[edgeIndex];

package/lib/mol-model-props/computed/representations/interactions-intra-unit-cylinder.js

@@ -41,7 +41,7 @@ function createIntraUnitInteractionsCylinderMesh(ctx, unit, structure, theme, pr
                     Vec3.set(posA, x[a[edgeIndex]], y[a[edgeIndex]], z[a[edgeIndex]]);
                     Vec3.set(posB, x[b[edgeIndex]], y[b[edgeIndex]], z[b[edgeIndex]]);
                 },
-                style: function (edgeIndex) { return 1 /* Dashed */; },
+                style: function (edgeIndex) { return 1 /* LinkStyle.Dashed */; },
                 radius: function (edgeIndex) {
                     location.element = unit.elements[members[offsets[a[edgeIndex]]]];
                     var sizeA = theme.size.size(location);
@@ -50,7 +50,7 @@ function createIntraUnitInteractionsCylinderMesh(ctx, unit, structure, theme, pr
                     return Math.min(sizeA, sizeB) * sizeFactor;
                 },
                 ignore: function (edgeIndex) {
-                    if (flag[edgeIndex] === 1 /* Filtered */)
+                    if (flag[edgeIndex] === 1 /* InteractionFlag.Filtered */)
                         return true;
                     if (childUnit) {
                         var f = a[edgeIndex];

package/lib/mol-model-props/computed/secondary-structure/dssp/bends.js

@@ -49,7 +49,7 @@ export function assignBends(ctx) {
         Vec3.sub(caPlus2, caPos, caPosNext2);
         var angle = radToDeg(Vec3.angle(caMinus2, caPlus2));
         if (angle && angle > 70.00) {
-            flags[i] |= 32 /* S */;
+            flags[i] |= 32 /* DSSPType.Flag.S */;
         }
     }
 }

package/lib/mol-model-props/computed/secondary-structure/dssp/bridges.js

@@ -34,34 +34,34 @@ export function assignBridges(ctx) {
             i = k + 1; // k is i - 1
             j = l;
             if (i !== j && hbonds.getDirectedEdgeIndex(j, i + 1) !== -1) {
-                flags[i] |= 2 /* B */;
-                flags[j] |= 2 /* B */;
+                flags[i] |= 2 /* DSSPType.Flag.B */;
+                flags[j] |= 2 /* DSSPType.Flag.B */;
                 // TODO move to constructor, actually omit object all together
-                bridges[bridges.length] = new Bridge(i, j, 0 /* PARALLEL */);
+                bridges[bridges.length] = new Bridge(i, j, 0 /* BridgeType.PARALLEL */);
             }
             // Parallel Bridge(i, j) =: [Hbond(j - 1, i) and Hbond(i, j + 1)]
             i = k;
             j = l - 1; // l is j + 1
             if (i !== j && hbonds.getDirectedEdgeIndex(j - 1, i) !== -1) {
-                flags[i] |= 2 /* B */;
-                flags[j] |= 2 /* B */;
-                bridges[bridges.length] = new Bridge(j, i, 0 /* PARALLEL */);
+                flags[i] |= 2 /* DSSPType.Flag.B */;
+                flags[j] |= 2 /* DSSPType.Flag.B */;
+                bridges[bridges.length] = new Bridge(j, i, 0 /* BridgeType.PARALLEL */);
             }
             // Antiparallel Bridge(i, j) =: [Hbond(i, j) and Hbond(j, i)]
             i = k;
             j = l;
             if (i !== j && hbonds.getDirectedEdgeIndex(j, i) !== -1) {
-                flags[i] |= 2 /* B */;
-                flags[j] |= 2 /* B */;
-                bridges[bridges.length] = new Bridge(j, i, 1 /* ANTI_PARALLEL */);
+                flags[i] |= 2 /* DSSPType.Flag.B */;
+                flags[j] |= 2 /* DSSPType.Flag.B */;
+                bridges[bridges.length] = new Bridge(j, i, 1 /* BridgeType.ANTI_PARALLEL */);
             }
             // Antiparallel Bridge(i, j) =: [Hbond(i - 1, j + 1) and Hbond(j - 1, i + l)]
             i = k + 1;
             j = l - 1;
             if (i !== j && hbonds.getDirectedEdgeIndex(j - 1, i + 1) !== -1) {
-                flags[i] |= 2 /* B */;
-                flags[j] |= 2 /* B */;
-                bridges[bridges.length] = new Bridge(j, i, 1 /* ANTI_PARALLEL */);
+                flags[i] |= 2 /* DSSPType.Flag.B */;
+                flags[j] |= 2 /* DSSPType.Flag.B */;
+                bridges[bridges.length] = new Bridge(j, i, 1 /* BridgeType.ANTI_PARALLEL */);
             }
         }
     }

package/lib/mol-model-props/computed/secondary-structure/dssp/helices.js

@@ -19,8 +19,8 @@ import { DSSPType } from './common';
 export function assignHelices(ctx) {
     var proteinInfo = ctx.proteinInfo, flags = ctx.flags;
     var residueCount = proteinInfo.residueIndices.length;
-    var turnFlag = [1024 /* T3S */, 2048 /* T4S */, 4096 /* T5S */, 128 /* T3 */, 256 /* T4 */, 512 /* T5 */];
-    var helixFlag = [0, 0, 0, 8 /* G */, 1 /* H */, 16 /* I */];
+    var turnFlag = [1024 /* DSSPType.Flag.T3S */, 2048 /* DSSPType.Flag.T4S */, 4096 /* DSSPType.Flag.T5S */, 128 /* DSSPType.Flag.T3 */, 256 /* DSSPType.Flag.T4 */, 512 /* DSSPType.Flag.T5 */];
+    var helixFlag = [0, 0, 0, 8 /* DSSPType.Flag.G */, 1 /* DSSPType.Flag.H */, 16 /* DSSPType.Flag.I */];
     var helixCheckOrder = ctx.params.oldOrdering ? [4, 3, 5] : [3, 4, 5];
     for (var ni = 0; ni < helixCheckOrder.length; ni++) {
         var n = helixCheckOrder[ni];
@@ -30,14 +30,14 @@ export function assignHelices(ctx) {
             var fI2 = DSSPType.create(flags[i + 1]);
             // TODO rework to elegant solution which will not break instantly
             if (ctx.params.oldOrdering) {
-                if ((n === 3 && (DSSPType.is(fI, 1 /* H */) || DSSPType.is(fI2, 1 /* H */)) || // for 3-10 yield to alpha helix
-                    (n === 5 && ((DSSPType.is(fI, 1 /* H */) || DSSPType.is(fI, 8 /* G */)) || (DSSPType.is(fI2, 1 /* H */) || DSSPType.is(fI2, 8 /* G */)))))) { // for pi yield to all other helices
+                if ((n === 3 && (DSSPType.is(fI, 1 /* DSSPType.Flag.H */) || DSSPType.is(fI2, 1 /* DSSPType.Flag.H */)) || // for 3-10 yield to alpha helix
+                    (n === 5 && ((DSSPType.is(fI, 1 /* DSSPType.Flag.H */) || DSSPType.is(fI, 8 /* DSSPType.Flag.G */)) || (DSSPType.is(fI2, 1 /* DSSPType.Flag.H */) || DSSPType.is(fI2, 8 /* DSSPType.Flag.G */)))))) { // for pi yield to all other helices
                     continue;
                 }
             }
             else {
-                if ((n === 4 && (DSSPType.is(fI, 8 /* G */) || DSSPType.is(fI2, 8 /* G */)) || // for alpha helix yield to 3-10
-                    (n === 5 && ((DSSPType.is(fI, 1 /* H */) || DSSPType.is(fI, 8 /* G */)) || (DSSPType.is(fI2, 1 /* H */) || DSSPType.is(fI2, 8 /* G */)))))) { // for pi yield to all other helices
+                if ((n === 4 && (DSSPType.is(fI, 8 /* DSSPType.Flag.G */) || DSSPType.is(fI2, 8 /* DSSPType.Flag.G */)) || // for alpha helix yield to 3-10
+                    (n === 5 && ((DSSPType.is(fI, 1 /* DSSPType.Flag.H */) || DSSPType.is(fI, 8 /* DSSPType.Flag.G */)) || (DSSPType.is(fI2, 1 /* DSSPType.Flag.H */) || DSSPType.is(fI2, 8 /* DSSPType.Flag.G */)))))) { // for pi yield to all other helices
                     continue;
                 }
             }

package/lib/mol-model-props/computed/secondary-structure/dssp/ladders.js

@@ -11,7 +11,7 @@ function shouldExtendLadder(ladder, bridge) {
     // only extend if residue 1 is sequence neighbor with regard to ladder
     if (bridge.partner1 !== ladder.firstEnd + 1)
         return false;
-    if (bridge.type === 0 /* PARALLEL */) {
+    if (bridge.type === 0 /* BridgeType.PARALLEL */) {
         if (bridge.partner2 === ladder.secondEnd + 1) {
             return true;
         }
@@ -32,7 +32,7 @@ function resemblesBulge(ladder1, ladder2) {
     if (!(ladder1.type === ladder2.type && ladder2.firstStart - ladder1.firstEnd < 6 &&
         ladder1.firstStart < ladder2.firstStart && ladder2.nextLadder === 0))
         return false;
-    if (ladder1.type === 0 /* PARALLEL */) {
+    if (ladder1.type === 0 /* BridgeType.PARALLEL */) {
         return bulgeCriterion2(ladder1, ladder2);
     }
     else {
@@ -59,7 +59,7 @@ export function assignLadders(ctx) {
             if (shouldExtendLadder(ladder, bridge)) {
                 found = true;
                 ladder.firstEnd++;
-                if (bridge.type === 0 /* PARALLEL */) {
+                if (bridge.type === 0 /* BridgeType.PARALLEL */) {
                     ladder.secondEnd++;
                 }
                 else {

package/lib/mol-model-props/computed/secondary-structure/dssp/sheets.js

@@ -6,7 +6,7 @@
  */
 import { DSSPType } from './common';
 function isHelixType(f) {
-    return DSSPType.is(f, 8 /* G */) || DSSPType.is(f, 1 /* H */) || DSSPType.is(f, 16 /* I */);
+    return DSSPType.is(f, 8 /* DSSPType.Flag.G */) || DSSPType.is(f, 1 /* DSSPType.Flag.H */) || DSSPType.is(f, 16 /* DSSPType.Flag.I */);
 }
 /**
  * sheet=: set of one or more ladders connected by shared residues
@@ -21,15 +21,15 @@ export function assignSheets(ctx) {
             var diff = ladder.firstStart - lcount;
             var l2count = ladder.secondStart - diff;
             if (ladder.firstStart !== ladder.firstEnd) {
-                flags[lcount] |= 4 /* E */;
-                flags[l2count] |= 4 /* E */;
+                flags[lcount] |= 4 /* DSSPType.Flag.E */;
+                flags[l2count] |= 4 /* DSSPType.Flag.E */;
             }
             else {
-                if (!isHelixType(flags[lcount]) && DSSPType.is(flags[lcount], 4 /* E */)) {
-                    flags[lcount] |= 2 /* B */;
+                if (!isHelixType(flags[lcount]) && DSSPType.is(flags[lcount], 4 /* DSSPType.Flag.E */)) {
+                    flags[lcount] |= 2 /* DSSPType.Flag.B */;
                 }
-                if (!isHelixType(flags[l2count]) && DSSPType.is(flags[l2count], 4 /* E */)) {
-                    flags[l2count] |= 2 /* B */;
+                if (!isHelixType(flags[l2count]) && DSSPType.is(flags[l2count], 4 /* DSSPType.Flag.E */)) {
+                    flags[l2count] |= 2 /* DSSPType.Flag.B */;
                 }
             }
         }
@@ -37,16 +37,16 @@ export function assignSheets(ctx) {
             continue;
         var conladder = ladders[ladder.nextLadder];
         for (var lcount = ladder.firstStart; lcount <= conladder.firstEnd; lcount++) {
-            flags[lcount] |= 4 /* E */;
+            flags[lcount] |= 4 /* DSSPType.Flag.E */;
         }
-        if (ladder.type === 0 /* PARALLEL */) {
+        if (ladder.type === 0 /* BridgeType.PARALLEL */) {
             for (var lcount = ladder.secondStart; lcount <= conladder.secondEnd; lcount++) {
-                flags[lcount] |= 4 /* E */;
+                flags[lcount] |= 4 /* DSSPType.Flag.E */;
             }
         }
         else {
             for (var lcount = conladder.secondEnd; lcount <= ladder.secondStart; lcount++) {
-                flags[lcount] |= 4 /* E */;
+                flags[lcount] |= 4 /* DSSPType.Flag.E */;
             }
         }
     }

package/lib/mol-model-props/computed/secondary-structure/dssp/turns.js

@@ -13,7 +13,7 @@
  */
 export function assignTurns(ctx) {
     var proteinInfo = ctx.proteinInfo, hbonds = ctx.hbonds, flags = ctx.flags;
-    var turnFlag = [1024 /* T3S */, 2048 /* T4S */, 4096 /* T5S */, 128 /* T3 */, 256 /* T4 */, 512 /* T5 */];
+    var turnFlag = [1024 /* DSSPType.Flag.T3S */, 2048 /* DSSPType.Flag.T4S */, 4096 /* DSSPType.Flag.T5S */, 128 /* DSSPType.Flag.T3 */, 256 /* DSSPType.Flag.T4 */, 512 /* DSSPType.Flag.T5 */];
     for (var idx = 0; idx < 3; idx++) {
         for (var i = 0, il = proteinInfo.residueIndices.length - 1; i < il; ++i) {
             // check if hbond exists
@@ -21,12 +21,12 @@ export function assignTurns(ctx) {
                 flags[i] |= turnFlag[idx + 3] | turnFlag[idx];
                 if (ctx.params.oldDefinition) {
                     for (var k = 1; k < idx + 3; ++k) {
-                        flags[i + k] |= turnFlag[idx + 3] | 64 /* T */;
+                        flags[i + k] |= turnFlag[idx + 3] | 64 /* DSSPType.Flag.T */;
                     }
                 }
                 else {
                     for (var k = 0; k <= idx + 3; ++k) {
-                        flags[i + k] |= turnFlag[idx + 3] | 64 /* T */;
+                        flags[i + k] |= turnFlag[idx + 3] | 64 /* DSSPType.Flag.T */;
                     }
                 }
             }

package/lib/mol-model-props/computed/secondary-structure/dssp.js

@@ -129,71 +129,71 @@ function mapToKind(assignment) {
 }
 /** Original priority: H,B,E,G,I,T,S */
 function getOriginalResidueFlag(f) {
-    if (DSSPType.is(f, 1 /* H */))
+    if (DSSPType.is(f, 1 /* DSSPType.Flag.H */))
         return SecondaryStructureType.SecondaryStructureDssp.H;
-    if (DSSPType.is(f, 4 /* E */))
+    if (DSSPType.is(f, 4 /* DSSPType.Flag.E */))
         return SecondaryStructureType.SecondaryStructureDssp.E;
-    if (DSSPType.is(f, 2 /* B */))
+    if (DSSPType.is(f, 2 /* DSSPType.Flag.B */))
         return SecondaryStructureType.SecondaryStructureDssp.B;
-    if (DSSPType.is(f, 8 /* G */))
+    if (DSSPType.is(f, 8 /* DSSPType.Flag.G */))
         return SecondaryStructureType.SecondaryStructureDssp.G;
-    if (DSSPType.is(f, 16 /* I */))
+    if (DSSPType.is(f, 16 /* DSSPType.Flag.I */))
         return SecondaryStructureType.SecondaryStructureDssp.I;
-    if (DSSPType.is(f, 64 /* T */))
+    if (DSSPType.is(f, 64 /* DSSPType.Flag.T */))
         return SecondaryStructureType.SecondaryStructureDssp.T;
-    if (DSSPType.is(f, 32 /* S */))
+    if (DSSPType.is(f, 32 /* DSSPType.Flag.S */))
         return SecondaryStructureType.SecondaryStructureDssp.S;
-    return 0 /* None */;
+    return 0 /* SecondaryStructureType.Flag.None */;
 }
 function getOriginalFlagName(f) {
-    if (DSSPType.is(f, 1 /* H */))
+    if (DSSPType.is(f, 1 /* DSSPType.Flag.H */))
         return 'H';
-    if (DSSPType.is(f, 4 /* E */))
+    if (DSSPType.is(f, 4 /* DSSPType.Flag.E */))
         return 'E';
-    if (DSSPType.is(f, 2 /* B */))
+    if (DSSPType.is(f, 2 /* DSSPType.Flag.B */))
         return 'B';
-    if (DSSPType.is(f, 8 /* G */))
+    if (DSSPType.is(f, 8 /* DSSPType.Flag.G */))
         return 'G';
-    if (DSSPType.is(f, 16 /* I */))
+    if (DSSPType.is(f, 16 /* DSSPType.Flag.I */))
         return 'I';
-    if (DSSPType.is(f, 64 /* T */))
+    if (DSSPType.is(f, 64 /* DSSPType.Flag.T */))
         return 'T';
-    if (DSSPType.is(f, 32 /* S */))
+    if (DSSPType.is(f, 32 /* DSSPType.Flag.S */))
         return 'S';
     return '-';
 }
 /** Version 2.1.0 priority: I,H,B,E,G,T,S */
 function getUpdatedResidueFlag(f) {
-    if (DSSPType.is(f, 16 /* I */))
+    if (DSSPType.is(f, 16 /* DSSPType.Flag.I */))
         return SecondaryStructureType.SecondaryStructureDssp.I;
-    if (DSSPType.is(f, 1 /* H */))
+    if (DSSPType.is(f, 1 /* DSSPType.Flag.H */))
         return SecondaryStructureType.SecondaryStructureDssp.H;
-    if (DSSPType.is(f, 4 /* E */))
+    if (DSSPType.is(f, 4 /* DSSPType.Flag.E */))
         return SecondaryStructureType.SecondaryStructureDssp.E;
-    if (DSSPType.is(f, 2 /* B */))
+    if (DSSPType.is(f, 2 /* DSSPType.Flag.B */))
         return SecondaryStructureType.SecondaryStructureDssp.B;
-    if (DSSPType.is(f, 8 /* G */))
+    if (DSSPType.is(f, 8 /* DSSPType.Flag.G */))
         return SecondaryStructureType.SecondaryStructureDssp.G;
-    if (DSSPType.is(f, 64 /* T */))
+    if (DSSPType.is(f, 64 /* DSSPType.Flag.T */))
         return SecondaryStructureType.SecondaryStructureDssp.T;
-    if (DSSPType.is(f, 32 /* S */))
+    if (DSSPType.is(f, 32 /* DSSPType.Flag.S */))
         return SecondaryStructureType.SecondaryStructureDssp.S;
-    return 0 /* None */;
+    return 0 /* SecondaryStructureType.Flag.None */;
 }
 function getUpdatedFlagName(f) {
-    if (DSSPType.is(f, 16 /* I */))
+    if (DSSPType.is(f, 16 /* DSSPType.Flag.I */))
         return 'I';
-    if (DSSPType.is(f, 1 /* H */))
+    if (DSSPType.is(f, 1 /* DSSPType.Flag.H */))
         return 'H';
-    if (DSSPType.is(f, 4 /* E */))
+    if (DSSPType.is(f, 4 /* DSSPType.Flag.E */))
         return 'E';
-    if (DSSPType.is(f, 2 /* B */))
+    if (DSSPType.is(f, 2 /* DSSPType.Flag.B */))
         return 'B';
-    if (DSSPType.is(f, 8 /* G */))
+    if (DSSPType.is(f, 8 /* DSSPType.Flag.G */))
         return 'G';
-    if (DSSPType.is(f, 64 /* T */))
+    if (DSSPType.is(f, 64 /* DSSPType.Flag.T */))
         return 'T';
-    if (DSSPType.is(f, 32 /* S */))
+    if (DSSPType.is(f, 32 /* DSSPType.Flag.S */))
         return 'S';
     return '-';
 }

package/lib/mol-model-props/computed/themes/accessible-surface-area.js

@@ -64,7 +64,7 @@ export function AccessibleSurfaceAreaColorTheme(ctx, props) {
 export var AccessibleSurfaceAreaColorThemeProvider = {
     name: 'accessible-surface-area',
     label: 'Accessible Surface Area',
-    category: "Residue Property" /* Residue */,
+    category: "Residue Property" /* ColorTheme.Category.Residue */,
     factory: AccessibleSurfaceAreaColorTheme,
     getParams: getAccessibleSurfaceAreaColorThemeParams,
     defaultValues: PD.getDefaultValues(AccessibleSurfaceAreaColorThemeParams),

package/lib/mol-model-props/computed/themes/interaction-type.js

@@ -33,23 +33,23 @@ var InteractionTypeColorTable = [
 ];
 function typeColor(type) {
     switch (type) {
-        case 4 /* HydrogenBond */:
+        case 4 /* InteractionType.HydrogenBond */:
             return InteractionTypeColors.HydrogenBond;
-        case 6 /* Hydrophobic */:
+        case 6 /* InteractionType.Hydrophobic */:
             return InteractionTypeColors.Hydrophobic;
-        case 5 /* HalogenBond */:
+        case 5 /* InteractionType.HalogenBond */:
             return InteractionTypeColors.HalogenBond;
-        case 1 /* Ionic */:
+        case 1 /* InteractionType.Ionic */:
             return InteractionTypeColors.Ionic;
-        case 7 /* MetalCoordination */:
+        case 7 /* InteractionType.MetalCoordination */:
             return InteractionTypeColors.MetalCoordination;
-        case 2 /* CationPi */:
+        case 2 /* InteractionType.CationPi */:
             return InteractionTypeColors.CationPi;
-        case 3 /* PiStacking */:
+        case 3 /* InteractionType.PiStacking */:
             return InteractionTypeColors.PiStacking;
-        case 8 /* WeakHydrogenBond */:
+        case 8 /* InteractionType.WeakHydrogenBond */:
             return InteractionTypeColors.WeakHydrogenBond;
-        case 0 /* Unknown */:
+        case 0 /* InteractionType.Unknown */:
             return DefaultColor;
     }
 }
@@ -95,7 +95,7 @@ export function InteractionTypeColorTheme(ctx, props) {
 export var InteractionTypeColorThemeProvider = {
     name: 'interaction-type',
     label: 'Interaction Type',
-    category: "Miscellaneous" /* Misc */,
+    category: "Miscellaneous" /* ColorTheme.Category.Misc */,
     factory: InteractionTypeColorTheme,
     getParams: getInteractionTypeColorThemeParams,
     defaultValues: PD.getDefaultValues(InteractionTypeColorThemeParams),

package/lib/mol-model-props/integrative/cross-link-restraint/color.js

@@ -50,7 +50,7 @@ export function CrossLinkColorTheme(ctx, props) {
 export var CrossLinkColorThemeProvider = {
     name: 'cross-link',
     label: 'Cross Link',
-    category: "Miscellaneous" /* Misc */,
+    category: "Miscellaneous" /* ColorTheme.Category.Misc */,
     factory: CrossLinkColorTheme,
     getParams: getCrossLinkColorThemeParams,
     defaultValues: PD.getDefaultValues(CrossLinkColorThemeParams),

package/lib/mol-model-props/integrative/cross-link-restraint/format.js

@@ -60,9 +60,9 @@ var ModelCrossLinkRestraint;
         }
         function getMapByKind(kind) {
             switch (kind) {
-                case 0 /* Atomic */: return atomicElementMap;
-                case 1 /* Spheres */: return sphereElementMap;
-                case 2 /* Gaussians */: return gaussianElementMap;
+                case 0 /* Unit.Kind.Atomic */: return atomicElementMap;
+                case 1 /* Unit.Kind.Spheres */: return sphereElementMap;
+                case 2 /* Unit.Kind.Gaussians */: return gaussianElementMap;
             }
         }
         /** map from atomic element to cross link indices */

package/lib/mol-model-props/sequence/sifts-mapping.js

@@ -70,7 +70,7 @@ var SIFTSMapping;
         var residue = new Array(count);
         for (var i = 0; i < count; i++) {
             var row = atomSourceIndex.value(residueOffsets[i]);
-            if (db_name.valueKind(row) !== 0 /* Present */) {
+            if (db_name.valueKind(row) !== 0 /* Column.ValueKind.Present */) {
                 dbName[i] = '';
                 accession[i] = '';
                 num[i] = '';

package/lib/mol-model-props/sequence/themes/sifts-mapping.js

@@ -72,7 +72,7 @@ export function SIFTSMappingColorTheme(ctx, props) {
 export var SIFTSMappingColorThemeProvider = {
     name: 'sifts-mapping',
     label: 'SIFTS Mapping',
-    category: "Residue Property" /* Residue */,
+    category: "Residue Property" /* ColorTheme.Category.Residue */,
     factory: SIFTSMappingColorTheme,
     getParams: getSIFTSMappingColorThemeParams,
     defaultValues: PD.getDefaultValues(SIFTSMappingColorThemeParams),

package/lib/mol-plugin/animation-loop.d.ts

@@ -1,7 +1,8 @@
 /**
- * Copyright (c) 2020 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 David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { PluginContext } from './context';
 import { PluginAnimationManager } from '../mol-plugin-state/manager/animation';

package/lib/mol-plugin/animation-loop.js

@@ -1,10 +1,13 @@
 /**
- * Copyright (c) 2020 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 David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 import { __awaiter, __generator } from "tslib";
 import { now } from '../mol-util/now';
+import { isTimingMode } from '../mol-util/debug';
+import { printTimerResults } from '../mol-gl/webgl/timer';
 var PluginAnimationLoop = /** @class */ (function () {
     function PluginAnimationLoop(plugin) {
         var _this = this;
@@ -26,14 +29,24 @@ var PluginAnimationLoop = /** @class */ (function () {
         configurable: true
     });
     PluginAnimationLoop.prototype.tick = function (t, options) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var timerResults, _i, timerResults_1, result;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0: return [4 /*yield*/, this.plugin.managers.animation.tick(t, options === null || options === void 0 ? void 0 : options.isSynchronous, options === null || options === void 0 ? void 0 : options.animation)];
                     case 1:
-                        _b.sent();
+                        _c.sent();
                         (_a = this.plugin.canvas3d) === null || _a === void 0 ? void 0 : _a.tick(t, options);
+                        if (isTimingMode) {
+                            timerResults = (_b = this.plugin.canvas3d) === null || _b === void 0 ? void 0 : _b.webgl.timer.resolve();
+                            if (timerResults) {
+                                for (_i = 0, timerResults_1 = timerResults; _i < timerResults_1.length; _i++) {
+                                    result = timerResults_1[_i];
+                                    printTimerResults([result]);
+                                }
+                            }
+                        }
                         return [2 /*return*/];
                 }
             });