molstar 3.8.2 → 3.10.0

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

@@ -23,19 +23,19 @@ function addHydrophobicAtom(structure, unit, builder) {
     var _loop_1 = function (i, il) {
         var element = typeSymbol(unit, i);
         var flag = false;
-        if (element === "C" /* C */) {
+        if (element === "C" /* Elements.C */) {
             flag = true;
             eachBondedAtom(structure, unit, i, function (unitB, indexB) {
                 var elementB = typeSymbol(unitB, indexB);
-                if (elementB !== "C" /* C */ && elementB !== "H" /* H */)
+                if (elementB !== "C" /* Elements.C */ && elementB !== "H" /* Elements.H */)
                     flag = false;
             });
         }
-        else if (element === "F" /* F */) {
+        else if (element === "F" /* Elements.F */) {
             flag = true;
         }
         if (flag) {
-            builder.add(8 /* HydrophobicAtom */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+            builder.add(8 /* FeatureType.HydrophobicAtom */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
         }
     };
     for (var i = 0, il = elements.length; i < il; ++i) {
@@ -43,7 +43,7 @@ function addHydrophobicAtom(structure, unit, builder) {
     }
 }
 function isHydrophobicContact(ti, tj) {
-    return ti === 8 /* HydrophobicAtom */ && tj === 8 /* HydrophobicAtom */;
+    return ti === 8 /* FeatureType.HydrophobicAtom */ && tj === 8 /* FeatureType.HydrophobicAtom */;
 }
 function testHydrophobic(structure, infoA, infoB, distanceSq) {
     var typeA = infoA.types[infoA.feature];
@@ -52,19 +52,19 @@ function testHydrophobic(structure, infoA, infoB, distanceSq) {
         return;
     var indexA = infoA.members[infoA.offsets[infoA.feature]];
     var indexB = infoB.members[infoB.offsets[infoB.feature]];
-    if (typeSymbol(infoA.unit, indexA) === "F" /* F */ && typeSymbol(infoB.unit, indexB) === "F" /* F */)
+    if (typeSymbol(infoA.unit, indexA) === "F" /* Elements.F */ && typeSymbol(infoB.unit, indexB) === "F" /* Elements.F */)
         return;
-    return 6 /* Hydrophobic */;
+    return 6 /* InteractionType.Hydrophobic */;
 }
 //
-export var HydrophobicAtomProvider = Features.Provider([8 /* HydrophobicAtom */], addHydrophobicAtom);
+export var HydrophobicAtomProvider = Features.Provider([8 /* FeatureType.HydrophobicAtom */], addHydrophobicAtom);
 export var HydrophobicProvider = {
     name: 'hydrophobic',
     params: HydrophobicParams,
     createTester: function (props) {
         return {
             maxDistance: props.distanceMax,
-            requiredFeatures: new Set([8 /* HydrophobicAtom */]),
+            requiredFeatures: new Set([8 /* FeatureType.HydrophobicAtom */]),
             getType: function (structure, infoA, infoB, distanceSq) { return testHydrophobic(structure, infoA, infoB, distanceSq); }
         };
     }

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

@@ -14,25 +14,25 @@ export var MetalCoordinationParams = {
     distanceMax: PD.Numeric(3.0, { min: 1, max: 5, step: 0.1 }),
 };
 var IonicTypeMetals = [
-    "LI" /* LI */, "NA" /* NA */, "K" /* K */, "RB" /* RB */, "CS" /* CS */,
-    "MG" /* MG */, "CA" /* CA */, "SR" /* SR */, "BA" /* BA */, "AL" /* AL */,
-    "GA" /* GA */, "IN" /* IN */, "TL" /* TL */, "SC" /* SC */, "SN" /* SN */,
-    "PB" /* PB */, "BI" /* BI */, "SB" /* SB */, "HG" /* HG */
+    "LI" /* Elements.LI */, "NA" /* Elements.NA */, "K" /* Elements.K */, "RB" /* Elements.RB */, "CS" /* Elements.CS */,
+    "MG" /* Elements.MG */, "CA" /* Elements.CA */, "SR" /* Elements.SR */, "BA" /* Elements.BA */, "AL" /* Elements.AL */,
+    "GA" /* Elements.GA */, "IN" /* Elements.IN */, "TL" /* Elements.TL */, "SC" /* Elements.SC */, "SN" /* Elements.SN */,
+    "PB" /* Elements.PB */, "BI" /* Elements.BI */, "SB" /* Elements.SB */, "HG" /* Elements.HG */
 ];
 function addMetal(structure, unit, builder) {
     var elements = unit.elements;
     var _a = unit.model.atomicConformation, x = _a.x, y = _a.y, z = _a.z;
     for (var i = 0, il = elements.length; i < il; ++i) {
         var element = typeSymbol(unit, i);
-        var type = 0 /* None */;
+        var type = 0 /* FeatureType.None */;
         if (IonicTypeMetals.includes(element)) {
-            type = 13 /* IonicTypeMetal */;
+            type = 13 /* FeatureType.IonicTypeMetal */;
         }
-        else if (isTransitionMetal(element) || element === "ZN" /* ZN */ || element === "CD" /* CD */) {
-            type = 12 /* TransitionMetal */;
+        else if (isTransitionMetal(element) || element === "ZN" /* Elements.ZN */ || element === "CD" /* Elements.CD */) {
+            type = 12 /* FeatureType.TransitionMetal */;
         }
         if (type) {
-            builder.add(type, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+            builder.add(type, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
         }
     }
 }
@@ -60,17 +60,17 @@ function addMetalBinding(structure, unit, builder) {
         var isStandardAminoacid = AminoAcidNames.has(resname);
         var isStandardBase = BaseNames.has(resname);
         if (!isStandardAminoacid && !isStandardBase) {
-            if (isHalogen(element) || element === "O" /* O */ || element === "S" /* S */) {
+            if (isHalogen(element) || element === "O" /* Elements.O */ || element === "S" /* Elements.S */) {
                 dative = true;
                 ionic = true;
             }
-            else if (element === "N" /* N */) {
+            else if (element === "N" /* Elements.N */) {
                 dative = true;
             }
         }
         else if (isStandardAminoacid) {
             // main chain oxygen atom or oxygen, nitrogen and sulfur from specific amino acids
-            if (element === "O" /* O */) {
+            if (element === "O" /* Elements.O */) {
                 if (['ASP', 'GLU', 'SER', 'THR', 'TYR', 'ASN', 'GLN'].includes(resname) && isProteinSidechain(atomname)) {
                     dative = true;
                     ionic = true;
@@ -80,11 +80,11 @@ function addMetalBinding(structure, unit, builder) {
                     ionic = true;
                 }
             }
-            else if (element === "S" /* S */ && (resname === 'CYS' || resname === 'MET')) {
+            else if (element === "S" /* Elements.S */ && (resname === 'CYS' || resname === 'MET')) {
                 dative = true;
                 ionic = true;
             }
-            else if (element === "N" /* N */) {
+            else if (element === "N" /* Elements.N */) {
                 if (resname === 'HIS' && isProteinSidechain(atomname)) {
                     dative = true;
                 }
@@ -93,7 +93,7 @@ function addMetalBinding(structure, unit, builder) {
         else if (isStandardBase) {
             // http://pubs.acs.org/doi/pdf/10.1021/acs.accounts.6b00253
             // http://onlinelibrary.wiley.com/doi/10.1002/anie.200900399/full
-            if (element === "O" /* O */ && isNucleicBackbone(atomname)) {
+            if (element === "O" /* Elements.O */ && isNucleicBackbone(atomname)) {
                 dative = true;
                 ionic = true;
             }
@@ -106,20 +106,20 @@ function addMetalBinding(structure, unit, builder) {
             }
         }
         if (dative) {
-            builder.add(11 /* DativeBondPartner */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+            builder.add(11 /* FeatureType.DativeBondPartner */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
         }
         if (ionic) {
-            builder.add(10 /* IonicTypePartner */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+            builder.add(10 /* FeatureType.IonicTypePartner */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
         }
     }
 }
 function isMetalCoordination(ti, tj) {
-    if (ti === 12 /* TransitionMetal */) {
-        return (tj === 11 /* DativeBondPartner */ ||
-            tj === 12 /* TransitionMetal */);
+    if (ti === 12 /* FeatureType.TransitionMetal */) {
+        return (tj === 11 /* FeatureType.DativeBondPartner */ ||
+            tj === 12 /* FeatureType.TransitionMetal */);
     }
-    else if (ti === 13 /* IonicTypeMetal */) {
-        return (tj === 10 /* IonicTypePartner */);
+    else if (ti === 13 /* FeatureType.IonicTypeMetal */) {
+        return (tj === 10 /* FeatureType.IonicTypePartner */);
     }
 }
 function testMetalCoordination(structure, infoA, infoB, distanceSq) {
@@ -127,18 +127,18 @@ function testMetalCoordination(structure, infoA, infoB, distanceSq) {
     var typeB = infoB.types[infoB.feature];
     if (!isMetalCoordination(typeA, typeB) && !isMetalCoordination(typeB, typeA))
         return;
-    return 7 /* MetalCoordination */;
+    return 7 /* InteractionType.MetalCoordination */;
 }
 //
-export var MetalProvider = Features.Provider([13 /* IonicTypeMetal */, 12 /* TransitionMetal */], addMetal);
-export var MetalBindingProvider = Features.Provider([10 /* IonicTypePartner */, 11 /* DativeBondPartner */], addMetalBinding);
+export var MetalProvider = Features.Provider([13 /* FeatureType.IonicTypeMetal */, 12 /* FeatureType.TransitionMetal */], addMetal);
+export var MetalBindingProvider = Features.Provider([10 /* FeatureType.IonicTypePartner */, 11 /* FeatureType.DativeBondPartner */], addMetalBinding);
 export var MetalCoordinationProvider = {
     name: 'metal-coordination',
     params: MetalCoordinationParams,
     createTester: function (props) {
         return {
             maxDistance: props.distanceMax,
-            requiredFeatures: new Set([13 /* IonicTypeMetal */, 12 /* TransitionMetal */, 10 /* IonicTypePartner */, 11 /* DativeBondPartner */]),
+            requiredFeatures: new Set([13 /* FeatureType.IonicTypeMetal */, 12 /* FeatureType.TransitionMetal */, 10 /* FeatureType.IonicTypePartner */, 11 /* FeatureType.DativeBondPartner */]),
             getType: function (structure, infoA, infoB, distanceSq) { return testMetalCoordination(structure, infoA, infoB, distanceSq); }
         };
     }

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 */;
                     }
                 }
             }