@absmartly/sdk-plugins 1.2.1 → 1.3.0

package/es/core/ExposureTracker.js

@@ -34,6 +34,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -78,7 +89,7 @@ var ExposureTracker = /** @class */ (function () {
      * @param hasViewportTrigger - Whether ANY variant matching URL filter has viewport trigger
      */
     ExposureTracker.prototype.registerExperiment = function (experimentName, currentVariant, currentChanges, allVariantsChanges, hasImmediateTrigger, hasViewportTrigger) {
-        var _this = this;
+        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
         if (this.debug) {
             logDebug("[EXPOSURE] [".concat(experimentName, "] Registering experiment for exposure tracking"), {
                 experimentName: experimentName,
@@ -101,36 +112,55 @@ var ExposureTracker = /** @class */ (function () {
         // We need to track ALL possible positions where elements could be
         var moveElements = new Map(); // selector -> Set of target parent positions
         var deleteElements = new Set(); // selectors for delete changes
-        allVariantsChanges.forEach(function (variantChanges) {
-            variantChanges.forEach(function (change) {
-                if (change.trigger_on_view) {
-                    if (change.type === 'move') {
-                        if (!moveElements.has(change.selector)) {
-                            moveElements.set(change.selector, new Set());
-                        }
-                        // Add the target parent for this move
-                        if (change.targetSelector) {
-                            moveElements.get(change.selector).add(change.targetSelector);
+        try {
+            for (var allVariantsChanges_1 = __values(allVariantsChanges), allVariantsChanges_1_1 = allVariantsChanges_1.next(); !allVariantsChanges_1_1.done; allVariantsChanges_1_1 = allVariantsChanges_1.next()) {
+                var variantChanges = allVariantsChanges_1_1.value;
+                try {
+                    for (var variantChanges_1 = (e_2 = void 0, __values(variantChanges)), variantChanges_1_1 = variantChanges_1.next(); !variantChanges_1_1.done; variantChanges_1_1 = variantChanges_1.next()) {
+                        var change = variantChanges_1_1.value;
+                        if (change.trigger_on_view) {
+                            if (change.type === 'move') {
+                                if (!moveElements.has(change.selector)) {
+                                    moveElements.set(change.selector, new Set());
+                                }
+                                // Add the target parent for this move
+                                if (change.targetSelector) {
+                                    moveElements.get(change.selector).add(change.targetSelector);
+                                }
+                            }
+                            else if (change.type === 'delete') {
+                                // Track delete changes - need special handling for placeholders
+                                deleteElements.add(change.selector);
+                            }
+                            else {
+                                // For other non-move, non-delete changes, track the selector directly
+                                viewportSelectors.add(change.selector);
+                            }
                         }
                     }
-                    else if (change.type === 'delete') {
-                        // Track delete changes - need special handling for placeholders
-                        deleteElements.add(change.selector);
-                    }
-                    else {
-                        // For other non-move, non-delete changes, track the selector directly
-                        viewportSelectors.add(change.selector);
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (variantChanges_1_1 && !variantChanges_1_1.done && (_b = variantChanges_1.return)) _b.call(variantChanges_1);
                     }
+                    finally { if (e_2) throw e_2.error; }
                 }
-            });
-        });
-        // For cross-variant move tracking, we need to track the EXACT POSITION where
-        // elements would appear in other variants. We use container-based invisible elements
-        // positioned exactly where the element would be, using CSS positioning.
-        moveElements.forEach(function (_targetParents, selector) {
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (allVariantsChanges_1_1 && !allVariantsChanges_1_1.done && (_a = allVariantsChanges_1.return)) _a.call(allVariantsChanges_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var _loop_1 = function (selector) {
+            var e_5, _f;
             // Collect all move changes for this element across ALL variants
             var allMovesForElement = [];
-            allVariantsChanges.forEach(function (variantChanges, variantIndex) {
+            for (var variantIndex = 0; variantIndex < allVariantsChanges.length; variantIndex++) {
+                var variantChanges = allVariantsChanges[variantIndex];
                 var moveChange = variantChanges.find(function (c) { return c.type === 'move' && c.selector === selector && c.trigger_on_view; });
                 if (moveChange === null || moveChange === void 0 ? void 0 : moveChange.targetSelector) {
                     allMovesForElement.push({
@@ -139,43 +169,68 @@ var ExposureTracker = /** @class */ (function () {
                         variantIndex: variantIndex,
                     });
                 }
-            });
+            }
             // Check if current variant has a move for this element
             var currentMoveIndex = allMovesForElement.findIndex(function (m) { return m.variantIndex === currentVariant; });
             if (currentMoveIndex >= 0) {
                 // Current variant HAS a move - track the element in its moved position
                 viewportSelectors.add(selector);
                 // For all OTHER variant positions, create container-based placeholders
-                allMovesForElement.forEach(function (move, index) {
+                for (var index = 0; index < allMovesForElement.length; index++) {
+                    var move = allMovesForElement[index];
                     if (index !== currentMoveIndex) {
                         // Create placeholder at the position where element WOULD be in another variant
-                        _this.createContainerPlaceholder(experimentName, selector, move.targetSelector, move.position);
+                        this_1.createContainerPlaceholder(experimentName, selector, move.targetSelector, move.position);
                     }
-                });
+                }
             }
             else {
                 // Current variant does NOT have a move - element stays in original position
                 viewportSelectors.add(selector);
-                // For ALL variant moves, create placeholders at those positions
-                allMovesForElement.forEach(function (move) {
-                    _this.createContainerPlaceholder(experimentName, selector, move.targetSelector, move.position);
-                });
+                try {
+                    // For ALL variant moves, create placeholders at those positions
+                    for (var allMovesForElement_1 = (e_5 = void 0, __values(allMovesForElement)), allMovesForElement_1_1 = allMovesForElement_1.next(); !allMovesForElement_1_1.done; allMovesForElement_1_1 = allMovesForElement_1.next()) {
+                        var move = allMovesForElement_1_1.value;
+                        this_1.createContainerPlaceholder(experimentName, selector, move.targetSelector, move.position);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (allMovesForElement_1_1 && !allMovesForElement_1_1.done && (_f = allMovesForElement_1.return)) _f.call(allMovesForElement_1);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
             }
-        });
-        // For cross-variant delete tracking, we need to handle elements that are deleted in some variants
-        // For variants with delete: replace element with 1px placeholder in the same position
-        // For variants without delete: track the actual element
-        deleteElements.forEach(function (selector) {
+        };
+        var this_1 = this;
+        try {
+            // For cross-variant move tracking, we need to track the EXACT POSITION where
+            // elements would appear in other variants. We use container-based invisible elements
+            // positioned exactly where the element would be, using CSS positioning.
+            for (var moveElements_1 = __values(moveElements), moveElements_1_1 = moveElements_1.next(); !moveElements_1_1.done; moveElements_1_1 = moveElements_1.next()) {
+                var _e = __read(moveElements_1_1.value, 1), selector = _e[0];
+                _loop_1(selector);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (moveElements_1_1 && !moveElements_1_1.done && (_c = moveElements_1.return)) _c.call(moveElements_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        var _loop_2 = function (selector) {
             // Check if current variant has a delete for this selector
             var currentVariantHasDelete = currentChanges.some(function (c) { return c.type === 'delete' && c.selector === selector && c.trigger_on_view; });
             if (currentVariantHasDelete) {
                 // Current variant will delete this element - replace with in-place placeholder
-                var placeholdersCreated = _this.createInPlacePlaceholder(experimentName, selector);
+                var placeholdersCreated = this_2.createInPlacePlaceholder(experimentName, selector);
                 // If no placeholders created (element doesn't exist yet), track the selector
                 // so when element appears via MutationObserver, it will be tracked
                 if (placeholdersCreated === 0) {
                     viewportSelectors.add(selector);
-                    if (_this.debug) {
+                    if (this_2.debug) {
                         logDebug("[EXPOSURE] [".concat(experimentName, "] Delete element doesn't exist yet - tracking selector for when it appears"), { selector: selector });
                     }
                 }
@@ -184,7 +239,24 @@ var ExposureTracker = /** @class */ (function () {
                 // Current variant doesn't delete - track the real element
                 viewportSelectors.add(selector);
             }
-        });
+        };
+        var this_2 = this;
+        try {
+            // For cross-variant delete tracking, we need to handle elements that are deleted in some variants
+            // For variants with delete: replace element with 1px placeholder in the same position
+            // For variants without delete: track the actual element
+            for (var deleteElements_1 = __values(deleteElements), deleteElements_1_1 = deleteElements_1.next(); !deleteElements_1_1.done; deleteElements_1_1 = deleteElements_1.next()) {
+                var selector = deleteElements_1_1.value;
+                _loop_2(selector);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (deleteElements_1_1 && !deleteElements_1_1.done && (_d = deleteElements_1.return)) _d.call(deleteElements_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
         // Trigger flags are now passed in from DOMChangesPluginLite after URL filtering
         // This ensures only variants matching the current URL determine trigger behavior
         // Store experiment tracking info
@@ -293,7 +365,7 @@ var ExposureTracker = /** @class */ (function () {
      * Returns the number of placeholders created
      */
     ExposureTracker.prototype.createInPlacePlaceholder = function (experimentName, selector) {
-        var _this = this;
+        var _a;
         var elements = document.querySelectorAll(selector);
         if (elements.length === 0) {
             if (this.debug) {
@@ -302,15 +374,15 @@ var ExposureTracker = /** @class */ (function () {
             return 0;
         }
         var placeholdersCreated = 0;
-        elements.forEach(function (element, index) {
-            var _a;
+        for (var index = 0; index < elements.length; index++) {
+            var element = elements[index];
             // Create unique ID for the placeholder (remove special chars from selector for valid ID)
             var selectorId = selector.replace(/[^a-zA-Z0-9-]/g, '_');
             var placeholderId = "absmartly-delete-".concat(experimentName, "-").concat(selectorId, "-").concat(index);
             var placeholderKey = "".concat(experimentName, "-delete-").concat(selector, "-").concat(index);
             // Check if this element already has a placeholder
             if (element.hasAttribute('data-absmartly-delete-placeholder')) {
-                return;
+                continue;
             }
             // Create minimal placeholder using inline styles
             // This will be observable by IntersectionObserver but won't affect layout
@@ -325,14 +397,14 @@ var ExposureTracker = /** @class */ (function () {
             // Insert placeholder before the element, then remove the element
             (_a = element.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(placeholder, element);
             element.remove();
-            _this.placeholders.set(placeholderKey, placeholder);
+            this.placeholders.set(placeholderKey, placeholder);
             // Track the placeholder for viewport visibility
-            _this.trackElement(placeholder, experimentName);
+            this.trackElement(placeholder, experimentName);
             placeholdersCreated++;
-            if (_this.debug) {
+            if (this.debug) {
                 logDebug("[ABsmartly] Created in-place delete placeholder for ".concat(selector, " in experiment ").concat(experimentName));
             }
-        });
+        }
         return placeholdersCreated;
     };
     /**
@@ -372,20 +444,40 @@ var ExposureTracker = /** @class */ (function () {
      * Set up observers for the given selectors
      */
     ExposureTracker.prototype.observeSelectors = function (experimentName, selectors) {
-        var _this = this;
-        selectors.forEach(function (selector) {
-            // Try to find existing elements
-            var elements = document.querySelectorAll(selector);
-            if (elements.length > 0) {
-                elements.forEach(function (element) {
-                    _this.trackElement(element, experimentName);
-                });
+        var e_6, _a, e_7, _b;
+        try {
+            for (var selectors_1 = __values(selectors), selectors_1_1 = selectors_1.next(); !selectors_1_1.done; selectors_1_1 = selectors_1.next()) {
+                var selector = selectors_1_1.value;
+                // Try to find existing elements
+                var elements = document.querySelectorAll(selector);
+                if (elements.length > 0) {
+                    try {
+                        for (var elements_1 = (e_7 = void 0, __values(elements)), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
+                            var element = elements_1_1.value;
+                            this.trackElement(element, experimentName);
+                        }
+                    }
+                    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                    finally {
+                        try {
+                            if (elements_1_1 && !elements_1_1.done && (_b = elements_1.return)) _b.call(elements_1);
+                        }
+                        finally { if (e_7) throw e_7.error; }
+                    }
+                }
+                else {
+                    // Element doesn't exist yet, set up mutation observer to watch for it
+                    this.watchForSelector(selector, experimentName);
+                }
             }
-            else {
-                // Element doesn't exist yet, set up mutation observer to watch for it
-                _this.watchForSelector(selector, experimentName);
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (selectors_1_1 && !selectors_1_1.done && (_a = selectors_1.return)) _a.call(selectors_1);
             }
-        });
+            finally { if (e_6) throw e_6.error; }
+        }
     };
     /**
      * Track an element for viewport visibility
@@ -419,11 +511,22 @@ var ExposureTracker = /** @class */ (function () {
     ExposureTracker.prototype.setupIntersectionObserver = function () {
         var _this = this;
         this.observer = new IntersectionObserver(function (entries) {
-            entries.forEach(function (entry) {
-                if (entry.isIntersecting) {
-                    _this.handleElementVisible(entry.target);
+            var e_8, _a;
+            try {
+                for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+                    var entry = entries_1_1.value;
+                    if (entry.isIntersecting) {
+                        _this.handleElementVisible(entry.target);
+                    }
                 }
-            });
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
         }, {
             threshold: 0.01, // Trigger when even 1% is visible
             rootMargin: '0px',
@@ -435,14 +538,35 @@ var ExposureTracker = /** @class */ (function () {
     ExposureTracker.prototype.setupMutationObserver = function () {
         var _this = this;
         this.mutationObserver = new MutationObserver(function (mutations) {
-            mutations.forEach(function (mutation) {
-                mutation.addedNodes.forEach(function (node) {
-                    if (node instanceof Element) {
-                        // Check if this element or its children match any tracked selectors
-                        _this.checkNewElement(node);
+            var e_9, _a, e_10, _b;
+            try {
+                for (var mutations_1 = __values(mutations), mutations_1_1 = mutations_1.next(); !mutations_1_1.done; mutations_1_1 = mutations_1.next()) {
+                    var mutation = mutations_1_1.value;
+                    try {
+                        for (var _c = (e_10 = void 0, __values(mutation.addedNodes)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var node = _d.value;
+                            if (node instanceof Element) {
+                                // Check if this element or its children match any tracked selectors
+                                _this.checkNewElement(node);
+                            }
+                        }
                     }
-                });
-            });
+                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                        }
+                        finally { if (e_10) throw e_10.error; }
+                    }
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (mutations_1_1 && !mutations_1_1.done && (_a = mutations_1.return)) _a.call(mutations_1);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
         });
         this.mutationObserver.observe(document.body, {
             childList: true,
@@ -453,42 +577,86 @@ var ExposureTracker = /** @class */ (function () {
      * Check if a newly added element needs tracking
      */
     ExposureTracker.prototype.checkNewElement = function (element) {
-        var _this = this;
-        this.experiments.forEach(function (tracking, experimentName) {
-            tracking.allPossibleSelectors.forEach(function (selector) {
-                if (element.matches(selector)) {
-                    _this.trackElement(element, experimentName);
+        var e_11, _a, e_12, _b, e_13, _c;
+        try {
+            for (var _d = __values(this.experiments), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var _f = __read(_e.value, 2), experimentName = _f[0], tracking = _f[1];
+                try {
+                    for (var _g = (e_12 = void 0, __values(tracking.allPossibleSelectors)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var selector = _h.value;
+                        if (element.matches(selector)) {
+                            this.trackElement(element, experimentName);
+                        }
+                        try {
+                            // Also check children
+                            for (var _j = (e_13 = void 0, __values(element.querySelectorAll(selector))), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                var child = _k.value;
+                                this.trackElement(child, experimentName);
+                            }
+                        }
+                        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                        finally {
+                            try {
+                                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                            }
+                            finally { if (e_13) throw e_13.error; }
+                        }
+                    }
                 }
-                // Also check children
-                element.querySelectorAll(selector).forEach(function (child) {
-                    _this.trackElement(child, experimentName);
-                });
-            });
-        });
+                catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                    }
+                    finally { if (e_12) throw e_12.error; }
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
     };
     /**
      * Handle when an element becomes visible
      */
     ExposureTracker.prototype.handleElementVisible = function (element) {
-        var _this = this;
+        var e_14, _a;
         var tracked = this.trackedElements.get(element);
         if (!tracked)
             return;
-        tracked.experiments.forEach(function (experimentName) {
-            var experiment = _this.experiments.get(experimentName);
+        var _loop_3 = function (experimentName) {
+            var experiment = this_3.experiments.get(experimentName);
             if (experiment && !experiment.triggered) {
                 // Don't await here to avoid blocking the visibility handler
-                _this.triggerExposure(experimentName).catch(function (error) {
+                this_3.triggerExposure(experimentName).catch(function (error) {
                     logDebug("[ABsmartly] Failed to trigger exposure for ".concat(experimentName, ":"), error);
                 });
-                if (_this.debug) {
+                if (this_3.debug) {
                     var selector = tracked.isPlaceholder
                         ? element.getAttribute('data-absmartly-original-selector')
-                        : _this.getElementSelector(element);
+                        : this_3.getElementSelector(element);
                     logDebug("[ABsmartly] Triggering exposure for ".concat(experimentName, " via ").concat(selector));
                 }
             }
-        });
+        };
+        var this_3 = this;
+        try {
+            for (var _b = __values(tracked.experiments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var experimentName = _c.value;
+                _loop_3(experimentName);
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
     };
     /**
      * Trigger exposure for an experiment
@@ -535,30 +703,51 @@ var ExposureTracker = /** @class */ (function () {
      * Clean up tracking for an experiment that has been triggered
      */
     ExposureTracker.prototype.cleanupExperiment = function (experimentName) {
-        var _this = this;
-        // Remove from tracked elements
-        this.trackedElements.forEach(function (tracked, element) {
-            tracked.experiments.delete(experimentName);
-            if (tracked.experiments.size === 0) {
-                _this.observer.unobserve(element);
-                _this.trackedElements.delete(element);
+        var e_15, _a, e_16, _b;
+        try {
+            // Remove from tracked elements
+            for (var _c = __values(this.trackedElements), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), element = _e[0], tracked = _e[1];
+                tracked.experiments.delete(experimentName);
+                if (tracked.experiments.size === 0) {
+                    this.observer.unobserve(element);
+                    this.trackedElements.delete(element);
+                }
             }
-        });
-        // Remove placeholders
-        this.placeholders.forEach(function (placeholder, key) {
-            if (key.startsWith("".concat(experimentName, "-"))) {
-                placeholder.remove();
-                _this.placeholders.delete(key);
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
             }
-        });
+            finally { if (e_15) throw e_15.error; }
+        }
+        try {
+            // Remove placeholders
+            for (var _f = __values(this.placeholders), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var _h = __read(_g.value, 2), key = _h[0], placeholder = _h[1];
+                if (key.startsWith("".concat(experimentName, "-"))) {
+                    placeholder.remove();
+                    this.placeholders.delete(key);
+                }
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
         // Don't delete the experiment - keep it in the map so isTriggered() can still return true
         // Just clear the selectors since we don't need to track them anymore
         var experiment = this.experiments.get(experimentName);
         if (experiment) {
             experiment.allPossibleSelectors.clear();
         }
-        // Clean up mutation observer if no experiments left
-        if (this.experiments.size === 0 && this.mutationObserver) {
+        // Clean up mutation observer if all experiments have been triggered
+        var allTriggered = Array.from(this.experiments.values()).every(function (exp) { return exp.triggered; });
+        if (allTriggered && this.mutationObserver) {
             this.mutationObserver.disconnect();
             this.mutationObserver = null;
         }
@@ -596,13 +785,26 @@ var ExposureTracker = /** @class */ (function () {
      * Clean up all resources
      */
     ExposureTracker.prototype.destroy = function () {
+        var e_17, _a;
         // Disconnect observers
         this.observer.disconnect();
         if (this.mutationObserver) {
             this.mutationObserver.disconnect();
         }
-        // Remove all placeholders
-        this.placeholders.forEach(function (placeholder) { return placeholder.remove(); });
+        try {
+            // Remove all placeholders
+            for (var _b = __values(this.placeholders.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var placeholder = _c.value;
+                placeholder.remove();
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
         // Clear all tracking
         this.experiments.clear();
         this.trackedElements.clear();