molstar 2.3.5 → 2.3.9

package/lib/commonjs/mol-theme/color/polymer-index.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const PolymerIndexColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "interpolate" | "set";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate"> | PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors">>;
+    }>, "generate">>;
 };
 export declare type PolymerIndexColorThemeParams = typeof PolymerIndexColorThemeParams;
 export declare function getPolymerIndexColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "interpolate" | "set";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate"> | PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors">>;
+    }>, "generate">>;
 };
 export declare type PolymerIndexColorThemeProps = PD.Values<typeof PolymerIndexColorThemeParams>;
 export declare function PolymerIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<PolymerIndexColorThemeParams>): ColorTheme<PolymerIndexColorThemeParams>;

package/lib/commonjs/mol-theme/color/unit-index.d.ts

@@ -8,34 +8,34 @@ import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { ThemeDataContext } from '../../mol-theme/theme';
 export declare const UnitIndexColorThemeParams: {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "interpolate" | "set";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate"> | PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors">>;
+    }>, "generate">>;
 };
 export declare type UnitIndexColorThemeParams = typeof UnitIndexColorThemeParams;
 export declare function getUnitIndexColorThemeParams(ctx: ThemeDataContext): {
     palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+        list: {
+            kind: "interpolate" | "set";
+            colors: import("../../mol-util/color/color").ColorListEntry[];
+        };
+    }>, "colors"> | PD.NamedParams<PD.Normalize<{
         maxCount: number;
         hue: [number, number];
         chroma: [number, number];
         luminance: [number, number];
         clusteringStepCount: number;
         minSampleCount: number;
-    }>, "generate"> | PD.NamedParams<PD.Normalize<{
-        list: {
-            kind: "set" | "interpolate";
-            colors: import("../../mol-util/color/color").ColorListEntry[];
-        };
-    }>, "colors">>;
+    }>, "generate">>;
 };
 export declare function UnitIndexColorTheme(ctx: ThemeDataContext, props: PD.Values<UnitIndexColorThemeParams>): ColorTheme<UnitIndexColorThemeParams>;
 export declare const UnitIndexColorThemeProvider: ColorTheme.Provider<UnitIndexColorThemeParams, 'unit-index'>;

package/lib/commonjs/mol-theme/color.d.ts

