molstar 3.8.2 → 3.10.0

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

@@ -52,36 +52,36 @@ function addUnitPositiveCharges(structure, unit, builder) {
         if (PositvelyCharged.includes(compId)) {
             builder.startState();
             for (var j = start; j < end; ++j) {
-                if (typeSymbol(unit, j) === "N" /* N */ && !ProteinBackboneAtoms.has(atomId(unit, j))) {
+                if (typeSymbol(unit, j) === "N" /* Elements.N */ && !ProteinBackboneAtoms.has(atomId(unit, j))) {
                     builder.pushMember(x[elements[j]], y[elements[j]], z[elements[j]], j);
                 }
             }
-            builder.finishState(1 /* PositiveCharge */, 0 /* None */);
+            builder.finishState(1 /* FeatureType.PositiveCharge */, 0 /* FeatureGroup.None */);
         }
         else if (!PolymerNames.has(compId)) {
             addedElements.clear();
             for (var j = start; j < end; ++j) {
-                var group = 0 /* None */;
+                var group = 0 /* FeatureGroup.None */;
                 if (isGuanidine(structure, unit, j)) {
-                    group = 8 /* Guanidine */;
+                    group = 8 /* FeatureGroup.Guanidine */;
                 }
                 else if (isAcetamidine(structure, unit, j)) {
-                    group = 9 /* Acetamidine */;
+                    group = 9 /* FeatureGroup.Acetamidine */;
                 }
                 if (group) {
                     builder.startState();
                     eachBondedAtom(structure, unit, j, function (_, k) {
-                        if (typeSymbol(unit, k) === "N" /* N */) {
+                        if (typeSymbol(unit, k) === "N" /* Elements.N */) {
                             addedElements.add(k);
                             builder.pushMember(x[elements[k]], y[elements[k]], z[elements[k]], k);
                         }
                     });
-                    builder.finishState(1 /* PositiveCharge */, group);
+                    builder.finishState(1 /* FeatureType.PositiveCharge */, group);
                 }
             }
             for (var j = start; j < end; ++j) {
                 if (charge[j] > 0 && !addedElements.has(j)) {
-                    builder.add(1 /* PositiveCharge */, 0 /* None */, x[elements[j]], y[elements[j]], z[elements[j]], j);
+                    builder.add(1 /* FeatureType.PositiveCharge */, 0 /* FeatureGroup.None */, x[elements[j]], y[elements[j]], z[elements[j]], j);
                 }
             }
         }
@@ -100,59 +100,59 @@ function addUnitNegativeCharges(structure, unit, builder) {
         if (NegativelyCharged.includes(compId)) {
             builder.startState();
             for (var j = start; j < end; ++j) {
-                if (typeSymbol(unit, j) === "O" /* O */ && !ProteinBackboneAtoms.has(atomId(unit, j))) {
+                if (typeSymbol(unit, j) === "O" /* Elements.O */ && !ProteinBackboneAtoms.has(atomId(unit, j))) {
                     builder.pushMember(x[elements[j]], y[elements[j]], z[elements[j]], j);
                 }
             }
-            builder.finishState(2 /* NegativeCharge */, 0 /* None */);
+            builder.finishState(2 /* FeatureType.NegativeCharge */, 0 /* FeatureGroup.None */);
         }
         else if (BaseNames.has(compId)) {
             for (var j = start; j < end; ++j) {
                 if (isPhosphate(structure, unit, j)) {
                     builder.startState();
                     eachBondedAtom(structure, unit, j, function (_, k) {
-                        if (typeSymbol(unit, k) === "O" /* O */) {
+                        if (typeSymbol(unit, k) === "O" /* Elements.O */) {
                             builder.pushMember(x[elements[k]], y[elements[k]], z[elements[k]], k);
                         }
                     });
-                    builder.finishState(2 /* NegativeCharge */, 6 /* Phosphate */);
+                    builder.finishState(2 /* FeatureType.NegativeCharge */, 6 /* FeatureGroup.Phosphate */);
                 }
             }
         }
         else if (!PolymerNames.has(compId)) {
             for (var j = start; j < end; ++j) {
                 builder.startState();
-                if (typeSymbol(unit, j) === "N" /* N */ && !ProteinBackboneAtoms.has(atomId(unit, j))) {
+                if (typeSymbol(unit, j) === "N" /* Elements.N */ && !ProteinBackboneAtoms.has(atomId(unit, j))) {
                     builder.pushMember(x[elements[j]], y[elements[j]], z[elements[j]], j);
                 }
-                builder.finishState(2 /* NegativeCharge */, 0 /* None */);
-                var group = 0 /* None */;
+                builder.finishState(2 /* FeatureType.NegativeCharge */, 0 /* FeatureGroup.None */);
+                var group = 0 /* FeatureGroup.None */;
                 if (isSulfonicAcid(structure, unit, j)) {
-                    group = 4 /* SulfonicAcid */;
+                    group = 4 /* FeatureGroup.SulfonicAcid */;
                 }
                 else if (isPhosphate(structure, unit, j)) {
-                    group = 6 /* Phosphate */;
+                    group = 6 /* FeatureGroup.Phosphate */;
                 }
                 else if (isSulfate(structure, unit, j)) {
-                    group = 5 /* Sulfate */;
+                    group = 5 /* FeatureGroup.Sulfate */;
                 }
                 else if (isCarboxylate(structure, unit, j)) {
-                    group = 10 /* Carboxylate */;
+                    group = 10 /* FeatureGroup.Carboxylate */;
                 }
                 if (group) {
                     builder.startState();
                     eachBondedAtom(structure, unit, j, function (_, k) {
-                        if (typeSymbol(unit, k) === "O" /* O */) {
+                        if (typeSymbol(unit, k) === "O" /* Elements.O */) {
                             addedElements.add(k);
                             builder.pushMember(x[elements[k]], y[elements[k]], z[elements[k]], k);
                         }
                     });
-                    builder.finishState(2 /* NegativeCharge */, group);
+                    builder.finishState(2 /* FeatureType.NegativeCharge */, group);
                 }
             }
             for (var j = start; j < end; ++j) {
                 if (charge[j] < 0 && !addedElements.has(j)) {
-                    builder.add(2 /* NegativeCharge */, 0 /* None */, x[elements[j]], y[elements[j]], z[elements[j]], j);
+                    builder.add(2 /* FeatureType.NegativeCharge */, 0 /* FeatureGroup.None */, x[elements[j]], y[elements[j]], z[elements[j]], j);
                 }
             }
         }
@@ -169,19 +169,19 @@ function addUnitAromaticRings(structure, unit, builder) {
             var j = ring[i];
             builder.pushMember(x[elements[j]], y[elements[j]], z[elements[j]], j);
         }
-        builder.finishState(3 /* AromaticRing */, 0 /* None */);
+        builder.finishState(3 /* FeatureType.AromaticRing */, 0 /* FeatureGroup.None */);
     }
 }
 function isIonic(ti, tj) {
-    return ((ti === 2 /* NegativeCharge */ && tj === 1 /* PositiveCharge */) ||
-        (ti === 1 /* PositiveCharge */ && tj === 2 /* NegativeCharge */));
+    return ((ti === 2 /* FeatureType.NegativeCharge */ && tj === 1 /* FeatureType.PositiveCharge */) ||
+        (ti === 1 /* FeatureType.PositiveCharge */ && tj === 2 /* FeatureType.NegativeCharge */));
 }
 function isPiStacking(ti, tj) {
-    return ti === 3 /* AromaticRing */ && tj === 3 /* AromaticRing */;
+    return ti === 3 /* FeatureType.AromaticRing */ && tj === 3 /* FeatureType.AromaticRing */;
 }
 function isCationPi(ti, tj) {
-    return ((ti === 3 /* AromaticRing */ && tj === 1 /* PositiveCharge */) ||
-        (ti === 1 /* PositiveCharge */ && tj === 3 /* AromaticRing */));
+    return ((ti === 3 /* FeatureType.AromaticRing */ && tj === 1 /* FeatureType.PositiveCharge */) ||
+        (ti === 1 /* FeatureType.PositiveCharge */ && tj === 3 /* FeatureType.AromaticRing */));
 }
 var tmpPointA = Vec3();
 var tmpPointB = Vec3();
@@ -246,7 +246,7 @@ function testIonic(structure, infoA, infoB, distanceSq, opts) {
     var typeB = infoB.types[infoB.feature];
     if (isIonic(typeA, typeB)) {
         if (areFeaturesWithinDistanceSq(infoA, infoB, opts.distanceMaxSq)) {
-            return 1 /* Ionic */;
+            return 1 /* InteractionType.Ionic */;
         }
     }
 }
@@ -260,10 +260,10 @@ function testPiStacking(structure, infoA, infoB, distanceSq, opts) {
         var offset = Math.min(getOffset(infoA, infoB, tmpNormalB), getOffset(infoB, infoA, tmpNormalA));
         if (offset <= opts.offsetMax) {
             if (angle <= opts.angleDevMax || angle >= deg180InRad - opts.angleDevMax) {
-                return 3 /* PiStacking */; // parallel
+                return 3 /* InteractionType.PiStacking */; // parallel
             }
             else if (angle <= opts.angleDevMax + deg90InRad && angle >= deg90InRad - opts.angleDevMax) {
-                return 3 /* PiStacking */; // t-shaped
+                return 3 /* InteractionType.PiStacking */; // t-shaped
             }
         }
     }
@@ -272,18 +272,18 @@ function testCationPi(structure, infoA, infoB, distanceSq, opts) {
     var typeA = infoA.types[infoA.feature];
     var typeB = infoB.types[infoB.feature];
     if (isCationPi(typeA, typeB)) {
-        var _a = typeA === 3 /* AromaticRing */ ? [infoA, infoB] : [infoB, infoA], infoR = _a[0], infoC = _a[1];
+        var _a = typeA === 3 /* FeatureType.AromaticRing */ ? [infoA, infoB] : [infoB, infoA], infoR = _a[0], infoC = _a[1];
         getNormal(tmpNormalA, infoR);
         var offset = getOffset(infoC, infoR, tmpNormalA);
         if (offset <= opts.offsetMax) {
-            return 2 /* CationPi */;
+            return 2 /* InteractionType.CationPi */;
         }
     }
 }
 //
-export var NegativChargeProvider = Features.Provider([2 /* NegativeCharge */], addUnitNegativeCharges);
-export var PositiveChargeProvider = Features.Provider([1 /* PositiveCharge */], addUnitPositiveCharges);
-export var AromaticRingProvider = Features.Provider([3 /* AromaticRing */], addUnitAromaticRings);
+export var NegativChargeProvider = Features.Provider([2 /* FeatureType.NegativeCharge */], addUnitNegativeCharges);
+export var PositiveChargeProvider = Features.Provider([1 /* FeatureType.PositiveCharge */], addUnitPositiveCharges);
+export var AromaticRingProvider = Features.Provider([3 /* FeatureType.AromaticRing */], addUnitAromaticRings);
 export var IonicProvider = {
     name: 'ionic',
     params: IonicParams,
@@ -291,7 +291,7 @@ export var IonicProvider = {
         var opts = getIonicOptions(props);
         return {
             maxDistance: props.distanceMax,
-            requiredFeatures: new Set([2 /* NegativeCharge */, 1 /* PositiveCharge */]),
+            requiredFeatures: new Set([2 /* FeatureType.NegativeCharge */, 1 /* FeatureType.PositiveCharge */]),
             getType: function (structure, infoA, infoB, distanceSq) { return testIonic(structure, infoA, infoB, distanceSq, opts); }
         };
     }
@@ -303,7 +303,7 @@ export var PiStackingProvider = {
         var opts = getPiStackingOptions(props);
         return {
             maxDistance: props.distanceMax,
-            requiredFeatures: new Set([3 /* AromaticRing */]),
+            requiredFeatures: new Set([3 /* FeatureType.AromaticRing */]),
             getType: function (structure, infoA, infoB, distanceSq) { return testPiStacking(structure, infoA, infoB, distanceSq, opts); }
         };
     }
@@ -315,7 +315,7 @@ export var CationPiProvider = {
         var opts = getCationPiOptions(props);
         return {
             maxDistance: props.distanceMax,
-            requiredFeatures: new Set([3 /* AromaticRing */, 1 /* PositiveCharge */]),
+            requiredFeatures: new Set([3 /* FeatureType.AromaticRing */, 1 /* FeatureType.PositiveCharge */]),
             getType: function (structure, infoA, infoB, distanceSq) { return testCationPi(structure, infoA, infoB, distanceSq, opts); }
         };
     }

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

@@ -89,81 +89,81 @@ var InteractionsInterContacts = /** @class */ (function (_super) {
 }(InterUnitGraph));
 export function interactionTypeLabel(type) {
     switch (type) {
-        case 4 /* HydrogenBond */:
+        case 4 /* InteractionType.HydrogenBond */:
             return 'Hydrogen Bond';
-        case 6 /* Hydrophobic */:
+        case 6 /* InteractionType.Hydrophobic */:
             return 'Hydrophobic Contact';
-        case 5 /* HalogenBond */:
+        case 5 /* InteractionType.HalogenBond */:
             return 'Halogen Bond';
-        case 1 /* Ionic */:
+        case 1 /* InteractionType.Ionic */:
             return 'Ionic Interaction';
-        case 7 /* MetalCoordination */:
+        case 7 /* InteractionType.MetalCoordination */:
             return 'Metal Coordination';
-        case 2 /* CationPi */:
+        case 2 /* InteractionType.CationPi */:
             return 'Cation-Pi Interaction';
-        case 3 /* PiStacking */:
+        case 3 /* InteractionType.PiStacking */:
             return 'Pi Stacking';
-        case 8 /* WeakHydrogenBond */:
+        case 8 /* InteractionType.WeakHydrogenBond */:
             return 'Weak Hydrogen Bond';
-        case 0 /* Unknown */:
+        case 0 /* InteractionType.Unknown */:
             return 'Unknown Interaction';
     }
 }
 export function featureTypeLabel(type) {
     switch (type) {
-        case 0 /* None */:
+        case 0 /* FeatureType.None */:
             return 'None';
-        case 1 /* PositiveCharge */:
+        case 1 /* FeatureType.PositiveCharge */:
             return 'Positive Charge';
-        case 2 /* NegativeCharge */:
+        case 2 /* FeatureType.NegativeCharge */:
             return 'Negative Charge';
-        case 3 /* AromaticRing */:
+        case 3 /* FeatureType.AromaticRing */:
             return 'Aromatic Ring';
-        case 4 /* HydrogenDonor */:
+        case 4 /* FeatureType.HydrogenDonor */:
             return 'Hydrogen Donor';
-        case 5 /* HydrogenAcceptor */:
+        case 5 /* FeatureType.HydrogenAcceptor */:
             return 'Hydrogen Acceptor';
-        case 6 /* HalogenDonor */:
+        case 6 /* FeatureType.HalogenDonor */:
             return 'Halogen Donor';
-        case 7 /* HalogenAcceptor */:
+        case 7 /* FeatureType.HalogenAcceptor */:
             return 'Halogen Acceptor';
-        case 8 /* HydrophobicAtom */:
+        case 8 /* FeatureType.HydrophobicAtom */:
             return 'HydrophobicAtom';
-        case 9 /* WeakHydrogenDonor */:
+        case 9 /* FeatureType.WeakHydrogenDonor */:
             return 'Weak Hydrogen Donor';
-        case 10 /* IonicTypePartner */:
+        case 10 /* FeatureType.IonicTypePartner */:
             return 'Ionic Type Partner';
-        case 11 /* DativeBondPartner */:
+        case 11 /* FeatureType.DativeBondPartner */:
             return 'Dative Bond Partner';
-        case 12 /* TransitionMetal */:
+        case 12 /* FeatureType.TransitionMetal */:
             return 'Transition Metal';
-        case 13 /* IonicTypeMetal */:
+        case 13 /* FeatureType.IonicTypeMetal */:
             return 'Ionic Type Metal';
     }
 }
 export function featureGroupLabel(group) {
     switch (group) {
-        case 0 /* None */:
+        case 0 /* FeatureGroup.None */:
             return 'None';
-        case 1 /* QuaternaryAmine */:
+        case 1 /* FeatureGroup.QuaternaryAmine */:
             return 'Quaternary Amine';
-        case 2 /* TertiaryAmine */:
+        case 2 /* FeatureGroup.TertiaryAmine */:
             return 'Tertiary Amine';
-        case 3 /* Sulfonium */:
+        case 3 /* FeatureGroup.Sulfonium */:
             return 'Sulfonium';
-        case 4 /* SulfonicAcid */:
+        case 4 /* FeatureGroup.SulfonicAcid */:
             return 'Sulfonic Acid';
-        case 5 /* Sulfate */:
+        case 5 /* FeatureGroup.Sulfate */:
             return 'Sulfate';
-        case 6 /* Phosphate */:
+        case 6 /* FeatureGroup.Phosphate */:
             return 'Phosphate';
-        case 7 /* Halocarbon */:
+        case 7 /* FeatureGroup.Halocarbon */:
             return 'Halocarbon';
-        case 8 /* Guanidine */:
+        case 8 /* FeatureGroup.Guanidine */:
             return 'Guanidine';
-        case 9 /* Acetamidine */:
+        case 9 /* FeatureGroup.Acetamidine */:
             return 'Acetamidine';
-        case 10 /* Carboxylate */:
+        case 10 /* FeatureGroup.Carboxylate */:
             return 'Carboxylate';
     }
 }

package/lib/mol-model-props/computed/interactions/contacts-builder.js

@@ -53,7 +53,7 @@ var InterContactsBuilder;
                 builder.finishUnitPair();
             },
             add: function (indexA, indexB, type) {
-                builder.add(indexA, indexB, { type: type, flag: 0 /* None */ });
+                builder.add(indexA, indexB, { type: type, flag: 0 /* InteractionFlag.None */ });
             },
             getContacts: function (unitsFeatures) {
                 return new InteractionsInterContacts(builder.getMap(), unitsFeatures);

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

@@ -70,7 +70,7 @@ function checkLineOfSight(structure, infoA, infoB, distFactor) {
             continue;
         var element = typeSymbol(unit, i);
         // allow hydrogens
-        if (element === "H" /* H */)
+        if (element === "H" /* Elements.H */)
             continue;
         var vdw = VdwRadius(element);
         // check distance

package/lib/mol-model-props/computed/interactions/halogen-bonds.js

@@ -15,7 +15,7 @@ var HalogenBondsParams = {
     distanceMax: PD.Numeric(4.0, { min: 1, max: 5, step: 0.1 }),
     angleMax: PD.Numeric(30, { min: 0, max: 60, step: 1 }),
 };
-var halBondElements = ["CL" /* CL */, "BR" /* BR */, "I" /* I */, "AT" /* AT */];
+var halBondElements = ["CL" /* Elements.CL */, "BR" /* Elements.BR */, "I" /* Elements.I */, "AT" /* Elements.AT */];
 /**
  * Halogen bond donors (X-C, with X one of Cl, Br, I or At) not F!
  */
@@ -25,12 +25,12 @@ function addUnitHalogenDonors(structure, unit, builder) {
     for (var i = 0, il = elements.length; i < il; ++i) {
         var element = typeSymbol(unit, i);
         if (halBondElements.includes(element)) {
-            builder.add(6 /* HalogenDonor */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+            builder.add(6 /* FeatureType.HalogenDonor */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
         }
     }
 }
-var X = ["N" /* N */, "O" /* O */, "S" /* S */];
-var Y = ["C" /* C */, "N" /* N */, "P" /* P */, "S" /* S */];
+var X = ["N" /* Elements.N */, "O" /* Elements.O */, "S" /* Elements.S */];
+var Y = ["C" /* Elements.C */, "N" /* Elements.N */, "P" /* Elements.P */, "S" /* Elements.S */];
 /**
  * Halogen bond acceptors (Y-{O|N|S}, with Y=C,P,N,S)
  */
@@ -47,7 +47,7 @@ function addUnitHalogenAcceptors(structure, unit, builder) {
                 }
             });
             if (flag_1) {
-                builder.add(7 /* HalogenAcceptor */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+                builder.add(7 /* FeatureType.HalogenAcceptor */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
             }
         }
     };
@@ -56,8 +56,8 @@ function addUnitHalogenAcceptors(structure, unit, builder) {
     }
 }
 function isHalogenBond(ti, tj) {
-    return ((ti === 7 /* HalogenAcceptor */ && tj === 6 /* HalogenDonor */) ||
-        (ti === 6 /* HalogenDonor */ && tj === 7 /* HalogenAcceptor */));
+    return ((ti === 7 /* FeatureType.HalogenAcceptor */ && tj === 6 /* FeatureType.HalogenDonor */) ||
+        (ti === 6 /* FeatureType.HalogenDonor */ && tj === 7 /* FeatureType.HalogenAcceptor */));
 }
 // http://www.pnas.org/content/101/48/16789.full
 var OptimalHalogenAngle = degToRad(180); // adjusted from 165 to account for spherical statistics
@@ -72,7 +72,7 @@ function testHalogenBond(structure, infoA, infoB, opts) {
     var typeB = infoB.types[infoB.feature];
     if (!isHalogenBond(typeA, typeB))
         return;
-    var _a = typeA === 6 /* HalogenDonor */ ? [infoA, infoB] : [infoB, infoA], don = _a[0], acc = _a[1];
+    var _a = typeA === 6 /* FeatureType.HalogenDonor */ ? [infoA, infoB] : [infoB, infoA], don = _a[0], acc = _a[1];
     var donIndex = don.members[don.offsets[don.feature]];
     var accIndex = acc.members[acc.offsets[acc.feature]];
     var halogenAngles = calcAngles(structure, don.unit, donIndex, acc.unit, accIndex);
@@ -87,11 +87,11 @@ function testHalogenBond(structure, infoA, infoB, opts) {
         return;
     if (acceptorAngles.some(function (acceptorAngle) { return OptimalAcceptorAngle - acceptorAngle > opts.angleMax; }))
         return;
-    return 5 /* HalogenBond */;
+    return 5 /* InteractionType.HalogenBond */;
 }
 //
-export var HalogenDonorProvider = Features.Provider([6 /* HalogenDonor */], addUnitHalogenDonors);
-export var HalogenAcceptorProvider = Features.Provider([7 /* HalogenAcceptor */], addUnitHalogenAcceptors);
+export var HalogenDonorProvider = Features.Provider([6 /* FeatureType.HalogenDonor */], addUnitHalogenDonors);
+export var HalogenAcceptorProvider = Features.Provider([7 /* FeatureType.HalogenAcceptor */], addUnitHalogenAcceptors);
 export var HalogenBondsProvider = {
     name: 'halogen-bonds',
     params: HalogenBondsParams,
@@ -99,7 +99,7 @@ export var HalogenBondsProvider = {
         var opts = getOptions(props);
         return {
             maxDistance: props.distanceMax,
-            requiredFeatures: new Set([6 /* HalogenDonor */, 7 /* HalogenAcceptor */]),
+            requiredFeatures: new Set([6 /* FeatureType.HalogenDonor */, 7 /* FeatureType.HalogenAcceptor */]),
             getType: function (structure, infoA, infoB) { return testHalogenBond(structure, infoA, infoB, opts); }
         };
     }

package/lib/mol-model-props/computed/interactions/hydrogen-bonds.js

@@ -52,8 +52,8 @@ function addUnitHydrogenDonors(structure, unit, builder) {
         // include both nitrogen atoms in histidine due to
         // their often ambiguous protonation assignment
         isHistidineNitrogen(unit, i)) || (totalH[i] > 0 &&
-            (element === "N" /* N */ || element === "O" /* O */ || element === "S" /* S */))) {
-            builder.add(4 /* HydrogenDonor */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+            (element === "N" /* Elements.N */ || element === "O" /* Elements.O */ || element === "S" /* Elements.S */))) {
+            builder.add(4 /* FeatureType.HydrogenDonor */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
         }
     }
 }
@@ -65,12 +65,12 @@ function addUnitWeakHydrogenDonors(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) {
-        if (typeSymbol(unit, i) === "C" /* C */ &&
+        if (typeSymbol(unit, i) === "C" /* Elements.C */ &&
             totalH[i] > 0 &&
-            (bondToElementCount(structure, unit, i, "N" /* N */) > 0 ||
-                bondToElementCount(structure, unit, i, "O" /* O */) > 0 ||
+            (bondToElementCount(structure, unit, i, "N" /* Elements.N */) > 0 ||
+                bondToElementCount(structure, unit, i, "O" /* Elements.O */) > 0 ||
                 inAromaticRingWithElectronNegativeElement(unit, i))) {
-            builder.add(9 /* WeakHydrogenDonor */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+            builder.add(9 /* FeatureType.WeakHydrogenDonor */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
         }
     }
 }
@@ -83,7 +83,7 @@ function inAromaticRingWithElectronNegativeElement(unit, index) {
         var ring = all[ringIndices[i]];
         for (var j = 0, jl = ring.length; j < jl; ++j) {
             var element = typeSymbol(unit, ring[j]);
-            if (element === "N" /* N */ || element === "O" /* O */) {
+            if (element === "N" /* Elements.N */ || element === "O" /* Elements.O */) {
                 return true;
             }
         }
@@ -98,15 +98,15 @@ function addUnitHydrogenAcceptors(structure, unit, builder) {
     var elements = unit.elements;
     var _b = unit.model.atomicConformation, x = _b.x, y = _b.y, z = _b.z;
     var add = function (i) {
-        builder.add(5 /* HydrogenAcceptor */, 0 /* None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
+        builder.add(5 /* FeatureType.HydrogenAcceptor */, 0 /* FeatureGroup.None */, x[elements[i]], y[elements[i]], z[elements[i]], i);
     };
     for (var i = 0, il = elements.length; i < il; ++i) {
         var element = typeSymbol(unit, i);
-        if (element === "O" /* O */) {
+        if (element === "O" /* Elements.O */) {
             // Basically assume all oxygen atoms are acceptors!
             add(i);
         }
-        else if (element === "N" /* N */) {
+        else if (element === "N" /* Elements.N */) {
             if (isHistidineNitrogen(unit, i)) {
                 // include both nitrogen atoms in histidine due to
                 // their often ambiguous protonation assignment
@@ -117,14 +117,14 @@ function addUnitHydrogenAcceptors(structure, unit, builder) {
                 // It must have at least one lone pair not conjugated
                 var totalBonds = bondCount(structure, unit, i) + implicitH[i];
                 var ig = idealGeometry[i];
-                if ((ig === 4 /* Tetrahedral */ && totalBonds < 4) ||
-                    (ig === 3 /* Trigonal */ && totalBonds < 3) ||
-                    (ig === 2 /* Linear */ && totalBonds < 2)) {
+                if ((ig === 4 /* AtomGeometry.Tetrahedral */ && totalBonds < 4) ||
+                    (ig === 3 /* AtomGeometry.Trigonal */ && totalBonds < 3) ||
+                    (ig === 2 /* AtomGeometry.Linear */ && totalBonds < 2)) {
                     add(i);
                 }
             }
         }
-        else if (element === "S" /* S */) {
+        else if (element === "S" /* Elements.S */) {
             var resname = compId(unit, i);
             if (resname === 'CYS' || resname === 'MET' || formalCharge(unit, i) === -1) {
                 add(i);
@@ -133,7 +133,7 @@ function addUnitHydrogenAcceptors(structure, unit, builder) {
     }
 }
 function isWater(unit, index) {
-    return unit.model.atomicHierarchy.derived.residue.moleculeType[unit.residueIndex[unit.elements[index]]] === 2 /* Water */;
+    return unit.model.atomicHierarchy.derived.residue.moleculeType[unit.residueIndex[unit.elements[index]]] === 2 /* MoleculeType.Water */;
 }
 function isBackbone(unit, index) {
     return ProteinBackboneAtoms.has(atomId(unit, index));
@@ -142,7 +142,7 @@ function isRing(unit, index) {
     return unit.rings.elementRingIndices.has(index);
 }
 function isHistidineNitrogen(unit, index) {
-    return compId(unit, index) === 'HIS' && typeSymbol(unit, index) === "N" /* N */ && isRing(unit, index);
+    return compId(unit, index) === 'HIS' && typeSymbol(unit, index) === "N" /* Elements.N */ && isRing(unit, index);
 }
 function isBackboneHydrogenBond(unitA, indexA, unitB, indexB) {
     return isBackbone(unitA, indexA) && isBackbone(unitB, indexB);
@@ -151,12 +151,12 @@ function isWaterHydrogenBond(unitA, indexA, unitB, indexB) {
     return isWater(unitA, indexA) && isWater(unitB, indexB);
 }
 function isHydrogenBond(ti, tj) {
-    return ((ti === 5 /* HydrogenAcceptor */ && tj === 4 /* HydrogenDonor */) ||
-        (ti === 4 /* HydrogenDonor */ && tj === 5 /* HydrogenAcceptor */));
+    return ((ti === 5 /* FeatureType.HydrogenAcceptor */ && tj === 4 /* FeatureType.HydrogenDonor */) ||
+        (ti === 4 /* FeatureType.HydrogenDonor */ && tj === 5 /* FeatureType.HydrogenAcceptor */));
 }
 function isWeakHydrogenBond(ti, tj) {
-    return ((ti === 9 /* WeakHydrogenDonor */ && tj === 5 /* HydrogenAcceptor */) ||
-        (ti === 5 /* HydrogenAcceptor */ && tj === 9 /* WeakHydrogenDonor */));
+    return ((ti === 9 /* FeatureType.WeakHydrogenDonor */ && tj === 5 /* FeatureType.HydrogenAcceptor */) ||
+        (ti === 5 /* FeatureType.HydrogenAcceptor */ && tj === 9 /* FeatureType.WeakHydrogenDonor */));
 }
 function getGeometryOptions(props) {
     return {
@@ -180,7 +180,7 @@ function checkGeometry(structure, don, acc, opts) {
     var idealDonAngle = AtomGeometryAngles.get(don.idealGeometry[donIndex]) || deg120InRad;
     if (donAngles.some(function (donAngle) { return Math.abs(idealDonAngle - donAngle) > opts.maxDonAngleDev; }))
         return;
-    if (don.idealGeometry[donIndex] === 3 /* Trigonal */) {
+    if (don.idealGeometry[donIndex] === 3 /* AtomGeometry.Trigonal */) {
         var outOfPlane = calcPlaneAngle(structure, don.unit, donIndex, acc.unit, accIndex);
         if (outOfPlane !== undefined && outOfPlane > opts.maxDonOutOfPlaneAngle)
             return;
@@ -190,7 +190,7 @@ function checkGeometry(structure, don, acc, opts) {
     // Do not limit large acceptor angles
     if (accAngles.some(function (accAngle) { return idealAccAngle - accAngle > opts.maxAccAngleDev; }))
         return;
-    if (acc.idealGeometry[accIndex] === 3 /* Trigonal */) {
+    if (acc.idealGeometry[accIndex] === 3 /* AtomGeometry.Trigonal */) {
         var outOfPlane = calcPlaneAngle(structure, acc.unit, accIndex, don.unit, donIndex);
         if (outOfPlane !== undefined && outOfPlane > opts.maxAccOutOfPlaneAngle)
             return;
@@ -202,33 +202,33 @@ function testHydrogenBond(structure, infoA, infoB, distanceSq, opts) {
     var typeB = infoB.types[infoB.feature];
     if (!isHydrogenBond(typeA, typeB))
         return;
-    var _a = typeB === 5 /* HydrogenAcceptor */ ? [infoA, infoB] : [infoB, infoA], don = _a[0], acc = _a[1];
+    var _a = typeB === 5 /* FeatureType.HydrogenAcceptor */ ? [infoA, infoB] : [infoB, infoA], don = _a[0], acc = _a[1];
     var donIndex = don.members[don.offsets[don.feature]];
     var accIndex = acc.members[acc.offsets[acc.feature]];
     // check if distance is ok depending on non-sulfur-containing hbond
-    var maxDistSq = typeSymbol(don.unit, donIndex) === "S" /* S */ || typeSymbol(acc.unit, accIndex) === "S" /* S */ ? opts.maxSulfurDistSq : opts.maxDistSq;
+    var maxDistSq = typeSymbol(don.unit, donIndex) === "S" /* Elements.S */ || typeSymbol(acc.unit, accIndex) === "S" /* Elements.S */ ? opts.maxSulfurDistSq : opts.maxDistSq;
     if (distanceSq > maxDistSq)
         return;
     if (!opts.includeWater && isWaterHydrogenBond(don.unit, donIndex, acc.unit, accIndex))
         return;
     if (!checkGeometry(structure, don, acc, opts))
         return;
-    return 4 /* HydrogenBond */;
+    return 4 /* InteractionType.HydrogenBond */;
 }
 function testWeakHydrogenBond(structure, infoA, infoB, distanceSq, opts) {
     var typeA = infoA.types[infoA.feature];
     var typeB = infoB.types[infoB.feature];
     if (!isWeakHydrogenBond(typeA, typeB))
         return;
-    var _a = typeB === 5 /* HydrogenAcceptor */ ? [infoA, infoB] : [infoB, infoA], don = _a[0], acc = _a[1];
+    var _a = typeB === 5 /* FeatureType.HydrogenAcceptor */ ? [infoA, infoB] : [infoB, infoA], don = _a[0], acc = _a[1];
     if (!checkGeometry(structure, don, acc, opts))
         return;
-    return 8 /* WeakHydrogenBond */;
+    return 8 /* InteractionType.WeakHydrogenBond */;
 }
 //
-export var HydrogenDonorProvider = Features.Provider([4 /* HydrogenDonor */], addUnitHydrogenDonors);
-export var WeakHydrogenDonorProvider = Features.Provider([9 /* WeakHydrogenDonor */], addUnitWeakHydrogenDonors);
-export var HydrogenAcceptorProvider = Features.Provider([5 /* HydrogenAcceptor */], addUnitHydrogenAcceptors);
+export var HydrogenDonorProvider = Features.Provider([4 /* FeatureType.HydrogenDonor */], addUnitHydrogenDonors);
+export var WeakHydrogenDonorProvider = Features.Provider([9 /* FeatureType.WeakHydrogenDonor */], addUnitWeakHydrogenDonors);
+export var HydrogenAcceptorProvider = Features.Provider([5 /* FeatureType.HydrogenAcceptor */], addUnitHydrogenAcceptors);
 export var HydrogenBondsProvider = {
     name: 'hydrogen-bonds',
     params: HydrogenBondsParams,
@@ -237,7 +237,7 @@ export var HydrogenBondsProvider = {
         var opts = getHydrogenBondsOptions(props);
         return {
             maxDistance: maxDistance,
-            requiredFeatures: new Set([4 /* HydrogenDonor */, 5 /* HydrogenAcceptor */]),
+            requiredFeatures: new Set([4 /* FeatureType.HydrogenDonor */, 5 /* FeatureType.HydrogenAcceptor */]),
             getType: function (structure, infoA, infoB, distanceSq) { return testHydrogenBond(structure, infoA, infoB, distanceSq, opts); }
         };
     }
@@ -249,7 +249,7 @@ export var WeakHydrogenBondsProvider = {
         var opts = getGeometryOptions(props);
         return {
             maxDistance: props.distanceMax,
-            requiredFeatures: new Set([9 /* WeakHydrogenDonor */, 5 /* HydrogenAcceptor */]),
+            requiredFeatures: new Set([9 /* FeatureType.WeakHydrogenDonor */, 5 /* FeatureType.HydrogenAcceptor */]),
             getType: function (structure, infoA, infoB, distanceSq) { return testWeakHydrogenBond(structure, infoA, infoB, distanceSq, opts); }
         };
     }