@absmartly/sdk-plugins 1.0.1

package/es/core/DOMChangesPluginLite.js

@@ -0,0 +1,1124 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        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;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { DOMManipulatorLite } from './DOMManipulatorLite';
+import { VariantExtractor } from '../parsers/VariantExtractor';
+import { StyleSheetManager } from './StyleSheetManager';
+import { ExposureTracker } from './ExposureTracker';
+import { HTMLInjector } from './HTMLInjector';
+import { logDebug, logExperimentSummary, logPerformance, DEBUG } from '../utils/debug';
+import { URLMatcher } from '../utils/URLMatcher';
+var DOMChangesPluginLite = /** @class */ (function () {
+    function DOMChangesPluginLite(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.mutationObserver = null;
+        this.exposedExperiments = new Set();
+        this.eventListeners = new Map();
+        this.styleManagers = new Map();
+        this.initialized = false;
+        this.watchedElements = new WeakMap();
+        this.persistenceObserver = null;
+        this.reapplyingElements = new Set();
+        this.reapplyLogThrottle = new Map();
+        this.appliedStyleChanges = new Map();
+        this.antiFlickerTimeout = null;
+        this.antiFlickerStyleId = 'absmartly-antiflicker';
+        this.config = {
+            context: config.context,
+            autoApply: (_a = config.autoApply) !== null && _a !== void 0 ? _a : true,
+            spa: (_b = config.spa) !== null && _b !== void 0 ? _b : true,
+            visibilityTracking: (_c = config.visibilityTracking) !== null && _c !== void 0 ? _c : true,
+            extensionBridge: false, // Always false for lite version
+            dataSource: (_d = config.dataSource) !== null && _d !== void 0 ? _d : 'variable',
+            dataFieldName: (_e = config.dataFieldName) !== null && _e !== void 0 ? _e : '__dom_changes',
+            debug: (_f = config.debug) !== null && _f !== void 0 ? _f : false,
+            hideUntilReady: (_g = config.hideUntilReady) !== null && _g !== void 0 ? _g : false,
+            hideTimeout: (_h = config.hideTimeout) !== null && _h !== void 0 ? _h : 3000,
+            hideSelector: (_j = config.hideSelector) !== null && _j !== void 0 ? _j : '[data-absmartly-hide]',
+            hideTransition: (_k = config.hideTransition) !== null && _k !== void 0 ? _k : false,
+        };
+        if (!this.config.context) {
+            throw new Error('[ABsmartly] Context is required');
+        }
+        // Apply anti-flicker hiding immediately if enabled
+        if (this.config.hideUntilReady) {
+            this.hideContent();
+        }
+        this.domManipulator = new DOMManipulatorLite(this.config.debug, this);
+        this.variantExtractor = new VariantExtractor(this.config.context, this.config.dataSource, this.config.dataFieldName, this.config.debug);
+        this.exposureTracker = new ExposureTracker(this.config.context, this.config.debug);
+        this.htmlInjector = new HTMLInjector(this.config.debug);
+    }
+    DOMChangesPluginLite.prototype.ready = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, duration, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.initialized) {
+                            logDebug('Plugin already initialized');
+                            return [2 /*return*/];
+                        }
+                        startTime = performance.now();
+                        logDebug('Initializing ABsmartly DOM Changes Plugin Lite', {
+                            version: DOMChangesPluginLite.VERSION,
+                            config: {
+                                autoApply: this.config.autoApply,
+                                spa: this.config.spa,
+                                visibilityTracking: this.config.visibilityTracking,
+                                dataSource: this.config.dataSource,
+                                DEBUG: DEBUG,
+                            },
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        if (this.config.spa) {
+                            this.setupMutationObserver();
+                            this.setupURLChangeListener();
+                        }
+                        if (!this.config.autoApply) return [3 /*break*/, 3];
+                        // Apply HTML injections and DOM changes in parallel to minimize flickering
+                        return [4 /*yield*/, this.applyInjectionsAndChanges()];
+                    case 2:
+                        // Apply HTML injections and DOM changes in parallel to minimize flickering
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        this.initialized = true;
+                        this.registerWithContext();
+                        this.emit('initialized');
+                        duration = performance.now() - startTime;
+                        logPerformance('Plugin initialization', duration);
+                        logDebug("[ABsmartly] DOM plugin lite loaded successfully (v".concat(DOMChangesPluginLite.VERSION, ")"));
+                        if (this.config.debug) {
+                            logDebug('[ABsmartly] DOM Changes Plugin Lite initialized with debug mode');
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _a.sent();
+                        logDebug('[ABsmartly] Failed to initialize plugin:', error_1);
+                        throw error_1;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DOMChangesPluginLite.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.ready()];
+            });
+        });
+    };
+    DOMChangesPluginLite.prototype.setupMutationObserver = function () {
+        var observer = new MutationObserver(function () {
+            // Check for pending changes that might now be applicable
+            // Note: We don't have a centralized pending changes store in lite version,
+            // the PendingChangeManager handles this internally
+        });
+        observer.observe(document.body, {
+            childList: true,
+            subtree: true,
+        });
+        this.mutationObserver = observer;
+    };
+    /**
+     * Set up URL change listener for SPA mode
+     * Re-evaluates URL filters when URL changes and applies/removes changes accordingly
+     */
+    DOMChangesPluginLite.prototype.setupURLChangeListener = function () {
+        var _this = this;
+        var handleURLChange = function () { return __awaiter(_this, void 0, void 0, function () {
+            var newURL;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        newURL = window.location.href;
+                        logDebug('[ABsmartly] URL changed, re-evaluating experiments:', newURL);
+                        // Remove all current changes
+                        return [4 /*yield*/, this.removeAllChanges()];
+                    case 1:
+                        // Remove all current changes
+                        _a.sent();
+                        // Re-apply changes and injections with new URL (in parallel)
+                        return [4 /*yield*/, this.applyInjectionsAndChanges()];
+                    case 2:
+                        // Re-apply changes and injections with new URL (in parallel)
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        // Listen to popstate (back/forward navigation)
+        window.addEventListener('popstate', handleURLChange);
+        // Intercept pushState and replaceState
+        var originalPushState = history.pushState;
+        var originalReplaceState = history.replaceState;
+        history.pushState = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            originalPushState.apply(history, args);
+            handleURLChange();
+        };
+        history.replaceState = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            originalReplaceState.apply(history, args);
+            handleURLChange();
+        };
+        if (this.config.debug) {
+            logDebug('[ABsmartly] URL change listener set up for SPA mode');
+        }
+    };
+    /**
+     * Remove all currently applied changes
+     * Used when URL changes in SPA mode
+     */
+    DOMChangesPluginLite.prototype.removeAllChanges = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // Clear exposed experiments - ExposureTracker will re-register on next applyChanges
+                this.exposedExperiments.clear();
+                // Clear style managers - StyleSheetManager doesn't have a remove method
+                // The stylesheets will be reused or cleared on next applyChanges
+                this.styleManagers.clear();
+                // Clear applied style changes
+                this.appliedStyleChanges.clear();
+                // Clear HTML injections
+                this.htmlInjector.destroy();
+                // Clear variant extractor cache to force re-extraction
+                this.variantExtractor.clearCache();
+                if (this.config.debug) {
+                    logDebug('[ABsmartly] All change tracking cleared for URL change');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Apply HTML injections and DOM changes in parallel to minimize flickering
+     */
+    DOMChangesPluginLite.prototype.applyInjectionsAndChanges = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, currentURL, error_2, allInjectHTML, duration;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = performance.now();
+                        currentURL = window.location.href;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.config.context.ready()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        logDebug('[ABsmartly] Failed to wait for context ready:', error_2);
+                        return [2 /*return*/];
+                    case 4:
+                        allInjectHTML = this.variantExtractor.extractAllInjectHTML();
+                        // Apply injections and DOM changes in parallel for minimal flickering
+                        return [4 /*yield*/, Promise.all([this.applyHTMLInjections(allInjectHTML, currentURL), this.applyChanges()])];
+                    case 5:
+                        // Apply injections and DOM changes in parallel for minimal flickering
+                        _a.sent();
+                        duration = performance.now() - startTime;
+                        logPerformance('Apply injections and changes (parallel)', duration);
+                        if (this.config.debug) {
+                            logDebug('[ABsmartly] HTML injections and DOM changes applied in parallel', {
+                                duration: "".concat(duration.toFixed(2), "ms"),
+                                currentURL: currentURL,
+                            });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Apply HTML injections from all variants
+     */
+    DOMChangesPluginLite.prototype.applyHTMLInjections = function (allInjectHTML_1) {
+        return __awaiter(this, arguments, void 0, function (allInjectHTML, currentUrl) {
+            var injectionsByLocation;
+            if (currentUrl === void 0) { currentUrl = window.location.href; }
+            return __generator(this, function (_a) {
+                if (allInjectHTML.size === 0) {
+                    if (this.config.debug) {
+                        logDebug('[ABsmartly] No HTML injections found');
+                    }
+                    return [2 /*return*/];
+                }
+                injectionsByLocation = this.htmlInjector.collectInjections(allInjectHTML, currentUrl);
+                this.htmlInjector.inject(injectionsByLocation);
+                if (this.config.debug) {
+                    logDebug('[ABsmartly] HTML injections complete', {
+                        experimentsWithInjections: allInjectHTML.size,
+                        totalLocations: injectionsByLocation.size,
+                        currentUrl: currentUrl,
+                    });
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    DOMChangesPluginLite.prototype.applyChanges = function (experimentName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, currentURL, error_3, allExperiments, totalApplied, experimentStats, allExperiments_1, allExperiments_1_1, _a, expName, experimentData, currentVariant, variantData, urlFilter, globalDefaults, anyVariantMatchesURL, shouldApplyVisualChanges, changes, allVariantChanges, hasAnyChangesInAnyVariant, stats, hasImmediateTrigger, hasViewportTrigger, changes_1, changes_1_1, change, success, elements, changes_2, changes_2_1, change, hasAnyViewportTriggerInAnyVariant, hasAnyImmediateTriggerInAnyVariant, allVariantChanges_1, allVariantChanges_1_1, variantChanges, variantChanges_1, variantChanges_1_1, change, duration;
+            var e_1, _b, e_2, _c, e_3, _d, e_4, _e, e_5, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        startTime = performance.now();
+                        currentURL = window.location.href;
+                        logDebug('Starting to apply changes', {
+                            specificExperiment: experimentName || 'all',
+                            url: currentURL,
+                            action: 'apply_start',
+                        });
+                        if (this.config.debug) {
+                            logDebug('[ABsmartly] === DOM Changes Application Starting ===');
+                            logDebug('[ABsmartly] Target:', experimentName || 'all experiments');
+                            logDebug('[ABsmartly] Current URL:', currentURL);
+                            logDebug('[ABsmartly] Context ready:', true);
+                        }
+                        _g.label = 1;
+                    case 1:
+                        _g.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.config.context.ready()];
+                    case 2:
+                        _g.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_3 = _g.sent();
+                        logDebug('[ABsmartly] Failed to wait for context ready:', error_3);
+                        return [2 /*return*/];
+                    case 4:
+                        this.variantExtractor.clearCache();
+                        allExperiments = this.getAllExperimentsData();
+                        totalApplied = 0;
+                        experimentStats = new Map();
+                        logDebug('[ABsmartly] Experiments to process:', Array.from(allExperiments.keys()));
+                        logDebug('[ABsmartly] Total experiments with changes:', allExperiments.size);
+                        try {
+                            for (allExperiments_1 = __values(allExperiments), allExperiments_1_1 = allExperiments_1.next(); !allExperiments_1_1.done; allExperiments_1_1 = allExperiments_1.next()) {
+                                _a = __read(allExperiments_1_1.value, 2), expName = _a[0], experimentData = _a[1];
+                                // Skip if filtering by specific experiment
+                                if (experimentName && expName !== experimentName) {
+                                    continue;
+                                }
+                                currentVariant = this.config.context.peek(expName);
+                                variantData = experimentData.variantData, urlFilter = experimentData.urlFilter, globalDefaults = experimentData.globalDefaults;
+                                anyVariantMatchesURL = this.variantExtractor.anyVariantMatchesURL(expName, currentURL);
+                                if (!anyVariantMatchesURL) {
+                                    logDebug("[ABsmartly] Skipping experiment '".concat(expName, "' - no variant matches URL: ").concat(currentURL));
+                                    continue;
+                                }
+                                shouldApplyVisualChanges = this.shouldApplyVisualChanges(variantData, urlFilter, currentURL);
+                                changes = this.extractChangesFromData(variantData, globalDefaults);
+                                allVariantChanges = this.extractAllVariantChanges(expName);
+                                hasAnyChangesInAnyVariant = allVariantChanges.some(function (variantChanges) { return variantChanges && variantChanges.length > 0; });
+                                if (!hasAnyChangesInAnyVariant) {
+                                    // If NO variant has ANY changes, skip the entire experiment
+                                    if (this.config.debug) {
+                                        logDebug("[ABsmartly] Skipping experiment '".concat(expName, "' - no variants have changes"));
+                                    }
+                                    continue;
+                                }
+                                stats = { total: (changes === null || changes === void 0 ? void 0 : changes.length) || 0, success: 0, pending: 0 };
+                                if (this.config.debug) {
+                                    logDebug("[ABsmartly] Processing experiment '".concat(expName, "' (variant ").concat(currentVariant, "):"), {
+                                        urlMatches: shouldApplyVisualChanges,
+                                        changeCount: (changes === null || changes === void 0 ? void 0 : changes.length) || 0,
+                                        userVariantHasChanges: ((changes === null || changes === void 0 ? void 0 : changes.length) || 0) > 0,
+                                        changes: (changes === null || changes === void 0 ? void 0 : changes.map(function (c) { return ({
+                                            type: c.type,
+                                            selector: c.selector,
+                                            trigger: c.trigger_on_view ? 'viewport' : 'immediate',
+                                        }); })) || [],
+                                    });
+                                }
+                                hasImmediateTrigger = false;
+                                hasViewportTrigger = false;
+                                // Apply visual changes only if URL matches for user's variant AND user has changes
+                                if (shouldApplyVisualChanges && changes && changes.length > 0) {
+                                    try {
+                                        for (changes_1 = (e_2 = void 0, __values(changes)), changes_1_1 = changes_1.next(); !changes_1_1.done; changes_1_1 = changes_1.next()) {
+                                            change = changes_1_1.value;
+                                            success = this.domManipulator.applyChange(change, expName);
+                                            if (success) {
+                                                totalApplied++;
+                                                stats.success++;
+                                                if (change.trigger_on_view) {
+                                                    hasViewportTrigger = true;
+                                                }
+                                                else {
+                                                    hasImmediateTrigger = true;
+                                                }
+                                            }
+                                            else if (change.type !== 'create' && change.type !== 'styleRules') {
+                                                // Track pending changes for stats
+                                                try {
+                                                    elements = document.querySelectorAll(change.selector);
+                                                    if (elements.length === 0 && (this.config.spa || change.waitForElement)) {
+                                                        stats.pending++;
+                                                        if (change.trigger_on_view) {
+                                                            hasViewportTrigger = true;
+                                                        }
+                                                    }
+                                                }
+                                                catch (error) {
+                                                    if (this.config.debug) {
+                                                        logDebug("[ABsmartly] Invalid selector: ".concat(change.selector), error);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                    finally {
+                                        try {
+                                            if (changes_1_1 && !changes_1_1.done && (_c = changes_1.return)) _c.call(changes_1);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                    }
+                                }
+                                else if (changes && changes.length > 0) {
+                                    try {
+                                        // URL doesn't match for user's variant OR user has no changes
+                                        // Check if user's changes have viewport trigger (if they exist)
+                                        // We still need to set up tracking for SRM prevention
+                                        for (changes_2 = (e_3 = void 0, __values(changes)), changes_2_1 = changes_2.next(); !changes_2_1.done; changes_2_1 = changes_2.next()) {
+                                            change = changes_2_1.value;
+                                            if (change.trigger_on_view) {
+                                                hasViewportTrigger = true;
+                                            }
+                                            else {
+                                                hasImmediateTrigger = true;
+                                            }
+                                        }
+                                    }
+                                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                    finally {
+                                        try {
+                                            if (changes_2_1 && !changes_2_1.done && (_d = changes_2.return)) _d.call(changes_2);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                    }
+                                    logDebug("[ABsmartly] Experiment '".concat(expName, "' variant ").concat(currentVariant, " doesn't match URL filter or has no changes, but setting up tracking for SRM prevention"));
+                                }
+                                hasAnyViewportTriggerInAnyVariant = hasViewportTrigger;
+                                hasAnyImmediateTriggerInAnyVariant = hasImmediateTrigger;
+                                if (!hasViewportTrigger || !hasImmediateTrigger) {
+                                    try {
+                                        for (allVariantChanges_1 = (e_4 = void 0, __values(allVariantChanges)), allVariantChanges_1_1 = allVariantChanges_1.next(); !allVariantChanges_1_1.done; allVariantChanges_1_1 = allVariantChanges_1.next()) {
+                                            variantChanges = allVariantChanges_1_1.value;
+                                            if (variantChanges && variantChanges.length > 0) {
+                                                try {
+                                                    for (variantChanges_1 = (e_5 = void 0, __values(variantChanges)), variantChanges_1_1 = variantChanges_1.next(); !variantChanges_1_1.done; variantChanges_1_1 = variantChanges_1.next()) {
+                                                        change = variantChanges_1_1.value;
+                                                        if (change.trigger_on_view) {
+                                                            hasAnyViewportTriggerInAnyVariant = true;
+                                                        }
+                                                        else {
+                                                            hasAnyImmediateTriggerInAnyVariant = true;
+                                                        }
+                                                        // Early exit if we found both types
+                                                        if (hasAnyViewportTriggerInAnyVariant && hasAnyImmediateTriggerInAnyVariant) {
+                                                            break;
+                                                        }
+                                                    }
+                                                }
+                                                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (variantChanges_1_1 && !variantChanges_1_1.done && (_f = variantChanges_1.return)) _f.call(variantChanges_1);
+                                                    }
+                                                    finally { if (e_5) throw e_5.error; }
+                                                }
+                                            }
+                                            if (hasAnyViewportTriggerInAnyVariant && hasAnyImmediateTriggerInAnyVariant) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                    finally {
+                                        try {
+                                            if (allVariantChanges_1_1 && !allVariantChanges_1_1.done && (_e = allVariantChanges_1.return)) _e.call(allVariantChanges_1);
+                                        }
+                                        finally { if (e_4) throw e_4.error; }
+                                    }
+                                }
+                                // CRITICAL: Always register experiment for tracking if ANY variant has ANY trigger type
+                                // This prevents SRM even when user's variant doesn't match URL filter
+                                if (hasAnyViewportTriggerInAnyVariant || hasAnyImmediateTriggerInAnyVariant) {
+                                    this.exposureTracker.registerExperiment(expName, currentVariant || 0, changes || [], allVariantChanges);
+                                }
+                                // Note: We do NOT call treatment() here anymore to avoid duplicate calls.
+                                // The ExposureTracker.registerExperiment() will call triggerExposure() internally
+                                // when hasImmediateTrigger is true (see ExposureTracker line 169-174).
+                                // This prevents double treatment() calls that were causing test failures.
+                                experimentStats.set(expName, stats);
+                                logExperimentSummary(expName, stats.total, stats.success, stats.pending);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (allExperiments_1_1 && !allExperiments_1_1.done && (_b = allExperiments_1.return)) _b.call(allExperiments_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        duration = performance.now() - startTime;
+                        logPerformance('Apply changes', duration, {
+                            totalApplied: totalApplied,
+                            experiments: experimentStats.size,
+                        });
+                        if (this.config.debug) {
+                            logDebug('[ABsmartly] === DOM Changes Application Complete ===');
+                            logDebug('[ABsmartly] Summary:', {
+                                totalChangesApplied: totalApplied,
+                                experimentsProcessed: experimentStats.size,
+                                duration: "".concat(duration.toFixed(2), "ms"),
+                                experiments: Array.from(experimentStats.entries()).map(function (_a) {
+                                    var _b = __read(_a, 2), name = _b[0], stats = _b[1];
+                                    return ({
+                                        name: name,
+                                        total: stats.total,
+                                        success: stats.success,
+                                        pending: stats.pending,
+                                        pendingReason: stats.pending > 0 ? 'Elements not found yet (SPA mode will retry)' : undefined,
+                                    });
+                                }),
+                            });
+                        }
+                        // Show hidden content after changes are applied
+                        if (this.config.hideUntilReady) {
+                            this.showContent();
+                        }
+                        this.emit('changes-applied', { count: totalApplied, experimentName: experimentName });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get all experiments with their variant data and metadata
+     */
+    DOMChangesPluginLite.prototype.getAllExperimentsData = function () {
+        var e_6, _a;
+        var experiments = new Map();
+        var allVariants = this.variantExtractor.extractAllChanges();
+        try {
+            for (var allVariants_1 = __values(allVariants), allVariants_1_1 = allVariants_1.next(); !allVariants_1_1.done; allVariants_1_1 = allVariants_1.next()) {
+                var _b = __read(allVariants_1_1.value, 1), expName = _b[0];
+                var currentVariant = this.config.context.peek(expName);
+                if (currentVariant === undefined || currentVariant === null) {
+                    continue;
+                }
+                var variantsData = this.variantExtractor.getAllVariantsData(expName);
+                var variantData = variantsData.get(currentVariant);
+                if (!variantData) {
+                    continue;
+                }
+                // Extract URL filter and global defaults if using wrapped format
+                var urlFilter = null;
+                var globalDefaults = {};
+                if (variantData &&
+                    typeof variantData === 'object' &&
+                    !Array.isArray(variantData) &&
+                    'changes' in variantData) {
+                    var config = variantData;
+                    urlFilter = config.urlFilter;
+                    globalDefaults = {
+                        waitForElement: config.waitForElement,
+                        persistStyle: config.persistStyle,
+                        important: config.important,
+                        observerRoot: config.observerRoot,
+                    };
+                }
+                experiments.set(expName, { variantData: variantData, urlFilter: urlFilter, globalDefaults: globalDefaults });
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (allVariants_1_1 && !allVariants_1_1.done && (_a = allVariants_1.return)) _a.call(allVariants_1);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return experiments;
+    };
+    /**
+     * Extract changes from DOMChangesData and apply global defaults
+     */
+    DOMChangesPluginLite.prototype.extractChangesFromData = function (data, globalDefaults) {
+        var changes = null;
+        // Extract changes array
+        if (Array.isArray(data)) {
+            changes = data;
+        }
+        else if (data && typeof data === 'object' && 'changes' in data) {
+            changes = data.changes;
+        }
+        if (!changes || changes.length === 0) {
+            return null;
+        }
+        // Apply global defaults to each change
+        return changes.map(function (change) {
+            var _a, _b, _c, _d;
+            return (__assign(__assign({}, change), { waitForElement: (_a = change.waitForElement) !== null && _a !== void 0 ? _a : globalDefaults.waitForElement, persistStyle: (_b = change.persistStyle) !== null && _b !== void 0 ? _b : globalDefaults.persistStyle, important: (_c = change.important) !== null && _c !== void 0 ? _c : globalDefaults.important, observerRoot: (_d = change.observerRoot) !== null && _d !== void 0 ? _d : globalDefaults.observerRoot }));
+        });
+    };
+    /**
+     * Extract all variant changes for cross-variant tracking
+     */
+    DOMChangesPluginLite.prototype.extractAllVariantChanges = function (experimentName) {
+        var allVariantChanges = this.variantExtractor.getAllVariantChanges(experimentName);
+        var variantsData = this.variantExtractor.getAllVariantsData(experimentName);
+        // Apply global defaults to each variant's changes
+        var processedVariants = [];
+        var _loop_1 = function (i) {
+            var variantChanges = allVariantChanges[i];
+            var variantData = variantsData.get(i);
+            if (!variantChanges || variantChanges.length === 0) {
+                processedVariants.push([]);
+                return "continue";
+            }
+            // Extract global defaults if using wrapped format
+            var globalDefaults = {};
+            if (variantData &&
+                typeof variantData === 'object' &&
+                !Array.isArray(variantData) &&
+                'changes' in variantData) {
+                var config = variantData;
+                globalDefaults = {
+                    waitForElement: config.waitForElement,
+                    persistStyle: config.persistStyle,
+                    important: config.important,
+                    observerRoot: config.observerRoot,
+                };
+            }
+            // Apply global defaults
+            var processedChanges = variantChanges.map(function (change) {
+                var _a, _b, _c, _d;
+                return (__assign(__assign({}, change), { waitForElement: (_a = change.waitForElement) !== null && _a !== void 0 ? _a : globalDefaults.waitForElement, persistStyle: (_b = change.persistStyle) !== null && _b !== void 0 ? _b : globalDefaults.persistStyle, important: (_c = change.important) !== null && _c !== void 0 ? _c : globalDefaults.important, observerRoot: (_d = change.observerRoot) !== null && _d !== void 0 ? _d : globalDefaults.observerRoot }));
+            });
+            processedVariants.push(processedChanges);
+        };
+        for (var i = 0; i < allVariantChanges.length; i++) {
+            _loop_1(i);
+        }
+        return processedVariants;
+    };
+    /**
+     * Determine if visual changes should be applied based on URL filter
+     */
+    DOMChangesPluginLite.prototype.shouldApplyVisualChanges = function (variantData, urlFilter, url) {
+        // Legacy array format has no URL filter - always apply
+        if (Array.isArray(variantData)) {
+            return true;
+        }
+        // Wrapped format without URL filter - always apply
+        if (!urlFilter) {
+            return true;
+        }
+        // Check URL filter
+        return URLMatcher.matches(urlFilter, url);
+    };
+    DOMChangesPluginLite.prototype.hasChanges = function (experimentName) {
+        return this.domManipulator.hasChanges(experimentName);
+    };
+    DOMChangesPluginLite.prototype.applyChange = function (change, experimentName) {
+        logDebug('Applying single change via public API', {
+            experimentName: experimentName,
+            selector: change.selector,
+            changeType: change.type,
+        });
+        try {
+            var success = this.domManipulator.applyChange(change, experimentName);
+            if (success) {
+                this.emit('change_applied', {
+                    experimentName: experimentName,
+                    change: change,
+                });
+            }
+            return success;
+        }
+        catch (error) {
+            if (this.config.debug) {
+                logDebug('[ABsmartly] Error applying change:', error);
+            }
+            return false;
+        }
+    };
+    DOMChangesPluginLite.prototype.on = function (event, callback) {
+        var listeners = this.eventListeners.get(event) || [];
+        listeners.push(callback);
+        this.eventListeners.set(event, listeners);
+    };
+    DOMChangesPluginLite.prototype.off = function (event, callback) {
+        if (!callback) {
+            this.eventListeners.delete(event);
+        }
+        else {
+            var listeners = this.eventListeners.get(event) || [];
+            var index = listeners.indexOf(callback);
+            if (index !== -1) {
+                listeners.splice(index, 1);
+            }
+        }
+    };
+    DOMChangesPluginLite.prototype.emit = function (event, data) {
+        var e_7, _a;
+        var listeners = this.eventListeners.get(event) || [];
+        try {
+            for (var listeners_1 = __values(listeners), listeners_1_1 = listeners_1.next(); !listeners_1_1.done; listeners_1_1 = listeners_1.next()) {
+                var callback = listeners_1_1.value;
+                try {
+                    callback(data);
+                }
+                catch (error) {
+                    logDebug("[ABsmartly] Error in event listener for ".concat(event, ":"), error);
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (listeners_1_1 && !listeners_1_1.done && (_a = listeners_1.return)) _a.call(listeners_1);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    };
+    DOMChangesPluginLite.prototype.getStyleManager = function (experimentName) {
+        var id = "absmartly-styles-".concat(experimentName);
+        var manager = this.styleManagers.get(experimentName);
+        if (!manager) {
+            manager = new StyleSheetManager(id, this.config.debug);
+            this.styleManagers.set(experimentName, manager);
+        }
+        return manager;
+    };
+    DOMChangesPluginLite.prototype.buildCssRule = function (selector, properties, important) {
+        if (important === void 0) { important = true; }
+        var declarations = Object.entries(properties)
+            .map(function (_a) {
+            var _b = __read(_a, 2), prop = _b[0], value = _b[1];
+            var cssProp = prop.replace(/([A-Z])/g, '-$1').toLowerCase();
+            var bang = important ? ' !important' : '';
+            return "  ".concat(cssProp, ": ").concat(value).concat(bang, ";");
+        })
+            .join('\n');
+        return "".concat(selector, " {\n").concat(declarations, "\n}");
+    };
+    DOMChangesPluginLite.prototype.buildStateRules = function (selector, states, important) {
+        if (important === void 0) { important = true; }
+        var rules = [];
+        if (states.normal) {
+            rules.push(this.buildCssRule(selector, states.normal, important));
+        }
+        if (states.hover) {
+            rules.push(this.buildCssRule("".concat(selector, ":hover"), states.hover, important));
+        }
+        if (states.active) {
+            rules.push(this.buildCssRule("".concat(selector, ":active"), states.active, important));
+        }
+        if (states.focus) {
+            rules.push(this.buildCssRule("".concat(selector, ":focus"), states.focus, important));
+        }
+        return rules.join('\n\n');
+    };
+    DOMChangesPluginLite.prototype.refreshExperiments = function () {
+        if (this.config.debug) {
+            logDebug('[ABsmartly] Refreshing experiments and clearing cache');
+        }
+        this.variantExtractor.clearCache();
+        if (this.config.autoApply) {
+            this.applyInjectionsAndChanges();
+        }
+    };
+    DOMChangesPluginLite.prototype.destroy = function () {
+        this.domManipulator.destroy();
+        this.exposureTracker.destroy();
+        this.htmlInjector.destroy();
+        this.styleManagers.forEach(function (manager) { return manager.destroy(); });
+        this.styleManagers.clear();
+        if (this.mutationObserver) {
+            this.mutationObserver.disconnect();
+            this.mutationObserver = null;
+        }
+        if (this.persistenceObserver) {
+            this.persistenceObserver.disconnect();
+            this.persistenceObserver = null;
+        }
+        // Clean up anti-flicker timeout and style
+        if (this.antiFlickerTimeout !== null) {
+            clearTimeout(this.antiFlickerTimeout);
+            this.antiFlickerTimeout = null;
+        }
+        var antiFlickerStyle = document.getElementById(this.antiFlickerStyleId);
+        if (antiFlickerStyle) {
+            antiFlickerStyle.remove();
+        }
+        this.eventListeners.clear();
+        this.exposedExperiments.clear();
+        this.watchedElements = new WeakMap();
+        this.appliedStyleChanges.clear();
+        this.reapplyingElements.clear();
+        this.reapplyLogThrottle.clear();
+        this.unregisterFromContext();
+        this.initialized = false;
+        if (this.config.debug) {
+            logDebug('[ABsmartly] DOM Changes Plugin Lite destroyed');
+        }
+    };
+    DOMChangesPluginLite.prototype.registerWithContext = function () {
+        if (this.config.context) {
+            if (!this.config.context.__plugins) {
+                this.config.context.__plugins = {};
+            }
+            this.config.context.__plugins.domPlugin = {
+                name: 'DOMChangesPluginLite',
+                version: DOMChangesPluginLite.VERSION,
+                initialized: true,
+                capabilities: ['spa', 'visibility'],
+                instance: this,
+                timestamp: Date.now(),
+            };
+            this.config.context.__domPlugin = this.config.context.__plugins.domPlugin;
+            if (this.config.debug) {
+                logDebug('[ABsmartly] DOMChangesPluginLite registered with context at __plugins.domPlugin');
+            }
+        }
+    };
+    DOMChangesPluginLite.prototype.unregisterFromContext = function () {
+        var _a;
+        if (this.config.context) {
+            if ((_a = this.config.context.__plugins) === null || _a === void 0 ? void 0 : _a.domPlugin) {
+                delete this.config.context.__plugins.domPlugin;
+            }
+            if (this.config.context.__domPlugin) {
+                delete this.config.context.__domPlugin;
+            }
+            if (this.config.debug) {
+                logDebug('[ABsmartly] DOMChangesPluginLite unregistered from context');
+            }
+        }
+    };
+    /**
+     * Hide content to prevent flicker before experiments are applied
+     */
+    DOMChangesPluginLite.prototype.hideContent = function () {
+        var _this = this;
+        var mode = this.config.hideUntilReady;
+        if (!mode)
+            return;
+        // Check if style already exists (prevent duplicate injection)
+        if (document.getElementById(this.antiFlickerStyleId)) {
+            return;
+        }
+        var style = document.createElement('style');
+        style.id = this.antiFlickerStyleId;
+        var hasTransition = this.config.hideTransition !== false;
+        var selector = mode === 'body' ? 'body' : this.config.hideSelector || '[data-absmartly-hide]';
+        if (hasTransition) {
+            // Use both visibility:hidden and opacity:0 for smooth transition
+            style.textContent = "\n        ".concat(selector, " {\n          visibility: hidden !important;\n          opacity: 0 !important;\n        }\n      ");
+        }
+        else {
+            // Use only visibility:hidden for instant reveal (no layout shift)
+            style.textContent = "\n        ".concat(selector, " {\n          visibility: hidden !important;\n        }\n      ");
+        }
+        document.head.appendChild(style);
+        // Set timeout to show content even if experiments fail to load
+        this.antiFlickerTimeout = window.setTimeout(function () {
+            if (_this.config.debug) {
+                logDebug("[ABsmartly] Anti-flicker timeout reached (".concat(_this.config.hideTimeout, "ms), showing content"));
+            }
+            _this.showContent();
+        }, this.config.hideTimeout);
+        if (this.config.debug) {
+            logDebug("[ABsmartly] Anti-flicker enabled (mode: ".concat(mode, ", transition: ").concat(hasTransition ? this.config.hideTransition : 'none', ", timeout: ").concat(this.config.hideTimeout, "ms)"));
+        }
+    };
+    /**
+     * Show hidden content after experiments are applied
+     */
+    DOMChangesPluginLite.prototype.showContent = function () {
+        var _this = this;
+        // Clear timeout if still pending
+        if (this.antiFlickerTimeout !== null) {
+            clearTimeout(this.antiFlickerTimeout);
+            this.antiFlickerTimeout = null;
+        }
+        var style = document.getElementById(this.antiFlickerStyleId);
+        if (!style)
+            return;
+        var hasTransition = this.config.hideTransition !== false;
+        if (hasTransition) {
+            // Smooth fade-in: remove visibility, add transition, then animate opacity
+            var mode = this.config.hideUntilReady;
+            var selector = mode === 'body' ? 'body' : this.config.hideSelector || '[data-absmartly-hide]';
+            // Step 1: Remove visibility:hidden, keep opacity:0, add transition
+            style.textContent = "\n        ".concat(selector, " {\n          opacity: 0 !important;\n          transition: opacity ").concat(this.config.hideTransition, " !important;\n        }\n      ");
+            // Step 2: Force reflow to ensure transition applies
+            style.offsetHeight;
+            // Step 3: Trigger fade-in by setting opacity to 1
+            style.textContent = "\n        ".concat(selector, " {\n          opacity: 1 !important;\n          transition: opacity ").concat(this.config.hideTransition, " !important;\n        }\n      ");
+            // Step 4: Remove style after transition completes
+            var transitionDuration = parseFloat(this.config.hideTransition) * 1000;
+            setTimeout(function () {
+                style.remove();
+                if (_this.config.debug) {
+                    logDebug('[ABsmartly] Anti-flicker fade-in complete, style removed');
+                }
+            }, transitionDuration);
+            if (this.config.debug) {
+                logDebug("[ABsmartly] Anti-flicker fading in with transition: ".concat(this.config.hideTransition));
+            }
+        }
+        else {
+            // Instant reveal: just remove the style
+            style.remove();
+            if (this.config.debug) {
+                logDebug('[ABsmartly] Anti-flicker removed, content now visible');
+            }
+        }
+    };
+    DOMChangesPluginLite.prototype.watchElement = function (element, experimentName, change) {
+        var experiments = this.watchedElements.get(element);
+        if (!experiments) {
+            experiments = new Set();
+            this.watchedElements.set(element, experiments);
+        }
+        experiments.add(experimentName);
+        // Store the applied style change for this experiment
+        if (!this.appliedStyleChanges.has(experimentName)) {
+            this.appliedStyleChanges.set(experimentName, []);
+        }
+        var changes = this.appliedStyleChanges.get(experimentName);
+        var isNewWatch = !changes.includes(change);
+        if (isNewWatch) {
+            changes.push(change);
+            // Only log when actually adding a new watch, not on every reapply
+            if (this.config.debug) {
+                logDebug('[ABsmartly] Watching element for style persistence', {
+                    experimentName: experimentName,
+                    selector: change.selector,
+                    element: element.tagName,
+                });
+            }
+        }
+        if (!this.persistenceObserver) {
+            this.setupPersistenceObserver();
+        }
+    };
+    DOMChangesPluginLite.prototype.unwatchElement = function (element, experimentName) {
+        var experiments = this.watchedElements.get(element);
+        if (experiments) {
+            experiments.delete(experimentName);
+            if (experiments.size === 0) {
+                this.watchedElements.delete(element);
+            }
+        }
+    };
+    DOMChangesPluginLite.prototype.setupPersistenceObserver = function () {
+        var _this = this;
+        if (this.persistenceObserver)
+            return;
+        this.persistenceObserver = new MutationObserver(function (mutations) {
+            mutations.forEach(function (mutation) {
+                var element = mutation.target;
+                if (_this.reapplyingElements.has(element)) {
+                    return;
+                }
+                var experiments = _this.watchedElements.get(element);
+                if (experiments) {
+                    // Throttle mutation detection logs to once per 5 seconds per element
+                    if (_this.config.debug) {
+                        var elementKey = "mutation:".concat(element.tagName, ":").concat(element.getAttribute('name') || element.className);
+                        var now = Date.now();
+                        var lastLogged = _this.reapplyLogThrottle.get(elementKey) || 0;
+                        if (now - lastLogged > 5000) {
+                            logDebug('[ABsmartly] Style mutation detected on watched element', {
+                                element: element.tagName,
+                                selector: element.getAttribute('name') || element.className,
+                                oldValue: mutation.oldValue,
+                            });
+                            _this.reapplyLogThrottle.set(elementKey, now);
+                        }
+                    }
+                    experiments.forEach(function (experimentName) {
+                        var appliedChanges = _this.appliedStyleChanges.get(experimentName);
+                        if (appliedChanges) {
+                            appliedChanges.forEach(function (change) {
+                                var e_8, _a;
+                                if (change.type === 'style' && element.matches(change.selector)) {
+                                    var needsReapply = _this.checkStyleOverwritten(element, change.value);
+                                    if (needsReapply) {
+                                        _this.reapplyingElements.add(element);
+                                        _this.domManipulator.applyChange(change, experimentName);
+                                        var logKey = "".concat(experimentName, "-").concat(change.selector);
+                                        var now = Date.now();
+                                        var lastLogged = _this.reapplyLogThrottle.get(logKey) || 0;
+                                        if (_this.config.debug && now - lastLogged > 5000) {
+                                            logDebug('Reapplied style after mutation (React/framework conflict detected)', {
+                                                experimentName: experimentName,
+                                                selector: change.selector,
+                                                note: 'This happens when the page framework (React/Vue/etc) fights with DOM changes',
+                                            });
+                                            _this.reapplyLogThrottle.set(logKey, now);
+                                            // Cleanup old throttle entries to prevent memory leak
+                                            if (_this.reapplyLogThrottle.size > 100) {
+                                                var oldestAllowed = now - 60000; // 1 minute
+                                                try {
+                                                    for (var _b = __values(_this.reapplyLogThrottle.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                                        var _d = __read(_c.value, 2), key = _d[0], time = _d[1];
+                                                        if (time < oldestAllowed) {
+                                                            _this.reapplyLogThrottle.delete(key);
+                                                        }
+                                                    }
+                                                }
+                                                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                                                finally {
+                                                    try {
+                                                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                                    }
+                                                    finally { if (e_8) throw e_8.error; }
+                                                }
+                                            }
+                                        }
+                                        setTimeout(function () {
+                                            _this.reapplyingElements.delete(element);
+                                        }, 0);
+                                    }
+                                    else if (_this.config.debug) {
+                                        logDebug('[ABsmartly] Style mutation detected but no reapply needed', {
+                                            experimentName: experimentName,
+                                            selector: change.selector,
+                                        });
+                                    }
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+        });
+        this.persistenceObserver.observe(document.body, {
+            attributes: true,
+            attributeFilter: ['style'],
+            subtree: true,
+            attributeOldValue: true,
+        });
+        if (this.config.debug) {
+            logDebug('[ABsmartly] Style persistence observer setup complete');
+        }
+    };
+    DOMChangesPluginLite.prototype.checkStyleOverwritten = function (element, expectedStyles) {
+        var e_9, _a;
+        try {
+            for (var _b = __values(Object.entries(expectedStyles)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), prop = _d[0], value = _d[1];
+                var cssProp = prop.replace(/([A-Z])/g, '-$1').toLowerCase();
+                var currentValue = element.style.getPropertyValue(cssProp);
+                var currentPriority = element.style.getPropertyPriority(cssProp);
+                if (currentValue !== value || (value.includes('!important') && !currentPriority)) {
+                    return true;
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        return false;
+    };
+    DOMChangesPluginLite.VERSION = '1.0.0-lite';
+    return DOMChangesPluginLite;
+}());
+export { DOMChangesPluginLite };
+//# sourceMappingURL=DOMChangesPluginLite.js.map