@@ -56,108 +56,108 @@ declare namespace ColorTheme {
     export const BuiltIn: {
         'atom-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "atom-id">;
         'carbohydrate-symbol': Provider<{}, "carbohydrate-symbol">;
         'chain-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
             asymId: PD.Select<"label" | "auth">;
         }, "chain-id">;
         'element-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "element-index">;
         'element-symbol': Provider<{
             carbonColor: PD.Mapped<PD.NamedParams<PD.Normalize<{
                 palette: PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors"> | PD.NamedParams<PD.Normalize<{
                     maxCount: any;
                     hue: any;
                     chroma: any;
                     luminance: any;
                     clusteringStepCount: any;
                     minSampleCount: any;
-                }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                    list: any;
-                }>, "colors">;
+                }>, "generate">;
                 asymId: "label" | "auth";
             }>, "chain-id"> | PD.NamedParams<PD.Normalize<{
                 palette: PD.NamedParams<PD.Normalize<{
+                    list: any;
+                }>, "colors"> | PD.NamedParams<PD.Normalize<{
                     maxCount: any;
                     hue: any;
                     chroma: any;
                     luminance: any;
                     clusteringStepCount: any;
                     minSampleCount: any;
-                }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                    list: any;
-                }>, "colors">;
+                }>, "generate">;
             }>, "operator-name"> | PD.NamedParams<PD.Normalize<unknown>, "element-symbol">>;
             saturation: PD.Numeric;
             lightness: PD.Numeric;
         }, "element-symbol">;
         'entity-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "entity-id">;
         'entity-source': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "entity-source">;
         hydrophobicity: Provider<{
             list: PD.ColorList;
@@ -165,34 +165,34 @@ declare namespace ColorTheme {
         }, "hydrophobicity">;
         illustrative: Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
             asymId: PD.Select<"label" | "auth">;
         }, "illustrative">;
         'model-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "model-index">;
         'molecule-type': Provider<{
             saturation: PD.Numeric;
@@ -204,33 +204,33 @@ declare namespace ColorTheme {
         }, "occupancy">;
         'operator-hkl': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "operator-hkl">;
         'operator-name': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "operator-name">;
         'partial-charge': Provider<{
             domain: PD.Interval;
@@ -238,33 +238,33 @@ declare namespace ColorTheme {
         }, "partial-charge">;
         'polymer-id': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "polymer-id">;
         'polymer-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "polymer-index">;
         'residue-name': Provider<{
             saturation: PD.Numeric;
@@ -284,18 +284,18 @@ declare namespace ColorTheme {
         }, "uncertainty">;
         'unit-index': Provider<{
             palette: PD.Mapped<PD.NamedParams<PD.Normalize<{
+                list: {
+                    kind: "interpolate" | "set";
+                    colors: import("../mol-util/color/color").ColorListEntry[];
+                };
+            }>, "colors"> | PD.NamedParams<PD.Normalize<{
                 maxCount: number;
                 hue: [number, number];
                 chroma: [number, number];
                 luminance: [number, number];
                 clusteringStepCount: number;
                 minSampleCount: number;
-            }>, "generate"> | PD.NamedParams<PD.Normalize<{
-                list: {
-                    kind: "set" | "interpolate";
-                    colors: import("../mol-util/color/color").ColorListEntry[];
-                };
-            }>, "colors">>;
+            }>, "generate">>;
         }, "unit-index">;
         uniform: Provider<{
             value: PD.Color;

package/lib/commonjs/mol-theme/label.d.ts

@@ -18,6 +18,7 @@ export declare const DefaultLabelOptions: {
 export declare type LabelOptions = typeof DefaultLabelOptions;
 export declare function lociLabel(loci: Loci, options?: Partial<LabelOptions>): string;
 export declare function structureElementStatsLabel(stats: StructureElement.Stats, options?: Partial<LabelOptions>): string;
+export declare function structureElementLociLabelMany(locis: StructureElement.Loci[], options?: Partial<LabelOptions>): string;
 export declare function bondLabel(bond: Bond.Location, options?: Partial<LabelOptions>): string;
 export declare function bundleLabel(bundle: Loci.Bundle<any>, options?: Partial<LabelOptions>): string;
 export declare function _bundleLabel(bundle: Loci.Bundle<any>, options: LabelOptions): string;

package/lib/commonjs/mol-theme/label.js

@@ -6,7 +6,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dihedralLabel = exports.angleLabel = exports.distanceLabel = exports.elementLabel = exports._bundleLabel = exports.bundleLabel = exports.bondLabel = exports.structureElementStatsLabel = exports.lociLabel = exports.DefaultLabelOptions = void 0;
+exports.dihedralLabel = exports.angleLabel = exports.distanceLabel = exports.elementLabel = exports._bundleLabel = exports.bundleLabel = exports.bondLabel = exports.structureElementLociLabelMany = exports.structureElementStatsLabel = exports.lociLabel = exports.DefaultLabelOptions = void 0;
 var tslib_1 = require("tslib");
 var structure_1 = require("../mol-model/structure");
 var loci_1 = require("../mol-model/loci");
@@ -48,8 +48,8 @@ function lociLabel(loci, options) {
             return loci.volume.label || 'Volume';
         case 'isosurface-loci':
             return [
-                "" + (loci.volume.label || 'Volume'),
-                "Isosurface at " + volume_1.Volume.IsoValue.toString(loci.isoValue)
+                "".concat(loci.volume.label || 'Volume'),
+                "Isosurface at ".concat(volume_1.Volume.IsoValue.toString(loci.isoValue))
             ].join(' | ');
         case 'cell-loci':
             var size = int_1.OrderedSet.size(loci.indices);
@@ -57,21 +57,21 @@ function lociLabel(loci, options) {
             var absVal = volume_1.Volume.IsoValue.absolute(loci.volume.grid.cells.data[start]);
             var relVal = volume_1.Volume.IsoValue.toRelative(absVal, loci.volume.grid.stats);
             var label = [
-                "" + (loci.volume.label || 'Volume'),
-                "" + (size === 1 ? "Cell #" + start : size + " Cells")
+                "".concat(loci.volume.label || 'Volume'),
+                "".concat(size === 1 ? "Cell #".concat(start) : "".concat(size, " Cells"))
             ];
             if (size === 1) {
-                label.push(volume_1.Volume.IsoValue.toString(absVal) + " (" + volume_1.Volume.IsoValue.toString(relVal) + ")");
+                label.push("".concat(volume_1.Volume.IsoValue.toString(absVal), " (").concat(volume_1.Volume.IsoValue.toString(relVal), ")"));
             }
             return label.join(' | ');
     }
 }
 exports.lociLabel = lociLabel;
 function countLabel(count, label) {
-    return count === 1 ? "1 " + label : count + " " + label + "s";
+    return count === 1 ? "1 ".concat(label) : "".concat(count, " ").concat(label, "s");
 }
 function otherLabel(count, location, granularity, hidePrefix, reverse, condensed) {
-    return elementLabel(location, { granularity: granularity, hidePrefix: hidePrefix, reverse: reverse, condensed: condensed }) + " <small>[+ " + countLabel(count - 1, "other " + (0, string_1.capitalize)(granularity)) + "]</small>";
+    return "".concat(elementLabel(location, { granularity: granularity, hidePrefix: hidePrefix, reverse: reverse, condensed: condensed }), " <small>[+ ").concat(countLabel(count - 1, "other ".concat((0, string_1.capitalize)(granularity))), "]</small>");
 }
 /** Gets residue count of the model chain segments the unit is a subset of */
 function getResidueCount(unit) {
@@ -88,6 +88,16 @@ function structureElementStatsLabel(stats, options) {
     return o.htmlStyling ? label : (0, string_1.stripTags)(label);
 }
 exports.structureElementStatsLabel = structureElementStatsLabel;
+function structureElementLociLabelMany(locis, options) {
+    if (options === void 0) { options = {}; }
+    var stats = structure_1.StructureElement.Stats.create();
+    for (var _i = 0, locis_1 = locis; _i < locis_1.length; _i++) {
+        var l = locis_1[_i];
+        structure_1.StructureElement.Stats.add(stats, stats, structure_1.StructureElement.Stats.ofLoci(l));
+    }
+    return structureElementStatsLabel(stats, options);
+}
+exports.structureElementLociLabelMany = structureElementLociLabelMany;
 function _structureElementStatsLabel(stats, countsOnly, hidePrefix, condensed, reverse) {
     if (countsOnly === void 0) { countsOnly = false; }
     if (hidePrefix === void 0) { hidePrefix = false; }
@@ -228,10 +238,10 @@ function _elementLabel(location, granularity, hidePrefix, reverse) {
         var entry = location.unit.model.entry;
         if (entry.length > 30)
             entry = entry.substr(0, 27) + '\u2026'; // ellipsis
-        label.push("<small>" + entry + "</small>"); // entry
+        label.push("<small>".concat(entry, "</small>")); // entry
         if (granularity !== 'structure') {
-            label.push("<small>Model " + location.unit.model.modelNum + "</small>"); // model
-            label.push("<small>Instance " + location.unit.conformation.operator.name + "</small>"); // instance
+            label.push("<small>Model ".concat(location.unit.model.modelNum, "</small>")); // model
+            label.push("<small>Instance ".concat(location.unit.conformation.operator.name, "</small>")); // instance
         }
     }
     if (structure_1.Unit.isAtomic(location.unit)) {
@@ -260,33 +270,33 @@ function _atomicElementLabel(location, granularity, hideOccupancy) {
     var occupancy = structure_1.StructureProperties.atom.occupancy(location);
     var microHetCompIds = structure_1.StructureProperties.residue.microheterogeneityCompIds(location);
     var compId = granularity === 'residue' && microHetCompIds.length > 1 ?
-        "(" + microHetCompIds.join('|') + ")" : comp_id;
+        "(".concat(microHetCompIds.join('|'), ")") : comp_id;
     var label = [];
     switch (granularity) {
         case 'element':
-            label.push("<b>" + atom_id + "</b>" + (alt_id ? "%" + alt_id : ''));
+            label.push("<b>".concat(atom_id, "</b>").concat(alt_id ? "%".concat(alt_id) : ''));
         case 'conformation':
             if (granularity === 'conformation' && alt_id) {
-                label.push("<small>Conformation</small> <b>" + alt_id + "</b>");
+                label.push("<small>Conformation</small> <b>".concat(alt_id, "</b>"));
             }
         case 'residue':
             var seq_id = label_seq_id === auth_seq_id || !has_label_seq_id ? auth_seq_id : label_seq_id;
-            label.push("<b>" + compId + " " + seq_id + "</b>" + (seq_id !== auth_seq_id ? " <small>[auth</small> <b>" + auth_seq_id + "</b><small>]</small>" : '') + "<b>" + (ins_code ? ins_code : '') + "</b>");
+            label.push("<b>".concat(compId, " ").concat(seq_id, "</b>").concat(seq_id !== auth_seq_id ? " <small>[auth</small> <b>".concat(auth_seq_id, "</b><small>]</small>") : '', "<b>").concat(ins_code ? ins_code : '', "</b>"));
         case 'chain':
             if (label_asym_id === auth_asym_id) {
-                label.push("<b>" + label_asym_id + "</b>");
+                label.push("<b>".concat(label_asym_id, "</b>"));
             }
             else {
                 if (granularity === 'chain' && structure_1.Unit.Traits.is(location.unit.traits, 1 /* MultiChain */)) {
-                    label.push("<small>[auth</small> <b>" + auth_asym_id + "</b><small>]</small>");
+                    label.push("<small>[auth</small> <b>".concat(auth_asym_id, "</b><small>]</small>"));
                 }
                 else {
-                    label.push("<b>" + label_asym_id + "</b> <small>[auth</small> <b>" + auth_asym_id + "</b><small>]</small>");
+                    label.push("<b>".concat(label_asym_id, "</b> <small>[auth</small> <b>").concat(auth_asym_id, "</b><small>]</small>"));
                 }
             }
     }
     if (label.length > 0 && occupancy !== 1 && !hideOccupancy) {
-        label[0] = label[0] + " <small>[occupancy</small> <b>" + Math.round(100 * occupancy) / 100 + "</b><small>]</small>";
+        label[0] = "".concat(label[0], " <small>[occupancy</small> <b>").concat(Math.round(100 * occupancy) / 100, "</b><small>]</small>");
     }
     return label.reverse();
 }
@@ -303,13 +313,13 @@ function _coarseElementLabel(location, granularity) {
                 var entityIndex = structure_1.StructureProperties.coarse.entityKey(location);
                 var seq = location.unit.model.sequence.byEntityKey[entityIndex];
                 var comp_id = seq.sequence.compId.value(seq_id_begin - 1); // 1-indexed
-                label.push("<b>" + comp_id + " " + seq_id_begin + "</b>");
+                label.push("<b>".concat(comp_id, " ").concat(seq_id_begin, "</b>"));
             }
             else {
-                label.push("<b>" + seq_id_begin + "-" + seq_id_end + "</b>");
+                label.push("<b>".concat(seq_id_begin, "-").concat(seq_id_end, "</b>"));
             }
         case 'chain':
-            label.push("<b>" + asym_id + "</b>");
+            label.push("<b>".concat(asym_id, "</b>"));
     }
     return label.reverse();
 }
@@ -318,11 +328,11 @@ function distanceLabel(pair, options) {
     if (options === void 0) { options = {}; }
     var o = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, exports.DefaultLabelOptions), { measureOnly: false, unitLabel: '\u212B' }), options);
     var _a = pair.loci.map(function (l) { return loci_1.Loci.getCenter(l); }), cA = _a[0], cB = _a[1];
-    var distance = linear_algebra_1.Vec3.distance(cA, cB).toFixed(2) + " " + o.unitLabel;
+    var distance = "".concat(linear_algebra_1.Vec3.distance(cA, cB).toFixed(2), " ").concat(o.unitLabel);
     if (o.measureOnly)
         return distance;
     var label = bundleLabel(pair, o);
-    return o.condensed ? distance + " | " + label : "Distance " + distance + "</br>" + label;
+    return o.condensed ? "".concat(distance, " | ").concat(label) : "Distance ".concat(distance, "</br>").concat(label);
 }
 exports.distanceLabel = distanceLabel;
 function angleLabel(triple, options) {
@@ -331,22 +341,22 @@ function angleLabel(triple, options) {
     var _a = triple.loci.map(function (l) { return loci_1.Loci.getCenter(l); }), cA = _a[0], cB = _a[1], cC = _a[2];
     var vAB = linear_algebra_1.Vec3.sub((0, linear_algebra_1.Vec3)(), cA, cB);
     var vCB = linear_algebra_1.Vec3.sub((0, linear_algebra_1.Vec3)(), cC, cB);
-    var angle = (0, misc_1.radToDeg)(linear_algebra_1.Vec3.angle(vAB, vCB)).toFixed(2) + "\u00B0";
+    var angle = "".concat((0, misc_1.radToDeg)(linear_algebra_1.Vec3.angle(vAB, vCB)).toFixed(2), "\u00B0");
     if (o.measureOnly)
         return angle;
     var label = bundleLabel(triple, o);
-    return o.condensed ? angle + " | " + label : "Angle " + angle + "</br>" + label;
+    return o.condensed ? "".concat(angle, " | ").concat(label) : "Angle ".concat(angle, "</br>").concat(label);
 }
 exports.angleLabel = angleLabel;
 function dihedralLabel(quad, options) {
     if (options === void 0) { options = {}; }
     var o = (0, tslib_1.__assign)((0, tslib_1.__assign)((0, tslib_1.__assign)({}, exports.DefaultLabelOptions), { measureOnly: false }), options);
     var _a = quad.loci.map(function (l) { return loci_1.Loci.getCenter(l); }), cA = _a[0], cB = _a[1], cC = _a[2], cD = _a[3];
-    var dihedral = (0, misc_1.radToDeg)(linear_algebra_1.Vec3.dihedralAngle(cA, cB, cC, cD)).toFixed(2) + "\u00B0";
+    var dihedral = "".concat((0, misc_1.radToDeg)(linear_algebra_1.Vec3.dihedralAngle(cA, cB, cC, cD)).toFixed(2), "\u00B0");
     if (o.measureOnly)
         return dihedral;
     var label = bundleLabel(quad, o);
-    return o.condensed ? dihedral + " | " + label : "Dihedral " + dihedral + "</br>" + label;
+    return o.condensed ? "".concat(dihedral, " | ").concat(label) : "Dihedral ".concat(dihedral, "</br>").concat(label);
 }
 exports.dihedralLabel = dihedralLabel;
 //# sourceMappingURL=label.js.map