molstar 3.8.2 → 3.9.0

package/lib/mol-model-props/computed/chemistry/functional-group.js

@@ -10,7 +10,7 @@ function isAromatic(unit, index) {
     // TODO also extend unit.rings with geometry/composition-based aromaticity detection and use it here in addition
     var _a = unit.bonds, offset = _a.offset, edgeProps = _a.edgeProps;
     for (var i = offset[index], il = offset[index + 1]; i < il; ++i) {
-        if (BondType.is(16 /* Aromatic */, edgeProps.flags[i]))
+        if (BondType.is(16 /* BondType.Flag.Aromatic */, edgeProps.flags[i]))
             return true;
     }
     return false;
@@ -28,15 +28,15 @@ function bondToCarbonylCount(structure, unit, index) {
  * Nitrogen in a quaternary amine
  */
 export function isQuaternaryAmine(structure, unit, index) {
-    return (typeSymbol(unit, index) === "N" /* N */ &&
+    return (typeSymbol(unit, index) === "N" /* Elements.N */ &&
         bondCount(structure, unit, index) === 4 &&
-        bondToElementCount(structure, unit, index, "H" /* H */) === 0);
+        bondToElementCount(structure, unit, index, "H" /* Elements.H */) === 0);
 }
 /**
  * Nitrogen in a tertiary amine
  */
 export function isTertiaryAmine(structure, unit, index, idealValence) {
-    return (typeSymbol(unit, index) === "N" /* N */ &&
+    return (typeSymbol(unit, index) === "N" /* Elements.N */ &&
         bondCount(structure, unit, index) === 4 &&
         idealValence === 3);
 }
@@ -45,8 +45,8 @@ export function isTertiaryAmine(structure, unit, index, idealValence) {
  */
 export function isImide(structure, unit, index) {
     var flag = false;
-    if (typeSymbol(unit, index) === "N" /* N */ &&
-        (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* H */)) === 2) {
+    if (typeSymbol(unit, index) === "N" /* Elements.N */ &&
+        (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* Elements.H */)) === 2) {
         flag = bondToCarbonylCount(structure, unit, index) === 2;
     }
     return flag;
@@ -56,8 +56,8 @@ export function isImide(structure, unit, index) {
  */
 export function isAmide(structure, unit, index) {
     var flag = false;
-    if (typeSymbol(unit, index) === "N" /* N */ &&
-        (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* H */)) === 2) {
+    if (typeSymbol(unit, index) === "N" /* Elements.N */ &&
+        (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* Elements.H */)) === 2) {
         flag = bondToCarbonylCount(structure, unit, index) === 1;
     }
     return flag;
@@ -66,30 +66,30 @@ export function isAmide(structure, unit, index) {
  * Sulfur in a sulfonium group
  */
 export function isSulfonium(structure, unit, index) {
-    return (typeSymbol(unit, index) === "S" /* S */ &&
+    return (typeSymbol(unit, index) === "S" /* Elements.S */ &&
         bondCount(structure, unit, index) === 3 &&
-        bondToElementCount(structure, unit, index, "H" /* H */) === 0);
+        bondToElementCount(structure, unit, index, "H" /* Elements.H */) === 0);
 }
 /**
  * Sulfur in a sulfonic acid or sulfonate group
  */
 export function isSulfonicAcid(structure, unit, index) {
-    return (typeSymbol(unit, index) === "S" /* S */ &&
-        bondToElementCount(structure, unit, index, "O" /* O */) === 3);
+    return (typeSymbol(unit, index) === "S" /* Elements.S */ &&
+        bondToElementCount(structure, unit, index, "O" /* Elements.O */) === 3);
 }
 /**
  * Sulfur in a sulfate group
  */
 export function isSulfate(structure, unit, index) {
-    return (typeSymbol(unit, index) === "S" /* S */ &&
-        bondToElementCount(structure, unit, index, "O" /* O */) === 4);
+    return (typeSymbol(unit, index) === "S" /* Elements.S */ &&
+        bondToElementCount(structure, unit, index, "O" /* Elements.O */) === 4);
 }
 /**
  * Phosphor in a phosphate group
  */
 export function isPhosphate(structure, unit, index) {
-    return (typeSymbol(unit, index) === "P" /* P */ &&
-        bondToElementCount(structure, unit, index, "O" /* O */) === bondCount(structure, unit, index));
+    return (typeSymbol(unit, index) === "P" /* Elements.P */ &&
+        bondToElementCount(structure, unit, index, "O" /* Elements.O */) === bondCount(structure, unit, index));
 }
 /**
  * Halogen with one bond to a carbon
@@ -97,7 +97,7 @@ export function isPhosphate(structure, unit, index) {
 export function isHalocarbon(structure, unit, index) {
     return (isHalogen(typeSymbol(unit, index)) &&
         bondCount(structure, unit, index) === 1 &&
-        bondToElementCount(structure, unit, index, "C" /* C */) === 1);
+        bondToElementCount(structure, unit, index, "C" /* Elements.C */) === 1);
 }
 /**
  * Carbon in a carbonyl/acyl group
@@ -106,10 +106,10 @@ export function isHalocarbon(structure, unit, index) {
  */
 export function isCarbonyl(structure, unit, index) {
     var flag = false;
-    if (typeSymbol(unit, index) === "C" /* C */) {
+    if (typeSymbol(unit, index) === "C" /* Elements.C */) {
         var _a = unit.bonds, offset = _a.offset, edgeProps = _a.edgeProps, b = _a.b;
         for (var i = offset[index], il = offset[index + 1]; i < il; ++i) {
-            if (edgeProps.order[i] === 2 && typeSymbol(unit, b[i]) === "O" /* O */) {
+            if (edgeProps.order[i] === 2 && typeSymbol(unit, b[i]) === "O" /* Elements.O */) {
                 flag = true;
                 break;
             }
@@ -122,12 +122,12 @@ export function isCarbonyl(structure, unit, index) {
  */
 export function isCarboxylate(structure, unit, index) {
     var terminalOxygenCount = 0;
-    if (typeSymbol(unit, index) === "C" /* C */ &&
-        bondToElementCount(structure, unit, index, "O" /* O */) === 2 &&
-        bondToElementCount(structure, unit, index, "C" /* C */) === 1) {
+    if (typeSymbol(unit, index) === "C" /* Elements.C */ &&
+        bondToElementCount(structure, unit, index, "O" /* Elements.O */) === 2 &&
+        bondToElementCount(structure, unit, index, "C" /* Elements.C */) === 1) {
         eachBondedAtom(structure, unit, index, function (unit, index) {
-            if (typeSymbol(unit, index) === "O" /* O */ &&
-                bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* H */) === 1) {
+            if (typeSymbol(unit, index) === "O" /* Elements.O */ &&
+                bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* Elements.H */) === 1) {
                 terminalOxygenCount += 1;
             }
         });
@@ -139,11 +139,11 @@ export function isCarboxylate(structure, unit, index) {
  */
 export function isGuanidine(structure, unit, index) {
     var terminalNitrogenCount = 0;
-    if (typeSymbol(unit, index) === "C" /* C */ &&
+    if (typeSymbol(unit, index) === "C" /* Elements.C */ &&
         bondCount(structure, unit, index) === 3 &&
-        bondToElementCount(structure, unit, index, "N" /* N */) === 3) {
+        bondToElementCount(structure, unit, index, "N" /* Elements.N */) === 3) {
         eachBondedAtom(structure, unit, index, function (unit, index) {
-            if (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* H */) === 1) {
+            if (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* Elements.H */) === 1) {
                 terminalNitrogenCount += 1;
             }
         });
@@ -155,12 +155,12 @@ export function isGuanidine(structure, unit, index) {
  */
 export function isAcetamidine(structure, unit, index) {
     var terminalNitrogenCount = 0;
-    if (typeSymbol(unit, index) === "C" /* C */ &&
+    if (typeSymbol(unit, index) === "C" /* Elements.C */ &&
         bondCount(structure, unit, index) === 3 &&
-        bondToElementCount(structure, unit, index, "N" /* N */) === 2 &&
-        bondToElementCount(structure, unit, index, "C" /* C */) === 1) {
+        bondToElementCount(structure, unit, index, "N" /* Elements.N */) === 2 &&
+        bondToElementCount(structure, unit, index, "C" /* Elements.C */) === 1) {
         eachBondedAtom(structure, unit, index, function (unit, index) {
-            if (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* H */) === 1) {
+            if (bondCount(structure, unit, index) - bondToElementCount(structure, unit, index, "H" /* Elements.H */) === 1) {
                 terminalNitrogenCount += 1;
             }
         });

package/lib/mol-model-props/computed/chemistry/geometry.js

@@ -9,41 +9,41 @@ import { Vec3 } from '../../../mol-math/linear-algebra';
 import { eachBondedAtom, typeSymbol } from './util';
 export function geometryLabel(geometry) {
     switch (geometry) {
-        case 0 /* Spherical */:
+        case 0 /* AtomGeometry.Spherical */:
             return 'Spherical';
-        case 1 /* Terminal */:
+        case 1 /* AtomGeometry.Terminal */:
             return 'Terminal';
-        case 2 /* Linear */:
+        case 2 /* AtomGeometry.Linear */:
             return 'Linear';
-        case 3 /* Trigonal */:
+        case 3 /* AtomGeometry.Trigonal */:
             return 'Trigonal';
-        case 4 /* Tetrahedral */:
+        case 4 /* AtomGeometry.Tetrahedral */:
             return 'Tetrahedral';
-        case 5 /* TrigonalBiPyramidal */:
+        case 5 /* AtomGeometry.TrigonalBiPyramidal */:
             return 'Trigonal Bi-Pyramidal';
-        case 6 /* Octahedral */:
+        case 6 /* AtomGeometry.Octahedral */:
             return 'Octahedral';
-        case 7 /* SquarePlanar */:
+        case 7 /* AtomGeometry.SquarePlanar */:
             return 'Square Planar';
-        case 8 /* Unknown */:
+        case 8 /* AtomGeometry.Unknown */:
             return 'Unknown';
     }
 }
 export function assignGeometry(totalCoordination) {
     switch (totalCoordination) {
-        case 0: return 0 /* Spherical */;
-        case 1: return 1 /* Terminal */;
-        case 2: return 2 /* Linear */;
-        case 3: return 3 /* Trigonal */;
-        case 4: return 4 /* Tetrahedral */;
-        default: return 8 /* Unknown */;
+        case 0: return 0 /* AtomGeometry.Spherical */;
+        case 1: return 1 /* AtomGeometry.Terminal */;
+        case 2: return 2 /* AtomGeometry.Linear */;
+        case 3: return 3 /* AtomGeometry.Trigonal */;
+        case 4: return 4 /* AtomGeometry.Tetrahedral */;
+        default: return 8 /* AtomGeometry.Unknown */;
     }
 }
 export var AtomGeometryAngles = new Map([
-    [2 /* Linear */, degToRad(180)],
-    [3 /* Trigonal */, degToRad(120)],
-    [4 /* Tetrahedral */, degToRad(109.4721)],
-    [6 /* Octahedral */, degToRad(90)]
+    [2 /* AtomGeometry.Linear */, degToRad(180)],
+    [3 /* AtomGeometry.Trigonal */, degToRad(120)],
+    [4 /* AtomGeometry.Tetrahedral */, degToRad(109.4721)],
+    [6 /* AtomGeometry.Octahedral */, degToRad(90)]
 ]);
 // tmp objects for `calcAngles` and `calcPlaneAngle`
 var tmpDir1 = Vec3();
@@ -60,7 +60,7 @@ export function calcAngles(structure, unitA, indexA, unitB, indexB) {
     unitB.conformation.position(unitB.elements[indexB], tmpPosB);
     Vec3.sub(tmpDir1, tmpPosB, tmpPosA);
     eachBondedAtom(structure, unitA, indexA, function (unitX, indexX) {
-        if (typeSymbol(unitX, indexX) !== "H" /* H */) {
+        if (typeSymbol(unitX, indexX) !== "H" /* Elements.H */) {
             unitX.conformation.position(unitX.elements[indexX], tmpPosX);
             Vec3.sub(tmpDir2, tmpPosX, tmpPosA);
             angles.push(Vec3.angle(tmpDir1, tmpDir2));
@@ -86,7 +86,7 @@ export function calcPlaneAngle(structure, unitA, indexA, unitB, indexB) {
     eachBondedAtom(structure, unitA, indexA, function (unitX, indexX) {
         if (ni > 1)
             return;
-        if (typeSymbol(unitX, indexX) !== "H" /* H */) {
+        if (typeSymbol(unitX, indexX) !== "H" /* Elements.H */) {
             unitX1 = unitX;
             indexX1 = indexX;
             unitX.conformation.position(unitX.elements[indexX], tmpPosX);
@@ -99,7 +99,7 @@ export function calcPlaneAngle(structure, unitA, indexA, unitB, indexB) {
                 return;
             if (unitX === unitA && indexX === indexA)
                 return;
-            if (typeSymbol(unitX, indexX) !== "H" /* H */) {
+            if (typeSymbol(unitX, indexX) !== "H" /* Elements.H */) {
                 unitX.conformation.position(unitX.elements[indexX], tmpPosX);
                 Vec3.sub(neighbours[ni++], tmpPosX, tmpPosA);
             }

package/lib/mol-model-props/computed/chemistry/valence-model.js

@@ -34,7 +34,7 @@ var tmpConjBondItB = new Bond.ElementBondIterator();
  */
 function isConjugated(structure, unit, index) {
     var element = typeSymbol(unit, index);
-    var hetero = element === "O" /* O */ || element === "N" /* N */;
+    var hetero = element === "O" /* Elements.O */ || element === "N" /* Elements.N */;
     if (hetero && bondCount(structure, unit, index) === 4)
         return false;
     tmpConjBondItA.setElement(structure, unit, index);
@@ -48,8 +48,8 @@ function isConjugated(structure, unit, index) {
             while (tmpConjBondItB.hasNext) {
                 var bB = tmpConjBondItB.move();
                 if (bB.order > 1) {
-                    if ((elementB === "P" /* P */ || elementB === "S" /* S */) &&
-                        typeSymbol(bB.otherUnit, bB.otherIndex) === "O" /* O */) {
+                    if ((elementB === "P" /* Elements.P */ || elementB === "S" /* Elements.S */) &&
+                        typeSymbol(bB.otherUnit, bB.otherIndex) === "O" /* Elements.O */) {
                         continue;
                     }
                     return true;
@@ -89,7 +89,7 @@ var tmpChargeBondItB = new Bond.ElementBondIterator();
  * a much simpler view and deduces one from the other
  */
 export function calculateHydrogensCharge(structure, unit, index, props) {
-    var hydrogenCount = bondToElementCount(structure, unit, index, "H" /* H */);
+    var hydrogenCount = bondToElementCount(structure, unit, index, "H" /* Elements.H */);
     var element = typeSymbol(unit, index);
     var charge = formalCharge(unit, index);
     var assignCharge = (props.assignCharge === 'always' || (props.assignCharge === 'auto' && charge === 0));
@@ -99,21 +99,21 @@ export function calculateHydrogensCharge(structure, unit, index, props) {
     var conjugated = isConjugated(structure, unit, index);
     var multiBond = (valence - degree > 0);
     var implicitHCount = 0;
-    var geom = 8 /* Unknown */;
+    var geom = 8 /* AtomGeometry.Unknown */;
     switch (element) {
-        case "H" /* H */:
+        case "H" /* Elements.H */:
             if (assignCharge) {
                 if (degree === 0) {
                     charge = 1;
-                    geom = 0 /* Spherical */;
+                    geom = 0 /* AtomGeometry.Spherical */;
                 }
                 else if (degree === 1) {
                     charge = 0;
-                    geom = 1 /* Terminal */;
+                    geom = 1 /* AtomGeometry.Terminal */;
                 }
             }
             break;
-        case "C" /* C */:
+        case "C" /* Elements.C */:
             // TODO: Isocyanide?
             if (assignCharge) {
                 charge = 0; // Assume carbon always neutral
@@ -125,7 +125,7 @@ export function calculateHydrogensCharge(structure, unit, index, props) {
             // Carbocation is planar, carbanion is tetrahedral
             geom = assignGeometry(degree + implicitHCount + Math.max(0, -charge));
             break;
-        case "N" /* N */:
+        case "N" /* Elements.N */:
             if (assignCharge) {
                 if (!assignH) { // Trust input H explicitly:
                     charge = valence - 3;
@@ -147,7 +147,7 @@ export function calculateHydrogensCharge(structure, unit, index, props) {
                     while (tmpChargeBondItA.hasNext) {
                         var b = tmpChargeBondItA.move();
                         var elementB = typeSymbol(b.otherUnit, b.otherIndex);
-                        if (elementB === "S" /* S */ || isMetal(elementB)) {
+                        if (elementB === "S" /* Elements.S */ || isMetal(elementB)) {
                             charge = 0;
                             break;
                         }
@@ -173,7 +173,7 @@ export function calculateHydrogensCharge(structure, unit, index, props) {
                 geom = assignGeometry(degree + implicitHCount + 1 - charge);
             }
             break;
-        case "O" /* O */:
+        case "O" /* Elements.O */:
             if (assignCharge) {
                 if (!assignH) {
                     charge = valence - 2;
@@ -186,7 +186,7 @@ export function calculateHydrogensCharge(structure, unit, index, props) {
                         while (tmpChargeBondItB.hasNext) {
                             var bB = tmpChargeBondItB.move();
                             if (!(bB.otherUnit === unit && bB.otherIndex === index) &&
-                                typeSymbol(bB.otherUnit, bB.otherIndex) === "O" /* O */ &&
+                                typeSymbol(bB.otherUnit, bB.otherIndex) === "O" /* Elements.O */ &&
                                 bB.order === 2) {
                                 charge = -1;
                                 break b1;
@@ -210,10 +210,10 @@ export function calculateHydrogensCharge(structure, unit, index, props) {
             break;
         // Only handles thiols/thiolates/thioether/sulfonium. Sulfoxides and higher
         // oxidiation states are assumed neutral S (charge carried on O if required)
-        case "S" /* S */:
+        case "S" /* Elements.S */:
             if (assignCharge) {
                 if (!assignH) {
-                    if (valence <= 3 && bondToElementCount(structure, unit, index, "O" /* O */) === 0) {
+                    if (valence <= 3 && bondToElementCount(structure, unit, index, "O" /* Elements.O */) === 0) {
                         charge = valence - 2; // e.g. explicitly deprotonated thiol
                     }
                     else {
@@ -231,32 +231,32 @@ export function calculateHydrogensCharge(structure, unit, index, props) {
                 geom = assignGeometry(degree + implicitHCount - charge + 2);
             }
             break;
-        case "F" /* F */:
-        case "CL" /* CL */:
-        case "BR" /* BR */:
-        case "I" /* I */:
-        case "AT" /* AT */:
+        case "F" /* Elements.F */:
+        case "CL" /* Elements.CL */:
+        case "BR" /* Elements.BR */:
+        case "I" /* Elements.I */:
+        case "AT" /* Elements.AT */:
             // Never implicitly protonate halides
             if (assignCharge) {
                 charge = valence - 1;
             }
             break;
-        case "LI" /* LI */:
-        case "NA" /* NA */:
-        case "K" /* K */:
-        case "RB" /* RB */:
-        case "CS" /* CS */:
-        case "FR" /* FR */:
+        case "LI" /* Elements.LI */:
+        case "NA" /* Elements.NA */:
+        case "K" /* Elements.K */:
+        case "RB" /* Elements.RB */:
+        case "CS" /* Elements.CS */:
+        case "FR" /* Elements.FR */:
             if (assignCharge) {
                 charge = 1 - valence;
             }
             break;
-        case "BE" /* BE */:
-        case "MG" /* MG */:
-        case "CA" /* CA */:
-        case "SR" /* SR */:
-        case "BA" /* BA */:
-        case "RA" /* RA */:
+        case "BE" /* Elements.BE */:
+        case "MG" /* Elements.MG */:
+        case "CA" /* Elements.CA */:
+        case "SR" /* Elements.SR */:
+        case "BA" /* Elements.BA */:
+        case "RA" /* Elements.RA */:
             if (assignCharge) {
                 charge = 2 - valence;
             }

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