molstar 3.8.2 → 3.9.0

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

@@ -55,36 +55,36 @@ function addUnitPositiveCharges(structure, unit, builder) {
         if (PositvelyCharged.includes(compId)) {
             builder.startState();
             for (var j = start; j < end; ++j) {
-                if ((0, util_1.typeSymbol)(unit, j) === "N" /* N */ && !types_1.ProteinBackboneAtoms.has((0, util_1.atomId)(unit, j))) {
+                if ((0, util_1.typeSymbol)(unit, j) === "N" /* Elements.N */ && !types_1.ProteinBackboneAtoms.has((0, util_1.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 (!types_1.PolymerNames.has(compId)) {
             addedElements.clear();
             for (var j = start; j < end; ++j) {
-                var group = 0 /* None */;
+                var group = 0 /* FeatureGroup.None */;
                 if ((0, functional_group_1.isGuanidine)(structure, unit, j)) {
-                    group = 8 /* Guanidine */;
+                    group = 8 /* FeatureGroup.Guanidine */;
                 }
                 else if ((0, functional_group_1.isAcetamidine)(structure, unit, j)) {
-                    group = 9 /* Acetamidine */;
+                    group = 9 /* FeatureGroup.Acetamidine */;
                 }
                 if (group) {
                     builder.startState();
                     (0, util_1.eachBondedAtom)(structure, unit, j, function (_, k) {
-                        if ((0, util_1.typeSymbol)(unit, k) === "N" /* N */) {
+                        if ((0, util_1.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);
                 }
             }
         }
@@ -103,59 +103,59 @@ function addUnitNegativeCharges(structure, unit, builder) {
         if (NegativelyCharged.includes(compId)) {
             builder.startState();
             for (var j = start; j < end; ++j) {
-                if ((0, util_1.typeSymbol)(unit, j) === "O" /* O */ && !types_1.ProteinBackboneAtoms.has((0, util_1.atomId)(unit, j))) {
+                if ((0, util_1.typeSymbol)(unit, j) === "O" /* Elements.O */ && !types_1.ProteinBackboneAtoms.has((0, util_1.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 (types_1.BaseNames.has(compId)) {
             for (var j = start; j < end; ++j) {
                 if ((0, functional_group_1.isPhosphate)(structure, unit, j)) {
                     builder.startState();
                     (0, util_1.eachBondedAtom)(structure, unit, j, function (_, k) {
-                        if ((0, util_1.typeSymbol)(unit, k) === "O" /* O */) {
+                        if ((0, util_1.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 (!types_1.PolymerNames.has(compId)) {
             for (var j = start; j < end; ++j) {
                 builder.startState();
-                if ((0, util_1.typeSymbol)(unit, j) === "N" /* N */ && !types_1.ProteinBackboneAtoms.has((0, util_1.atomId)(unit, j))) {
+                if ((0, util_1.typeSymbol)(unit, j) === "N" /* Elements.N */ && !types_1.ProteinBackboneAtoms.has((0, util_1.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 ((0, functional_group_1.isSulfonicAcid)(structure, unit, j)) {
-                    group = 4 /* SulfonicAcid */;
+                    group = 4 /* FeatureGroup.SulfonicAcid */;
                 }
                 else if ((0, functional_group_1.isPhosphate)(structure, unit, j)) {
-                    group = 6 /* Phosphate */;
+                    group = 6 /* FeatureGroup.Phosphate */;
                 }
                 else if ((0, functional_group_1.isSulfate)(structure, unit, j)) {
-                    group = 5 /* Sulfate */;
+                    group = 5 /* FeatureGroup.Sulfate */;
                 }
                 else if ((0, functional_group_1.isCarboxylate)(structure, unit, j)) {
-                    group = 10 /* Carboxylate */;
+                    group = 10 /* FeatureGroup.Carboxylate */;
                 }
                 if (group) {
                     builder.startState();
                     (0, util_1.eachBondedAtom)(structure, unit, j, function (_, k) {
-                        if ((0, util_1.typeSymbol)(unit, k) === "O" /* O */) {
+                        if ((0, util_1.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);
                 }
             }
         }
@@ -172,19 +172,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 = (0, linear_algebra_1.Vec3)();
 var tmpPointB = (0, linear_algebra_1.Vec3)();
@@ -249,7 +249,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 */;
         }
     }
 }
@@ -263,10 +263,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
             }
         }
     }
@@ -275,18 +275,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 */;
         }
     }
 }
 //
-exports.NegativChargeProvider = features_1.Features.Provider([2 /* NegativeCharge */], addUnitNegativeCharges);
-exports.PositiveChargeProvider = features_1.Features.Provider([1 /* PositiveCharge */], addUnitPositiveCharges);
-exports.AromaticRingProvider = features_1.Features.Provider([3 /* AromaticRing */], addUnitAromaticRings);
+exports.NegativChargeProvider = features_1.Features.Provider([2 /* FeatureType.NegativeCharge */], addUnitNegativeCharges);
+exports.PositiveChargeProvider = features_1.Features.Provider([1 /* FeatureType.PositiveCharge */], addUnitPositiveCharges);
+exports.AromaticRingProvider = features_1.Features.Provider([3 /* FeatureType.AromaticRing */], addUnitAromaticRings);
 exports.IonicProvider = {
     name: 'ionic',
     params: IonicParams,
@@ -294,7 +294,7 @@ exports.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); }
         };
     }
@@ -306,7 +306,7 @@ exports.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); }
         };
     }
@@ -318,7 +318,7 @@ exports.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/commonjs/mol-model-props/computed/interactions/common.js

@@ -92,83 +92,83 @@ var InteractionsInterContacts = /** @class */ (function (_super) {
 exports.InteractionsInterContacts = InteractionsInterContacts;
 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';
     }
 }
 exports.interactionTypeLabel = interactionTypeLabel;
 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';
     }
 }
 exports.featureTypeLabel = featureTypeLabel;
 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/commonjs/mol-model-props/computed/interactions/contacts-builder.js

@@ -55,7 +55,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 common_1.InteractionsInterContacts(builder.getMap(), unitsFeatures);

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

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

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

@@ -18,7 +18,7 @@ var HalogenBondsParams = {
     distanceMax: param_definition_1.ParamDefinition.Numeric(4.0, { min: 1, max: 5, step: 0.1 }),
     angleMax: param_definition_1.ParamDefinition.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!
  */
@@ -28,12 +28,12 @@ function addUnitHalogenDonors(structure, unit, builder) {
     for (var i = 0, il = elements.length; i < il; ++i) {
         var element = (0, util_1.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)
  */
@@ -50,7 +50,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);
             }
         }
     };
@@ -59,8 +59,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 = (0, misc_1.degToRad)(180); // adjusted from 165 to account for spherical statistics
@@ -75,7 +75,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 = (0, geometry_1.calcAngles)(structure, don.unit, donIndex, acc.unit, accIndex);
@@ -90,11 +90,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 */;
 }
 //
-exports.HalogenDonorProvider = features_1.Features.Provider([6 /* HalogenDonor */], addUnitHalogenDonors);
-exports.HalogenAcceptorProvider = features_1.Features.Provider([7 /* HalogenAcceptor */], addUnitHalogenAcceptors);
+exports.HalogenDonorProvider = features_1.Features.Provider([6 /* FeatureType.HalogenDonor */], addUnitHalogenDonors);
+exports.HalogenAcceptorProvider = features_1.Features.Provider([7 /* FeatureType.HalogenAcceptor */], addUnitHalogenAcceptors);
 exports.HalogenBondsProvider = {
     name: 'halogen-bonds',
     params: HalogenBondsParams,
@@ -102,7 +102,7 @@ exports.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/commonjs/mol-model-props/computed/interactions/hydrogen-bonds.js

@@ -55,8 +55,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);
         }
     }
 }
@@ -68,12 +68,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 ((0, util_1.typeSymbol)(unit, i) === "C" /* C */ &&
+        if ((0, util_1.typeSymbol)(unit, i) === "C" /* Elements.C */ &&
             totalH[i] > 0 &&
-            ((0, util_1.bondToElementCount)(structure, unit, i, "N" /* N */) > 0 ||
-                (0, util_1.bondToElementCount)(structure, unit, i, "O" /* O */) > 0 ||
+            ((0, util_1.bondToElementCount)(structure, unit, i, "N" /* Elements.N */) > 0 ||
+                (0, util_1.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);
         }
     }
 }
@@ -86,7 +86,7 @@ function inAromaticRingWithElectronNegativeElement(unit, index) {
         var ring = all[ringIndices[i]];
         for (var j = 0, jl = ring.length; j < jl; ++j) {
             var element = (0, util_1.typeSymbol)(unit, ring[j]);
-            if (element === "N" /* N */ || element === "O" /* O */) {
+            if (element === "N" /* Elements.N */ || element === "O" /* Elements.O */) {
                 return true;
             }
         }
@@ -101,15 +101,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 = (0, util_1.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
@@ -120,14 +120,14 @@ function addUnitHydrogenAcceptors(structure, unit, builder) {
                 // It must have at least one lone pair not conjugated
                 var totalBonds = (0, util_1.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 = (0, util_1.compId)(unit, i);
             if (resname === 'CYS' || resname === 'MET' || (0, util_1.formalCharge)(unit, i) === -1) {
                 add(i);
@@ -136,7 +136,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 types_1.ProteinBackboneAtoms.has((0, util_1.atomId)(unit, index));
@@ -145,7 +145,7 @@ function isRing(unit, index) {
     return unit.rings.elementRingIndices.has(index);
 }
 function isHistidineNitrogen(unit, index) {
-    return (0, util_1.compId)(unit, index) === 'HIS' && (0, util_1.typeSymbol)(unit, index) === "N" /* N */ && isRing(unit, index);
+    return (0, util_1.compId)(unit, index) === 'HIS' && (0, util_1.typeSymbol)(unit, index) === "N" /* Elements.N */ && isRing(unit, index);
 }
 function isBackboneHydrogenBond(unitA, indexA, unitB, indexB) {
     return isBackbone(unitA, indexA) && isBackbone(unitB, indexB);
@@ -154,12 +154,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 {
@@ -183,7 +183,7 @@ function checkGeometry(structure, don, acc, opts) {
     var idealDonAngle = geometry_1.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 = (0, geometry_1.calcPlaneAngle)(structure, don.unit, donIndex, acc.unit, accIndex);
         if (outOfPlane !== undefined && outOfPlane > opts.maxDonOutOfPlaneAngle)
             return;
@@ -193,7 +193,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 = (0, geometry_1.calcPlaneAngle)(structure, acc.unit, accIndex, don.unit, donIndex);
         if (outOfPlane !== undefined && outOfPlane > opts.maxAccOutOfPlaneAngle)
             return;
@@ -205,33 +205,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 = (0, util_1.typeSymbol)(don.unit, donIndex) === "S" /* S */ || (0, util_1.typeSymbol)(acc.unit, accIndex) === "S" /* S */ ? opts.maxSulfurDistSq : opts.maxDistSq;
+    var maxDistSq = (0, util_1.typeSymbol)(don.unit, donIndex) === "S" /* Elements.S */ || (0, util_1.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 */;
 }
 //
-exports.HydrogenDonorProvider = features_1.Features.Provider([4 /* HydrogenDonor */], addUnitHydrogenDonors);
-exports.WeakHydrogenDonorProvider = features_1.Features.Provider([9 /* WeakHydrogenDonor */], addUnitWeakHydrogenDonors);
-exports.HydrogenAcceptorProvider = features_1.Features.Provider([5 /* HydrogenAcceptor */], addUnitHydrogenAcceptors);
+exports.HydrogenDonorProvider = features_1.Features.Provider([4 /* FeatureType.HydrogenDonor */], addUnitHydrogenDonors);
+exports.WeakHydrogenDonorProvider = features_1.Features.Provider([9 /* FeatureType.WeakHydrogenDonor */], addUnitWeakHydrogenDonors);
+exports.HydrogenAcceptorProvider = features_1.Features.Provider([5 /* FeatureType.HydrogenAcceptor */], addUnitHydrogenAcceptors);
 exports.HydrogenBondsProvider = {
     name: 'hydrogen-bonds',
     params: HydrogenBondsParams,
@@ -240,7 +240,7 @@ exports.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); }
         };
     }
@@ -252,7 +252,7 @@ exports.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); }
         };
     }