molstar 3.8.2 → 3.10.0

package/lib/mol-model-props/computed/accessible-surface-area/shrake-rupley/radii.js

@@ -43,7 +43,7 @@ export function assignRadiusForHeavyAtoms(ctx) {
             var atomId = label_atom_id(l);
             var moleculeType = getElementMoleculeType(unit, eI);
             // skip water and optionally non-polymer groups
-            if (moleculeType === 2 /* Water */ || (!ctx.nonPolymer && !isPolymer(moleculeType))) {
+            if (moleculeType === 2 /* MoleculeType.Water */ || (!ctx.nonPolymer && !isPolymer(moleculeType))) {
                 atomRadiusType[mj] = 0;
                 serialResidueIndex[mj] = -1;
                 continue;
@@ -57,7 +57,7 @@ export function assignRadiusForHeavyAtoms(ctx) {
             if (isNucleic(moleculeType)) {
                 atomRadiusType[mj] = determineRadiusNucl(atomId, element, compId);
             }
-            else if (moleculeType === 5 /* Protein */) {
+            else if (moleculeType === 5 /* MoleculeType.Protein */) {
                 atomRadiusType[mj] = determineRadiusAmino(atomId, element, compId);
             }
             else {

package/lib/mol-model-props/computed/accessible-surface-area/shrake-rupley.js

@@ -111,9 +111,9 @@ var AccessibleSurfaceArea;
     AccessibleSurfaceArea.getNormalizedValue = getNormalizedValue;
     function getFlag(location, accessibleSurfaceArea) {
         var value = getNormalizedValue(location, accessibleSurfaceArea);
-        return value === -1 ? 0 /* NA */ :
-            value < 0.16 ? 1 /* Buried */ :
-                2 /* Accessible */;
+        return value === -1 ? 0 /* Flag.NA */ :
+            value < 0.16 ? 1 /* Flag.Buried */ :
+                2 /* Flag.Accessible */;
     }
     AccessibleSurfaceArea.getFlag = getFlag;
 })(AccessibleSurfaceArea || (AccessibleSurfaceArea = {}));

package/lib/mol-model-props/computed/accessible-surface-area.js

@@ -21,7 +21,7 @@ export var AccessibleSurfaceAreaSymbols = {
         var accessibleSurfaceArea = AccessibleSurfaceAreaProvider.get(ctx.element.structure).value;
         if (!accessibleSurfaceArea)
             return false;
-        return AccessibleSurfaceArea.getFlag(ctx.element, accessibleSurfaceArea) === 1 /* Buried */;
+        return AccessibleSurfaceArea.getFlag(ctx.element, accessibleSurfaceArea) === 1 /* AccessibleSurfaceArea.Flag.Buried */;
     }),
     isAccessible: QuerySymbolRuntime.Dynamic(CustomPropSymbol('computed', 'accessible-surface-area.is-accessible', Type.Bool), function (ctx) {
         if (!Unit.isAtomic(ctx.element.unit))
@@ -29,7 +29,7 @@ export var AccessibleSurfaceAreaSymbols = {
         var accessibleSurfaceArea = AccessibleSurfaceAreaProvider.get(ctx.element.structure).value;
         if (!accessibleSurfaceArea)
             return false;
-        return AccessibleSurfaceArea.getFlag(ctx.element, accessibleSurfaceArea) === 2 /* Accessible */;
+        return AccessibleSurfaceArea.getFlag(ctx.element, accessibleSurfaceArea) === 2 /* AccessibleSurfaceArea.Flag.Accessible */;
     }),
 };
 export var AccessibleSurfaceAreaProvider = CustomStructureProperty.createProvider({

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