drugflow-molstar 0.4.6 → 0.4.8

package/lib/superposition-focus-representation.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SuperpositionFocusRepresentation = exports.SuperpositionFocusRepresentationTags = void 0;
-const structure_1 = require("Molstar/mol-model/structure");
-const structure_representation_params_1 = require("Molstar/mol-plugin-state/helpers/structure-representation-params");
-const transforms_1 = require("Molstar/mol-plugin-state/transforms");
-const behavior_1 = require("Molstar/mol-plugin/behavior");
-const builder_1 = require("Molstar/mol-script/language/builder");
-const mol_state_1 = require("Molstar/mol-state");
-const param_definition_1 = require("Molstar/mol-util/param-definition");
-const commands_1 = require("Molstar/mol-plugin/commands");
-const loci_details_1 = require("./loci-details");
-const SuperpositionFocusRepresentationParams = (plugin) => {
-    const reprParams = transforms_1.StateTransforms.Representation.StructureRepresentation3D.definition.params(void 0, plugin);
+var tslib_1 = require("tslib");
+var structure_1 = require("Molstar/mol-model/structure");
+var structure_representation_params_1 = require("Molstar/mol-plugin-state/helpers/structure-representation-params");
+var transforms_1 = require("Molstar/mol-plugin-state/transforms");
+var behavior_1 = require("Molstar/mol-plugin/behavior");
+var builder_1 = require("Molstar/mol-script/language/builder");
+var mol_state_1 = require("Molstar/mol-state");
+var param_definition_1 = require("Molstar/mol-util/param-definition");
+var commands_1 = require("Molstar/mol-plugin/commands");
+var loci_details_1 = require("./loci-details");
+var SuperpositionFocusRepresentationParams = function (plugin) {
+    var reprParams = transforms_1.StateTransforms.Representation.StructureRepresentation3D.definition.params(void 0, plugin);
     return {
         expandRadius: param_definition_1.ParamDefinition.Numeric(5, { min: 1, max: 10, step: 1 }),
         surroundingsParams: param_definition_1.ParamDefinition.Group(reprParams, {
@@ -25,13 +26,21 @@ var SuperpositionFocusRepresentationTags;
     SuperpositionFocusRepresentationTags["SurrSel"] = "superposition-focus-surr-sel";
     SuperpositionFocusRepresentationTags["SurrRepr"] = "superposition-focus-surr-repr";
 })(SuperpositionFocusRepresentationTags || (exports.SuperpositionFocusRepresentationTags = SuperpositionFocusRepresentationTags = {}));
-const TagSet = new Set([SuperpositionFocusRepresentationTags.SurrSel, SuperpositionFocusRepresentationTags.SurrRepr]);
-class SuperpositionFocusRepresentationBehavior extends behavior_1.PluginBehavior.WithSubscribers {
-    get surrLabel() { return `[Focus] Surroundings (${this.params.expandRadius} Å)`; }
-    ensureShape(cell) {
-        const state = this.plugin.state.data, tree = state.tree;
-        const builder = state.build();
-        const refs = mol_state_1.StateSelection.findUniqueTagsInSubtree(tree, cell.transform.ref, TagSet);
+var TagSet = new Set([SuperpositionFocusRepresentationTags.SurrSel, SuperpositionFocusRepresentationTags.SurrRepr]);
+var SuperpositionFocusRepresentationBehavior = /** @class */ (function (_super) {
+    tslib_1.__extends(SuperpositionFocusRepresentationBehavior, _super);
+    function SuperpositionFocusRepresentationBehavior() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(SuperpositionFocusRepresentationBehavior.prototype, "surrLabel", {
+        get: function () { return "[Focus] Surroundings (".concat(this.params.expandRadius, " \u00C5)"); },
+        enumerable: false,
+        configurable: true
+    });
+    SuperpositionFocusRepresentationBehavior.prototype.ensureShape = function (cell) {
+        var state = this.plugin.state.data, tree = state.tree;
+        var builder = state.build();
+        var refs = mol_state_1.StateSelection.findUniqueTagsInSubtree(tree, cell.transform.ref, TagSet);
         // Selections
         if (!refs[SuperpositionFocusRepresentationTags.SurrSel]) {
             refs[SuperpositionFocusRepresentationTags.SurrSel] = builder
@@ -44,72 +53,121 @@ class SuperpositionFocusRepresentationBehavior extends behavior_1.PluginBehavior
                 .to(refs[SuperpositionFocusRepresentationTags.SurrSel])
                 .apply(transforms_1.StateTransforms.Representation.StructureRepresentation3D, this.params.surroundingsParams, { tags: SuperpositionFocusRepresentationTags.SurrRepr }).ref;
         }
-        return { state, builder, refs };
-    }
-    clear(root) {
-        const state = this.plugin.state.data;
-        const surrs = state.select(mol_state_1.StateSelection.Generators.byRef(root).subtree().withTag(SuperpositionFocusRepresentationTags.SurrSel));
+        return { state: state, builder: builder, refs: refs };
+    };
+    SuperpositionFocusRepresentationBehavior.prototype.clear = function (root) {
+        var e_1, _a;
+        var state = this.plugin.state.data;
+        var surrs = state.select(mol_state_1.StateSelection.Generators.byRef(root).subtree().withTag(SuperpositionFocusRepresentationTags.SurrSel));
         if (surrs.length === 0)
             return;
-        const update = state.build();
-        const expression = builder_1.MolScriptBuilder.struct.generator.empty();
-        for (const s of surrs) {
-            update.to(s).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression }));
+        var update = state.build();
+        var expression = builder_1.MolScriptBuilder.struct.generator.empty();
+        try {
+            for (var surrs_1 = tslib_1.__values(surrs), surrs_1_1 = surrs_1.next(); !surrs_1_1.done; surrs_1_1 = surrs_1.next()) {
+                var s = surrs_1_1.value;
+                update.to(s).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, function (old) { return (tslib_1.__assign(tslib_1.__assign({}, old), { expression: expression })); });
+            }
         }
-        return commands_1.PluginCommands.State.Update(this.plugin, { state, tree: update, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
-    }
-    async focus(sourceLoci) {
-        const parent = this.plugin.helpers.substructureParent.get(sourceLoci.structure);
-        if (!parent || !parent.obj)
-            return;
-        const loci = structure_1.StructureElement.Loci.remap(sourceLoci, parent.obj.data);
-        const residueLoci = structure_1.StructureElement.Loci.extendToWholeResidues(loci);
-        const residueBundle = structure_1.StructureElement.Bundle.fromLoci(residueLoci);
-        const target = structure_1.StructureElement.Bundle.toExpression(residueBundle);
-        let surroundings = builder_1.MolScriptBuilder.struct.modifier.includeSurroundings({
-            0: target,
-            radius: this.params.expandRadius,
-            'as-whole-residues': true
-        });
-        const lociDeatils = (0, loci_details_1.lociDetails)(sourceLoci);
-        if (!lociDeatils) {
-            surroundings = builder_1.MolScriptBuilder.struct.modifier.exceptBy({
-                0: surroundings,
-                by: target
-            });
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (surrs_1_1 && !surrs_1_1.done && (_a = surrs_1.return)) _a.call(surrs_1);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
-        const { state, builder, refs } = this.ensureShape(parent);
-        builder.to(refs[SuperpositionFocusRepresentationTags.SurrSel]).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression: surroundings, label: this.surrLabel }));
-        await commands_1.PluginCommands.State.Update(this.plugin, { state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
-    }
-    register(ref) {
-        this.subscribeObservable(this.plugin.managers.structure.focus.behaviors.current, (entry) => {
+        return commands_1.PluginCommands.State.Update(this.plugin, { state: state, tree: update, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
+    };
+    SuperpositionFocusRepresentationBehavior.prototype.focus = function (sourceLoci) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var parent, loci, residueLoci, residueBundle, target, surroundings, lociDeatils, _a, state, builder, refs;
+            var _this = this;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        parent = this.plugin.helpers.substructureParent.get(sourceLoci.structure);
+                        if (!parent || !parent.obj)
+                            return [2 /*return*/];
+                        loci = structure_1.StructureElement.Loci.remap(sourceLoci, parent.obj.data);
+                        residueLoci = structure_1.StructureElement.Loci.extendToWholeResidues(loci);
+                        residueBundle = structure_1.StructureElement.Bundle.fromLoci(residueLoci);
+                        target = structure_1.StructureElement.Bundle.toExpression(residueBundle);
+                        surroundings = builder_1.MolScriptBuilder.struct.modifier.includeSurroundings({
+                            0: target,
+                            radius: this.params.expandRadius,
+                            'as-whole-residues': true
+                        });
+                        lociDeatils = (0, loci_details_1.lociDetails)(sourceLoci);
+                        if (!lociDeatils) {
+                            surroundings = builder_1.MolScriptBuilder.struct.modifier.exceptBy({
+                                0: surroundings,
+                                by: target
+                            });
+                        }
+                        _a = this.ensureShape(parent), state = _a.state, builder = _a.builder, refs = _a.refs;
+                        builder.to(refs[SuperpositionFocusRepresentationTags.SurrSel]).update(transforms_1.StateTransforms.Model.StructureSelectionFromExpression, function (old) { return (tslib_1.__assign(tslib_1.__assign({}, old), { expression: surroundings, label: _this.surrLabel })); });
+                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.plugin, { state: state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } })];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SuperpositionFocusRepresentationBehavior.prototype.register = function (ref) {
+        var _this = this;
+        this.subscribeObservable(this.plugin.managers.structure.focus.behaviors.current, function (entry) {
             // if (entry) this.focus(entry.loci);
             // else this.clear(StateTransform.RootRef);
-            this.clear(mol_state_1.StateTransform.RootRef);
+            _this.clear(mol_state_1.StateTransform.RootRef);
             if (entry)
-                this.focus(entry.loci);
+                _this.focus(entry.loci);
         });
-    }
-    async update(params) {
-        const old = this.params;
-        this.params = params;
-        const state = this.plugin.state.data;
-        const builder = state.build();
-        const all = mol_state_1.StateSelection.Generators.root.subtree();
-        for (const repr of state.select(all.withTag(SuperpositionFocusRepresentationTags.SurrRepr))) {
-            builder.to(repr).update(this.params.surroundingsParams);
-        }
-        await commands_1.PluginCommands.State.Update(this.plugin, { state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
-        if (params.expandRadius !== old.expandRadius)
-            await this.clear(mol_state_1.StateTransform.RootRef);
-        return true;
-    }
-}
+    };
+    SuperpositionFocusRepresentationBehavior.prototype.update = function (params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var old, state, builder, all, _a, _b, repr;
+            var e_2, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        old = this.params;
+                        this.params = params;
+                        state = this.plugin.state.data;
+                        builder = state.build();
+                        all = mol_state_1.StateSelection.Generators.root.subtree();
+                        try {
+                            for (_a = tslib_1.__values(state.select(all.withTag(SuperpositionFocusRepresentationTags.SurrRepr))), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                repr = _b.value;
+                                builder.to(repr).update(this.params.surroundingsParams);
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        return [4 /*yield*/, commands_1.PluginCommands.State.Update(this.plugin, { state: state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } })];
+                    case 1:
+                        _d.sent();
+                        if (!(params.expandRadius !== old.expandRadius)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.clear(mol_state_1.StateTransform.RootRef)];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    return SuperpositionFocusRepresentationBehavior;
+}(behavior_1.PluginBehavior.WithSubscribers));
 exports.SuperpositionFocusRepresentation = behavior_1.PluginBehavior.create({
     name: 'create-superposition-focus-representation',
     display: { name: 'Superposition Focus Representation' },
     category: 'interaction',
     ctor: SuperpositionFocusRepresentationBehavior,
-    params: (_, plugin) => SuperpositionFocusRepresentationParams(plugin)
+    params: function (_, plugin) { return SuperpositionFocusRepresentationParams(plugin); }
 });

package/lib/superposition-sifts-mapping.js

@@ -1,90 +1,124 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.alignAndSuperposeWithSIFTSMapping = void 0;
-const int_1 = require("Molstar/mol-data/int");
-const minimize_rmsd_1 = require("Molstar/mol-math/linear-algebra/3d/minimize-rmsd");
-const sifts_mapping_1 = require("./sifts-mapping");
-const element_1 = require("Molstar/mol-model/structure/structure/element");
+exports.alignAndSuperposeWithSIFTSMapping = alignAndSuperposeWithSIFTSMapping;
+var tslib_1 = require("tslib");
+var int_1 = require("Molstar/mol-data/int");
+var minimize_rmsd_1 = require("Molstar/mol-math/linear-algebra/3d/minimize-rmsd");
+var sifts_mapping_1 = require("./sifts-mapping");
+var element_1 = require("Molstar/mol-model/structure/structure/element");
 function alignAndSuperposeWithSIFTSMapping(structures, options) {
-    const indexMap = new Map();
-    for (let i = 0; i < structures.length; i++) {
-        let includeResidueTest = options?.includeResidueTest ?? _includeAllResidues;
-        if (options?.applyTestIndex && !options.applyTestIndex.includes(i))
+    var e_1, _a;
+    var _b, _c;
+    var indexMap = new Map();
+    for (var i = 0; i < structures.length; i++) {
+        var includeResidueTest = (_b = options === null || options === void 0 ? void 0 : options.includeResidueTest) !== null && _b !== void 0 ? _b : _includeAllResidues;
+        if ((options === null || options === void 0 ? void 0 : options.applyTestIndex) && !options.applyTestIndex.includes(i))
             includeResidueTest = _includeAllResidues;
-        buildIndex(structures[i], indexMap, i, options?.traceOnly ?? true, includeResidueTest);
+        buildIndex(structures[i], indexMap, i, (_c = options === null || options === void 0 ? void 0 : options.traceOnly) !== null && _c !== void 0 ? _c : true, includeResidueTest);
     }
-    const index = Array.from(indexMap.values());
+    var index = Array.from(indexMap.values());
     // TODO: support non-first structure pivots
-    const pairs = findPairs(structures.length, index);
-    const zeroOverlapPairs = [];
-    const failedPairs = [];
-    const entries = [];
-    for (const p of pairs) {
-        if (p.count === 0) {
-            zeroOverlapPairs.push([p.i, p.j]);
-        }
-        else {
-            const [a, b] = getPositionTables(index, p.i, p.j, p.count);
-            const transform = minimize_rmsd_1.MinimizeRmsd.compute({ a, b });
-            if (Number.isNaN(transform.rmsd)) {
-                failedPairs.push([p.i, p.j]);
+    var pairs = findPairs(structures.length, index);
+    var zeroOverlapPairs = [];
+    var failedPairs = [];
+    var entries = [];
+    try {
+        for (var pairs_1 = tslib_1.__values(pairs), pairs_1_1 = pairs_1.next(); !pairs_1_1.done; pairs_1_1 = pairs_1.next()) {
+            var p = pairs_1_1.value;
+            if (p.count === 0) {
+                zeroOverlapPairs.push([p.i, p.j]);
             }
             else {
-                entries.push({ transform, pivot: p.i, other: p.j });
+                var _d = tslib_1.__read(getPositionTables(index, p.i, p.j, p.count), 2), a = _d[0], b = _d[1];
+                var transform = minimize_rmsd_1.MinimizeRmsd.compute({ a: a, b: b });
+                if (Number.isNaN(transform.rmsd)) {
+                    failedPairs.push([p.i, p.j]);
+                }
+                else {
+                    entries.push({ transform: transform, pivot: p.i, other: p.j });
+                }
             }
         }
     }
-    return { entries, zeroOverlapPairs, failedPairs };
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (pairs_1_1 && !pairs_1_1.done && (_a = pairs_1.return)) _a.call(pairs_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { entries: entries, zeroOverlapPairs: zeroOverlapPairs, failedPairs: failedPairs };
 }
-exports.alignAndSuperposeWithSIFTSMapping = alignAndSuperposeWithSIFTSMapping;
 function getPositionTables(index, pivot, other, N) {
-    const xs = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
-    const ys = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
-    let o = 0;
-    for (const { pivots } of index) {
-        const a = pivots[pivot];
-        const b = pivots[other];
-        if (!a || !b)
-            continue;
-        const l = Math.min(a[2] - a[1], b[2] - b[1]);
-        // TODO: check if residue types match?
-        for (let i = 0; i < l; i++) {
-            let eI = (a[1] + i);
-            xs.x[o] = a[0].conformation.x(eI);
-            xs.y[o] = a[0].conformation.y(eI);
-            xs.z[o] = a[0].conformation.z(eI);
-            eI = (b[1] + i);
-            ys.x[o] = b[0].conformation.x(eI);
-            ys.y[o] = b[0].conformation.y(eI);
-            ys.z[o] = b[0].conformation.z(eI);
-            o++;
+    var e_2, _a;
+    var xs = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
+    var ys = minimize_rmsd_1.MinimizeRmsd.Positions.empty(N);
+    var o = 0;
+    try {
+        for (var index_1 = tslib_1.__values(index), index_1_1 = index_1.next(); !index_1_1.done; index_1_1 = index_1.next()) {
+            var pivots = index_1_1.value.pivots;
+            var a = pivots[pivot];
+            var b = pivots[other];
+            if (!a || !b)
+                continue;
+            var l = Math.min(a[2] - a[1], b[2] - b[1]);
+            // TODO: check if residue types match?
+            for (var i = 0; i < l; i++) {
+                var eI = (a[1] + i);
+                xs.x[o] = a[0].conformation.x(eI);
+                xs.y[o] = a[0].conformation.y(eI);
+                xs.z[o] = a[0].conformation.z(eI);
+                eI = (b[1] + i);
+                ys.x[o] = b[0].conformation.x(eI);
+                ys.y[o] = b[0].conformation.y(eI);
+                ys.z[o] = b[0].conformation.z(eI);
+                o++;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (index_1_1 && !index_1_1.done && (_a = index_1.return)) _a.call(index_1);
         }
+        finally { if (e_2) throw e_2.error; }
     }
     return [xs, ys];
 }
 function findPairs(N, index) {
-    const pairwiseCounts = [];
-    for (let i = 0; i < N; i++) {
+    var e_3, _a;
+    var pairwiseCounts = [];
+    for (var i = 0; i < N; i++) {
         pairwiseCounts[i] = [];
-        for (let j = 0; j < N; j++)
+        for (var j = 0; j < N; j++)
             pairwiseCounts[i][j] = 0;
     }
-    for (const { pivots } of index) {
-        for (let i = 0; i < N; i++) {
-            if (!pivots[i])
-                continue;
-            const lI = pivots[i][2] - pivots[i][1];
-            for (let j = i + 1; j < N; j++) {
-                if (!pivots[j])
+    try {
+        for (var index_2 = tslib_1.__values(index), index_2_1 = index_2.next(); !index_2_1.done; index_2_1 = index_2.next()) {
+            var pivots = index_2_1.value.pivots;
+            for (var i = 0; i < N; i++) {
+                if (!pivots[i])
                     continue;
-                const lJ = pivots[j][2] - pivots[j][1];
-                pairwiseCounts[i][j] = pairwiseCounts[i][j] + Math.min(lI, lJ);
+                var lI = pivots[i][2] - pivots[i][1];
+                for (var j = i + 1; j < N; j++) {
+                    if (!pivots[j])
+                        continue;
+                    var lJ = pivots[j][2] - pivots[j][1];
+                    pairwiseCounts[i][j] = pairwiseCounts[i][j] + Math.min(lI, lJ);
+                }
             }
         }
     }
-    const ret = [];
-    for (let j = 1; j < N; j++) {
-        ret[j - 1] = { i: 0, j, count: pairwiseCounts[0][j] };
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (index_2_1 && !index_2_1.done && (_a = index_2.return)) _a.call(index_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    var ret = [];
+    for (var j = 1; j < N; j++) {
+        ret[j - 1] = { i: 0, j: j, count: pairwiseCounts[0][j] };
     }
     // TODO: support non-first structure pivots
     // for (let i = 0; i < N - 1; i++) {
@@ -101,53 +135,64 @@ function findPairs(N, index) {
 }
 function _includeAllResidues() { return true; }
 function buildIndex(structure, index, sI, traceOnly, includeTest) {
-    const loc = element_1.StructureElement.Location.create(structure);
-    for (const unit of structure.units) {
-        if (unit.kind !== 0 /* Unit.Kind.Atomic */)
-            continue;
-        const { elements, model } = unit;
-        loc.unit = unit;
-        const map = sifts_mapping_1.SIFTSMapping.Provider.get(model).value;
-        if (!map)
-            return;
-        const { dbName, accession, num } = map;
-        const chainsIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.chainAtomSegments, elements);
-        const residuesIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.residueAtomSegments, elements);
-        const traceElementIndex = unit.model.atomicHierarchy.derived.residue.traceElementIndex;
-        while (chainsIt.hasNext) {
-            const chainSegment = chainsIt.move();
-            residuesIt.setSegment(chainSegment);
-            while (residuesIt.hasNext) {
-                const residueSegment = residuesIt.move();
-                const rI = residueSegment.index;
-                if (!dbName[rI])
-                    continue;
-                const traceElement = traceElementIndex[rI];
-                let start, end;
-                if (traceOnly) {
-                    start = traceElement;
-                    if (start === -1)
+    var e_4, _a, _b;
+    var loc = element_1.StructureElement.Location.create(structure);
+    try {
+        for (var _c = tslib_1.__values(structure.units), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var unit = _d.value;
+            if (unit.kind !== 0 /* Unit.Kind.Atomic */)
+                continue;
+            var elements = unit.elements, model = unit.model;
+            loc.unit = unit;
+            var map = sifts_mapping_1.SIFTSMapping.Provider.get(model).value;
+            if (!map)
+                return;
+            var dbName = map.dbName, accession = map.accession, num = map.num;
+            var chainsIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.chainAtomSegments, elements);
+            var residuesIt = int_1.Segmentation.transientSegments(unit.model.atomicHierarchy.residueAtomSegments, elements);
+            var traceElementIndex = unit.model.atomicHierarchy.derived.residue.traceElementIndex;
+            while (chainsIt.hasNext) {
+                var chainSegment = chainsIt.move();
+                residuesIt.setSegment(chainSegment);
+                while (residuesIt.hasNext) {
+                    var residueSegment = residuesIt.move();
+                    var rI = residueSegment.index;
+                    if (!dbName[rI])
                         continue;
-                    end = start + 1;
-                }
-                else {
-                    start = elements[residueSegment.start];
-                    end = elements[residueSegment.end - 1] + 1;
-                }
-                loc.element = (traceElement >= 0 ? traceElement : start);
-                if (!includeTest(loc, rI, start, end))
-                    continue;
-                const key = `${dbName[rI]}-${accession[rI].split('-')[0]}-${num[rI]}`;
-                if (!index.has(key)) {
-                    index.set(key, { key, pivots: { [sI]: [unit, start, end] } });
-                }
-                else {
-                    const entry = index.get(key);
-                    if (!entry.pivots[sI]) {
-                        entry.pivots[sI] = [unit, start, end];
+                    var traceElement = traceElementIndex[rI];
+                    var start = void 0, end = void 0;
+                    if (traceOnly) {
+                        start = traceElement;
+                        if (start === -1)
+                            continue;
+                        end = start + 1;
+                    }
+                    else {
+                        start = elements[residueSegment.start];
+                        end = elements[residueSegment.end - 1] + 1;
+                    }
+                    loc.element = (traceElement >= 0 ? traceElement : start);
+                    if (!includeTest(loc, rI, start, end))
+                        continue;
+                    var key = "".concat(dbName[rI], "-").concat(accession[rI].split('-')[0], "-").concat(num[rI]);
+                    if (!index.has(key)) {
+                        index.set(key, { key: key, pivots: (_b = {}, _b[sI] = [unit, start, end], _b) });
+                    }
+                    else {
+                        var entry = index.get(key);
+                        if (!entry.pivots[sI]) {
+                            entry.pivots[sI] = [unit, start, end];
+                        }
                     }
                 }
             }
         }
     }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
 }