molstar 3.8.2 → 3.9.0

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); }
         };
     }

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); }
         };
     }