@pendo/agent 2.291.3 → 2.292.0

package/dist/pendo.module.js

@@ -463,6 +463,9 @@ function shouldUseUnminifiedAgent(config, debuggingEnabled) {
     return !isExtension(config) && isMinifiedAgent(config) && debuggingEnabled;
 }
 function findAgentScriptTag(scripts = [], apiKey) {
+    if (document.currentScript) {
+        return document.currentScript;
+    }
     const regex = /^https:\/\/[\w\-.]*cdn[\w\-.]*\.(pendo-dev\.com|pendo\.io)\/agent\/static\/([\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}|PENDO_API_KEY)\/pendo\.js$/g;
     for (let i = 0; i < scripts.length; i++) {
         const script = scripts[i];
@@ -3687,6 +3690,10 @@ function globalBucket(env) {
 }
 
 function isNativeCode(fn) { return /native/.test(fn); }
+const detectNativeBrowserAPI = (name) => {
+    const fn = _.get(window, name);
+    return (fn && isNativeCode(fn));
+};
 
 var isOldIE = function (olderThan, tVersion) {
     olderThan = olderThan || 10;
@@ -3904,8 +3911,8 @@ var SERVER = '';
 var ASSET_HOST = '';
 var ASSET_PATH = '';
 var DESIGNER_SERVER = '';
-var VERSION = '2.291.3_';
-var PACKAGE_VERSION = '2.291.3';
+var VERSION = '2.292.0_';
+var PACKAGE_VERSION = '2.292.0';
 var LOADER = 'xhr';
 /* eslint-enable agent-eslint-rules/no-gulp-env-references */
 /**
@@ -12196,6 +12203,92 @@ class LocalStorageEventBuffer {
 }
 var localStorageEventBuffer = new LocalStorageEventBuffer();
 
+class PerformanceMonitor {
+    constructor() {
+        this._isPerformanceApiAvailable = this._checkPerformanceApi();
+        this._measuringPerformance = false;
+        this._marks = {};
+        this._measures = {};
+    }
+    initialize() {
+        this._measuringPerformance = true;
+        this._markPerformance('initialize');
+        // temporary clear interval while working on send implementation
+        this.interval = setInterval(() => {
+            this._clearMarksAndMeasures();
+        }, 1000 * 60 * 10);
+        return () => {
+            this.teardown();
+        };
+    }
+    teardown() {
+        this._measuringPerformance = false;
+        this._markPerformance('teardown');
+        this._clearMarksAndMeasures();
+        clearInterval(this.interval);
+    }
+    startTimer(name) {
+        this._markPerformance(`${name}-start`);
+    }
+    stopTimer(name) {
+        this._markPerformance(`${name}-stop`);
+        this._measurePerformance(name);
+    }
+    track(name) {
+        this._markPerformance(name);
+    }
+    send() {
+        performance.getEntries();
+        // TODO: implement filter/send process
+        this._clearMarksAndMeasures();
+    }
+    _checkPerformanceApi() {
+        return detectNativeBrowserAPI('performance.mark') &&
+            detectNativeBrowserAPI('performance.measure') &&
+            detectNativeBrowserAPI('performance.getEntries') &&
+            detectNativeBrowserAPI('performance.clearMarks') &&
+            detectNativeBrowserAPI('performance.clearMeasures');
+    }
+    _shouldMeasurePerformance() {
+        return this._isPerformanceApiAvailable && this._measuringPerformance;
+    }
+    _markPerformance(name) {
+        if (!this._shouldMeasurePerformance())
+            return;
+        name = `pendo-${name}`;
+        performance.mark(name);
+        this._count(this._marks, name);
+    }
+    _measurePerformance(name) {
+        if (!this._shouldMeasurePerformance())
+            return;
+        name = `pendo-${name}`;
+        const startMark = `${name}-start`;
+        const stopMark = `${name}-stop`;
+        performance.measure(name, startMark, stopMark);
+        this._count(this._measures, name);
+    }
+    _count(registry, name) {
+        if (!registry[name]) {
+            registry[name] = 1;
+        }
+        else {
+            registry[name]++;
+        }
+    }
+    _clearMarksAndMeasures() {
+        _.each(this._marks, (count, name) => {
+            performance.clearMarks(name);
+        });
+        _.each(this._measures, (count, name) => {
+            performance.clearMeasures(name);
+        });
+        this._marks = {};
+        this._measures = {};
+    }
+}
+var PerformanceMonitor$1 = new PerformanceMonitor();
+
 var defaultTrackName = '_PENDO_UNNAMED_';
 var SILO_AVG_COMPRESSION_RATIO = 5;
 /**
@@ -12257,21 +12350,7 @@ function collectEvent(type, props, url, name, eventProperties, context) {
         agenticEventQueue.push(event);
         return;
     }
-    eventQueue.push(attachMonitoringData(store, event));
-}
-function attachMonitoringData(store, event) {
-    try {
-        if (!store.getters['monitoring/shouldFlush']())
-            return event;
-        var payload = store.getters['monitoring/payload']();
-        store.dispatch('monitoring/flush');
-        if (!_.isEmpty(payload)) {
-            event.ops = payload;
-        }
-    }
-    catch (e) {
-    }
-    return event;
+    eventQueue.push(event);
 }
 // @const {Event.type[]}
 var WHITELIST_FREE_NPS = ['load', 'meta', 'identify'];
@@ -12710,7 +12789,7 @@ function createSendQueue(options, send, guaranteedSend) {
             }
         });
         queue.onTimeout = function () {
-            store.commit('monitoring/incrementCounter', options.beacon + 'GifFailures');
+            PerformanceMonitor$1.track(`${options.beacon}-gif-failure`);
         };
         queue.retryPending = true;
         return queue;
@@ -13002,7 +13081,7 @@ var handleEmbeddedData = function (src) {
     return src + '';
 };
 function getAttributeValue(element, attrName) {
-    return element.getAttribute ? element.getAttribute(attrName) : element[attrName];
+    return store.getters['nodeAttr/getAttribute']()(element, attrName);
 }
 var extractAttribute = function (element, attrName, type) {
     if (!element || !element.nodeName)
@@ -21054,10 +21133,6 @@ class UpdateRunner {
         }
     }
     complete(time) {
-        store.commit('monitoring/setTimer', {
-            name: 'guideUpdateTimeMS',
-            time: this.updateTotalTime
-        });
         store.commit('guideUpdate/completeUpdate', time);
         this.cancel();
     }
@@ -26540,6 +26615,11 @@ var EventRouter = function () {
         var config = configParam.value;
         var cases = casesParam.value;
         var conditionResult = evaluateCondition(conditionType, config);
+        Events.trigger('appUsage', {
+            type: 'conditionalSplitResult',
+            elementId: evt.srcElement.id,
+            conditionResult
+        });
         var matchingCase = _.find(cases, function (caseItem) {
             return caseItem.value === conditionResult;
         });
@@ -26607,16 +26687,27 @@ var GuideActivity = (function () {
     var isObject = _.isObject;
     var findWhere = _.findWhere;
     const _guideResolvers = [];
+    var conditionalSplitEventQueue = [];
     return {
         type: GA_TYPE,
         handler(evtData) {
             var appData = evtData.data[0];
+            if (appData && appData.type === 'conditionalSplitResult') {
+                finalizeConditionalSplitEvent(appData);
+                return;
+            }
             var browserEvt = evtData.data[1];
             if (!shouldHandleEvent(appData, browserEvt))
                 return;
             var activityEvent = transformToGuideActivity(appData);
             if (activityEvent) {
-                stageGuideEvent(activityEvent);
+                const firstAction = _.get(activityEvent, ['props', 'ui_element_actions', 0, 'action']);
+                if (firstAction === 'conditionalSplit') {
+                    conditionalSplitEventQueue.push(activityEvent);
+                }
+                else {
+                    stageGuideEvent(activityEvent);
+                }
             }
         },
         registerGuideResolver(callBack) {
@@ -26629,6 +26720,22 @@ var GuideActivity = (function () {
             }
         }
     };
+    function finalizeConditionalSplitEvent(evtData) {
+        const { conditionResult, elementId } = evtData;
+        const matchingEventIndex = _.findIndex(conditionalSplitEventQueue, (event) => {
+            return event.props.ui_element_id === elementId;
+        });
+        if (matchingEventIndex === -1)
+            return;
+        const matchingEvent = conditionalSplitEventQueue.splice(matchingEventIndex, 1)[0];
+        const conditionalSplitAction = matchingEvent.props.ui_element_actions[0];
+        conditionalSplitAction.condition_result = conditionResult;
+        const cases = conditionalSplitAction.cases;
+        const resultCase = cases[conditionResult];
+        matchingEvent.props.ui_element_actions = matchingEvent.props.ui_element_actions.concat(resultCase);
+        delete conditionalSplitAction.cases;
+        stageGuideEvent(matchingEvent);
+    }
     function isClickEvent(browserEvt) {
         return browserEvt && browserEvt.type === 'click';
     }
@@ -26745,58 +26852,7 @@ var GuideActivity = (function () {
             ];
         }
         if (element.actions !== undefined) {
-            return _.map(element.actions, function (action) {
-                switch (action.action) {
-                    case 'automation':
-                        var automationIds = findWhere(action.parameters, { name: 'automationIds' });
-                        return {
-                            action: action.action,
-                            automationIds
-                        };
-                    case 'openLink':
-                        var url = findWhere(action.parameters, { name: 'url' });
-                        var target = findWhere(action.parameters, { name: 'target' });
-                        return {
-                            action: action.action,
-                            url: sanitizeUrl(url.value),
-                            target: target.value
-                        };
-                    case 'submitPollAndGoToStep':
-                    case 'goToStep':
-                        var guideStepId = findWhere(action.parameters, { name: 'goToStepId' });
-                        return {
-                            action: action.action,
-                            guideStepId: guideStepId.value
-                        };
-                    case 'guideSnoozed':
-                        var duration = findWhere(action.parameters, { name: 'snooze_duration' });
-                        var timeUnit = findWhere(action.parameters, { name: 'time_unit' });
-                        return {
-                            action: action.action,
-                            duration: duration.value,
-                            timeUnit: timeUnit.value
-                        };
-                    case 'showGuide':
-                    case 'launchGuide':
-                        var guideId = action.parameters[0];
-                        var stepId = action.parameters[1] || {};
-                        return {
-                            action: action.action,
-                            guideId: guideId.value,
-                            stepId: stepId.value
-                        };
-                    case 'advanceGuide':
-                    case 'previousStep':
-                    case 'submitPoll':
-                    case 'dismissGuide':
-                    case 'confirmation':
-                        return {
-                            action: action.action
-                        };
-                    default:
-                        return {};
-                }
-            });
+            return _.map(element.actions, processAction);
         }
         if (uiElement.templateName === 'pendo_task_list_item') {
             if (_.isArray(element.templateChildren) && element.templateChildren[uiElement.templateChildIndex]) {
@@ -26808,6 +26864,79 @@ var GuideActivity = (function () {
         }
         return [];
     }
+    function processAction(action) {
+        switch (action.action) {
+            case 'automation':
+                var automationIds = findWhere(action.parameters, { name: 'automationIds' });
+                return {
+                    action: action.action,
+                    automationIds
+                };
+            case 'openLink':
+                var url = findWhere(action.parameters, { name: 'url' });
+                var target = findWhere(action.parameters, { name: 'target' });
+                return {
+                    action: action.action,
+                    url: sanitizeUrl(url.value),
+                    target: target.value
+                };
+            case 'submitPollAndGoToStep':
+            case 'goToStep':
+                var guideStepId = findWhere(action.parameters, { name: 'goToStepId' });
+                return {
+                    action: action.action,
+                    guideStepId: guideStepId.value
+                };
+            case 'guideSnoozed':
+                var duration = findWhere(action.parameters, { name: 'snooze_duration' });
+                var timeUnit = findWhere(action.parameters, { name: 'time_unit' });
+                return {
+                    action: action.action,
+                    duration: duration.value,
+                    timeUnit: timeUnit.value
+                };
+            case 'showGuide':
+            case 'launchGuide':
+                var guideId = action.parameters[0];
+                var stepId = action.parameters[1] || {};
+                return {
+                    action: action.action,
+                    guideId: guideId.value,
+                    stepId: stepId.value
+                };
+            case 'conditionalSplit':
+                var name = findWhere(action.parameters, { name: 'name' });
+                var conditionType = findWhere(action.parameters, { name: 'conditionType' });
+                var config = findWhere(action.parameters, { name: 'config' });
+                var cases = findWhere(action.parameters, { name: 'cases' });
+                var processedCases = _.reduce(cases.value, function (acc, c) {
+                    acc[c.value] = _.map(c.actions, function (a) {
+                        var processedAction = processAction(a);
+                        processedAction.source = a.source;
+                        return processedAction;
+                    });
+                    return acc;
+                }, {});
+                return {
+                    action: action.action,
+                    name: name.value,
+                    condition_type: conditionType.value,
+                    element_selector: config.value.elementSelector,
+                    feature_id: config.value.featureId,
+                    cases: processedCases // will be removed in finalizeConditionalSplitEvent
+                };
+            case 'advanceGuide':
+            case 'previousStep':
+            case 'submitPoll':
+            case 'dismissGuide':
+            case 'confirmation':
+                return {
+                    action: action.action
+                };
+            default:
+                return {};
+        }
+    }
     function transformToGuideActivity(appData) {
         var activeGuideObj = getGuideForEvent(appData);
         if (!activeGuideObj)
@@ -27006,14 +27135,14 @@ var didAccountIdentityChange = function (props) {
 function initIdentityEvents() {
     if (initialized)
         return;
-    Events.identify.on(function (event) {
+    const collectIdentifyEvent = function (event) {
         var props = event.data[0];
         if (wasAnonymousVisitorIdentified(props) || didAccountIdentityChange(props)) {
             collectEvent('identify', props);
             flushLater(); // unconditionally on next tick
         }
-    });
-    Events.metadata.on(function (event) {
+    };
+    const collectMetadataEvent = function (event) {
         // Check to see if this Application is sending metadata to the backend using
         // different mechanism (like Segment webhooks)
         var blockAgentMetadata = isMetadataBlocked();
@@ -27024,9 +27153,17 @@ function initIdentityEvents() {
                 flushLater(); // unconditionally on next tick
             }
         }
-    });
+    };
+    Events.identify.on(collectIdentifyEvent);
+    Events.metadata.on(collectMetadataEvent);
     Events.identify.on(handleIdentifyEvent);
     initialized = true;
+    return function () {
+        Events.identify.off(collectIdentifyEvent);
+        Events.metadata.off(collectMetadataEvent);
+        Events.identify.off(handleIdentifyEvent);
+        initialized = false;
+    };
 }
 
 /*
@@ -27237,7 +27374,7 @@ class ShadowDomManager extends EventTarget {
     }
     initialize() {
         this.unpatchAttachShadow = this.patchAttachShadow(Element);
-        this.findShadowRoots(document);
+        this.findShadowRoots(document, 5000, (shadowRoot) => this.triggerAttachShadow(shadowRoot));
     }
     triggerAttachShadow(shadowRoot) {
         this.cache.add(shadowRoot);
@@ -27246,7 +27383,7 @@ class ShadowDomManager extends EventTarget {
             shadowRoot
         });
     }
-    findShadowRoots(document, maxPerSearch = 5000) {
+    findShadowRoots(document, maxPerSearch = 5000, onShadowRootFound) {
         if (!_.isFunction(document.createNodeIterator))
             return;
         let nodesChecked = 0;
@@ -27262,7 +27399,7 @@ class ShadowDomManager extends EventTarget {
                 while ((currentNode = iterator.nextNode())) {
                     nodesChecked++;
                     if (currentNode && currentNode.shadowRoot) {
-                        this.triggerAttachShadow(currentNode.shadowRoot);
+                        onShadowRootFound(currentNode.shadowRoot);
                         queue.push(currentNode.shadowRoot);
                         this.foundShadowRoots = true;
                     }
@@ -27383,7 +27520,8 @@ function registerEventHandlers({ events = [] }) {
 let initializeCounter = 0;
 const initializeImmediately = 'initializeImmediately';
 /**
- * Initializes the Pendo Agent in a browser window.
+ * Initializes the Pendo agent in a browser window. This function only needs to be called once per page load. Any subsequent calls, without first having called `teardown`, will be ignored.
+ * Once the agent has been initialized, any updates to identity or metadata should be done using `identify` or `updateOptions`.
  *
  * @access public
  * @function
@@ -27529,13 +27667,14 @@ const initialize = makeSafe(function (options) {
         teardownFns.push(forwardInternalEvents(Events));
         registerEventHandlers(options);
         teardownFns.push(initGuides(observer)); // this is safe.  loadGuides actually does the loading.
-        initIdentityEvents(); // setup identify and meta event listeners
+        teardownFns.push(initIdentityEvents()); // setup identify and meta event listeners
         teardownFns.push(wirePage());
         teardownFns.push(initializePlugins());
         teardownFns.push(launchDesignerOrPreview(options));
         Events.appUsage.on(GuideActivity.handler);
         Events.appUsage.on(ResourceCenterActivity.handler);
         teardownFns.push(flushEvery(SEND_INTERVAL));
+        teardownFns.push(PerformanceMonitor$1.initialize());
     }
     Events.appHidden.on(() => {
         flushNow(true, { hidden: true });
@@ -29028,11 +29167,14 @@ var attrActionEnum = {
     href: ['Replace', 'ForceSecure'],
     protocol: ['ForceSecure']
 };
-function UrlAttrTransform(attr, action, data) {
+const TARGETS = ['location', 'attribute', 'both'];
+const DEFAULT_TARGET = 'location';
+function UrlTransform(attr, action, data, target) {
     if (_.isObject(attr)) {
         action = attr.action;
         data = attr.data;
         attr = attr.attr;
+        target = attr.target;
     }
     if (!attrActionEnum[attr]) {
         var validAttrs = _.keys(attrActionEnum).join(', ');
@@ -29042,11 +29184,16 @@ function UrlAttrTransform(attr, action, data) {
         var validActions = attrActionEnum[attr].join(', ');
         throw new Error('Invalid transform action: "' + action + '" for attribute "' + attr + '". Valid actions for "' + attr + '" are: ' + validActions + '. Example: {attr: "' + attr + '", action: "' + attrActionEnum[attr][0] + '", data: ...}');
     }
+    // validate 'target'
+    if (TARGETS.indexOf(target) < 0) {
+        target = DEFAULT_TARGET;
+    }
     this.attr = attr;
     this.action = action;
     this.data = data;
+    this.target = target || DEFAULT_TARGET;
 }
-UrlAttrTransform.prototype.applyToURL = function (url) {
+UrlTransform.prototype.applyTo = function (url) {
     var actionImpls = {
         AllowOnlyKeys(url, attr, data) {
             if (_.isFunction(data)) {
@@ -29119,26 +29266,26 @@ UrlAttrTransform.prototype.applyToURL = function (url) {
     };
     return actionImpls[this.action](url, this.attr, this.data);
 };
-UrlAttrTransform.prototype.toString = function () {
+UrlTransform.prototype.toString = function () {
     return this.attr + ' - ' + this.action + ' - ' + JSON.stringify(this.data);
 };
 // Static method, not on the instance
-UrlAttrTransform.fromJSON = function (obj) {
-    if (obj instanceof UrlAttrTransform) {
+UrlTransform.fromJSON = function (obj) {
+    if (obj instanceof UrlTransform) {
         return obj;
     }
     // Validate input is an object
     if (!_.isObject(obj)) {
-        throw new Error('UrlAttrTransform.fromJSON expects an object. Received: ' + typeof obj + '. Example: {attr: "search", action: "AddTo", data: {key: "value"}}');
+        throw new Error('UrlTransform.fromJSON expects an object. Received: ' + typeof obj + '. Example: {attr: "search", action: "AddTo", data: {key: "value"}}');
     }
     // Validate required properties
     if (!obj.attr) {
         var allValidAttrs = _.keys(attrActionEnum).join(', ');
-        throw new Error('UrlAttrTransform is missing required "attr" property. Valid attributes are: ' + allValidAttrs + '. Example: {attr: "search", action: "AddTo", data: {key: "value"}}');
+        throw new Error('UrlTransform is missing required "attr" property. Valid attributes are: ' + allValidAttrs + '. Example: {attr: "search", action: "AddTo", data: {key: "value"}}');
     }
     if (!obj.action) {
         var attrValidActions = attrActionEnum[obj.attr] ? attrActionEnum[obj.attr].join(', ') : 'AllowOnlyKeys, ExcludeKeys, AddTo, Replace, Clear';
-        throw new Error('UrlAttrTransform is missing required "action" property. Valid actions depend on the attribute. For "' + obj.attr + '" attribute, valid actions are: ' + attrValidActions + '. Example: {attr: "' + obj.attr + '", action: "AddTo", data: {key: "value"}}');
+        throw new Error('UrlTransform is missing required "action" property. Valid actions depend on the attribute. For "' + obj.attr + '" attribute, valid actions are: ' + attrValidActions + '. Example: {attr: "' + obj.attr + '", action: "AddTo", data: {key: "value"}}');
     }
     // Validate attribute and action combination
     if (!attrActionEnum[obj.attr]) {
@@ -29177,7 +29324,7 @@ UrlAttrTransform.fromJSON = function (obj) {
         }
     }
     try {
-        return new UrlAttrTransform(obj.attr, obj.action, obj.data);
+        return new UrlTransform(obj.attr, obj.action, obj.data, obj.target);
     }
     catch (error) {
         // If it's already a detailed error from our validation, re-throw it
@@ -29186,7 +29333,7 @@ UrlAttrTransform.fromJSON = function (obj) {
             throw error;
         }
         // Otherwise, wrap the original error with context
-        throw new Error('Failed to create UrlAttrTransform: ' + error.message + '. Transform object: ' + JSON.stringify(obj));
+        throw new Error('Failed to create UrlTransform: ' + error.message + '. Transform object: ' + JSON.stringify(obj));
     }
 };
 
@@ -29196,13 +29343,13 @@ function isURL(u) {
 var LocationModule = (function (global) {
     var createElectronTranforms = function (appname, resourcesPath, directory, userHome) {
         return [
-            new UrlAttrTransform('pathname', 'Replace', function (path) {
+            new UrlTransform('pathname', 'Replace', function (path) {
                 var newPath = path.replace(resourcesPath, appname);
                 newPath = newPath.replace(directory, appname);
                 newPath = newPath.replace(userHome, '');
                 return newPath;
             }),
-            new UrlAttrTransform('href', 'ForceSecure')
+            new UrlTransform('href', 'ForceSecure')
         ];
     };
     var DEFAULT_SRC_FN = function () {
@@ -29241,17 +29388,23 @@ var LocationModule = (function (global) {
         },
         addTransforms(context, transforms) {
             _.each(transforms, function (f) {
-                context.commit('addTransform', UrlAttrTransform.fromJSON(f));
+                const t = UrlTransform.fromJSON(f);
+                if (t.target === 'location' || t.target === 'both') {
+                    context.commit('addTransform', t);
+                }
+                if (t.target === 'attribute' || t.target === 'both') {
+                    store.dispatch('nodeAttr/addAttrTransform', t);
+                }
             });
         },
         addInternalTransforms(context, transforms) {
             _.each(transforms, function (f) {
-                context.commit('addInternalTransform', UrlAttrTransform.fromJSON(f));
+                context.commit('addInternalTransform', UrlTransform.fromJSON(f));
             });
         },
         removeInternalTransforms(context, transforms) {
             _.each(transforms, function (f) {
-                context.commit('removeInternalTransform', UrlAttrTransform.fromJSON(f));
+                context.commit('removeInternalTransform', UrlTransform.fromJSON(f));
             });
         },
         startPolling(context) {
@@ -29279,6 +29432,7 @@ var LocationModule = (function (global) {
         },
         clearTransforms(state) {
             state.transforms = [];
+            store.commit('nodeAttr/clearURLTransforms');
         },
         clearInternalTransforms(state) {
             state.internalTransforms = [];
@@ -29334,7 +29488,7 @@ var LocationModule = (function (global) {
     };
     var transformUrl = function (transforms, url) {
         return _.reduce(transforms, function (tUrl, f) {
-            return f.applyToURL(tUrl);
+            return f.applyTo(tUrl);
         }, url);
     };
     var urlGetter = function (state) {
@@ -32551,10 +32705,12 @@ var GuideUpdateModule = (function () {
             state.scheduledUpdate = scheduledUpdate;
         },
         startUpdate(state, time) {
+            PerformanceMonitor$1.startTimer('guide-loop');
             state.needsUpdate = false;
             state.updateId = time;
         },
         completeUpdate(state, time) {
+            PerformanceMonitor$1.stopTimer('guide-loop');
             state.updateId = null;
             state.updateCompleteTime = time;
         }
@@ -32663,75 +32819,6 @@ var HealthCheckModule = (function () {
     };
 })();
 
-var MonitoringModule = (function () {
-    var state = {
-        lastFlush: getNow(),
-        flushInterval: 5 * 60 * 1000,
-        counters: {
-            ptmGifFailures: 0,
-            guideGifFailures: 0
-        },
-        timers: {}
-    };
-    var actions = {
-        flush(context) {
-            _.each(context.state.counters, function (value, counterName) {
-                context.commit('resetCounter', counterName);
-            });
-            _.each(context.state.timers, function (value, timerName) {
-                context.commit('resetTimer', timerName);
-            });
-            context.commit('setLastFlush', context.getters.now());
-        }
-    };
-    var mutations = {
-        setLastFlush(state, lastFlush) {
-            state.lastFlush = lastFlush;
-        },
-        incrementCounter(state, counterName) {
-            if (state.counters[counterName] === undefined)
-                return;
-            state.counters[counterName]++;
-        },
-        resetCounter(state, counterName) {
-            if (state.counters[counterName] === undefined)
-                return;
-            state.counters[counterName] = 0;
-        },
-        setTimer(state, { name, time } = {}) {
-            if (!name || time == null)
-                return;
-            state.timers[name] = time;
-        },
-        resetTimer(state, timerName) {
-            delete state.timers[timerName];
-        }
-    };
-    var getters = {
-        shouldFlush(state, getters) {
-            return (getters.now() - state.lastFlush) >= state.flushInterval;
-        },
-        payload(state) {
-            var counters = _.reduce(state.counters, function (obj, value, key) {
-                if (value > 0) {
-                    obj[key] = value;
-                }
-                return obj;
-            }, {});
-            return _.extend({}, counters, state.timers);
-        },
-        now() {
-            return getNow();
-        }
-    };
-    return {
-        state,
-        actions,
-        mutations,
-        getters
-    };
-})();
-
 var MetadataModule = (function () {
     var state = {
         visitor: {},
@@ -32920,7 +33007,6 @@ const DebuggerModule = (() => {
             context.commit('setTabId', EventTracer.getTabId());
             context.commit('setInstallType', getInstallType());
             const isTop = isLeader() && window.top === window; // only a leader frame that is a top window can launch debugger
-            state.isTop !== isTop;
             context.commit('setIsTop', isTop);
             context.commit('isLeader', isLeader());
             if (isTop) {
@@ -32971,6 +33057,8 @@ const DebuggerModule = (() => {
             context.commit('enableEventLogging', enabled);
         },
         eventCaptured: (context, data) => {
+            if (pendo$1.designerEnabled || isInPreviewMode() || isInDesignerPreviewMode())
+                return;
             if (!context.state.isTop) {
                 crossFrameChannel.postMessage({
                     action: 'debugger/receiveEventCaptured',
@@ -33209,6 +33297,68 @@ const DebuggerModule = (() => {
     };
 })();
 
+const NodeAttrModule = (function (global) {
+    const state = {
+        transforms: []
+    };
+    const actions = {
+        addAttrTransform(context, urlTransform) {
+            context.commit('addTransform', urlTransform);
+        }
+    };
+    const mutations = {
+        addTransform(state, transform) {
+            state.transforms.push(transform);
+        },
+        clearURLTransforms(state) {
+            // XXX if ever support non url transforms for attributes then we'll need to check the Transform type
+            // or determine some other way how to purge only URL transforms as Location API provides a way for these to be
+            // cleared via the API.
+            state.transforms = [];
+        }
+    };
+    const applyTransforms = (transforms, url) => {
+        return _.reduce(transforms, function (tUrl, f) {
+            return f.applyTo(tUrl);
+        }, url);
+    };
+    const resolveAttrValueAsURL = (attrValue) => {
+        // let's let the browser do this work for us...
+        const a = document.createElement('a'); // this handles relative urls nicely
+        a.href = attrValue;
+        return new URL(a.href);
+    };
+    const getters = {
+        getAttribute(state) {
+            return function (element, attrName) {
+                let attrValue = element.getAttribute ? element.getAttribute(attrName) : element[attrName];
+                if (_.size(state.transforms) < 1) {
+                    return attrValue;
+                }
+                try {
+                    let url = resolveAttrValueAsURL(attrValue);
+                    url = _.reduce([
+                        _.partial(applyTransforms, state.transforms)
+                    ], (url, fn) => {
+                        return fn(url);
+                    }, url);
+                    return url.href;
+                }
+                catch (e) {
+                    log.critical(e);
+                    return attrValue;
+                }
+            };
+        }
+    };
+    return {
+        state,
+        actions,
+        mutations,
+        getters
+    };
+})();
+
 function registerModules(store) {
     store.registerModule('debugger', DebuggerModule);
     store.registerModule('errorLog', ErrorLogModule);
@@ -33217,9 +33367,9 @@ function registerModules(store) {
     store.registerModule('guideState', GuideStateModule);
     store.registerModule('healthCheck', HealthCheckModule);
     store.registerModule('location', LocationModule);
-    store.registerModule('monitoring', MonitoringModule);
     store.registerModule('metadata', MetadataModule);
     store.registerModule('preview', PreviewModule);
+    store.registerModule('nodeAttr', NodeAttrModule);
 }
 
 const IFrameMonitor = (function () {
@@ -36262,7 +36412,7 @@ const EventProperties = (function () {
             return [];
         }
         return [
-            new UrlAttrTransform('search', 'AddTo', function () { return collectPageEventProperties(); })
+            new UrlTransform('search', 'AddTo', function () { return collectPageEventProperties(); })
         ];
     }
     function createPageEventProperties() {
@@ -47304,6 +47454,7 @@ class SessionRecorder {
         this.sendQueue = new SendQueue(bind(this.transport.send, this.transport));
         this.sendQueue.onTimeout = bind(this.sendFailure, this, 'SEND_TIMEOUT');
         this.isNewSession = false;
+        this.isCheckingVisitorEligibility = false;
         this.addConfigOptions();
         this.config = configReader.get(RECORDING_CONFIG);
         this.onRecordingStart = this.pendo._.isFunction(configReader.get(RECORDING_CONFIG_ON_RECORDING_START))
@@ -47406,19 +47557,32 @@ class SessionRecorder {
             clearTimeout(this._changeIdentityTimer);
             this.visitorId = options.visitor.id;
             this.accountId = options.account.id;
-            return this.fetchVisitorConfig().then(visitorConfig => {
-                if ((!visitorConfig || !visitorConfig.enable) && this.isRecording()) {
-                    this.stop();
-                }
-                else if (visitorConfig && visitorConfig.enable && !this.isRecording()) {
-                    this._startRecordingForVisitor(visitorConfig);
-                }
-            }).catch((e) => {
-                this.api.log.critical('Failed to re-fetch recording config', { error: e });
-                this.logStopReason('VISITOR_CONFIG_ERROR');
-            });
+            return this.checkVisitorEligibility();
         }
     }
+    checkVisitorEligibility(continuationCallback) {
+        if (!this.isRecording() && this.pendo._.isNull(this.visitorId) && this.pendo._.isNull(this.accountId))
+            return;
+        this.isCheckingVisitorEligibility = true;
+        return this.fetchVisitorConfig().then(visitorConfig => {
+            if ((!visitorConfig || !visitorConfig.enable) && this.isRecording()) {
+                this.stop();
+            }
+            if (visitorConfig && visitorConfig.enable && this.isRecording()) {
+                if (continuationCallback) {
+                    continuationCallback.call(this);
+                }
+            }
+            if (visitorConfig && visitorConfig.enable && !this.isRecording()) {
+                this._startRecordingForVisitor(visitorConfig);
+            }
+        }).catch((e) => {
+            this.api.log.critical('Failed to re-fetch recording config', { error: e });
+            this.logStopReason('VISITOR_CONFIG_ERROR');
+        }).finally(() => {
+            this.isCheckingVisitorEligibility = false;
+        });
+    }
     snapshot() {
         if (!this.isRecording())
             return;
@@ -47680,13 +47844,24 @@ class SessionRecorder {
         if ((!prevLastEmitTime && isMeta)) {
             skipUserInteractionCheck = true;
         }
-        this.storeLastUserInteractionEventInformation(event, this.visitorId, this.accountId, skipUserInteractionCheck);
+        // Ensures events emitted while the visitor eligibility check is in flight are compared against events emitted
+        // before the visitor eligibility check occurred. This means these events which fall outside of the inactivity
+        // duration will not be placed in the buffer and captured. This is ok since they occurred outside of the
+        // inactivity period and before the next snapshot.
+        if (!this.isCheckingVisitorEligibility) {
+            this.storeLastUserInteractionEventInformation(event, this.visitorId, this.accountId, skipUserInteractionCheck);
+        }
         const inactivityDuration = this.pendo._.get(this.visitorConfig, 'inactivityDuration', THIRTY_MINUTES);
         if (prevLastEmitTime && event.timestamp - prevLastEmitTime > inactivityDuration && !isSnapshot && !isMeta) {
-            this.send();
-            this.clearSessionInfo();
-            this.snapshot();
-            return; // ignore this current event, since we're about to get a fresh snapshot
+            if (!this.isCheckingVisitorEligibility) {
+                const continuationCallback = function () {
+                    this.send();
+                    this.clearSessionInfo();
+                    this.snapshot();
+                };
+                this.checkVisitorEligibility(continuationCallback);
+            }
+            return;
         }
         /*
         * META events and Snapshots are special and need to be packaged together. This is made possible by
@@ -47721,8 +47896,16 @@ class SessionRecorder {
             const exceedsEventFreq = this.eventsSinceLastKeyFrame >= this.pendo._.get(this.visitorConfig, 'keyframeEventFrequency', 4548); // Defaults determined by BE originally, shouldn't really ever be used
             const exceedsRecordingSizeLimit = this.currentRecordingSize >= this.pendo._.get(this.visitorConfig, 'recordingSizeLimit', ONE_HUNDRED_MB_IN_BYTES);
             if (exceeds24Hours || (exceedsTimeFreq && exceedsEventFreq) || exceedsRecordingSizeLimit) {
-                this.currentRecordingSize = 0;
-                this.snapshot();
+                const continuationCallback = function () {
+                    this.currentRecordingSize = 0;
+                    this.snapshot();
+                };
+                if (exceeds24Hours && !this.isCheckingVisitorEligibility) {
+                    this.checkVisitorEligibility(continuationCallback);
+                }
+                else {
+                    continuationCallback.call(this);
+                }
             }
         }
     }
@@ -48961,17 +49144,14 @@ class ConsoleCaptureBuffer {
     constructor(pendo, pluginAPI) {
         this.pendo = pendo;
         this.pluginAPI = pluginAPI;
-        this.infoEvents = [];
-        this.warnEvents = [];
-        this.errorEvents = [];
+        this.events = [];
         this.lastEvent = null;
-        this.devLogEvent = null;
         this.tokens = TOKEN_MAX_SIZE;
         this.lastRefillTime = this.pluginAPI.util.getNow();
         this.nextRefillTime = this.lastRefillTime + TOKEN_REFRESH_INTERVAL;
     }
     isEmpty() {
-        return this.infoEvents.length === 0 && this.warnEvents.length === 0 && this.errorEvents.length === 0;
+        return this.events.length === 0;
     }
     refillTokens() {
         const now = this.pluginAPI.util.getNow();
@@ -48985,10 +49165,8 @@ class ConsoleCaptureBuffer {
         }
     }
     clear() {
+        this.events = [];
         this.lastEvent = null;
-        this.infoEvents.length = 0;
-        this.warnEvents.length = 0;
-        this.errorEvents.length = 0;
     }
     push(event) {
         const { devLogLevel } = event;
@@ -48998,50 +49176,16 @@ class ConsoleCaptureBuffer {
         if (this.tokens === 0)
             return false;
         this.lastEvent = event;
-        this.processEvent(event);
+        this.events.push(event);
         this.tokens = Math.max(this.tokens - 1, 0);
         return true;
     }
-    processEvent(event) {
-        switch (event.devLogLevel) {
-            case 'info':
-                this.infoEvents.push(event);
-                break;
-            case 'warn':
-                this.warnEvents.push(event);
-                break;
-            case 'error':
-                this.errorEvents.push(event);
-                break;
-        }
-    }
-    createDevLogEventWithPayload({ events, level }) {
-        if (events.length === 0)
-            return;
-        const totalCount = this.pendo._.reduce(events, (sum, event) => sum + (event.devLogCount || 1), 0);
-        return Object.assign(Object.assign({}, this.devLogEvent), { devLogLevel: level, devLogCount: totalCount, devLogPayload: this.pendo.compress(events) });
-    }
-    generateJZB() {
-        const payload = [];
-        this.pendo._.each(DEV_LOG_LEVELS, level => {
-            const events = this[`${level}Events`];
-            if (events.length === 0)
-                return;
-            const devLogEventWithPayload = this.createDevLogEventWithPayload({
-                events,
-                level
-            });
-            payload.push(devLogEventWithPayload);
-        });
-        this.devLogEvent = null;
-        return this.pendo.compress(payload);
-    }
-    pack(url) {
+    pack() {
         if (this.isEmpty())
-            return [];
-        const jzb = this.generateJZB();
+            return;
+        const jzb = this.pendo.compress(this.events);
         this.clear();
-        return [{ url, jzb }];
+        return jzb;
     }
 }
 
@@ -55825,12 +55969,11 @@ function ConsoleCapture() {
         initialize,
         teardown,
         addIntercepts,
-        createDevLog,
+        createConsoleEvent,
         captureStackTrace,
         send,
         onAppHidden,
         onAppUnloaded,
-        onEventCaptured,
         onPtmPaused,
         onPtmUnpaused,
         get buffer() {
@@ -55864,7 +56007,6 @@ function ConsoleCapture() {
         pluginAPI.Events.ready.on(addIntercepts);
         pluginAPI.Events.appUnloaded.on(onAppUnloaded);
         pluginAPI.Events.appHidden.on(onAppHidden);
-        pluginAPI.Events.eventCaptured.on(onEventCaptured);
         pluginAPI.Events['ptm:paused'].on(onPtmPaused);
         pluginAPI.Events['ptm:unpaused'].on(onPtmUnpaused);
         pluginAPI.log.info('Console logs are being captured');
@@ -55875,36 +56017,19 @@ function ConsoleCapture() {
     function onAppUnloaded() {
         send({ unload: true });
     }
-    /**
-     * Handles eventCaptured events to monitor recordingId changes and/or link devLog events with recordingId
-     *
-     * @param {object} event - eventCaptured event
-     */
-    function onEventCaptured(event) {
-        if (!event || !event.data || !event.data.length || !buffer.devLogEvent)
-            return;
-        const capturedEvent = event.data[0];
-        const { type, recordingId, recordingSessionId } = capturedEvent;
-        if (type === DEV_LOG_TYPE || type === 'identify' || !recordingId || !recordingSessionId)
-            return;
-        const { recordingId: devLogRecordingId } = buffer.devLogEvent;
-        // if recordingId has changed, send current buffer immediately to separate recording sessions
-        if (devLogRecordingId && recordingId !== devLogRecordingId) {
-            send();
-            return;
-        }
-    }
     function onPtmPaused() {
         isPtmPaused = true;
     }
     function onPtmUnpaused() {
         isPtmPaused = false;
-        if (!buffer.devLogEvent) {
-            buffer.devLogEvent = createDevLogEvent();
+        if (!buffer.isEmpty()) {
+            for (const event of buffer.events) {
+                pluginAPI.Events.eventCaptured.trigger(event);
+            }
+            send();
         }
-        pluginAPI.Events.eventCaptured.trigger(buffer.devLogEvent);
     }
-    function createDevLogEvent() {
+    function createDevLogEnvelope() {
         return {
             visitorId: globalPendo.get_visitor_id(),
             accountId: globalPendo.get_account_id(),
@@ -55923,14 +56048,14 @@ function ConsoleCapture() {
                 // slice 1 to omit originalFn
                 const args = _.toArray(arguments).slice(1);
                 originalFn.apply(console, args);
-                createDevLog(args, methodName);
+                createConsoleEvent(args, methodName);
             });
             console[methodName]._pendoUnwrap = function () {
                 console[methodName] = originalMethod;
             };
         });
     }
-    function createDevLog(args, methodName) {
+    function createConsoleEvent(args, methodName) {
         if (!args || args.length === 0)
             return;
         // stringify args
@@ -55958,22 +56083,16 @@ function ConsoleCapture() {
             buffer.lastEvent.devLogCount++;
             return;
         }
-        const devLog = {
-            devLogLevel: methodName === 'log' ? 'info' : methodName,
-            devLogMsg: scrubPII(message),
-            devLogTrace: stackTrace,
-            devLogTimestamp: pluginAPI.util.getNow(),
-            devLogCount: 1
-        };
-        const wasAccepted = buffer.push(devLog);
+        const devLogEnvelope = createDevLogEnvelope();
+        const consoleEvent = Object.assign(Object.assign({}, devLogEnvelope), { devLogLevel: methodName === 'log' ? 'info' : methodName, devLogMessage: scrubPII(message), devLogTrace: stackTrace, devLogCount: 1 });
+        const wasAccepted = buffer.push(consoleEvent);
         if (wasAccepted) {
-            if (buffer.devLogEvent === null && !isPtmPaused) {
-                buffer.devLogEvent = createDevLogEvent();
-                pluginAPI.Events.eventCaptured.trigger(buffer.devLogEvent);
+            if (!isPtmPaused) {
+                pluginAPI.Events.eventCaptured.trigger(consoleEvent);
             }
             updateLastLog(logKey);
         }
-        return devLog;
+        return consoleEvent;
     }
     function captureStackTrace(maxStackFrames) {
         try {
@@ -55993,19 +56112,23 @@ function ConsoleCapture() {
     function send({ unload = false, hidden = false } = {}) {
         if (!buffer || buffer.isEmpty())
             return;
+        if (!globalPendo.isSendingEvents()) {
+            buffer.clear();
+            return;
+        }
         const queryParams = {
             v: globalPendo.VERSION,
             ct: pluginAPI.util.getNow()
         };
         const url = pluginAPI.transmit.buildBaseDataUrl('devlog', globalPendo.apiKey, queryParams);
-        const payloads = buffer.pack(url);
-        if (!payloads || payloads.length === 0)
+        const jzb = buffer.pack();
+        if (!jzb)
             return;
         if (unload || hidden) {
-            sendQueue.drain(payloads, unload);
+            sendQueue.drain([{ url, jzb }], unload);
         }
         else {
-            sendQueue.push(...payloads);
+            sendQueue.push({ url, jzb });
         }
     }
     function teardown() {
@@ -56021,7 +56144,6 @@ function ConsoleCapture() {
         }
         pluginAPI.Events.appHidden.off(onAppHidden);
         pluginAPI.Events.appUnloaded.off(onAppUnloaded);
-        pluginAPI.Events.eventCaptured.off(onEventCaptured);
         pluginAPI.Events['ptm:paused'].off(onPtmPaused);
         pluginAPI.Events['ptm:unpaused'].off(onPtmUnpaused);
         _.each(CONSOLE_METHODS, function (methodName) {