@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/tracker.js

@@ -0,0 +1,916 @@
+import { __webpack_require__ } from "../js/runtime.js";
+import { esm_browser_v4, _class_private_field_loose_base, _class_private_field_loose_key, __decorate, __metadata } from "../js/4101.js";
+import { supportedBrowserLanguage } from "../components/helpers/languages.js";
+import { getEventTarget, addEventListener, isDomVisible, cloneEvent } from "../src/dom.js";
+import { PersonalizationManager } from "../src/personalizations/personalization-manager.js";
+import { BUTTON_LIKE_SELECTOR, isWithinQualifiedElement } from "../src/smart_website/utils.js";
+import { fromBase64 } from "../src/string.js";
+import { every, after } from "../src/timing.js";
+import { default as WidgetObject } from "./widget_object.js";
+import { captureWidgetExceptions } from "./capture_widget_exceptions.js";
+import { isSafariUserAgent } from "./constants.js";
+import { default as data360_visitor } from "./data360_visitor.js";
+import { default as eloqua_visitor } from "./eloqua_visitor.js";
+import { armFormCtaBookerIntent } from "./form_cta_booker_intent.js";
+import { default as hubspot_visitor } from "./hubspot_visitor.js";
+import { default as marketo_visitor } from "./marketo_visitor.js";
+import { ButtonsFormsTriggeringTracer } from "./meetings/tracing/buttons_forms_triggering_tracer.js";
+import { default as pardot_visitor } from "./pardot_visitor.js";
+import { default as personalizations_config } from "./personalizations_config.js";
+import { default as smart_website_config } from "./smart_website_config.js";
+import "./telemetry/index.js";
+import { inject } from "../src/mixins/injectable.js";
+import { ignoreIfDisposed } from "../src/mixins/disposable.js";
+import { telemetry, withTelemetryCtx, getTelemetryCtx } from "./telemetry/telemetry.js";
+
+const debounce = __webpack_require__("37753");
+var debounce_default = /*#__PURE__*/__webpack_require__.n(debounce);
+const throttle = __webpack_require__("61442");
+var throttle_default = /*#__PURE__*/__webpack_require__.n(throttle);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const events = [
+    "scroll",
+    "mousemove",
+    "click",
+    "touchstart",
+    "keypress"
+];
+const HIJACK_BUTTON_DEBOUNCE_MS = 100;
+const EXPERIENCE_TIMEOUT_MS = 5000;
+const FALLBACK_EVENT_SYMBOL = Symbol("FALLBACK_EVENT");
+const FALLBACK_EVENT_VALUE = "QUALIFIED_FALLBACK_EVENT";
+const HIJACK_CLICK_DEBOUNCE_MS = 1200;
+const PRIVACY_DISCLOSURE_MESSAGE_TYPES = [
+    "text",
+    "field_entry",
+    "lightbox_gather",
+    "calendar_event_offer"
+];
+var _onVisibilityChange = /*#__PURE__*/ _class_private_field_loose_key("_onVisibilityChange");
+class Tracker extends WidgetObject {
+    async init() {
+        var _this_config_pardotConfig;
+        this.telemetryCtx = getTelemetryCtx();
+        this.widget.logTiming("Time to init tracker", "widget_time_to_init_tracker_ms");
+        events.forEach((event)=>{
+            this.callOnDispose(addEventListener(window, event, this.eventHandler, {
+                capture: true
+            }));
+        });
+        this.callOnDispose(addEventListener(window, "visibilitychange", _class_private_field_loose_base(this, _onVisibilityChange)[_onVisibilityChange], {
+            capture: true
+        }));
+        this.callOnDispose(addEventListener(window, "pagehide", this.onPageHide, {
+            capture: true
+        }));
+        this.callOnDispose(()=>{
+            var _this_widget_personalizationObserver;
+            return (_this_widget_personalizationObserver = this.widget.personalizationObserver) == null ? void 0 : _this_widget_personalizationObserver.stop();
+        });
+        this.callOnDispose(()=>this.handleButtonTriggers.cancel());
+        if ((_this_config_pardotConfig = this.config.pardotConfig) == null ? void 0 : _this_config_pardotConfig.accountId) {
+            await telemetry.startActiveSpanAsync("Init pardot", {}, this.telemetryCtx, async (span)=>{
+                if (!this.config.pardotConfig) return;
+                const pardot = await new pardot_visitor(this.config.pardotConfig).getIdentities();
+                this.setInitializationParams({
+                    pardot: {
+                        prospect_email: pardot.prospectEmail,
+                        visitor_id: pardot.visitorId
+                    }
+                });
+                span.end();
+            });
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        if (this.config.hasMarketo) {
+            await telemetry.startActiveSpanAsync("Init marketo", {}, this.telemetryCtx, async (span)=>{
+                const marketoToken = await new marketo_visitor().getToken();
+                if (marketoToken !== undefined) {
+                    this.setInitializationParams({
+                        marketo: {
+                            token: marketoToken
+                        }
+                    });
+                }
+                span.end();
+            });
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        if (this.config.hasHubSpot) {
+            await telemetry.startActiveSpanAsync("Init hubspot", {}, this.telemetryCtx, async (span)=>{
+                const hubspotToken = await new hubspot_visitor().getToken(this.widget.config.hubspotTokenRetrievalTimeout);
+                if (hubspotToken !== undefined) {
+                    this.setInitializationParams({
+                        hubspot: {
+                            token: hubspotToken
+                        }
+                    });
+                }
+                span.end();
+            });
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        if (this.config.hasData360) {
+            await telemetry.startActiveSpanAsync("Init data360", {}, this.telemetryCtx, async (span)=>{
+                const deviceId = await new data360_visitor().getDeviceId();
+                if (deviceId !== undefined) {
+                    this.setInitializationParams({
+                        data360: {
+                            deviceId
+                        }
+                    });
+                }
+                span.end();
+            });
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        if (this.config.hasEloqua) {
+            await telemetry.startActiveSpanAsync("Init eloqua", {}, this.telemetryCtx, async (span)=>{
+                const eloquaToken = new eloqua_visitor().getToken();
+                if (eloquaToken !== undefined) {
+                    this.setInitializationParams({
+                        eloqua: {
+                            token: eloquaToken
+                        }
+                    });
+                }
+                span.end();
+            });
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        if (this.visitor.smartFormData) {
+            if (this.config.hasSmartForms) {
+                this.experienceAdapter.showLightboxLoading();
+                // Pre-offer SLI: a submit saved by `saveSmartFormData` before this page
+                // context existed, replayed at init. Unlike the api_handler path this IS
+                // a replay, so the clock necessarily starts here — the original submit
+                // moment belongs to a previous context — the same compromise the
+                // redirect-replay arm site in `widget.ts` documents.
+                //
+                // Armed inside the `hasSmartForms` guard rather than beside the params:
+                // without smart forms there is no lightbox, no wait the visitor can see,
+                // and no path to a booker, so counting it would add journeys to the
+                // denominator that could never have produced an offer.
+                if (this.featureFlags.bookerJourneySLI) {
+                    armFormCtaBookerIntent("form:smart_form", this.visitor.smartFormData.botApiName);
+                }
+            }
+            this.setInitializationParams({
+                smart_form: {
+                    field_values: this.visitor.smartFormData.fieldValues,
+                    bot_api_name: this.visitor.smartFormData.botApiName
+                }
+            });
+            this.visitor.clearSmartFormData();
+        }
+        if (!this.widget.isMeetingLink) {
+            const shouldRebroadcast = !!(this.visitor.lastValidRebroadcastTime && this.visitor.lastValidRebroadcastTime > this.widget.dateProvider.new().getTime());
+            if (shouldRebroadcast) {
+                const rebroadcastMessage = "[Qualified] Page loaded within the valid rebroadcast period, and thus is going to rebroadcast the last element conversation.";
+                this.widget.debugLog(rebroadcastMessage);
+            }
+            withTelemetryCtx(this.telemetryCtx, ()=>{
+                this.createPageView({
+                    singlePageApp: false,
+                    reconnecting: false,
+                    rebroadcast: shouldRebroadcast,
+                    qualifiedRedirected: this.visitor.qualifiedRedirected
+                });
+            });
+            this.visitor.setQualifiedRedirect(undefined);
+            this.visitor.setLastValidRebroadcastTime(undefined);
+        }
+        const searchParams = new URLSearchParams(window.location.search);
+        if (searchParams.has("q_offer_info")) {
+            let id, expiration;
+            try {
+                var _searchParams_get;
+                ({ id, expiration } = JSON.parse(fromBase64((_searchParams_get = searchParams.get("q_offer_info")) != null ? _searchParams_get : "")));
+            } catch (e) {
+                this.widget.debugLog("Error parsing offer info: " + e);
+            }
+            if (id && expiration && expiration > this.dateProvider.now()) {
+                this.pageViewActivityEmitter.emitOfferLanded({
+                    offerVersionId: id
+                });
+            }
+            const uri = new URL(window.location.href);
+            uri.searchParams.delete("q_offer_info");
+            // Remove the offer info from the URL so that it doesn't get rebroadcasted
+            window.history.replaceState(window.history.state, "", uri.toString());
+        }
+        this.updatePageVisible();
+        this.channel.emit("initTrackerCreatePageView");
+        this.initializationParams = {};
+        this.initialize();
+    }
+    startBehaviorTracker() {
+        var _this_config_featureFlags;
+        this.timerStartedAt = Date.now();
+        const secondsToWait = ((_this_config_featureFlags = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags.leads) ? 5 : 10;
+        const timerDisposer = every(500, ()=>{
+            if (this.timerStartedAt) {
+                this.timerTimeOnSite = Date.now() - this.timerStartedAt;
+            }
+            if (this.experienceAdapter.apMessagesCount >= 2 || this.experienceAdapter.autoRespondPounceCount >= 2 || this.experienceAdapter.userResponded || this.experienceAdapter.visitorResponded) {
+                stopBehaviorTracker();
+            }
+            if (this.timerTimeOnSite > secondsToWait * 1000) {
+                // 10s * (1000ms /  1s) = 10,000ms
+                this.metActiveThreshold();
+                stopBehaviorTracker();
+            }
+        });
+        // For window focusing
+        const windowFocusDisposer = addEventListener(window, "focus", ()=>{
+            this.timerStartedAt = Date.now();
+        });
+        const windowBlurDisposer = addEventListener(window, "blur", ()=>{
+            this.timerStartedAt = null;
+        });
+        // For tab focusing
+        const pageVisibilityDisposer = addEventListener(window, "visibilitychange", ()=>{
+            if (document.visibilityState === "visible") {
+                this.timerStartedAt = Date.now();
+            } else {
+                this.timerStartedAt = null;
+            }
+        });
+        const stopBehaviorTracker = ()=>{
+            pageVisibilityDisposer();
+            windowFocusDisposer();
+            windowBlurDisposer();
+            timerDisposer();
+        };
+    }
+    closestSelector(target, triggers) {
+        return Object.keys(triggers).find((key)=>{
+            const keySelector = key + ", " + key + " *";
+            const matchResult = target.matches(keySelector);
+            if (matchResult) {
+                this.widget.debugLog("trigger " + keySelector + " matched");
+            }
+            return matchResult;
+        });
+    }
+    handleTriggers(event, triggers, botType) {
+        this.widget.debugLog("Handling " + botType + " triggers: " + JSON.stringify(triggers));
+        let selector;
+        let filterFn;
+        const TargetClass = this.featureFlags.smartCtaNestedTriggersSupport ? Element : HTMLElement;
+        if (botType === "SMART_CTA") {
+            filterFn = (el)=>{
+                var _this_smartWebsiteConfig;
+                return el instanceof TargetClass && !!(selector = (_this_smartWebsiteConfig = this.smartWebsiteConfig) == null ? void 0 : _this_smartWebsiteConfig.matchingSelector(el));
+            };
+        } else {
+            filterFn = (el)=>el instanceof TargetClass && !!(selector = this.closestSelector(el, triggers));
+        }
+        const target = getEventTarget(event, {
+            filterFn,
+            hasShadowDomSupport: this.featureFlags.smartCtaShadowDomSupport,
+            nestedTriggersSupport: this.featureFlags.smartCtaNestedTriggersSupport
+        });
+        if (!selector || !target) return;
+        // preventDefault here since we're hijacking the click
+        event.preventDefault();
+        // stopPropagation here since we're hijacking the click
+        event.stopPropagation();
+        if (this.waitingForFallbackEvent) {
+            return;
+        }
+        this.afterInit(async ()=>{
+            await this.widget.initialized;
+            this.lastButtonTriggerEvent = {
+                event,
+                target,
+                selector: selector
+            };
+            this.hijackClick(botType, triggers[selector], this.lastButtonTriggerEvent);
+            this.recordClickActivity(event);
+        });
+    }
+    initialize() {
+        this.initialized = true;
+        this.afterInitQueue.forEach((queuedAction)=>queuedAction());
+        this.afterInitQueue = [];
+    }
+    setInitializationParams(params) {
+        if (this.initialized) {
+            throw new Error("Tracker already initialized!");
+        } else {
+            Object.assign(this.initializationParams, params);
+        }
+    }
+    constructor(injectionProps){
+        var _ref;
+        var _this_widget_personalizationObserver, _this_config_featureFlags, _this_config_featureFlags1, _this_config_featureFlags2;
+        super(injectionProps), Object.defineProperty(this, _onVisibilityChange, {
+            writable: true,
+            value: void 0
+        }), this.initialized = false, // AI Nudge
+        this.timerStartedAt = null, this.experienceLoadingStartTimeMap = new Map(), this.lastButtonTriggerEvent = null, this.isBotRedirecting = false, this.waitingForFallbackEvent = false, // @ts-expect-error property decorator typing
+        this.eventHandler = (e)=>{
+            // Cut down on noise by ignoring mousemove when document isn't focused
+            if (e.type !== "mousemove" || document.hasFocus()) {
+                this.registerActivity();
+            }
+            // Conditions are listed independently for clarity.
+            // Let non clicks propagate
+            if (e.type !== "click") return;
+            // Let clicks without a target propagate
+            if (!e.target) return;
+            if (FALLBACK_EVENT_SYMBOL in e && e[FALLBACK_EVENT_SYMBOL] === FALLBACK_EVENT_VALUE) {
+                this.waitingForFallbackEvent = false;
+            }
+            this.handleButtonTriggers(e);
+        }, /**
+   * Debounce for the case of EventDispatch triggering duplicated click events for the same
+   * selectors within a tight window.
+   *
+   * See discussion in https://github.com/FatbearLabs/fireball/pull/9915#issuecomment-1716515215
+   */ this.handleButtonTriggers = debounce_default()((e)=>{
+            // Cannot trigger smart cta/manual bot experiences on meeting link pages
+            if (this.widget.isMeetingLink) {
+                return;
+            }
+            // Let fallback events propagate and also debounce trigger handling
+            if (FALLBACK_EVENT_SYMBOL in e && e[FALLBACK_EVENT_SYMBOL] === FALLBACK_EVENT_VALUE) {
+                return;
+            }
+            if (e.target instanceof Element && isWithinQualifiedElement(e.target)) {
+                return;
+            }
+            this.handleSmartCtaTriggers(e);
+            this.handleManualBotTriggers(e);
+        }, HIJACK_BUTTON_DEBOUNCE_MS, {
+            leading: true,
+            trailing: false
+        }), this.recordClickActivity = (e)=>{
+            if (e.target instanceof Element && this.pageViewActivityEmitter && this.smartWebsiteConfig) {
+                const selector = this.smartWebsiteConfig.matchingSelector(e.target);
+                if (selector) {
+                    var _this_personalizationsConfig;
+                    const metadata = (_this_personalizationsConfig = this.personalizationsConfig) == null ? void 0 : _this_personalizationsConfig.lookupSelectorMetadata(selector);
+                    this.pageViewActivityEmitter.emitPersonalizationClick({
+                        selector,
+                        experimentArmId: metadata == null ? void 0 : metadata.experimentArmId
+                    });
+                }
+            }
+        }, this.updatePageVisible = ()=>{
+            if (!this.navigating) {
+                this.pageVisible = isDomVisible();
+            }
+        }, // Idle tracking
+        this.registerActivity = debounce_default()(()=>{
+            if (this.isDisposed) {
+                return;
+            }
+            this.widget.registerClientActivity();
+            // visitor active again, create new page view
+            if (this.expiredFromInactivity && document.hasFocus()) {
+                var _this_channel_connect;
+                this.expiredFromInactivity = false;
+                (_this_channel_connect = this.channel.connect()) == null ? void 0 : _this_channel_connect.then(()=>{
+                    if (this.widget.isMeetingLink) {
+                        // TODO: remove once meeting link has its own pack
+                        this.recordMeetingLinkLoad();
+                    } else {
+                        this.createPageView();
+                    }
+                    // Needs to be toggled only after creating page view so that SPA page
+                    // views are blocked
+                    this.initialize();
+                    this.initializationParams = {};
+                });
+            }
+        }, 200), this.hijackClick = debounce_default()(async (botType, apiName, param)=>{
+            let { target, selector, event } = param;
+            const transaction = esm_browser_v4();
+            const startTime = performance.now();
+            this.experienceLoadingStartTimeMap.set(transaction, startTime);
+            let loadingId;
+            if (botType === "MANUAL") {
+                if (this.config.hasMeetingBookerExperienceBuilder) {
+                    this.experienceAdapter.showLightboxLoading();
+                } else {
+                    this.experienceAdapter.showMessengerLoading();
+                }
+            } else if (botType === "SMART_CTA") {
+                try {
+                    ButtonsFormsTriggeringTracer.startButtonClickSpan();
+                    // Pre-offer SLI: the click is the visitor's intent moment. Gated at arm,
+                    // so nothing is tracked at all for teams without the flag.
+                    if (this.featureFlags.bookerJourneySLI) {
+                        // `apiName` — the experience this selector is configured to trigger —
+                        // not `visitor.botApiName`, which is a state key no widget code path
+                        // ever writes (only `smartFormData.botApiName` is set), so it would
+                        // leave every CTA intent with no experience dimension at all.
+                        armFormCtaBookerIntent("cta:" + selector, apiName);
+                    }
+                    const loadingTarget = this.featureFlags.smartCtaNestedTriggersSupport ? target.closest(BUTTON_LIKE_SELECTOR) : target;
+                    this.personalizationManager.add(loadingTarget, selector);
+                    loadingId = this.personalizationManager.applyLoading(loadingTarget, "spinner");
+                    loadingId && this.experienceAdapter.showInlineLoading(loadingId);
+                } catch (e) {
+                    this.widget.debugLog("Failed to add inline spinner " + e.message);
+                    this.widget.serverLog({
+                        message: e.message,
+                        type: "both",
+                        extra: {
+                            event: "meeting_progress_loading_bar_error"
+                        }
+                    });
+                }
+            }
+            this.widget.debugLog("Showing experience for trigger [" + transaction + "]: " + selector);
+            this.showExperience(apiName, undefined, transaction);
+            const showExperienceDisposer = after(EXPERIENCE_TIMEOUT_MS, ()=>{
+                if (!this.experienceLoadingStartTimeMap.has(transaction)) {
+                    return;
+                }
+                this.widget.debugLog("Experience timed out [" + transaction + "]: " + selector);
+                this.experienceAdapter.closeLightbox();
+                loadingId && this.personalizationManager.removeLoadingByUuid(loadingId);
+                // This fallback is called if we don't receive a response from the server within the timeout
+                this.dispatchFallbackEvent({
+                    event,
+                    target,
+                    selector
+                });
+            });
+            this.callOnDispose(showExperienceDisposer);
+        }, HIJACK_CLICK_DEBOUNCE_MS, {
+            leading: true,
+            trailing: false
+        }), this.handleManualBotTriggers = (e)=>{
+            this.handleTriggers(e, this.config.manualBotTriggers, "MANUAL");
+        }, this.handleSmartCtaTriggers = (e)=>{
+            var _this_smartWebsiteConfig;
+            if ((_this_smartWebsiteConfig = this.smartWebsiteConfig) == null ? void 0 : _this_smartWebsiteConfig.hasCurrentTriggerSelectors) {
+                this.handleTriggers(e, this.smartWebsiteConfig.triggerSelectors, "SMART_CTA");
+            }
+        }, this.afterInit = (callback)=>{
+            if (this.initialized) {
+                callback();
+            } else {
+                this.afterInitQueue.push(callback);
+            }
+        }, this.handlePardotFormSubmitted = async (botApiName)=>{
+            if (botApiName === void 0) botApiName = "default";
+            await telemetry.startActiveSpanAsync("Pardot form submitted", {}, this.telemetryCtx, async (span)=>{
+                const pardot = this.config.pardotConfig ? await new pardot_visitor(this.config.pardotConfig).getIdentities() : {};
+                if (this.isDisposed) {
+                    return;
+                }
+                this.channel.send({
+                    event: "pardotFormSubmitted",
+                    payload: {
+                        bot_api_name: botApiName,
+                        pardot_prospect_email: pardot.prospectEmail,
+                        pardot_visitor_id: pardot.visitorId
+                    }
+                });
+                span.end();
+            });
+        }, this.handleSmartFormSubmitted = (fieldValues, botApiName)=>{
+            if (botApiName === void 0) botApiName = "default";
+            this.channel.send({
+                event: "smartFormSubmitted",
+                payload: {
+                    field_values: fieldValues,
+                    bot_api_name: botApiName
+                }
+            });
+        }, // TODO: Fix eslint error when this file is edited
+        // eslint-disable-next-line default-param-last
+        this.showExperience = (botApiName, initialClientState, transaction)=>{
+            if (botApiName === void 0) botApiName = "default";
+            this.channel.perform("show_experience", {
+                api_name: botApiName,
+                initial_client_state: initialClientState,
+                transaction
+            });
+        }, this.showFormExperience = (botApiName, formDestinations)=>{
+            var _this_widget_visitor_smartFormData, _this_widget_visitor_formData, _this_widget_visitor_smartFormData1;
+            if (!this.config.hasSmartForms) return;
+            const validBotApiName = botApiName || ((_this_widget_visitor_smartFormData = this.widget.visitor.smartFormData) == null ? void 0 : _this_widget_visitor_smartFormData.botApiName);
+            const validFieldValues = ((_this_widget_visitor_formData = this.widget.visitor.formData) == null ? void 0 : _this_widget_visitor_formData.fieldValues) || ((_this_widget_visitor_smartFormData1 = this.widget.visitor.smartFormData) == null ? void 0 : _this_widget_visitor_smartFormData1.fieldValues);
+            this.channel.perform("show_form_experience", {
+                bot_api_name: validBotApiName,
+                field_values: validFieldValues,
+                form_data: this.widget.visitor.formData,
+                form_destinations: formDestinations
+            });
+            this.widget.visitor.clearSmartFormData();
+            this.widget.visitor.clearFormData();
+        }, // TODO: extract redirect logic into its own handler, for setting up a form experience
+        // to be shown on the next page load
+        this.showExperienceForForm = (formType, formData, showOnRedirect)=>{
+            if (showOnRedirect === void 0) showOnRedirect = false;
+            var _formData_formActionUrl;
+            if (!this.config.hasSmartForms) {
+                this.widget.debugState.logEvent("tracker:showExperienceForForm", "error", {}, "smart_forms flag is not enabled");
+                return;
+            }
+            if (formData.formActionUrl && !this.config.formBotTriggers.pardot.includes((_formData_formActionUrl = formData.formActionUrl) == null ? void 0 : _formData_formActionUrl.replace(/^https?:\/\//, ""))) {
+                this.widget.debugState.logEvent("tracker:showExperienceForForm", "error", {}, "Form action URL is not in the list of Pardot form action URLs");
+                return;
+            }
+            if (showOnRedirect) {
+                this.widget.visitor.setFormExperienceDataWithExpiry({
+                    formType,
+                    formData
+                });
+                window.postMessage({
+                    source: "qualified",
+                    token: this.config.token,
+                    message: "done",
+                    verb: "showExperienceForForm"
+                }, window.location.origin);
+            } else {
+                var _formData_formActionUrl1;
+                ButtonsFormsTriggeringTracer.startSubmitFormSpan({
+                    "form.type": formType,
+                    "form.with_redirect": false
+                });
+                // Pre-offer SLI: the submit is the visitor's intent moment.
+                //
+                // No experience name on this path. `smartFormData` is written only by the
+                // `saveSmartFormData` API, so for a Marketo/HubSpot/custom submit arriving
+                // here any value it holds belongs to a different journey — reading it would
+                // attribute this form to an unrelated experience, which is worse than
+                // leaving the dimension absent. `formData` carries no api name either
+                // (`formEmail` / `formId` / `formActionUrl` only). Same call as the
+                // redirect-replay site in `widget.ts`.
+                if (this.featureFlags.bookerJourneySLI) {
+                    armFormCtaBookerIntent("form:" + formType);
+                }
+                this.experienceAdapter.showLightboxLoading();
+                this.channel.perform("show_experience_for_form", {
+                    form_type: formType,
+                    form_data: {
+                        raw: formData.raw || formData,
+                        form_id: formData.formId,
+                        form_email: formData.formEmail,
+                        form_action_url: (_formData_formActionUrl1 = formData.formActionUrl) == null ? void 0 : _formData_formActionUrl1.replace(/^https?:\/\//, "")
+                    }
+                });
+            }
+            this.widget.debugState.logEvent("tracker:showExperienceForForm", "success", {});
+        }, this.metActiveThreshold = ()=>{
+            const meta_description = document.querySelector('meta[name="description"]');
+            let description = null;
+            if (meta_description instanceof HTMLMetaElement) {
+                description = meta_description.content;
+            }
+            this.channel.perform("met_active_threshold", {
+                // Hack to prevent "Message from" title flashes from being fed to the backend
+                // Needed only temporarily until we start using chunks in auto pounce instead of the HTML title
+                title: this.resolveTitle(),
+                description,
+                source: this.experienceAdapter.apMessagesCount > 0 ? "auto_pounce" : "auto_respond"
+            });
+        }, this.resolveTitle = ()=>{
+            const { originalDocumentTitle } = this.experienceAdapter;
+            const documentTitle = document.title;
+            const resolvedTitle = originalDocumentTitle != null ? originalDocumentTitle : documentTitle;
+            if (resolvedTitle.startsWith("Message from")) {
+                var _this_experienceAdapter_originalDocumentTitle;
+                const message = "Resolved title is flash title for met_active_threshold";
+                this.widget.serverLog({
+                    message,
+                    extra: {
+                        original_document_title: (_this_experienceAdapter_originalDocumentTitle = this.experienceAdapter.originalDocumentTitle) != null ? _this_experienceAdapter_originalDocumentTitle : "original_document_title was null or undefined",
+                        document_title: document.title,
+                        url: window.document.location.href
+                    }
+                });
+            }
+            return resolvedTitle.startsWith("Message from") ? null : resolvedTitle;
+        }, this.getIdentity = ()=>{
+            this.channel.send({
+                event: "getIdentity",
+                payload: {}
+            });
+        }, this.setFieldValues = (fieldValues)=>{
+            this.channel.send({
+                event: "setFieldValues",
+                payload: {
+                    field_values: fieldValues
+                }
+            });
+        }, // TODO: remove once meeting link has its own pack
+        this.recordMeetingLinkLoad = (token)=>{
+            if (token === void 0) token = undefined;
+            const data = Object.assign({}, this.initializationParams, {
+                wu: this.widget.widgetId,
+                url: document.location.href,
+                wv: this.config.version,
+                referrer: document.referrer,
+                mlt: token || this.widget.meetingLinkToken
+            });
+            return this.channel.perform("record_meeting_link_load", data);
+        }, this.recordPrivacyDisclosure = (target, conversationId)=>{
+            const browserLocale = supportedBrowserLanguage(navigator.language);
+            return this.channel.perform("record_privacy_disclosure", {
+                target,
+                conversation_id: conversationId,
+                meeting_link_locale: browserLocale
+            });
+        }, this.recordPrivacyDisclosureConsent = (message)=>{
+            if (message.type && PRIVACY_DISCLOSURE_MESSAGE_TYPES.includes(message.type)) {
+                return this.channel.perform("record_privacy_disclosure_consent", {
+                    message_id: message.id
+                });
+            }
+        }, this.createPageView = (param)=>{
+            let { singlePageApp, reconnecting, rebroadcast, qualifiedRedirected } = param === void 0 ? {
+                singlePageApp: false,
+                reconnecting: false,
+                rebroadcast: false,
+                qualifiedRedirected: false
+            } : param;
+            const telemetryCtx = getTelemetryCtx();
+            // Ignore if URL hasn't changed
+            if (singlePageApp && document.location.href === this.lastPageViewUrl) return;
+            if (singlePageApp && !this.initialized) return;
+            this.lastPageViewUrl = document.location.href;
+            const data = Object.assign({}, this.initializationParams, {
+                wu: this.widget.widgetId,
+                url: document.location.href,
+                single_page_app: singlePageApp,
+                wv: this.config.version,
+                referrer: document.referrer,
+                reconnecting,
+                rebroadcast,
+                has_custom_form_data: this.visitor.hasFormData,
+                redirect_count: this.getRedirectCount()
+            });
+            const urlParams = new URLSearchParams(document.location.search);
+            if (urlParams.get("q_profiler_id")) {
+                data.q_profiler_id = urlParams.get("q_profiler_id");
+            }
+            this.widget.debugLog("Show clientside lightbox loading", "info", {
+                rebroadcast: String(rebroadcast),
+                qualifiedRedirected: String(qualifiedRedirected)
+            });
+            if (rebroadcast && !qualifiedRedirected) {
+                this.experienceAdapter.showLightboxLoading();
+            }
+            return withTelemetryCtx(telemetryCtx, ()=>this.channel.perform("record_page_view", data));
+        }, this.logExperienceLoadingTime = (transaction)=>{
+            const startTime = this.experienceLoadingStartTimeMap.get(transaction);
+            if (!startTime) {
+                return;
+            }
+            const delta = performance.now() - startTime;
+            const message = "Button experience loading time";
+            this.widget.logTiming(message, "buttons_time_to_socket_ms", delta);
+            this.experienceLoadingStartTimeMap.delete(transaction);
+        }, this.dispatchFallbackEvent = (buttonTriggerEvent)=>{
+            var _this_lastButtonTriggerEvent;
+            const { event, target: clickedElement, selector } = buttonTriggerEvent;
+            if (!event || this.isBotRedirecting) return;
+            // Force-open in current tab, because Safari does not allow us to open in a new tab asynchronously.
+            // This is a compromise. New tab is ideal, but Safari makes this impossible.
+            if (isSafariUserAgent && clickedElement instanceof HTMLAnchorElement && clickedElement.href && typeof clickedElement.target === "string" && clickedElement.target.toLowerCase() === "_blank") {
+                window.location.href = clickedElement.href;
+                this.waitingForFallbackEvent = false;
+            } else {
+                this.waitingForFallbackEvent = true;
+                const newEvent = cloneEvent(event, {
+                    [FALLBACK_EVENT_SYMBOL]: FALLBACK_EVENT_VALUE
+                });
+                // Manipulations to host's DOM can cause the last event target to be detached
+                // For example, when adding a loading icon, we cleanup the inners of a button.
+                // Since the event is triggered on the cleaned element of that button,
+                // We need to check if target isConnected to DOM.
+                if (clickedElement == null ? void 0 : clickedElement.isConnected) {
+                    clickedElement.dispatchEvent(newEvent);
+                } else if (selector) {
+                    var _this_personalizationManager_get;
+                    (_this_personalizationManager_get = this.personalizationManager.get(selector)) == null ? void 0 : _this_personalizationManager_get.dispatchEvent(newEvent);
+                }
+            }
+            if (event === ((_this_lastButtonTriggerEvent = this.lastButtonTriggerEvent) == null ? void 0 : _this_lastButtonTriggerEvent.event)) {
+                this.lastButtonTriggerEvent = null;
+            }
+        }, _class_private_field_loose_base(this, _onVisibilityChange)[_onVisibilityChange] = throttle_default()(()=>{
+            if (!this.isDisposed) {
+                this.updatePageVisible();
+                this.sendHeartbeat();
+            }
+        }, 1000), // @ts-expect-error property decorator typing
+        this.onPageHide = ()=>{
+            this.navigating = true;
+        }, // @ts-expect-error property decorator typing
+        this.onPing = ()=>{
+            var _this_config_heartbeatPingDivisor;
+            // Heartbeat frequency divisor. Default 2 (was hardcoded prior to INF-1108).
+            // With 4-second pings, divisor of 2 sends a heartbeat every 8 seconds (every 2nd ping).
+            // Fallback to 2 if config is missing (server-side validates to >= 1).
+            const divisor = (_this_config_heartbeatPingDivisor = this.config.heartbeatPingDivisor) != null ? _this_config_heartbeatPingDivisor : 2;
+            if (this.pingCounter++ % divisor === 0) {
+                this.sendHeartbeat();
+            }
+        }, this.sendHeartbeat = ()=>{
+            if (this.heartbeatManager.blocked) {
+                return;
+            }
+            this.channel.send({
+                event: "heartbeat",
+                payload: {
+                    client_activity_at: this.widget.lastClientActivityAt,
+                    page_visible: this.pageVisible
+                }
+            });
+        }, // @ts-expect-error property decorator typing
+        this.onSessionEnded = ()=>{
+            // TODO: when would this happen, backend didn't see heartbeats for awhile, but the cables are
+            // still connected?
+            this.channel.disconnect();
+            this.channel.connect();
+        }, // @ts-expect-error property decorator typing
+        this.onIdleTooLong = ()=>{
+            this.expiredFromInactivity = true;
+            this.initialized = false;
+            this.channel.disconnect();
+        }, // @ts-expect-error property decorator typing
+        this.onBotRedirect = ()=>{
+            this.visitor.setQualifiedRedirect(true);
+            this.isBotRedirecting = true;
+        }, // @ts-expect-error property decorator typing
+        this.onEndLoadingState = ()=>{
+            var // Clear any active loading overlay in the v2 adapter path.
+            // In v1, the iframe handles this via postMessage; v2 needs an explicit signal write.
+            // Guard: experienceAdapter may not be initialized yet if the channel fires before Widget.init() completes.
+            _this_experienceAdapter;
+            (_this_experienceAdapter = this.experienceAdapter) == null ? void 0 : _this_experienceAdapter.closeLightbox();
+            // This fallback is called if we should trigger the default behavior of the last button click
+            // i.e if the button click was hijacked but the visitor was disqualified
+            this.lastButtonTriggerEvent && this.dispatchFallbackEvent(this.lastButtonTriggerEvent);
+        }, this.getRedirectCount = ()=>{
+            var _performance_getEntriesByType;
+            const navigationEntry = performance.getEntriesByType == null ? void 0 : (_performance_getEntriesByType = performance.getEntriesByType.call(performance, "navigation")) == null ? void 0 : _performance_getEntriesByType[0];
+            return navigationEntry == null ? void 0 : navigationEntry.redirectCount;
+        };
+        this.lastPageViewUrl = "";
+        this.pingCounter = 0;
+        this.navigating = false;
+        this.pageVisible = true;
+        this.expiredFromInactivity = false;
+        this.initializationParams = {};
+        this.telemetryCtx = undefined;
+        this.afterInitQueue = [];
+        // AI Nudge
+        this.timerStartedAt = null;
+        this.timerTimeOnSite = 0;
+        if (this.config.smartCtaTriggers) {
+            this.smartWebsiteConfig = new smart_website_config({
+                smartCtaTriggers: this.config.smartCtaTriggers
+            });
+        }
+        this.personalizationManager = ((_this_widget_personalizationObserver = this.widget.personalizationObserver) == null ? void 0 : _this_widget_personalizationObserver.manager) || new PersonalizationManager((_ref = (_this_config_featureFlags = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags.smartCtaEnhancedFreezing) != null ? _ref : false);
+        if (this.config.experimentSelectors && this.config.experimentSelectors.length > 0) {
+            var _this_widget_personalizationObserver1;
+            (_this_widget_personalizationObserver1 = this.widget.personalizationObserver) == null ? void 0 : _this_widget_personalizationObserver1.stop(true);
+            this.personalizationsConfig = new personalizations_config({
+                experimentSelectors: this.config.experimentSelectors,
+                currentUrl: window.location.href,
+                activityEmitter: this.pageViewActivityEmitter
+            }, this.personalizationManager);
+        }
+        this.channel.on("ping", this.onPing);
+        this.channel.on("sessionEnded", this.onSessionEnded);
+        this.channel.on("idleTooLong", this.onIdleTooLong);
+        this.channel.on("redirect", this.onBotRedirect);
+        this.channel.on("endLoadingState", this.onEndLoadingState);
+        this.channel.on("reconnected", ()=>{
+            /**
+       * When idle, "initialized" is set to false.
+       * We just want to send this pageview if the reconnection was from an active connection trying to recover after being lost
+       * instead of idle connection reconnecting.
+       * Idle connections page views are already being taken care on "registerActivity" debounce.
+       */ if (this.initialized) {
+                this.createPageView({
+                    singlePageApp: false,
+                    reconnecting: true,
+                    rebroadcast: false
+                });
+            }
+        });
+        this.channel.on("personalizeWebsite", (data)=>{
+            var _this_personalizationsConfig;
+            return (_this_personalizationsConfig = this.personalizationsConfig) == null ? void 0 : _this_personalizationsConfig.onPersonalizeWebsite(data);
+        });
+        this.channel.on("showExperienceEnd", this.logExperienceLoadingTime);
+        this.channel.on("endInlineLoading", (uuid)=>{
+            this.personalizationManager.removeLoadingByUuid(uuid);
+        });
+        this.channel.on("widgetEvent", (name)=>this.widget.emitWidgetEvent(name));
+        this.channel.on("syncScriptState", (scriptState)=>{
+            try {
+                this.widget.iframeManager.handleSyncScriptState(scriptState);
+            } catch (unused) {
+            // V2 path: IframeManager not registered, syncScriptState is v1-only — safe to ignore
+            }
+        });
+        if (((_this_config_featureFlags1 = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags1.demo) || ((_this_config_featureFlags2 = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags2.demoKillSessionShortcut)) {
+            // Demo utility to quickly kill the session. Shift-Cmd-K (Mac) or Shift-Ctrl-K (Windows/Linux)
+            this.callOnDispose(addEventListener(document, "keydown", async (event)=>{
+                // eslint-disable-next-line rulesdir/enforce-comment
+                if (event.key === "k" && (event.metaKey || event.ctrlKey) && event.shiftKey) {
+                    event.preventDefault();
+                    await this.channel.perform("kill_session", {});
+                    this.channel.disconnect();
+                    // Show a small red dot in the bottom right corner to let SE know session was killed
+                    // z-index allows it to show over the multimodal widget
+                    const indicator = document.createElement("div");
+                    // eslint-disable-next-line rulesdir/enforce-comment
+                    indicator.style.cssText = "position:fixed;bottom:10px;right:10px;width:10px;height:10px;background:#f44;border-radius:50%;z-index:2147483648";
+                    document.body.appendChild(indicator);
+                }
+            }));
+        }
+    }
+}
+__decorate([
+    inject,
+    __metadata("design:type", typeof HeartbeatManager === "undefined" ? Object : HeartbeatManager)
+], Tracker.prototype, "heartbeatManager", void 0);
+__decorate([
+    ignoreIfDisposed
+], Tracker.prototype, "eventHandler", void 0);
+__decorate([
+    captureWidgetExceptions,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        typeof Event === "undefined" ? Object : Event,
+        typeof TriggerQuerySelectors === "undefined" ? Object : TriggerQuerySelectors,
+        typeof BotType === "undefined" ? Object : BotType
+    ]),
+    __metadata("design:returntype", void 0)
+], Tracker.prototype, "handleTriggers", null);
+__decorate([
+    ignoreIfDisposed
+], Tracker.prototype, "onPageHide", void 0);
+__decorate([
+    ignoreIfDisposed
+], Tracker.prototype, "onPing", void 0);
+__decorate([
+    ignoreIfDisposed
+], Tracker.prototype, "onSessionEnded", void 0);
+__decorate([
+    ignoreIfDisposed
+], Tracker.prototype, "onIdleTooLong", void 0);
+__decorate([
+    ignoreIfDisposed
+], Tracker.prototype, "onBotRedirect", void 0);
+__decorate([
+    ignoreIfDisposed
+], Tracker.prototype, "onEndLoadingState", void 0);
+/* export default */ const tracker = (Tracker);
+
+var tracker_HIJACK_CLICK_DEBOUNCE_MS = /* unused export */ undefined;
+var tracker_PRIVACY_DISCLOSURE_MESSAGE_TYPES = /* unused export */ undefined;
+export { tracker_HIJACK_CLICK_DEBOUNCE_MS as HIJACK_CLICK_DEBOUNCE_MS, tracker_PRIVACY_DISCLOSURE_MESSAGE_TYPES as PRIVACY_DISCLOSURE_MESSAGE_TYPES };
+export default tracker;