@pendo/agent 2.290.2 → 2.291.1

package/dist/pendo.module.js

@@ -2992,7 +2992,8 @@ var ConfigReader = (function () {
         /**
          * Use this setting when using `preferMutationObserver` with an application that has Shadow DOM elements.
          * On page load, the Agent will run a full document scan for shadow roots and attach a MutationObserver to
-         * all results.
+         * all results. This setting also allows the agent to run CSS selectors in all shadow roots, so CSS selectors
+         * can be written without specifying the full path through all shadow roots with the `::shadow` pseudo-class.
          *
          * @access public
          * @category Config/Core
@@ -3903,8 +3904,8 @@ var SERVER = '';
 var ASSET_HOST = '';
 var ASSET_PATH = '';
 var DESIGNER_SERVER = '';
-var VERSION = '2.290.2_';
-var PACKAGE_VERSION = '2.290.2';
+var VERSION = '2.291.1_';
+var PACKAGE_VERSION = '2.291.1';
 var LOADER = 'xhr';
 /* eslint-enable agent-eslint-rules/no-gulp-env-references */
 /**
@@ -6131,6 +6132,16 @@ function isElementShadowRoot(elem, _win) {
 function getParent(elem, _win) {
     return isElementShadowRoot(elem, _win) ? elem.host : elem.parentNode;
 }
+function contains(context, elem, _win) {
+    let parent = elem;
+    while (parent) {
+        if (parent === context) {
+            return true;
+        }
+        parent = getParent(parent, _win);
+    }
+    return false;
+}
 
 var shadowAPI = (function () {
     function isShadowSelector(selector) {
@@ -6163,10 +6174,19 @@ var shadowAPI = (function () {
         isElementShadowRoot: isElementShadowRoot,
         getParent: getParent,
         isShadowSelector,
-        wrapSizzle(Sizzle) {
+        wrapSizzle(Sizzle, shadowDomManager) {
             Sizzle.intercept(function (Sizzle, selection, context, results, seed) {
                 if (!isShadowSelector(selection)) {
-                    return Sizzle(selection, context, results, seed);
+                    const queryResults = Sizzle(selection, context, results, seed);
+                    if (shadowDomManager.cache.size > 0) {
+                        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
+                        shadowDomManager.cache.forEach(shadowRoot => {
+                            if (!context || context === document || contains(context, shadowRoot)) {
+                                queryResults.push(...Sizzle(selection, shadowRoot, results, seed));
+                            }
+                        });
+                    }
+                    return queryResults;
                 }
                 if (!_.isFunction(document.documentElement.attachShadow)) {
                     return Sizzle(selection.replace(shadowAPI.PSEUDO_REGEX, ''), context, results, seed);
@@ -10041,15 +10061,15 @@ var setStyles = function (element, style) {
         }
     });
 };
-var getScreenDimensions = function () {
+var getScreenDimensions = function (win = window) {
     if (isBrowserInQuirksmode()) {
         return {
-            width: document.documentElement.offsetWidth || 0,
-            height: document.documentElement.offsetHeight || 0
+            width: win.document.documentElement.offsetWidth || 0,
+            height: win.document.documentElement.offsetHeight || 0
         };
     }
-    var w = window.innerWidth || document.documentElement.clientWidth;
-    var h = window.innerHeight || document.documentElement.clientHeight;
+    var w = win.innerWidth || win.document.documentElement.clientWidth;
+    var h = win.innerHeight || win.document.documentElement.clientHeight;
     return { width: w, height: h };
 };
 var _isInViewport = function (elemPos) {
@@ -10185,32 +10205,34 @@ function getSiblings(node) {
  * @param  {HTMLElement}  element
  * @returns {boolean}
  */
-function isInDocument(element) {
-    if (SizzleProxy.contains(document, element))
+function isInDocument(element, doc = document) {
+    if (SizzleProxy.contains(doc, element))
         return true;
     while (element && element.parentNode || shadowAPI.isElementShadowRoot(element)) {
         element = shadowAPI.getParent(element);
     }
-    return element === document;
+    return element === doc;
 }
 var getClientRect = function (element) {
-    var pbody = getBody();
-    if (element === null) {
+    if (element == null) {
         return;
     }
-    else if ((element === document || element === window)) {
+    var doc = element.ownerDocument || document;
+    var win = doc.defaultView || window;
+    var pbody = getBody(doc);
+    if ((element === doc || element === win)) {
         var viewport = {
-            left: window.pageXOffset || pbody.scrollLeft,
-            top: window.pageYOffset || pbody.scrollTop,
-            width: window.innerWidth,
-            height: window.innerHeight
+            left: win.pageXOffset || pbody.scrollLeft,
+            top: win.pageYOffset || pbody.scrollTop,
+            width: win.innerWidth,
+            height: win.innerHeight
         };
         viewport.right = viewport.left + viewport.width;
         viewport.bottom = viewport.top + viewport.height;
         return viewport;
     }
     else {
-        var clientRect = getOffsetPosition(element);
+        var clientRect = getOffsetPosition(element, win);
         clientRect.right = clientRect.left + clientRect.width;
         clientRect.bottom = clientRect.top + clientRect.height;
         return clientRect;
@@ -11015,7 +11037,7 @@ DomQuery.$ = {
         if (target && target.parentNode) {
             target.parentNode.insertBefore(this[0], target);
             // Execute scripts (if any) when the fragment enters the document
-            if (isInDocument(document)) {
+            if (isInDocument(document, this)) {
                 _.each(SizzleProxy('script', this[0]), evalScript);
             }
         }
@@ -13763,7 +13785,7 @@ function treatAsMobileDevice() {
     }
     return sniffer.isMobileUserAgent();
 }
-function getGuideAttachPoint() {
+function getGuideAttachPoint(doc = document) {
     var attachPoint = getGuideAttachPoint.attachPoint;
     if (attachPoint == null) {
         var attachPointSelector = ConfigReader.get('guides.attachPoint');
@@ -13786,7 +13808,7 @@ function getGuideAttachPoint() {
         }
         getGuideAttachPoint.attachPoint = attachPoint;
     }
-    return attachPoint || getBody();
+    return attachPoint || getBody(doc);
 }
 var findBadgeForStep = function (step) {
     var badge = badgesShown[step.guideId];
@@ -13809,7 +13831,7 @@ var findBadgeForStep = function (step) {
  * where do we render?  find destination for that.
  */
 // this is used for rendering
-var getElementForGuideStep = function (step) {
+var getElementForGuideStep = function (step, doc) {
     if (!step) {
         log.info('Can\'t get element for null step');
         return null;
@@ -13820,20 +13842,20 @@ var getElementForGuideStep = function (step) {
     if (!step.overrideElement && canSetOverrideElement) {
         step.overrideElement = findBadgeForStep(step);
     }
-    step.targetElement = getElementForTargeting(step);
+    step.targetElement = getElementForTargeting(step, doc);
     if (step.overrideElement) {
         return step.overrideElement;
     }
     return step.targetElement;
 };
-var getElementForTargeting = function (step) {
+var getElementForTargeting = function (step, doc) {
     var selector = step.elementPathRule || null;
     var results;
     if (selector) {
-        results = SizzleProxy(selector);
+        results = SizzleProxy(selector, doc);
     }
     else {
-        results = [getBody()];
+        results = [getBody(doc)];
     }
     if (results.length === 0) {
         return null;
@@ -16027,7 +16049,7 @@ var BuildingBlockTooltips = (function () {
         const guideContainer = providedGuideContainer || getGuideContainer(step);
         if (!guideContainer)
             return;
-        const element = step.element || getElementForGuideStep(step);
+        const element = step.element || getElementForGuideStep(step, guideContainer.ownerDocument || document);
         if (!element)
             return;
         const width = guideContainer.style.width;
@@ -16052,9 +16074,11 @@ var BuildingBlockTooltips = (function () {
         return treatAsMobileDevice() ? MOBILE_TOOLTIP_CSS_NAME : TOOLTIP_CSS_NAME;
     }
     function getTooltipPositioningContext(step, element, json, guideContainer) {
-        var elementPos = getOffsetPosition(element);
+        var targetDocument = element.ownerDocument || document;
+        var targetWindow = targetDocument.defaultView || window;
+        var elementPos = getOffsetPosition(element, targetWindow);
         var screenPos = getScreenPosition(element);
-        var screenDimensions = getScreenDimensions();
+        var screenDimensions = getScreenDimensions(targetWindow);
         var layoutDir = step.attributes.layoutDir || 'auto';
         // RETURN IF THE FOUND ELEMENT IS NOT VISIBLE ON THE SCREEN.
         if (elementPos.height === 0 && elementPos.width === 0) {
@@ -16102,7 +16126,7 @@ var BuildingBlockTooltips = (function () {
         var tooltipDiv = step.guideElement;
         tooltipDiv.addClass(buildTooltipCSSName());
         attachBBAdvanceActions(step);
-        var tooltipDimensions = getBBTooltipDimensions(elementPos, { height: tooltipSizes.height, width: tooltipSizes.width }, caretDimensions, step.attributes.layoutDir, screenPos);
+        var tooltipDimensions = getBBTooltipDimensions(elementPos, { height: tooltipSizes.height, width: tooltipSizes.width }, caretDimensions, step.attributes.layoutDir, screenPos, tooltipContext.screenDimensions);
         if (step) {
             step.dim = tooltipDimensions;
         }
@@ -16181,8 +16205,7 @@ var BuildingBlockTooltips = (function () {
             }
         }
     }
-    function getBBTooltipDimensions(elementPos, tooltipSizes, caretSizes, layoutDir, screenPos) {
-        var screenDimensions = getScreenDimensions();
+    function getBBTooltipDimensions(elementPos, tooltipSizes, caretSizes, layoutDir, screenPos, screenDimensions) {
         var layoutDirection = layoutDir || 'auto';
         var tooltipDimensions = {
             width: Math.min(tooltipSizes.width, screenDimensions.width),
@@ -16312,23 +16335,23 @@ var BuildingBlockTooltips = (function () {
         else if (layoutDirection === 'top') {
             tooltipPosition.top = elementPosition.top - height;
         }
-        const boundaries = getBoundaries();
+        const boundaries = getBoundaries(screenDimensions);
         if (horizontalBias === 'right') {
             tooltipPosition.left = calculateRightBiasPosition(elementPosition, tooltipDimensions, caretSizes, screenDimensions, boundaries.right, boundaries.left);
         }
         else if (horizontalBias === 'left') {
-            tooltipPosition.left = calculateLeftBiasPosition(elementPosition, tooltipDimensions, caretSizes, boundaries.right, boundaries.left);
+            tooltipPosition.left = calculateLeftBiasPosition(elementPosition, tooltipDimensions, caretSizes, screenDimensions, boundaries.right, boundaries.left);
         }
         else {
             // ASSUME CENTER
-            tooltipPosition.left = calculateCenterBiasPosition(elementPosition, tooltipDimensions, boundaries.right, boundaries.left);
+            tooltipPosition.left = calculateCenterBiasPosition(elementPosition, tooltipDimensions, screenDimensions, boundaries.right, boundaries.left);
         }
         return tooltipPosition;
     }
-    function getBoundaries() {
+    function getBoundaries(screenDimensions) {
         return {
-            right: window.innerWidth * TOOLTIP_CONSTANTS.BOUNDARY_MARGIN_RIGHT,
-            left: window.innerWidth * TOOLTIP_CONSTANTS.BOUNDARY_MARGIN_LEFT
+            right: screenDimensions.width * TOOLTIP_CONSTANTS.BOUNDARY_MARGIN_RIGHT,
+            left: screenDimensions.width * TOOLTIP_CONSTANTS.BOUNDARY_MARGIN_LEFT
         };
     }
     function calculateCaretPadding(caretSizes) {
@@ -16349,7 +16372,7 @@ var BuildingBlockTooltips = (function () {
         if (tooltipRight > rightBoundary) {
             const overflow = tooltipRight - rightBoundary;
             if (leftVal - overflow < leftBoundary) {
-                return spaceEvenly(leftVal, width);
+                return spaceEvenly(leftVal, width, screenDimensions);
             }
             else {
                 return leftVal - overflow;
@@ -16357,7 +16380,7 @@ var BuildingBlockTooltips = (function () {
         }
         return leftVal;
     }
-    function calculateLeftBiasPosition(elementPosition, tooltipDimensions, caretSizes, rightBoundary, leftBoundary) {
+    function calculateLeftBiasPosition(elementPosition, tooltipDimensions, caretSizes, screenDimensions, rightBoundary, leftBoundary) {
         const caretPadding = calculateCaretPadding(caretSizes);
         const width = tooltipDimensions.width;
         var leftVal = elementPosition.left - width + (elementPosition.width / 2) + caretPadding;
@@ -16365,7 +16388,7 @@ var BuildingBlockTooltips = (function () {
             const overflow = leftBoundary - leftVal;
             const tooltipRight = leftVal + width;
             if (tooltipRight + overflow > rightBoundary) {
-                return spaceEvenly(leftVal, width);
+                return spaceEvenly(leftVal, width, screenDimensions);
             }
             else {
                 return leftVal + overflow;
@@ -16373,7 +16396,7 @@ var BuildingBlockTooltips = (function () {
         }
         return leftVal;
     }
-    function calculateCenterBiasPosition(elementPosition, tooltipDimensions, rightBoundary, leftBoundary) {
+    function calculateCenterBiasPosition(elementPosition, tooltipDimensions, screenDimensions, rightBoundary, leftBoundary) {
         const width = tooltipDimensions.width;
         var leftVal = elementPosition.left + (elementPosition.width / 2) - (width / 2);
         let tooltipRight = leftVal + width;
@@ -16381,7 +16404,7 @@ var BuildingBlockTooltips = (function () {
             const overflow = tooltipRight - rightBoundary;
             leftVal -= overflow;
             if (leftVal < leftBoundary) {
-                return spaceEvenly(leftVal, width);
+                return spaceEvenly(leftVal, width, screenDimensions);
             }
         }
         else if (leftVal < leftBoundary) {
@@ -16389,14 +16412,14 @@ var BuildingBlockTooltips = (function () {
             leftVal += overflow;
             let tooltipRight = leftVal + width;
             if (tooltipRight > rightBoundary) {
-                return spaceEvenly(leftVal, width);
+                return spaceEvenly(leftVal, width, screenDimensions);
             }
         }
         return leftVal;
     }
-    function spaceEvenly(leftVal, width) {
+    function spaceEvenly(leftVal, width, screenDimensions) {
         const availableLeftSpace = leftVal;
-        const availableRightSpace = window.innerWidth - (leftVal + width);
+        const availableRightSpace = screenDimensions.width - (leftVal + width);
         if (availableLeftSpace > availableRightSpace) {
             return leftVal - (availableLeftSpace - availableRightSpace) / 2;
         }
@@ -16619,8 +16642,10 @@ var BuildingBlockTooltips = (function () {
         var guideContainer = providedGuideContainer || getGuideContainer(step);
         if (!guideContainer)
             return;
-        var element = step.element || getElementForGuideStep(step);
-        var elPos = getOffsetPosition(element);
+        var targetDocument = guideContainer.ownerDocument || document;
+        var targetWindow = targetDocument.defaultView || window;
+        var element = step.element || getElementForGuideStep(step, targetDocument);
+        var elPos = getOffsetPosition(element, targetWindow);
         // If display:none then don't re-position
         if (getComputedStyle_safe(step.elements[0]).display === 'none')
             return;
@@ -16642,7 +16667,7 @@ var BuildingBlockTooltips = (function () {
             borderColor: ttContainerStyles.borderColor,
             borderWidth: parseInt(ttContainerStyles.borderWidth, 10) || 0
         };
-        var tooltipDimensions = this.getBBTooltipDimensions(elPos, tooltipSizes, caretStyles, layoutDir, screenPos);
+        var tooltipDimensions = this.getBBTooltipDimensions(elPos, tooltipSizes, caretStyles, layoutDir, screenPos, getScreenDimensions(targetWindow));
         if (caretStyles.height && caretStyles.width) {
             var caretDiv = ttdiv.find('.pendo-tooltip-caret')[0];
             var borderCaret = ttdiv.find('.pendo-tooltip-caret-border')[0];
@@ -20009,6 +20034,9 @@ var GuideStateModule = (function () {
             }
             context.commit('setLastGuideStepSeen', lastGuideStepSeen);
             pendo$1.lastGuideStepSeen = lastGuideStepSeen;
+            if (guideCache) {
+                guideCache.update(lastGuideStepSeen);
+            }
         },
         updateThrottlingState(context, state) {
             context.commit('setThrottlingState', state);
@@ -21343,6 +21371,16 @@ Badge.behaviors = [
     ShowOnHover
 ];
 function InlinePosition() {
+    function getShadowDomAdjustedTarget(target) {
+        try {
+            if (target.shadowRoot && !target.shadowRoot.querySelector('slot')) {
+                return target.shadowRoot;
+            }
+        }
+        catch (e) {
+        }
+        return target;
+    }
     if (this.position === 'inline' || this.position === 'inline-right' || this.position === 'inline-left') {
         this.before('show', function () {
             var targetElem = this.target();
@@ -21355,18 +21393,19 @@ function InlinePosition() {
             }
             if (targetElem && targetElem.tagName) {
                 var tagName = targetElem.tagName.toLowerCase();
+                var shadowDomAdjustedTarget = getShadowDomAdjustedTarget(targetElem);
                 if (/br|input|img|select|textarea/.test(tagName)) {
                     if (badgeElem.parentNode === targetElem.parentNode)
                         return;
                     // Insert after if targetElem cannot have children
                     targetElem.parentNode.insertBefore(badgeElem, targetElem.nextSibling);
                 }
-                else if (badgeElem.parentNode !== targetElem) {
+                else if (badgeElem.parentNode !== shadowDomAdjustedTarget) {
                     if (this.position === 'inline' || this.position === 'inline-right') {
-                        targetElem.appendChild(badgeElem);
+                        shadowDomAdjustedTarget.appendChild(badgeElem);
                     }
                     else if (this.position === 'inline-left') {
-                        targetElem.prepend(badgeElem);
+                        shadowDomAdjustedTarget.prepend(badgeElem);
                     }
                 }
             }
@@ -23210,7 +23249,7 @@ var BuildingBlockWatermark = (function () {
     }
     function buildWatermark(options, buildNodeFromJSON) {
         options = options || {};
-        if (!options.isTraining)
+        if (!options.isTraining || options.isEmbedded)
             return;
         var watermarkGuide = options.targetAccount ? findWatermarkByTargetAccount(options.targetAccount) : findWatermarkByAppId(options.appId);
         if (!watermarkGuide || !watermarkGuide.steps)
@@ -23783,6 +23822,149 @@ function testGuideGifEndpoint(loader, apiKey) {
     });
 }
 
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+class GuideCache {
+    constructor(apiKey, ConfigReader) {
+        this.apiKey = apiKey;
+        this.cacheGuides = ConfigReader.get('cacheGuides');
+        this.cacheGuidesTimeout = ConfigReader.get('cacheGuidesTimeout');
+        this.cacheGuidesPersistent = ConfigReader.get('cacheGuidesPersistent');
+        this.cache = null;
+        this.db = null;
+    }
+    openDB(apiKey, indexedDB = window.indexedDB) {
+        if (!this.cacheGuidesPersistent)
+            return q.resolve();
+        if (this.db)
+            return q.resolve(this.db);
+        const deferred = q.defer();
+        const request = indexedDB.open(`pendo-${apiKey}`, 1);
+        request.onerror = () => {
+            log.warn('Error opening guide database');
+            this.cacheGuidesPersistent = false;
+            deferred.resolve();
+        };
+        request.onsuccess = (event) => {
+            const db = event.target.result;
+            this.db = db;
+            deferred.resolve(db);
+        };
+        request.onupgradeneeded = (event) => {
+            const db = event.target.result;
+            const objectStore = db.createObjectStore('guides', { keyPath: 'guide.id' });
+            objectStore.transaction.oncomplete = () => {
+                this.db = db;
+                deferred.resolve(db);
+            };
+        };
+        return deferred.promise;
+    }
+    load(now = getNow()) {
+        if (this.cache)
+            return q.resolve(this.cache);
+        this.cache = {};
+        if (!this.db)
+            return q.resolve(this.cache);
+        const deferred = q.defer();
+        const objectStore = this.db.transaction(['guides'], 'readwrite').objectStore('guides');
+        const request = objectStore.getAll();
+        request.onerror = () => {
+            log.warn('Error loading guide cache');
+            this.cacheGuidesPersistent = false;
+            this.db = null;
+            deferred.resolve(this.cache);
+        };
+        request.onsuccess = (event) => {
+            const cachedGuides = event.target.result;
+            _.each(cachedGuides, (cachedGuide) => {
+                if (cachedGuide.expires > now) {
+                    this.cache[cachedGuide.guide.id] = cachedGuide;
+                }
+                else {
+                    objectStore.delete(cachedGuide.guide.id);
+                }
+            });
+            deferred.resolve(this.cache);
+        };
+        return deferred.promise;
+    }
+    add(guide, visitorId, now = getNow()) {
+        if (!this.cacheGuides)
+            return;
+        if (!this.cache)
+            return;
+        const cachedGuide = {
+            expires: now + this.cacheGuidesTimeout,
+            visitorId,
+            guide: deepClone(guide)
+        };
+        this.cache[guide.id] = cachedGuide;
+        return this.save(cachedGuide);
+    }
+    save(cachedGuide) {
+        if (!this.db)
+            return;
+        const objectStore = this.db.transaction(['guides'], 'readwrite').objectStore('guides');
+        const deferred = q.defer();
+        const update = objectStore.put(cachedGuide);
+        update.onerror = () => {
+            log.warn(`Error saving guide to cache ${cachedGuide.guide.id}`);
+            deferred.resolve();
+        };
+        update.onsuccess = () => {
+            deferred.resolve();
+        };
+        return deferred.promise;
+    }
+    update(lastGuideStepSeen) {
+        if (!this.cache)
+            return;
+        const cachedGuide = this.cache[lastGuideStepSeen.guideId];
+        if (!cachedGuide)
+            return;
+        const cachedStep = _.find(cachedGuide.guide.steps, (s) => s.id === lastGuideStepSeen.guideStepId);
+        if (!cachedStep)
+            return;
+        cachedStep.seenState = lastGuideStepSeen.state;
+        cachedStep.seenReason = lastGuideStepSeen.seenReason;
+        cachedStep.dismissCount = lastGuideStepSeen.dismissCount;
+        cachedStep.snoozeEndTime = lastGuideStepSeen.snoozeEndTime;
+        return this.save(cachedGuide);
+    }
+    list(visitorId, now = getNow()) {
+        if (!this.cacheGuides)
+            return q.resolve([]);
+        return this.openDB(this.apiKey).then(() => {
+            return this.load(now);
+        }).then(() => {
+            const list = [];
+            _.each(this.cache, (cachedGuide) => {
+                if (cachedGuide.expires > now && cachedGuide.visitorId === visitorId) {
+                    list.push(_.pick(cachedGuide.guide, 'id', 'lastUpdatedAt', 'language'));
+                }
+                else {
+                    delete this.cache[cachedGuide.guide.id];
+                }
+            });
+            return list;
+        });
+    }
+    get(guideId) {
+        if (this.cache && this.cache[guideId]) {
+            return deepClone(this.cache[guideId].guide);
+        }
+    }
+    clear() {
+        this.cache = {};
+        if (this.db) {
+            const objectStore = this.db.transaction(['guides'], 'readwrite').objectStore('guides');
+            objectStore.clear();
+        }
+    }
+}
+
 const pendoLocalStorage$1 = agentStorage.getLocal();
 var guideEvtCache = [];
 var controlGuideLogMessage = 'Guide was not shown because this visitor is in a control group of an active experiment for the guide';
@@ -25024,14 +25206,6 @@ function handleDoNotProcess() {
     store.commit('debugger/doNotProcess', true);
     log.info('not tracking visitor due to 451 response');
 }
-function resetCachedGuide(guide) {
-    _.each(guide.steps, function (step) {
-        if (_.get(step, 'attributes.stayHidden')) {
-            delete step.attributes.stayHidden;
-        }
-    });
-    return guide;
-}
 function guidesPayload(guidesJson) {
     if (!mostRecentGuideRequest)
         return;
@@ -25041,13 +25215,13 @@ function guidesPayload(guidesJson) {
     }
     if (_.isString(guidesJson.id) && guidesJson.id !== mostRecentGuideRequest.id)
         return;
-    const cachedGuides = _.indexBy(pendo$1.guides, 'id');
     _.extend(pendo$1, guidesJson);
     pendo$1.guides = _.map(pendo$1.guides, function (guide) {
         if (_.keys(guide).length == 1 && guide.id) {
-            return resetCachedGuide(cachedGuides[guide.id]);
+            return guideCache.get(guide.id);
         }
         else {
+            guideCache.add(guide, get_visitor_id());
             return guide;
         }
     });
@@ -25082,48 +25256,53 @@ var loadGuideJs = function (apiKey, params) {
             log.info('no metadata to send', { contexts: ['guides', 'metadata'] });
         }
     }
-    var jzb = compress(params);
-    var queryString = {
-        id: guideRequestId,
-        jzb,
-        v: VERSION,
-        ct: (new Date()).getTime()
-    };
-    if (isAdoptPartner && params.accountId && params.accountId !== 'ACCOUNT-UNIQUE-ID') {
-        queryString.acc = base64EncodeString(params.accountId);
-    }
-    if (isDebuggingEnabled()) {
-        // Include debug info from server
-        queryString.debug = true;
-    }
-    var url = buildBaseDataUrl(guideLoaderImpl.endpoint(), apiKey, queryString);
-    var loadingPromise;
-    var jwtOptions = JWT.get();
-    if (url.length > URL_MAX_LENGTH || !_.isEmpty(jwtOptions)) {
-        delete queryString.jzb;
-        url = buildBaseDataUrl('guide.json', apiKey, queryString);
-        var payload = _.extend({ events: jzb }, jwtOptions);
-        loadingPromise = guideLoaderImpl.post(url, payload, pendo$1, _.noop);
-    }
-    else {
-        loadingPromise = guideLoaderImpl.load(url, pendo$1, _.noop);
-    }
-    return q.all([
-        // eslint-disable-next-line dot-notation
-        loadingPromise['catch'](function (result) {
-            if (result.status === 451) {
-                handleDoNotProcess();
-            }
-            // passthrough rejections to subscribers
-            return q.reject(result);
-        }),
-        deferred.promise,
-        testGuideGifEndpoint(guideLoaderImpl, apiKey)
-    ]).then(function ([, , testGuideGifResult]) {
-        setGuidesBlocked(testGuideGifResult);
-        if (!testGuideGifResult.success) {
-            return q.reject();
+    return guideCache.list(params.visitorId).then(cachedGuides => {
+        if (cachedGuides.length > 0) {
+            params.cachedGuides = cachedGuides;
+        }
+        var jzb = compress(params);
+        var queryString = {
+            id: guideRequestId,
+            jzb,
+            v: VERSION,
+            ct: (new Date()).getTime()
+        };
+        if (isAdoptPartner && params.accountId && params.accountId !== 'ACCOUNT-UNIQUE-ID') {
+            queryString.acc = base64EncodeString(params.accountId);
+        }
+        if (isDebuggingEnabled()) {
+            // Include debug info from server
+            queryString.debug = true;
+        }
+        var url = buildBaseDataUrl(guideLoaderImpl.endpoint(), apiKey, queryString);
+        var jwtOptions = JWT.get();
+        let loadingPromise;
+        if (url.length > URL_MAX_LENGTH || !_.isEmpty(jwtOptions)) {
+            delete queryString.jzb;
+            url = buildBaseDataUrl('guide.json', apiKey, queryString);
+            var payload = _.extend({ events: jzb }, jwtOptions);
+            loadingPromise = guideLoaderImpl.post(url, payload, pendo$1, _.noop);
         }
+        else {
+            loadingPromise = guideLoaderImpl.load(url, pendo$1, _.noop);
+        }
+        return q.all([
+            // eslint-disable-next-line dot-notation
+            loadingPromise['catch'](function (result) {
+                if (result.status === 451) {
+                    handleDoNotProcess();
+                }
+                // passthrough rejections to subscribers
+                return q.reject(result);
+            }),
+            deferred.promise,
+            testGuideGifEndpoint(guideLoaderImpl, apiKey)
+        ]).then(function ([, , testGuideGifResult]) {
+            setGuidesBlocked(testGuideGifResult);
+            if (!testGuideGifResult.success) {
+                return q.reject();
+            }
+        });
     });
 };
 var guideLoaderImpl = XHRGuideLoader;
@@ -25236,18 +25415,6 @@ function shouldLoadGuides(visitorId, callback) {
     }
     return true;
 }
-function getCachedGuideList(pendo, cacheInfo, now = getNow()) {
-    let cachedGuides = [];
-    if (ConfigReader.get('cacheGuides')) {
-        if (now - (cacheInfo.lastUncached || 0) < ConfigReader.get('cacheGuidesTimeout')) {
-            cachedGuides = _.map(pendo.guides, guide => _.pick(guide, 'id', 'lastUpdatedAt', 'language'));
-        }
-        if (!cachedGuides.length) {
-            cacheInfo.lastUncached = now;
-        }
-    }
-    return cachedGuides;
-}
 /**
  * Manually load guides for current visitor and URL. This is typically handled automatically by the Agent
  * whenever the host Application changes its URL. In rare circumstances, a host Application may chose to
@@ -25282,10 +25449,6 @@ var loadGuides = function (apiKey, visitorId, page, callback) {
         url: page,
         oldVisitorId: get_old_visitor_id()
     };
-    const cachedGuides = getCachedGuideList(pendo$1, loadGuides);
-    if (cachedGuides.length && !visitorChanged) {
-        params.cachedGuides = cachedGuides;
-    }
     const reqId = _.uniqueId();
     loadGuides.reqId = reqId;
     loadGuideJs(apiKey, params).then(function () {
@@ -25570,6 +25733,7 @@ function securityPolicyViolationFn(evt) {
         forceGuideReload();
     }
 }
+let guideCache;
 /**
  * Resets and starts guide loop
  *
@@ -25578,11 +25742,12 @@ function securityPolicyViolationFn(evt) {
  * @example
  * pendo.initGuides()
  */
-var initGuides = function () {
+var initGuides = function (observer) {
     const teardownFns = [];
     teardownFns.push(initGuideAnalytics({
         localStorageUnload: ConfigReader.get('analytics.localStorageUnload')
     }));
+    guideCache = new GuideCache(pendo$1.apiKey, ConfigReader);
     GuideMonitor.run();
     teardownFns.push(GuideMonitor.stop);
     Events.appUnloaded.on(function () {
@@ -25642,8 +25807,8 @@ var initGuides = function () {
     teardownFns.push(attachEventInternal(window, 'gestureend', adjustGuidesOnGestureEnd, true));
     teardownFns.push(attachEventInternal(window, 'securitypolicyviolation', securityPolicyViolationFn));
     teardownFns.push(createVideoFullScreenListeners());
-    if (ConfigReader.get('preferMutationObserver') && sniffer.MutationObserver) {
-        var updateGuide = function (event) {
+    if (observer.observing) {
+        var updateGuide = function () {
             store.dispatch('guideUpdate/documentChanged');
         };
         const debouncedUpdate = _.debounce(updateGuide, 50);
@@ -25651,10 +25816,8 @@ var initGuides = function () {
         teardownFns.push(attachEvent(window, 'animationend', debouncedUpdate));
         teardownFns.push(attachEvent(window, 'transitionend', debouncedUpdate));
         teardownFns.push(attachEvent(window, 'mouseover', debouncedUpdate));
+        store.commit('guideUpdate/setObserver', observer);
         store.commit('guideUpdate/setUseObserver');
-        if (ConfigReader.get('observeShadowRoots')) {
-            store.commit('guideUpdate/setObserveShadowRoots');
-        }
         teardownFns.push(() => store.dispatch('guideUpdate/stopObserver'));
     }
     /**
@@ -25700,6 +25863,7 @@ var initGuides = function () {
     agentStorage.registry.addLocal(AD_BLOCK_STORAGE_KEY, { duration: 14400000 }); // 4 hours default duration
     GuideRuntime.initialize();
     return () => {
+        guideCache = null;
         reloadGuides.reset();
         resetPendoUI();
         cancelGuideRequest();
@@ -27035,6 +27199,168 @@ const isReady = (pendoObj) => {
     return pendoObj.doesExist(pendoObj.apiKey);
 };
 
+class ShadowDomManager extends EventTarget {
+    constructor() {
+        super();
+        this.cache = new Set();
+        this.foundShadowRoots = false;
+        this.stoppedSearchEarly = false;
+    }
+    updateCache() {
+        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
+        this.cache.forEach(shadowRoot => {
+            if (!isInDocument(shadowRoot)) {
+                this.cache.delete(shadowRoot);
+                this.dispatchEvent({
+                    type: 'detachShadow',
+                    shadowRoot
+                });
+            }
+        });
+    }
+    patchAttachShadow(Element) {
+        const original = Element.prototype.attachShadow;
+        const self = this;
+        Element.prototype.attachShadow = function (options) {
+            const shadowRoot = original.call(this, options);
+            if (this.shadowRoot) {
+                self.triggerAttachShadow(this.shadowRoot);
+            }
+            return shadowRoot;
+        };
+        Element.prototype.attachShadow.toString = function () {
+            return original.toString();
+        };
+        return () => {
+            Element.prototype.attachShadow = original;
+        };
+    }
+    initialize() {
+        this.unpatchAttachShadow = this.patchAttachShadow(Element);
+        this.findShadowRoots(document);
+    }
+    triggerAttachShadow(shadowRoot) {
+        this.cache.add(shadowRoot);
+        this.dispatchEvent({
+            type: 'attachShadow',
+            shadowRoot
+        });
+    }
+    findShadowRoots(document, maxPerSearch = 5000) {
+        if (!_.isFunction(document.createNodeIterator))
+            return;
+        let nodesChecked = 0;
+        let queue = [getBody(document)];
+        let currentNode;
+        function eachShadowRoot(iterator) {
+            do {
+                if (!iterator) {
+                    iterator = document.createNodeIterator(queue.pop(), NodeFilter.SHOW_ELEMENT);
+                }
+                if (!iterator || !iterator.nextNode)
+                    break;
+                while ((currentNode = iterator.nextNode())) {
+                    nodesChecked++;
+                    if (currentNode && currentNode.shadowRoot) {
+                        this.triggerAttachShadow(currentNode.shadowRoot);
+                        queue.push(currentNode.shadowRoot);
+                        this.foundShadowRoots = true;
+                    }
+                    if (nodesChecked % maxPerSearch === 0)
+                        break;
+                }
+                if (currentNode)
+                    break;
+                iterator = null;
+            } while (queue.length);
+            if (currentNode && this.foundShadowRoots) {
+                this.findTimeout = setTimeout$1(() => {
+                    this.findTimeout = null;
+                    eachShadowRoot.call(this, iterator);
+                }, 50);
+            }
+            if (nodesChecked === maxPerSearch && !this.foundShadowRoots) {
+                this.stoppedSearchEarly = true;
+            }
+        }
+        eachShadowRoot.call(this);
+    }
+    teardown() {
+        this.cache.clear();
+        if (_.isFunction(this.unpatchAttachShadow)) {
+            this.unpatchAttachShadow();
+            this.unpatchAttachShadow = null;
+        }
+        if (this.findTimeout) {
+            clearTimeout(this.findTimeout);
+            this.findTimeout = null;
+        }
+    }
+}
+
+class UberMutationObserver extends EventTarget {
+    constructor(observerClass = getZoneSafeMethod('MutationObserver')) {
+        super();
+        this.ObserverClass = observerClass;
+        this.observing = false;
+        this.observers = new Map();
+        this.triggerMutation = this.dispatchMutationEvent;
+        this.shadowDom = new ShadowDomManager();
+        this.shadowDom.addEventListener('attachShadow', _.bind(this.handleAttachShadow, this));
+        this.shadowDom.addEventListener('detachShadow', _.bind(this.handleDetachShadow, this));
+        this.addEventListener('mutation', () => {
+            this.shadowDom.updateCache();
+        });
+    }
+    initialize(pendo, PluginAPI) {
+        const configReader = PluginAPI.ConfigReader;
+        if (!configReader.get('preferMutationObserver') || !pendo.sniffer.MutationObserver) {
+            return;
+        }
+        this.observeShadowRoots = configReader.get('observeShadowRoots');
+        this.startObserver(document.documentElement);
+        this.observing = true;
+        if (this.observeShadowRoots) {
+            this.shadowDom.initialize();
+        }
+    }
+    startObserver(target) {
+        const observer = new this.ObserverClass(mutation => this.triggerMutation(mutation));
+        this.observers.set(target, observer);
+        observer.observe(target, {
+            subtree: true,
+            attributes: true,
+            childList: true,
+            characterData: true
+        });
+    }
+    teardown() {
+        this.observers.clear();
+        this.shadowDom.teardown();
+    }
+    dispatchMutationEvent(mutation) {
+        this.dispatchEvent({
+            type: 'mutation',
+            mutation
+        });
+    }
+    triggerMutationOnce(mutation) {
+        this.triggerMutation = _.noop;
+        queueMicrotask(() => {
+            this.dispatchMutationEvent(mutation);
+            this.triggerMutation = this.triggerMutationOnce;
+        });
+    }
+    handleAttachShadow({ shadowRoot }) {
+        this.triggerMutation = this.triggerMutationOnce;
+        this.startObserver(shadowRoot);
+    }
+    handleDetachShadow({ shadowRoot }) {
+        this.observers.delete(shadowRoot);
+    }
+}
+var observer = new UberMutationObserver();
+
 // ---------------------------------------------------------------------------
 function registerEventHandlers({ events = [] }) {
     _.each(events, (callback, eventName) => {
@@ -27145,6 +27471,9 @@ const initialize = makeSafe(function (options) {
     teardownFns.push(initializeEventBuffer({
         localStorageUnload: localStorageUnloadEnabled
     }));
+    // needs to happen before initGuides
+    observer.initialize(pendo$1, PluginAPI);
+    teardownFns.push(() => observer.teardown());
     if (pendoCore) {
         /**
         * Current visitor id for pendo installation, either anonymous or identified. Used to determine
@@ -27184,21 +27513,12 @@ const initialize = makeSafe(function (options) {
         * @label OPTIONS_HASH_KEY_NAME
         */
         agentStorage.registry.addLocal(OPTIONS_HASH_KEY_NAME);
-        /**
-        * Stores debugging configuration and state for the Pendo debugger.
-        *
-        * @name debug-enabled
-        * @category Cookies/localStorage
-        * @access public
-        * @label debugEnabled
-        */
-        agentStorage.registry.addLocal(debugEnabled, { isPlain: true, serializer: JSON.stringify, deserializer: SafeJsonDeserializer });
         // Disable content pre-fetch for guide center
         pendo$1.disableGuideCenterContentSearch = options.disableGuideCenterContentSearch;
         // Register handlers passed through pendo_options
         teardownFns.push(forwardInternalEvents(Events));
         registerEventHandlers(options);
-        teardownFns.push(initGuides()); // this is safe.  loadGuides actually does the loading.
+        teardownFns.push(initGuides(observer)); // this is safe.  loadGuides actually does the loading.
         initIdentityEvents(); // setup identify and meta event listeners
         teardownFns.push(wirePage());
         teardownFns.push(initializePlugins());
@@ -27489,6 +27809,7 @@ var BuildingBlockGuides = (function () {
         }
     }
     function renderGuideFromJSON(json, step, guides, options) {
+        options = options || {};
         var guide = step.getGuide();
         var containerJSON = findGuideContainerJSON(json);
         var isResourceCenter = _.get(guide, 'attributes.resourceCenter');
@@ -27500,7 +27821,7 @@ var BuildingBlockGuides = (function () {
         var isAnnouncementModule = _.get(guide, 'attributes.resourceCenter.moduleId') === 'AnnouncementsModule';
         step.hasEscapeListener = false;
         step.containerId = containerJSON && containerJSON.props && containerJSON.props.id;
-        step.element = getElementForGuideStep(step);
+        step.element = getElementForGuideStep(step, options.document);
         var guideToAppend = BuildingBlockGuides.buildNodeFromJSON(json, step, guides);
         step.guideElement = guideToAppend;
         var guideContainer = guideToAppend.find('#' + step.containerId);
@@ -27519,19 +27840,20 @@ var BuildingBlockGuides = (function () {
         // between re-renders
         guideContainer.css({ visibility: 'hidden' });
         guideToAppend.css({ visibility: 'hidden' });
+        const embedConfig = _.get(guide, 'attributes.embedConfig', null);
         var watermark = BuildingBlockWatermark.buildWatermark({
             appId: guide.appId,
             targetAccount: guide.targetAccount,
             isTraining: guide.isTraining,
-            isBottomAligned: guideContainer.attr(verticalAlignmentAttr) === 'Bottom Aligned'
+            isBottomAligned: guideContainer.attr(verticalAlignmentAttr) === 'Bottom Aligned',
+            isEmbedded: !!embedConfig
         }, BuildingBlockGuides.buildNodeFromJSON);
         if (watermark) {
             guideContainer.append(watermark);
         }
         var hasImageCount = step && step.attributes && step.attributes.imgCount;
         // Do conditional Guide Rendering Things
-        var parent = getGuideAttachPoint();
-        const embedConfig = _.get(guide, 'attributes.embedConfig', null);
+        var parent = getGuideAttachPoint(options.document);
         if (embedConfig) {
             const guideContainerId = 'pendo-guide-container';
             const baseContainerId = 'pendo-base';
@@ -32144,75 +32466,6 @@ function updateMasterGuideList(state) {
     }
 }
 
-function addShadowObserver(shadowRoot, observerCallback) {
-    const MutationObserver = getZoneSafeMethod('MutationObserver');
-    const shadowObserver = new MutationObserver(observerCallback);
-    shadowObserver.observe(shadowRoot, {
-        subtree: true,
-        attributes: true,
-        childList: true,
-        characterData: true
-    });
-}
-function patchAttachShadow(observerCallback) {
-    const original = Element.prototype.attachShadow;
-    Element.prototype.attachShadow = function (options) {
-        const shadowRoot = original.call(this, options);
-        if (this.shadowRoot) {
-            addShadowObserver(this.shadowRoot, observerCallback);
-        }
-        return shadowRoot;
-    };
-    Element.prototype.attachShadow.toString = function () {
-        return original.toString();
-    };
-}
-function startObserver(observerCallback) {
-    patchAttachShadow(observerCallback);
-    if (!_.isFunction(document.createNodeIterator))
-        return;
-    const maxPerSearch = 5000;
-    let nodesChecked = 0;
-    let queue = [getBody()];
-    let currentNode;
-    function eachShadowRoot(iterator) {
-        do {
-            if (!iterator) {
-                iterator = document.createNodeIterator(queue.pop(), NodeFilter.SHOW_ELEMENT);
-            }
-            if (!iterator || !iterator.nextNode)
-                break;
-            while ((currentNode = iterator.nextNode())) {
-                nodesChecked++;
-                if (currentNode && currentNode.shadowRoot) {
-                    addShadowObserver(currentNode.shadowRoot, observerCallback);
-                    queue.push(currentNode.shadowRoot);
-                    shadowDomManager.foundShadowRoots = true;
-                }
-                if (nodesChecked % maxPerSearch === 0)
-                    break;
-            }
-            if (currentNode)
-                break;
-            iterator = null;
-        } while (queue.length);
-        if (currentNode && shadowDomManager.foundShadowRoots) {
-            setTimeout$1(() => {
-                eachShadowRoot(iterator);
-            }, 50);
-        }
-        if (nodesChecked === maxPerSearch && !shadowDomManager.foundShadowRoots) {
-            shadowDomManager.stoppedSearchEarly = true;
-        }
-    }
-    eachShadowRoot();
-}
-const shadowDomManager = {
-    startObserver,
-    foundShadowRoots: false,
-    stoppedSearchEarly: false
-};
-
 var GuideUpdateModule = (function () {
     var observer;
     function observerCallback() {
@@ -32223,7 +32476,6 @@ var GuideUpdateModule = (function () {
     }
     var state = {
         useObserver: false,
-        observeShadowRoots: false,
         observing: false,
         needsUpdate: false,
         scheduledUpdate: null,
@@ -32254,43 +32506,31 @@ var GuideUpdateModule = (function () {
                 context.commit('setScheduledUpdate', null);
             }
         },
-        startObserverIfNeeded(context, observerClass) {
+        startObserverIfNeeded(context) {
             if (context.state.useObserver) {
-                var observerInstance = context.getters.observer();
-                if (!observerInstance) {
-                    observerInstance = new (observerClass || getZoneSafeMethod('MutationObserver'))(observerCallback);
-                    observer = observerInstance;
-                }
                 if (!context.state.observing) {
-                    observerInstance.observe(document.documentElement, {
-                        subtree: true,
-                        attributes: true,
-                        childList: true,
-                        characterData: true
-                    });
-                    if (context.state.observeShadowRoots) {
-                        shadowDomManager.startObserver(observerCallback);
-                    }
+                    const observer = context.getters.observer();
+                    observer.addEventListener('mutation', observerCallback);
                     context.commit('setObserving', true);
                 }
             }
         },
         stopObserver(context) {
-            var observerInstance = context.getters.observer();
-            if (observerInstance && _.isFunction(observerInstance.disconnect)) {
-                observerInstance.disconnect();
+            const observer = context.getters.observer();
+            if (observer) {
+                observer.removeEventListener('mutation', observerCallback);
             }
             context.commit('setObserving', false);
             context.dispatch('stopScheduledUpdate');
         }
     };
     var mutations = {
+        setObserver(state, _observer) {
+            observer = _observer;
+        },
         setUseObserver(state) {
             state.useObserver = true;
         },
-        setObserveShadowRoots(state) {
-            state.observeShadowRoots = true;
-        },
         setObserving(state, observing) {
             state.observing = observing;
         },
@@ -36205,7 +36445,9 @@ function debuggerExports() {
         isStagingServer,
         AutoDisplay,
         isLeader,
-        Events
+        Events,
+        observer,
+        guideCache
     };
 }
 function startDebuggingModuleIfEnabled() {
@@ -38565,6 +38807,15 @@ function isConfiguredForMV3(config) {
     return config && config.useAssetHostForDesigner;
 }
 function initAgent(pendo, PendoConfig) {
+    /**
+        * Stores debugging configuration and state for the Pendo debugger.
+        *
+        * @name debug-enabled
+        * @category Cookies/localStorage
+        * @access public
+        * @label debugEnabled
+        */
+    agentStorage.registry.addLocal(debugEnabled, { isPlain: true, serializer: JSON.stringify, deserializer: SafeJsonDeserializer });
     setPendoConfig(PendoConfig);
     overwriteBuiltConfigWithPendoConfig();
     if (!loadAsModule(PendoConfig) && loadAlternateAgent(PendoConfig, pendo, isDebuggingEnabled()))
@@ -38584,7 +38835,7 @@ function initAgent(pendo, PendoConfig) {
     AsyncContent.reset();
     store.dispatch('frames/init');
     logPublic.init();
-    shadowAPI.wrapSizzle(SizzleProxy);
+    shadowAPI.wrapSizzle(SizzleProxy, observer.shadowDom);
     SizzleProxy.intercept(sizzleAttachPointInterceptor);
     populatePendoObject(pendo);
     log.addEventListener('log', _.partial(store.dispatch, 'errorLog/write'));
@@ -38678,7 +38929,8 @@ function TextCapture() {
     }
     function isTextCapturable(text) {
         var trimmedText = pluginAPI.util.trim.call(text);
-        return isEnabled() || pendoGlobal._.has(whitelist, trimmedText) || pendoGlobal._.has(whitelist, text);
+        // pass the text as an array so that our toPath override doesn't try to split it on `.`
+        return isEnabled() || pendoGlobal._.has(whitelist, [trimmedText]) || pendoGlobal._.has(whitelist, [text]);
     }
     function hasWhitelist() {
         return pendoGlobal._.size(whitelist) > 0;
@@ -47274,7 +47526,8 @@ class SessionRecorder {
             }, SEND_INTERVAL$1);
             var config = this.recordingConfig(visitorConfig);
             this._stop = this.record(this.pendo._.extend({
-                emit: bind(this.emit, this)
+                emit: bind(this.emit, this),
+                errorHandler: bind(this.errorHandler, this)
             }, config));
             this._refreshIds();
             this.onRecordingStart();
@@ -47386,6 +47639,9 @@ class SessionRecorder {
             return null;
         }
     }
+    errorHandler(error) {
+        this.logStopReason('RRWEB_ERROR', error);
+    }
     /**
      * Handle new rrweb events coming in. This will also make sure that we are properly sending a "keyframe"
      * as the BE expects it. A "keyframe" should consist of only the events needed to start a recording. This includes
@@ -47489,6 +47745,10 @@ class SessionRecorder {
                 this.sendHostedResources(hostedResourcesEvent);
                 break;
             }
+            case 'emptyPayload': {
+                this.logStopReason('EMPTY_PAYLOAD');
+                break;
+            }
             case 'missingData': {
                 this.logStopReason(`MISSING_${messageData.missingData}`);
                 break;
@@ -48298,6 +48558,11 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
             }
             if (e.data.url && e.data.payload) {
                 let { url, payload, shouldCacheResources } = e.data;
+                if (Object.keys(payload).length === 0) {
+                    postMessage({
+                        type: 'emptyPayload'
+                    });
+                }
                 const { sequence } = payload;
                 const stringifiedRecordingPayload = JSON.stringify(payload.recordingPayload);
                 // calculate and post back the recording payload size before the payload is compressed
@@ -51511,7 +51776,8 @@ var ConfigReader = (function () {
         /**
          * Use this setting when using `preferMutationObserver` with an application that has Shadow DOM elements.
          * On page load, the Agent will run a full document scan for shadow roots and attach a MutationObserver to
-         * all results.
+         * all results. This setting also allows the agent to run CSS selectors in all shadow roots, so CSS selectors
+         * can be written without specifying the full path through all shadow roots with the `::shadow` pseudo-class.
          *
          * @access public
          * @category Config/Core