@pendo/agent 2.290.1 → 2.291.0

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.1_';
-var PACKAGE_VERSION = '2.290.1';
+var VERSION = '2.291.0_';
+var PACKAGE_VERSION = '2.291.0';
 var LOADER = 'xhr';
 /* eslint-enable agent-eslint-rules/no-gulp-env-references */
 /**
@@ -10060,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) {
@@ -10204,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;
@@ -11034,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);
             }
         }
@@ -13782,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');
@@ -13805,7 +13808,7 @@ function getGuideAttachPoint() {
         }
         getGuideAttachPoint.attachPoint = attachPoint;
     }
-    return attachPoint || getBody();
+    return attachPoint || getBody(doc);
 }
 var findBadgeForStep = function (step) {
     var badge = badgesShown[step.guideId];
@@ -13828,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;
@@ -13839,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;
@@ -16046,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);
         if (!element)
             return;
         const width = guideContainer.style.width;
@@ -16071,9 +16074,10 @@ var BuildingBlockTooltips = (function () {
         return treatAsMobileDevice() ? MOBILE_TOOLTIP_CSS_NAME : TOOLTIP_CSS_NAME;
     }
     function getTooltipPositioningContext(step, element, json, guideContainer) {
-        var elementPos = getOffsetPosition(element);
+        var targetWindow = element.ownerDocument.defaultView;
+        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) {
@@ -16121,7 +16125,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;
         }
@@ -16200,8 +16204,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),
@@ -16331,23 +16334,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) {
@@ -16368,7 +16371,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;
@@ -16376,7 +16379,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;
@@ -16384,7 +16387,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;
@@ -16392,7 +16395,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;
@@ -16400,7 +16403,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) {
@@ -16408,14 +16411,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;
         }
@@ -16638,8 +16641,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;
+        var targetWindow = targetDocument.defaultView;
+        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;
@@ -16661,7 +16666,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];
@@ -20028,6 +20033,9 @@ var GuideStateModule = (function () {
             }
             context.commit('setLastGuideStepSeen', lastGuideStepSeen);
             pendo$1.lastGuideStepSeen = lastGuideStepSeen;
+            if (guideCache) {
+                guideCache.update(lastGuideStepSeen);
+            }
         },
         updateThrottlingState(context, state) {
             context.commit('setThrottlingState', state);
@@ -21362,6 +21370,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();
@@ -21374,18 +21392,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);
                     }
                 }
             }
@@ -23229,7 +23248,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)
@@ -23802,6 +23821,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';
@@ -25043,14 +25205,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;
@@ -25060,13 +25214,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;
         }
     });
@@ -25101,48 +25255,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;
@@ -25255,18 +25414,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
@@ -25301,10 +25448,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 () {
@@ -25589,6 +25732,7 @@ function securityPolicyViolationFn(evt) {
         forceGuideReload();
     }
 }
+let guideCache;
 /**
  * Resets and starts guide loop
  *
@@ -25602,6 +25746,7 @@ var initGuides = function (observer) {
     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 () {
@@ -25717,6 +25862,7 @@ var initGuides = function (observer) {
     agentStorage.registry.addLocal(AD_BLOCK_STORAGE_KEY, { duration: 14400000 }); // 4 hours default duration
     GuideRuntime.initialize();
     return () => {
+        guideCache = null;
         reloadGuides.reset();
         resetPendoUI();
         cancelGuideRequest();
@@ -27157,6 +27303,7 @@ class UberMutationObserver extends EventTarget {
         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));
@@ -27177,7 +27324,7 @@ class UberMutationObserver extends EventTarget {
         }
     }
     startObserver(target) {
-        const observer = new this.ObserverClass(_.bind(this.triggerMutation, this));
+        const observer = new this.ObserverClass(mutation => this.triggerMutation(mutation));
         this.observers.set(target, observer);
         observer.observe(target, {
             subtree: true,
@@ -27190,13 +27337,21 @@ class UberMutationObserver extends EventTarget {
         this.observers.clear();
         this.shadowDom.teardown();
     }
-    triggerMutation(mutation) {
+    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 }) {
@@ -27357,15 +27512,6 @@ 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
@@ -27662,6 +27808,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');
@@ -27673,7 +27820,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);
@@ -27692,19 +27839,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';
@@ -36297,7 +36445,8 @@ function debuggerExports() {
         AutoDisplay,
         isLeader,
         Events,
-        observer
+        observer,
+        guideCache
     };
 }
 function startDebuggingModuleIfEnabled() {
@@ -38657,6 +38806,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()))
@@ -38770,7 +38928,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;
@@ -47366,7 +47525,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();
@@ -47478,6 +47638,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
@@ -47581,6 +47744,10 @@ class SessionRecorder {
                 this.sendHostedResources(hostedResourcesEvent);
                 break;
             }
+            case 'emptyPayload': {
+                this.logStopReason('EMPTY_PAYLOAD');
+                break;
+            }
             case 'missingData': {
                 this.logStopReason(`MISSING_${messageData.missingData}`);
                 break;
@@ -48390,6 +48557,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
@@ -51603,7 +51775,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