@pendo/agent 2.284.0 → 2.285.0

package/dist/pendo.module.js

@@ -454,7 +454,7 @@ function isMinifiedAgent(config) {
     return !config.unminified;
 }
 function isExtension(config) {
-    return config.installType === 'extension';
+    return config.installType === 'extension'; // can't use isExtensionAgent() here because of circular dependency and ConfigReader not being ready yet
 }
 function shouldUseStagingAgent(config) {
     return !isExtension(config) && !isStagingEnvironment(config) && isStagingServer(config);
@@ -3666,6 +3666,9 @@ function getInstallType() {
     var installType = ConfigReader.get('installType');
     return installType || NATIVE_INSTALL_TYPE;
 }
+function isExtensionAgent() {
+    return getInstallType() === EXTENSION_INSTALL_TYPE;
+}
 function subscriptionBucketPrefix(env) {
     if (env === PROD) {
         return 'pendo-static';
@@ -3765,6 +3768,7 @@ if (bodyStyle) {
         animations = _.isString(pdocument.body.style.webkitAnimation);
     }
 }
+var isChromeExtension = window.chrome && window.chrome.runtime && window.chrome.runtime.id;
 // Android has history.pushState, but it does not update location correctly
 // so let's not use the history API at all.
 // http://code.google.com/p/android/issues/detail?id=17471
@@ -3778,15 +3782,13 @@ var shouldWrapNativeHistory = _.memoize(function shouldWrapNativeHistory() {
     var historyDescriptors = window.history && _.isFunction(Object.getOwnPropertyDescriptors) && Object.getOwnPropertyDescriptors(window.history);
     var isHistoryWriteable = historyDescriptors && _.get(historyDescriptors, 'pushState.writable', true) && _.get(historyDescriptors, 'replaceState.writable', true);
     var hasAndroidSupport = !(android < 4);
-    var isExtension = getInstallType() === EXTENSION_INSTALL_TYPE;
-    return !!(hasNativeHistory && !isHistoryFrozen && isHistoryWriteable && hasAndroidSupport && !boxee && !isExtension);
+    return !!(hasNativeHistory && !isHistoryFrozen && isHistoryWriteable && hasAndroidSupport && !boxee && !isExtensionAgent());
 });
 function shouldWrapHashChange() {
     var hasNativeHashChange = 'onhashchange' in window;
     // IE8 compatible mode lies
     var hasSupportedDocMode = (!documentMode || documentMode > 7);
-    var isExtension = getInstallType() === EXTENSION_INSTALL_TYPE;
-    return !!(hasNativeHashChange && hasSupportedDocMode && !isExtension);
+    return !!(hasNativeHashChange && hasSupportedDocMode && !isExtensionAgent());
 }
 function isMobileUserAgent() {
     return (/Android|webOS|iPhone|iPod|BlackBerry|IEMobile|Opera Mini/i).test(getUA());
@@ -3820,7 +3822,8 @@ var sniffer = {
     addEventListener: _.isFunction(window.addEventListener),
     MutationObserver: isNativeCode(window.MutationObserver),
     isMinimumIEVersion,
-    isMobileUserAgent: _.memoize(isMobileUserAgent)
+    isMobileUserAgent: _.memoize(isMobileUserAgent),
+    isChromeExtension
 };
 
 var isBrowserInQuirksmode = function () {
@@ -3902,8 +3905,8 @@ var SERVER = '';
 var ASSET_HOST = '';
 var ASSET_PATH = '';
 var DESIGNER_SERVER = '';
-var VERSION = '2.284.0_';
-var PACKAGE_VERSION = '2.284.0';
+var VERSION = '2.285.0_';
+var PACKAGE_VERSION = '2.285.0';
 var LOADER = 'xhr';
 /* eslint-enable agent-eslint-rules/no-gulp-env-references */
 /**
@@ -3930,10 +3933,6 @@ var overwriteBuiltConfigWithPendoConfig = function () {
     var versionSuffix = isExtensionAgent() ? ENV + '_ext' : ENV;
     VERSION = PACKAGE_VERSION + '_' + versionSuffix;
 };
-function isExtensionAgent() {
-    const installType = getPendoConfigValue('installType') || getPendoConfigFromEnclosingScope().installType;
-    return installType === EXTENSION_INSTALL_TYPE;
-}
 function isProdAgent() {
     return ENV.indexOf('prod') !== -1;
 }
@@ -9464,8 +9463,13 @@ function getAssetHost() {
     }
     return assetHost;
 }
+function isLocalAgent(assetHost) {
+    return assetHost.indexOf('localhost') >= 0 || assetHost.indexOf('local.pendo.io') >= 0;
+}
 function getAssetUrl(filename) {
-    return `${getAssetHost()}/${ASSET_PATH ? ASSET_PATH + '/' : ''}${filename}`;
+    const assetHost = getAssetHost();
+    const file = isLocalAgent(assetHost) ? filename.replace('.min.js', '.js') : filename;
+    return `${assetHost}/${ASSET_PATH ? ASSET_PATH + '/' : ''}${file}`;
 }
 
 function treatAsAdoptPartner() {
@@ -13827,36 +13831,44 @@ function setFrameVisibility(visibility) {
     return store.dispatch('frames/updateFrameVisibility', { visibility });
 }
 
-var PublicEvents = (function () {
-    var events = Eventable.call({});
-    var useAsync = {
-        validateGuide: 1,
-        validateLauncher: 1,
-        validateGlobalScript: 1
-    };
-    var internalEvents = {
-        ready: 1,
-        deliverablesLoaded: 1,
-        guidesFailed: 1,
-        guidesLoaded: 1,
-        onClickCaptured: 1
-    };
-    _.each([
-        // Supported events
-        'ready',
-        'onClickCaptured',
-        'deliverablesLoaded',
-        'guidesFailed',
-        'guidesLoaded',
-        'validateGuide',
-        'validateLauncher',
-        'validateGlobalScript'
-    ], function (eventName) {
+const useAsync = {
+    validateGuide: 1,
+    validateLauncher: 1,
+    validateGlobalScript: 1
+};
+const internalEvents = {
+    ready: 1,
+    deliverablesLoaded: 1,
+    guidesFailed: 1,
+    guidesLoaded: 1,
+    onClickCaptured: 1
+};
+const supportedPublicEvents = [
+    'ready',
+    'onClickCaptured',
+    'deliverablesLoaded',
+    'guidesFailed',
+    'guidesLoaded',
+    'validateGuide',
+    'validateLauncher',
+    'validateGlobalScript'
+];
+function forwardInternalEvents(Events) {
+    const unsubscribes = _.reduce(supportedPublicEvents, function (unsubscribes, eventName) {
         if (internalEvents[eventName]) {
-            Events[eventName].on(function (event) {
+            const forward = function (event) {
                 return PublicEvents[eventName].apply(PublicEvents[eventName], event.data);
-            });
+            };
+            Events[eventName].on(forward);
+            unsubscribes.push(() => Events[eventName].off(forward));
         }
+        return unsubscribes;
+    }, []);
+    return () => _.each(unsubscribes, (unsubscribe) => unsubscribe());
+}
+var PublicEvents = (function () {
+    var events = Eventable.call({});
+    _.each(supportedPublicEvents, function (eventName) {
         events[eventName] = function (callback) {
             if (_.isFunction(callback)) {
                 return events.on(eventName, callback);
@@ -14677,10 +14689,12 @@ var GuideRuntime = (function (agentEvents) {
     var EventChannel = agentEvents.runtime;
     const pluginAddGlobalScripts = [];
     function initialize() {
+        EventChannel.on(handleEvent);
         const globalScripts = ConfigReader.get('guides.globalScripts');
         _.each(globalScripts, GuideRuntime.addGlobalScript);
     }
     function teardown() {
+        EventChannel.off(handleEvent);
         _.each(pluginAddGlobalScripts, GuideRuntime.removeGlobalScript);
     }
     function addGlobalScript(obj) {
@@ -14816,7 +14830,7 @@ var GuideRuntime = (function (agentEvents) {
             return 'hidden';
         return step.seenState;
     }
-    EventChannel.on(function (evt) {
+    function handleEvent(evt) {
         var step = evt.data[0];
         evt.step = step;
         delete evt.data;
@@ -14841,7 +14855,7 @@ var GuideRuntime = (function (agentEvents) {
             delete evt.cancel;
         }
         return evt;
-    });
+    }
     function GuideRuntimeContext(step) {
         this.step = step;
         _.each(['read', 'write', 'clear'], function (action) {
@@ -15864,6 +15878,16 @@ function vertical(elementPos, screenDim, layoutDir) {
     return TOP;
 }
 
+const TOOLTIP_CONSTANTS = {
+    DEFAULT_CARET_OFFSET: 10,
+    BOUNDARY_MARGIN_RIGHT: 0.98,
+    BOUNDARY_MARGIN_LEFT: 0.02,
+    Z_INDEX: {
+        DEFAULT: '300000',
+        CARET: 11,
+        BORDER_CARET: 10
+    }
+};
 var BuildingBlockTooltips = (function () {
     return {
         createBBTooltip,
@@ -15882,8 +15906,25 @@ var BuildingBlockTooltips = (function () {
         attachBBAdvanceActions,
         attachScrollHandlers,
         isBuildingBlockGuideRelativeToElement,
-        positionStepForTooltip
+        positionStepForTooltip,
+        patchGuideContainerWidthForResponsiveTooltips
     };
+    function patchGuideContainerWidthForResponsiveTooltips(step, providedGuideContainer, json) {
+        const guideContainer = providedGuideContainer || getGuideContainer(step);
+        if (!guideContainer)
+            return;
+        const element = step.element || getElementForGuideStep(step);
+        if (!element)
+            return;
+        const width = guideContainer.style.width;
+        if (!width || width.indexOf('vw') === -1) {
+            return;
+        }
+        const tooltipContext = getTooltipPositioningContext(step, element, json, guideContainer);
+        if (!tooltipContext)
+            return;
+        calculateVwRelativeToLayoutDir(guideContainer, tooltipContext);
+    }
     function positionStepForTooltip(step, json, guideContainerEle) {
         // This directly modifies step.guideElement object
         createBBTooltip(json, step.element, step, guideContainerEle);
@@ -15896,39 +15937,58 @@ var BuildingBlockTooltips = (function () {
     function buildTooltipCSSName() {
         return treatAsMobileDevice() ? MOBILE_TOOLTIP_CSS_NAME : TOOLTIP_CSS_NAME;
     }
-    function createBBTooltip(domJson, element, step, guideContainer) {
-        if (!step.guideElement)
-            return;
-        var tooltipDiv = step.guideElement;
-        tooltipDiv.addClass(buildTooltipCSSName());
+    function getTooltipPositioningContext(step, element, json, guideContainer) {
         var elementPos = getOffsetPosition(element);
+        var screenPos = getScreenPosition(element);
+        var screenDimensions = getScreenDimensions();
+        var layoutDir = step.attributes.layoutDir || 'auto';
         // RETURN IF THE FOUND ELEMENT IS NOT VISIBLE ON THE SCREEN.
         if (elementPos.height === 0 && elementPos.width === 0) {
             return null;
         }
-        var screenPos = getScreenPosition(element);
+        const elementIsNotVisible = step && !step.elementPathRule;
         var containerTruthTest = function (block) { return block.props.id === 'pendo-guide-container'; };
-        var containerDomJson = findDomBlockInDomJson(domJson, containerTruthTest);
+        var containerDomJson = findDomBlockInDomJson(json, containerTruthTest);
         if (!containerDomJson)
-            return;
-        var layoutDir = step.attributes.layoutDir;
-        var tooltipSizes = {
-            height: guideContainer.offsetHeight,
-            width: guideContainer.offsetWidth
-        };
+            return null;
         var caretDimensions = {
             height: parseInt(containerDomJson.props['data-caret-height'], 10) || 0,
             width: parseInt(containerDomJson.props['data-caret-width'], 10) || 0,
             backgroundColor: containerDomJson.props.style['background-color'],
-            offset: 10
+            offset: TOOLTIP_CONSTANTS.DEFAULT_CARET_OFFSET,
+            borderWidth: 0
         };
-        attachBBAdvanceActions(step);
         if (containerDomJson.props.style.border) {
             var guideBorderArray = containerDomJson.props.style.border.split(' ');
             caretDimensions.borderColor = guideBorderArray[2];
             caretDimensions.borderWidth = parseInt(guideBorderArray[0], 10);
         }
-        var tooltipDimensions = getBBTooltipDimensions(elementPos, tooltipSizes, caretDimensions, layoutDir, screenPos);
+        const tooltipSizes = {
+            width: guideContainer.offsetWidth,
+            height: guideContainer.offsetHeight,
+            layoutDir
+        };
+        return {
+            elementPos,
+            screenPos,
+            screenDimensions,
+            caretDimensions,
+            tooltipSizes,
+            containerDomJson,
+            elementIsNotVisible
+        };
+    }
+    function createBBTooltip(domJson, element, step, guideContainer) {
+        if (!step.guideElement)
+            return;
+        const tooltipContext = getTooltipPositioningContext(step, element, domJson, guideContainer);
+        if (!tooltipContext)
+            return null;
+        const { elementPos, tooltipSizes, screenPos, caretDimensions } = tooltipContext;
+        var tooltipDiv = step.guideElement;
+        tooltipDiv.addClass(buildTooltipCSSName());
+        attachBBAdvanceActions(step);
+        var tooltipDimensions = getBBTooltipDimensions(elementPos, { height: tooltipSizes.height, width: tooltipSizes.width }, caretDimensions, step.attributes.layoutDir, screenPos);
         if (step) {
             step.dim = tooltipDimensions;
         }
@@ -15946,15 +16006,13 @@ var BuildingBlockTooltips = (function () {
             guideContainer.style.position = 'absolute';
         }
         if (caretDimensions.height && caretDimensions.width) {
-            buildTooltipCaret(tooltipDiv, tooltipDimensions, caretDimensions);
+            buildTooltipCaret(tooltipDiv, tooltipDimensions, caretDimensions, elementPos);
         }
-        var inheritedZIndex = '300000';
+        var inheritedZIndex = TOOLTIP_CONSTANTS.Z_INDEX.DEFAULT;
         if (guideContainer && guideContainer.style && guideContainer.style['z-index']) {
             inheritedZIndex = guideContainer.style['z-index'];
         }
-        //
         // styles for OUTER Guide
-        //
         tooltipDiv.css({
             'z-index': inheritedZIndex
         });
@@ -16021,7 +16079,7 @@ var BuildingBlockTooltips = (function () {
         tooltipDimensions.hbias = horizontal(elementPos, screenDimensions, layoutDirection);
         tooltipDimensions.vbias = vertical(elementPos, screenDimensions, layoutDirection);
         tooltipDimensions.layoutDir = determineTooltipPosition(tooltipDimensions, screenDimensions, screenPos, layoutDirection);
-        var tooltipPosition = positionBBTooltipWithBias(tooltipDimensions, elementPos, screenDimensions);
+        var tooltipPosition = positionBBTooltipWithBias(tooltipDimensions, elementPos, screenDimensions, caretSizes);
         tooltipDimensions.top = tooltipPosition.top;
         tooltipDimensions.left = tooltipPosition.left;
         // Adjust tooltip top/left for the size of the caret
@@ -16039,6 +16097,32 @@ var BuildingBlockTooltips = (function () {
         }
         return tooltipDimensions;
     }
+    function calculateVwRelativeToLayoutDir(guideContainer, tooltipContext) {
+        const { elementPos, tooltipSizes, screenDimensions, caretDimensions, elementIsNotVisible } = tooltipContext;
+        const caretFullWidth = (parseInt(caretDimensions.width, 10) || 0);
+        const maxWidth = parseInt(guideContainer.style.maxWidth, 10);
+        const minWidth = parseInt(guideContainer.style.minWidth, 10);
+        const percentage = parseFloat(guideContainer.style.width) / 100;
+        if (elementIsNotVisible) {
+            tooltipSizes.width -= caretFullWidth;
+        }
+        else if (tooltipSizes.layoutDir === 'left') {
+            const availableSpaceToTheLeftOfElement = elementPos.left - caretFullWidth;
+            tooltipSizes.width = Math.max(0, availableSpaceToTheLeftOfElement * percentage);
+        }
+        else if (tooltipSizes.layoutDir === 'right') {
+            const availableSpaceToTheRightOfElement = screenDimensions.width - elementPos.right - caretFullWidth;
+            tooltipSizes.width = Math.max(0, availableSpaceToTheRightOfElement * percentage);
+        }
+        if (maxWidth && tooltipSizes.width > maxWidth) {
+            tooltipSizes.width = maxWidth;
+        }
+        if (minWidth && tooltipSizes.width < minWidth) {
+            tooltipSizes.width = minWidth;
+        }
+        // We need to patch the vw to the available space for the tooltip, otherwise 100vw would be the entire screen
+        guideContainer.style.width = tooltipSizes.width + 'px';
+    }
     function determineTooltipPosition(tooltipDimensions, screenDimensions, screenPos, layoutDirection) {
         if (layoutDirection && layoutDirection !== 'auto') {
             return layoutDirection;
@@ -16096,15 +16180,14 @@ var BuildingBlockTooltips = (function () {
             return position;
         return tooltipDimensions.hbias ? tooltipDimensions.hbias : 'bottom';
     }
-    function positionBBTooltipWithBias(tooltipDimensions, elementPosition, screenDimensions) {
+    function positionBBTooltipWithBias(tooltipDimensions, elementPosition, screenDimensions, caretSizes) {
         if (tooltipDimensions.layoutDir === 'top' || tooltipDimensions.layoutDir === 'bottom') {
-            return calculateToolTipPositionForTopBottom(tooltipDimensions, screenDimensions, elementPosition, tooltipDimensions.layoutDir, tooltipDimensions.hbias);
+            return calculateToolTipPositionForTopBottom(tooltipDimensions, screenDimensions, elementPosition, tooltipDimensions.layoutDir, tooltipDimensions.hbias, caretSizes);
         }
         return calculateToolTipPositionForLeftRight(tooltipDimensions, screenDimensions, elementPosition, tooltipDimensions.vbias);
     }
-    function calculateToolTipPositionForTopBottom(tooltipDimensions, screenDimensions, elementPosition, layoutDirection, horizontalBias) {
+    function calculateToolTipPositionForTopBottom(tooltipDimensions, screenDimensions, elementPosition, layoutDirection, horizontalBias, caretSizes) {
         var height = tooltipDimensions.height;
-        var width = tooltipDimensions.width;
         var tooltipPosition = {
             top: null,
             left: null
@@ -16115,22 +16198,95 @@ var BuildingBlockTooltips = (function () {
         else if (layoutDirection === 'top') {
             tooltipPosition.top = elementPosition.top - height;
         }
+        const boundaries = getBoundaries();
         if (horizontalBias === 'right') {
-            var leftVal = elementPosition.left + (elementPosition.width / 2);
-            if (leftVal + tooltipDimensions.width > screenDimensions.width) {
-                leftVal -= (leftVal + tooltipDimensions.width - screenDimensions.width);
-            }
-            tooltipPosition.left = leftVal;
+            tooltipPosition.left = calculateRightBiasPosition(elementPosition, tooltipDimensions, caretSizes, screenDimensions, boundaries.right, boundaries.left);
         }
         else if (horizontalBias === 'left') {
-            tooltipPosition.left = elementPosition.left - width + (elementPosition.width / 2);
+            tooltipPosition.left = calculateLeftBiasPosition(elementPosition, tooltipDimensions, caretSizes, boundaries.right, boundaries.left);
         }
         else {
             // ASSUME CENTER
-            tooltipPosition.left = elementPosition.left + (elementPosition.width / 2) - (width / 2);
+            tooltipPosition.left = calculateCenterBiasPosition(elementPosition, tooltipDimensions, boundaries.right, boundaries.left);
         }
         return tooltipPosition;
     }
+    function getBoundaries() {
+        return {
+            right: window.innerWidth * TOOLTIP_CONSTANTS.BOUNDARY_MARGIN_RIGHT,
+            left: window.innerWidth * TOOLTIP_CONSTANTS.BOUNDARY_MARGIN_LEFT
+        };
+    }
+    function calculateCaretPadding(caretSizes) {
+        return caretSizes.offset + caretSizes.width + caretSizes.borderWidth;
+    }
+    function calculateRightBiasPosition(elementPosition, tooltipDimensions, caretSizes, screenDimensions, rightBoundary, leftBoundary) {
+        const caretPadding = calculateCaretPadding(caretSizes);
+        const width = tooltipDimensions.width;
+        var leftVal = elementPosition.left + (elementPosition.width / 2) - caretPadding;
+        if (leftVal + tooltipDimensions.width > screenDimensions.width) {
+            leftVal -= (leftVal + tooltipDimensions.width - screenDimensions.width);
+        }
+        const tooltipRight = leftVal + width;
+        if (tooltipRight > rightBoundary) {
+            const overflow = tooltipRight - rightBoundary;
+            if (leftVal - overflow < leftBoundary) {
+                return spaceEvenly(leftVal, width);
+            }
+            else {
+                return leftVal - overflow;
+            }
+        }
+        return leftVal;
+    }
+    function calculateLeftBiasPosition(elementPosition, tooltipDimensions, caretSizes, rightBoundary, leftBoundary) {
+        const caretPadding = calculateCaretPadding(caretSizes);
+        const width = tooltipDimensions.width;
+        var leftVal = elementPosition.left - width + (elementPosition.width / 2) + caretPadding;
+        if (leftVal < leftBoundary) {
+            const overflow = leftBoundary - leftVal;
+            const tooltipRight = leftVal + width;
+            if (tooltipRight + overflow > rightBoundary) {
+                return spaceEvenly(leftVal, width);
+            }
+            else {
+                return leftVal + overflow;
+            }
+        }
+        return leftVal;
+    }
+    function calculateCenterBiasPosition(elementPosition, tooltipDimensions, rightBoundary, leftBoundary) {
+        const width = tooltipDimensions.width;
+        var leftVal = elementPosition.left + (elementPosition.width / 2) - (width / 2);
+        let tooltipRight = leftVal + width;
+        if (tooltipRight > rightBoundary) {
+            const overflow = tooltipRight - rightBoundary;
+            leftVal -= overflow;
+            if (leftVal < leftBoundary) {
+                return spaceEvenly(leftVal, width);
+            }
+        }
+        else if (leftVal < leftBoundary) {
+            const overflow = leftBoundary - leftVal;
+            leftVal += overflow;
+            let tooltipRight = leftVal + width;
+            if (tooltipRight > rightBoundary) {
+                return spaceEvenly(leftVal, width);
+            }
+        }
+        return leftVal;
+    }
+    function spaceEvenly(leftVal, width) {
+        const availableLeftSpace = leftVal;
+        const availableRightSpace = window.innerWidth - (leftVal + width);
+        if (availableLeftSpace > availableRightSpace) {
+            return leftVal - (availableLeftSpace - availableRightSpace) / 2;
+        }
+        else if (availableRightSpace > availableLeftSpace) {
+            return leftVal + (availableRightSpace - availableLeftSpace) / 2;
+        }
+        return leftVal;
+    }
     function calculateToolTipPositionForLeftRight(tooltipDimensions, screenDimensions, elementPosition, verticalBias) {
         var height = tooltipDimensions.height;
         var width = tooltipDimensions.width;
@@ -16161,12 +16317,12 @@ var BuildingBlockTooltips = (function () {
         }
         return tooltipPosition;
     }
-    function buildTooltipCaret(tooltipDiv, tooltipDimensions, caretDimensions) {
+    function buildTooltipCaret(tooltipDiv, tooltipDimensions, caretDimensions, elementPos) {
         var caretDiv = document.createElement('div');
         caretDiv.setAttribute('class', 'pendo-tooltip-caret pendo-tooltip-caret--' + tooltipDimensions.layoutDir);
         caretDiv.style.position = 'absolute';
-        caretDiv.style.zIndex = 11;
-        updateCaretStyles(caretDiv, tooltipDimensions, caretDimensions);
+        caretDiv.style.zIndex = TOOLTIP_CONSTANTS.Z_INDEX.CARET;
+        updateCaretStyles(caretDiv, tooltipDimensions, caretDimensions, elementPos);
         var guideDiv = tooltipDiv.find('#pendo-guide-container')[0].parentNode;
         guideDiv.appendChild(caretDiv);
         if (!caretDimensions.borderWidth)
@@ -16174,35 +16330,20 @@ var BuildingBlockTooltips = (function () {
         var borderCaret = buildBorderCaret(caretDiv, caretDimensions, tooltipDimensions.layoutDir);
         guideDiv.appendChild(borderCaret);
     }
-    function updateCaretStyles(caretDiv, tooltipDimensions, caretDimensions) {
+    function updateCaretStyles(caretDiv, tooltipDimensions, caretDimensions, elementPos) {
         if (tooltipDimensions.layoutDir === 'top' || tooltipDimensions.layoutDir === 'bottom') {
-            styleTopOrBottomCaret(caretDiv, tooltipDimensions, caretDimensions);
+            styleTopOrBottomCaret(caretDiv, tooltipDimensions, caretDimensions, elementPos);
         }
         if (tooltipDimensions.layoutDir === 'left' || tooltipDimensions.layoutDir === 'right') {
             styleLeftOrRightCaret(caretDiv, tooltipDimensions, caretDimensions);
         }
     }
-    function styleTopOrBottomCaret(caret, tooltipDimensions, caretDimensions) {
-        var screenDimensions = getScreenDimensions();
+    function styleTopOrBottomCaret(caret, tooltipDimensions, caretDimensions, elementPos) {
         caret.style['border-left'] = caretDimensions.width + 'px solid transparent';
         caret.style['border-right'] = caretDimensions.width + 'px solid transparent';
         caret.style.right = '';
-        if (tooltipDimensions.hbias === LEFT) {
-            var maxArrowLeft = tooltipDimensions.width - caretDimensions.width * 2 - caretDimensions.offset - caretDimensions.borderWidth;
-            caret.style.left = maxArrowLeft + 'px';
-            tooltipDimensions.left += caretDimensions.offset + caretDimensions.width + caretDimensions.borderWidth;
-        }
-        else if (tooltipDimensions.hbias === RIGHT) {
-            caret.style.left = (caretDimensions.offset + caretDimensions.borderWidth) + 'px';
-            tooltipDimensions.left -= caretDimensions.offset + caretDimensions.width + caretDimensions.borderWidth;
-            if (tooltipDimensions.left + tooltipDimensions.width > screenDimensions.width) {
-                tooltipDimensions.left = tooltipDimensions.left - (tooltipDimensions.left + tooltipDimensions.width - screenDimensions.width);
-            }
-            tooltipDimensions.left = Math.max(0, tooltipDimensions.left);
-        }
-        else { // ASSUME CENTER
-            caret.style.left = (tooltipDimensions.width / 2) - caretDimensions.width + 'px';
-        }
+        const caretOffset = calculateCaretOffset(elementPos, tooltipDimensions, caretDimensions, tooltipDimensions.hbias);
+        caret.style.left = caretOffset + 'px';
         // Tooltip is below element, put caret on the top of the tooltip
         if (tooltipDimensions.layoutDir === 'bottom') {
             caret.style['border-bottom'] = caretDimensions.height + 'px solid ' + caretDimensions.backgroundColor;
@@ -16227,6 +16368,23 @@ var BuildingBlockTooltips = (function () {
         }
         return caret;
     }
+    function calculateCaretOffset(elementPos, tooltipDimensions, caretDimensions, bias) {
+        if (elementPos && elementPos.left) {
+            const elementCenter = elementPos.left + (elementPos.width / 2);
+            return elementCenter - tooltipDimensions.left - caretDimensions.width; // always center the tooltip on the element
+        }
+        else {
+            if (bias === 'left') {
+                return tooltipDimensions.width - caretDimensions.width * 2 - caretDimensions.offset - caretDimensions.borderWidth;
+            }
+            else if (bias === 'right') {
+                return caretDimensions.offset + caretDimensions.borderWidth;
+            }
+            else { // center
+                return (tooltipDimensions.width / 2) - caretDimensions.width;
+            }
+        }
+    }
     function styleLeftOrRightCaret(caret, tooltipDimensions, caretDimensions) {
         var screenDimensions = getScreenDimensions();
         caret.style['border-top'] = caretDimensions.width + 'px solid transparent';
@@ -16275,7 +16433,7 @@ var BuildingBlockTooltips = (function () {
     function buildBorderCaret(caret, caretDimensions, tooltipLayoutDirection) {
         var borderCaret = caret.cloneNode();
         borderCaret.setAttribute('class', 'pendo-tooltip-caret-border');
-        borderCaret.style.zIndex = 10;
+        borderCaret.style.zIndex = TOOLTIP_CONSTANTS.Z_INDEX.BORDER_CARET;
         updateBorderCaretStyles(borderCaret, caretDimensions, tooltipLayoutDirection, caret);
         return borderCaret;
     }
@@ -16362,7 +16520,7 @@ var BuildingBlockTooltips = (function () {
             height: parseInt(ttContainer[0].getAttribute('data-caret-height'), 10) || 0,
             width: parseInt(ttContainer[0].getAttribute('data-caret-width'), 10) || 0,
             backgroundColor: ttContainer[0].style['background-color'],
-            offset: 10,
+            offset: TOOLTIP_CONSTANTS.DEFAULT_CARET_OFFSET,
             borderColor: ttContainerStyles.borderColor,
             borderWidth: parseInt(ttContainerStyles.borderWidth, 10)
         };
@@ -16371,7 +16529,7 @@ var BuildingBlockTooltips = (function () {
             var caretDiv = ttdiv.find('.pendo-tooltip-caret')[0];
             var borderCaret = ttdiv.find('.pendo-tooltip-caret-border')[0];
             if (caretDiv) {
-                updateCaretStyles(caretDiv, tooltipDimensions, caretStyles);
+                updateCaretStyles(caretDiv, tooltipDimensions, caretStyles, elPos);
             }
             if (borderCaret) {
                 updateBorderCaretStyles(borderCaret, caretStyles, tooltipDimensions.layoutDir, caretDiv);
@@ -17853,7 +18011,7 @@ var identify = makeSafe(function (visitor_id, account_id) {
 });
 var isSelfHosted = function () {
     var scripts = dom('script');
-    var selfHosted = isSelfHostedUrl(scripts) && (getInstallType() !== 'extension');
+    var selfHosted = isSelfHostedUrl(scripts) && !isExtensionAgent();
     return selfHosted;
 };
 var isSelfHostedUrl = function (scripts) {
@@ -17890,7 +18048,6 @@ function handleIdentifyEvent(event) {
     ConfigReader.setLocalConfig(options);
     store.commit('metadata/setMetadata', options);
 }
-Events.identify.on(handleIdentifyEvent);
 
 /*
 * Extension API
@@ -26527,6 +26684,7 @@ function initIdentityEvents() {
             }
         }
     });
+    Events.identify.on(handleIdentifyEvent);
     initialized = true;
 }
 
@@ -26857,6 +27015,7 @@ const initialize = makeSafe(function (options) {
         // 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.
         initIdentityEvents(); // setup identify and meta event listeners
@@ -27219,6 +27378,9 @@ var BuildingBlockGuides = (function () {
         }
         fixGuideStyleDocument(getGuideAttachPoint(), guideToAppend[0], step.id);
         sizeElements(guideToAppend);
+        if (relativeToElement) {
+            BuildingBlockTooltips.patchGuideContainerWidthForResponsiveTooltips(step, guideContainer[0], json);
+        }
         // We want to prevent announcement modules from running this code
         // because it will cause some elements to resize incorrectly to the
         // announcement *module* container instead of the announcement *guide* container
@@ -28309,25 +28471,28 @@ IntervalJob.prototype.stop = function () {
 };
 
 var urlFor = ajax.urlFor;
+// Define the valid attribute-action combinations once
+var attrActionEnum = {
+    search: ['AllowOnlyKeys', 'ExcludeKeys', 'AddTo', 'Replace', 'Clear'],
+    hash: ['Replace', 'Clear'],
+    pathname: ['Replace', 'Clear', 'AddTo'],
+    hostname: ['Replace'],
+    href: ['Replace', 'ForceSecure'],
+    protocol: ['ForceSecure']
+};
 function UrlAttrTransform(attr, action, data) {
-    var attrActionEnum = {
-        search: ['AllowOnlyKeys', 'ExcludeKeys', 'AddTo', 'Replace', 'Clear'],
-        hash: ['Replace', 'Clear'],
-        pathname: ['Replace'],
-        hostname: ['Replace'],
-        href: ['Replace', 'ForceSecure'],
-        protocol: ['ForceSecure']
-    };
     if (_.isObject(attr)) {
         action = attr.action;
         data = attr.data;
         attr = attr.attr;
     }
     if (!attrActionEnum[attr]) {
-        throw new Error('Invalid URL attribute type: ' + attr);
+        var validAttrs = _.keys(attrActionEnum).join(', ');
+        throw new Error('Invalid URL attribute type: "' + attr + '". Valid attributes are: ' + validAttrs + '. Example: {attr: "search", action: "AddTo", data: {key: "value"}}');
     }
     if (!_.contains(attrActionEnum[attr], action)) {
-        throw new Error('Invalid transform (' + action + ') for attribute (' + attr + ')');
+        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: ...}');
     }
     this.attr = attr;
     this.action = action;
@@ -28353,11 +28518,36 @@ UrlAttrTransform.prototype.applyToURL = function (url) {
             if (_.isFunction(data)) {
                 data = data(url[attr], url);
             }
+            // AddTo only works for search and pathname attributes; otherwise, do nothing
+            if (attr !== 'search' && attr !== 'pathname') {
+                return url;
+            }
+            if (attr === 'pathname') {
+                // Ensure pathname starts with '/' and append the new segment
+                var currentPath = url.pathname;
+                var newSegment = data;
+                if (!newSegment.startsWith('/')) {
+                    newSegment = '/' + newSegment;
+                }
+                if (currentPath.endsWith('/')) {
+                    url.pathname = currentPath + newSegment.substring(1);
+                }
+                else {
+                    url.pathname = currentPath + newSegment;
+                }
+                return url;
+            }
+            // For search attribute, use the existing urlFor logic
             var href = url.href;
             return new URL(urlFor(href, data));
         },
         Clear(url, attr) {
-            url[attr] = '';
+            if (attr === 'pathname') {
+                url.pathname = '/';
+            }
+            else {
+                url[attr] = '';
+            }
             return url;
         },
         Replace(url, attr, data) {
@@ -28389,7 +28579,67 @@ UrlAttrTransform.fromJSON = function (obj) {
     if (obj instanceof UrlAttrTransform) {
         return obj;
     }
-    return new UrlAttrTransform(obj.attr, obj.action, obj.data);
+    // 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"}}');
+    }
+    // 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"}}');
+    }
+    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"}}');
+    }
+    // Validate attribute and action combination
+    if (!attrActionEnum[obj.attr]) {
+        var validAttrs = _.keys(attrActionEnum).join(', ');
+        throw new Error('Invalid attribute "' + obj.attr + '". Valid attributes are: ' + validAttrs + '. Example: {attr: "search", action: "AddTo", data: {key: "value"}}');
+    }
+    if (!_.contains(attrActionEnum[obj.attr], obj.action)) {
+        var validActions = attrActionEnum[obj.attr].join(', ');
+        throw new Error('Invalid action "' + obj.action + '" for attribute "' + obj.attr + '". Valid actions for "' + obj.attr + '" are: ' + validActions + '. Example: {attr: "' + obj.attr + '", action: "' + attrActionEnum[obj.attr][0] + '", data: ...}');
+    }
+    // Validate data property for actions that require it
+    var actionsRequiringData = ['AllowOnlyKeys', 'ExcludeKeys', 'AddTo', 'Replace'];
+    if (_.contains(actionsRequiringData, obj.action) && obj.data === undefined) {
+        var dataExample = obj.action === 'Replace' ? '"newValue"'
+            : (obj.action === 'AddTo' ? '{key1: "value1"}' : '["key1", "key2"]');
+        throw new Error('Action "' + obj.action + '" requires a "data" property. Example: {attr: "' + obj.attr + '", action: "' + obj.action + '", data: ' + dataExample + '}');
+    }
+    // Validate data types for specific actions
+    if (obj.action === 'AllowOnlyKeys' || obj.action === 'ExcludeKeys') {
+        if (!_.isArray(obj.data)) {
+            throw new Error('Action "' + obj.action + '" requires "data" to be an array of strings. Example: {attr: "' + obj.attr + '", action: "' + obj.action + '", data: ["key1", "key2"]}');
+        }
+    }
+    if (obj.action === 'AddTo') {
+        if (obj.attr === 'pathname') {
+            // For pathname, data can be a string, object, or function
+            if (!_.isString(obj.data) && !_.isObject(obj.data) && !_.isFunction(obj.data)) {
+                throw new Error('Action "AddTo" for pathname requires "data" to be a string, object, or function. Example: {attr: "pathname", action: "AddTo", data: "additional/segment"}');
+            }
+        }
+        else {
+            // For other attributes (like search), data must be an object or function
+            if (!_.isObject(obj.data) && !_.isFunction(obj.data)) {
+                throw new Error('Action "AddTo" requires "data" to be an object or function. Example: {attr: "search", action: "AddTo", data: {key1: "value1", key2: "value2"}}');
+            }
+        }
+    }
+    try {
+        return new UrlAttrTransform(obj.attr, obj.action, obj.data);
+    }
+    catch (error) {
+        // If it's already a detailed error from our validation, re-throw it
+        if (error.message.includes('Invalid attribute') || error.message.includes('Invalid action') ||
+            error.message.includes('requires') || error.message.includes('expects')) {
+            throw error;
+        }
+        // Otherwise, wrap the original error with context
+        throw new Error('Failed to create UrlAttrTransform: ' + error.message + '. Transform object: ' + JSON.stringify(obj));
+    }
 };
 
 function isURL(u) {
@@ -35573,7 +35823,7 @@ const EventProperties = (function () {
                 return;
             }
             var value = collectEventProperty(ep);
-            if (value) {
+            if (doesExist(value)) {
                 result['_pendo_' + ep.name] = value;
             }
         }
@@ -36390,7 +36640,7 @@ const EmbeddedGuides = (function () {
         _ = globalPendo._;
         exportPublicEmbeddedGuideApi(pendo);
         pluginApi.Events.on('deliverablesLoaded', clearEmbeddedGuides);
-        pluginApi.Events.on('guideLoopStopped', hideAllEmbeddedGuides);
+        pluginApi.Events.on('guideLoopStopped', onGuidesStopped);
         pluginApi.Events.on('guideListChanged', initializeEmbeddedGuides);
         pluginApi.Events.on('urlChanged', setForceShowFirstStepFlags);
         pluginApi.GuideLoop.addUpdatePhase(processEmbeddedGuides);
@@ -36401,7 +36651,7 @@ const EmbeddedGuides = (function () {
     function teardown() {
         clearEmbeddedGuides();
         pluginApi.Events.off('deliverablesLoaded', clearEmbeddedGuides);
-        pluginApi.Events.off('guideLoopStopped', hideAllEmbeddedGuides);
+        pluginApi.Events.off('guideLoopStopped', onGuidesStopped);
         pluginApi.Events.off('guideListChanged', initializeEmbeddedGuides);
         pluginApi.Events.off('urlChanged', setForceShowFirstStepFlags);
         pluginApi.GuideLoop.removeUpdatePhase(processEmbeddedGuides);
@@ -36411,6 +36661,14 @@ const EmbeddedGuides = (function () {
             this.removeResizeEvent();
         _oldEmbeddedGuides.length = 0;
     }
+    function onGuidesStopped() {
+        // The guideLoopStopped event sometimes is sent when the guide loop is restarted, for example when a guide is advanced.
+        // Do not hide embedded guides in these cases.
+        // The delayGuides flag is set when guides are manually stopped, and unset when guides are manually started.
+        if (pluginApi.ConfigReader.get('delayGuides')) {
+            hideAllEmbeddedGuides();
+        }
+    }
     function processEmbeddedGuides() {
         _.forEach(embeddedGuides, function (guide) {
             guide.process();
@@ -37965,6 +38223,9 @@ function stubSnippetMethods(pendo) {
         };
     });
 }
+function isConfiguredForMV3(config) {
+    return config && config.useAssetHostForDesigner;
+}
 function initAgent(pendo, PendoConfig) {
     setPendoConfig(PendoConfig);
     overwriteBuiltConfigWithPendoConfig();
@@ -37972,6 +38233,9 @@ function initAgent(pendo, PendoConfig) {
         return false;
     if (pendo && pendo.VERSION)
         return false;
+    if (sniffer.isChromeExtension && !isConfiguredForMV3(PendoConfig)) {
+        console.warn('Pendo Agent detected running in a Chrome extension with setup that is incompatible with manifest V3. Please follow the linked instructions to maintain manifest V3 compatibility: https://www.npmjs.com/package/@pendo/agent#manifest-v3-extensions');
+    }
     if (ConfigReader.get('disablePendo')) {
         stubSnippetMethods(pendo);
         return false;
@@ -40882,8 +41146,8 @@ function stringifyStylesheet(s2) {
       return null;
     }
     let sheetHref = s2.href;
-    if (!sheetHref && s2.ownerNode && s2.ownerNode.ownerDocument) {
-      sheetHref = s2.ownerNode.ownerDocument.baseURI;
+    if (!sheetHref && s2.ownerNode) {
+      sheetHref = s2.ownerNode.baseURI;
     }
     const stringifiedRules = Array.from(
       rules2,