@posthog/browser-common 0.9.8 → 0.9.10

package/dist/autocapture-config.d.ts

@@ -0,0 +1,13 @@
+import type { AutocaptureConfig as DomAutocaptureConfig, RageclickConfig } from '@posthog/types';
+export interface AutocaptureConfig extends DomAutocaptureConfig {
+    enabled: boolean;
+    rageclick: boolean | RageclickConfig;
+    maskAllElementAttributes: boolean;
+    maskAllText: boolean;
+    disableCaptureUrlHashes: boolean;
+    getCurrentUrl?: (defaultUrl: string) => string;
+    remoteRequestsDisabled: boolean;
+}
+export interface AutocaptureConfigSource {
+    refresh(config: AutocaptureConfig): void;
+}

package/dist/autocapture-config.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/autocapture-config.mjs

@@ -0,0 +1 @@
+export { };

package/dist/autocapture.d.ts

@@ -0,0 +1,63 @@
+import type { Client } from './client';
+import type { Extension } from './extension';
+import type { ExtensionToken } from './token';
+import RageClick from './rageclick';
+import type { Properties } from '@posthog/types';
+import type { RemoteConfigResult } from './types/remote-config';
+import type { AutocaptureConfigSource } from './autocapture-config';
+export declare function getAugmentPropertiesFromElement(elem: Element): Properties;
+export declare function previousElementSibling(el: Element): Element | null;
+export declare function getDefaultProperties(eventType: string): Properties;
+export declare function getPropertiesFromElement(elem: Element, maskAllAttributes: boolean, maskText: boolean, elementAttributeIgnorelist: string[] | undefined, disableCaptureUrlHashes?: boolean): Properties;
+export declare function autocapturePropertiesForElement(target: Element, { e, maskAllElementAttributes, maskAllText, elementAttributeIgnoreList, elementsChainAsString, disableCaptureUrlHashes, }: {
+    e: Event;
+    maskAllElementAttributes: boolean;
+    maskAllText: boolean;
+    elementAttributeIgnoreList?: string[] | undefined;
+    elementsChainAsString: boolean;
+    disableCaptureUrlHashes: boolean;
+}): {
+    props: Properties;
+    explicitNoCapture?: boolean;
+    target?: Element;
+};
+export declare const AutocaptureExtension: ExtensionToken<Autocapture>;
+export declare class Autocapture implements Extension {
+    private readonly _configSource;
+    readonly name: ExtensionToken<Autocapture>;
+    _initialized: boolean;
+    _isDisabledServerSide: boolean | null;
+    _hasReceivedConfigResponse: boolean;
+    _elementSelectors: Set<string> | null;
+    private _elementSelectorsByOwner;
+    rageclicks: RageClick;
+    _elementsChainAsString: boolean;
+    private _listenerWindow;
+    private _listenerDocument;
+    private _client;
+    private readonly _config;
+    private _remoteConfigSubscription;
+    private _domEventHandler;
+    private _copiedTextHandler;
+    private _disposed;
+    private _pointerDown;
+    private _pointerExpiry;
+    private _clearPointer;
+    private _isExcludedPointerTarget;
+    private _trackPointer;
+    private _recoverClickTarget;
+    constructor(_configSource: AutocaptureConfigSource);
+    setup(client: Client): void;
+    dispose(): void;
+    private _refreshConfig;
+    private _compileUrlPatterns;
+    _addDomEventHandlers(): void;
+    private _removeDomEventHandlers;
+    startIfEnabled(): void;
+    onRemoteConfig(result: RemoteConfigResult): void;
+    setElementSelectors(selectors: Set<string>, owner?: object): void;
+    getElementSelectors(element: Element | null, additionalElement?: Element): string[] | null;
+    get isEnabled(): boolean;
+    private _captureEvent;
+    isBrowserSupported(): boolean;
+}

package/dist/autocapture.js

@@ -0,0 +1,533 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Autocapture: ()=>Autocapture,
+    AutocaptureExtension: ()=>AutocaptureExtension,
+    autocapturePropertiesForElement: ()=>autocapturePropertiesForElement,
+    getAugmentPropertiesFromElement: ()=>getAugmentPropertiesFromElement,
+    getDefaultProperties: ()=>getDefaultProperties,
+    getPropertiesFromElement: ()=>getPropertiesFromElement,
+    previousElementSibling: ()=>previousElementSibling
+});
+const general_utils_js_namespaceObject = require("./utils/general-utils.js");
+const autocapture_utils_js_namespaceObject = require("./utils/autocapture-utils.js");
+const external_rageclick_js_namespaceObject = require("./rageclick.js");
+var external_rageclick_js_default = /*#__PURE__*/ __webpack_require__.n(external_rageclick_js_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const core_namespaceObject = require("@posthog/core");
+const logger_js_namespaceObject = require("./utils/logger.js");
+const convert_to_url_js_namespaceObject = require("./utils/convert-to-url.js");
+const element_utils_js_namespaceObject = require("./utils/element-utils.js");
+const getWindow = ()=>"u" < typeof window ? void 0 : window;
+const getDocument = ()=>"u" < typeof document ? void 0 : document;
+const COPY_AUTOCAPTURE_EVENT = '$copy_autocapture';
+const logger = (0, logger_js_namespaceObject.createLogger)('[AutoCapture]');
+function limitText(length, text) {
+    if (text.length > length) return text.slice(0, length) + '...';
+    return text;
+}
+function getAugmentPropertiesFromElement(elem) {
+    const shouldCaptureEl = (0, autocapture_utils_js_namespaceObject.shouldCaptureElement)(elem);
+    if (!shouldCaptureEl) return {};
+    const props = {};
+    (0, general_utils_js_namespaceObject.each)(elem.attributes, function(attr) {
+        if (attr.name && 0 === attr.name.indexOf('data-ph-capture-attribute')) {
+            const propertyKey = attr.name.replace('data-ph-capture-attribute-', '');
+            const propertyValue = attr.value;
+            if (propertyKey && propertyValue && (0, autocapture_utils_js_namespaceObject.shouldCaptureValue)(propertyValue)) props[propertyKey] = propertyValue;
+        }
+    });
+    return props;
+}
+function previousElementSibling(el) {
+    if (el.previousElementSibling) return el.previousElementSibling;
+    let _el = el;
+    do _el = _el.previousSibling;
+    while (_el && !(0, element_utils_js_namespaceObject.isElementNode)(_el));
+    return _el;
+}
+function getDefaultProperties(eventType) {
+    return {
+        $event_type: eventType,
+        $ce_version: 1
+    };
+}
+function getPropertiesFromElement(elem, maskAllAttributes, maskText, elementAttributeIgnorelist, disableCaptureUrlHashes = false) {
+    const tag_name = elem.tagName.toLowerCase();
+    const props = {
+        tag_name: tag_name
+    };
+    if (autocapture_utils_js_namespaceObject.autocaptureCompatibleElements.indexOf(tag_name) > -1 && !maskText) if ('a' === tag_name.toLowerCase() || 'button' === tag_name.toLowerCase()) props['$el_text'] = limitText(1024, (0, autocapture_utils_js_namespaceObject.getDirectAndNestedSpanText)(elem));
+    else props['$el_text'] = limitText(1024, (0, autocapture_utils_js_namespaceObject.getSafeText)(elem));
+    const classes = (0, autocapture_utils_js_namespaceObject.getClassNames)(elem);
+    if (!maskAllAttributes && !elementAttributeIgnorelist?.includes('class') && classes.length > 0) props['classes'] = classes.filter(function(c) {
+        return '' !== c;
+    });
+    (0, general_utils_js_namespaceObject.each)(elem.attributes, function(attr) {
+        if ((0, autocapture_utils_js_namespaceObject.isSensitiveElement)(elem) && -1 === [
+            'name',
+            'id',
+            'class',
+            'aria-label'
+        ].indexOf(attr.name)) return;
+        if (elementAttributeIgnorelist?.includes(attr.name)) return;
+        if (!maskAllAttributes && (0, autocapture_utils_js_namespaceObject.shouldCaptureValue)(attr.value) && !(0, autocapture_utils_js_namespaceObject.isAngularStyleAttr)(attr.name)) {
+            let value = attr.value;
+            if ('class' === attr.name) value = (0, autocapture_utils_js_namespaceObject.splitClassString)(value).join(' ');
+            props['attr__' + attr.name] = limitText(1024, 'href' === attr.name && disableCaptureUrlHashes ? (0, core_namespaceObject.stripUrlHash)(value) : value);
+        }
+    });
+    let nthChild = 1;
+    let nthOfType = 1;
+    let currentElem = elem;
+    while(currentElem = previousElementSibling(currentElem)){
+        nthChild++;
+        if (currentElem.tagName === elem.tagName) nthOfType++;
+    }
+    props['nth_child'] = nthChild;
+    props['nth_of_type'] = nthOfType;
+    return props;
+}
+function autocapturePropertiesForElement(target, { e, maskAllElementAttributes, maskAllText, elementAttributeIgnoreList, elementsChainAsString, disableCaptureUrlHashes }) {
+    if (!(0, element_utils_js_namespaceObject.isElementNode)(target)) return {
+        props: {}
+    };
+    const targetElementList = [
+        target
+    ];
+    const seen = new Set([
+        target
+    ]);
+    let curEl = target;
+    while(curEl.parentNode && !(0, element_utils_js_namespaceObject.isTag)(curEl, 'body')){
+        if (targetElementList.length >= autocapture_utils_js_namespaceObject.MAX_DOM_ANCESTOR_DEPTH) break;
+        if ((0, element_utils_js_namespaceObject.isShadowRoot)(curEl.parentNode)) {
+            const host = curEl.parentNode.host;
+            if (seen.has(host)) break;
+            seen.add(host);
+            targetElementList.push(host);
+            curEl = host;
+            continue;
+        }
+        if (!(0, element_utils_js_namespaceObject.isElementNode)(curEl.parentNode)) break;
+        if (seen.has(curEl.parentNode)) break;
+        seen.add(curEl.parentNode);
+        targetElementList.push(curEl.parentNode);
+        curEl = curEl.parentNode;
+    }
+    const controlIndex = 'click' === e.type && 'http://www.w3.org/2000/svg' === target.namespaceURI ? targetElementList.findIndex((el)=>(0, element_utils_js_namespaceObject.isTag)(el, 'button') || (0, element_utils_js_namespaceObject.isTag)(el, 'a')) : -1;
+    if (controlIndex > 0) maskAllText = maskAllText || targetElementList.slice(0, controlIndex + 1).some((el)=>!(0, autocapture_utils_js_namespaceObject.shouldCaptureElement)(el) || (0, autocapture_utils_js_namespaceObject.isSensitiveElement)(el));
+    const elementsJson = [];
+    const autocaptureAugmentProperties = {};
+    let href = false;
+    let explicitNoCapture = false;
+    (0, general_utils_js_namespaceObject.each)(targetElementList, (el)=>{
+        const shouldCaptureEl = (0, autocapture_utils_js_namespaceObject.shouldCaptureElement)(el);
+        if ((0, element_utils_js_namespaceObject.isTag)(el, 'a') && !maskAllElementAttributes && !elementAttributeIgnoreList?.includes('href')) {
+            const hrefAttr = el.getAttribute('href');
+            href = shouldCaptureEl && !!hrefAttr && (0, autocapture_utils_js_namespaceObject.shouldCaptureValue)(hrefAttr) ? disableCaptureUrlHashes ? (0, core_namespaceObject.stripUrlHash)(hrefAttr) : hrefAttr : false;
+        }
+        const classes = (0, autocapture_utils_js_namespaceObject.getClassNames)(el);
+        if ((0, core_namespaceObject.includes)(classes, 'ph-no-capture')) explicitNoCapture = true;
+        elementsJson.push(getPropertiesFromElement(el, maskAllElementAttributes, maskAllText, elementAttributeIgnoreList, disableCaptureUrlHashes));
+        const augmentProperties = getAugmentPropertiesFromElement(el);
+        (0, general_utils_js_namespaceObject.each)(augmentProperties, (value, key)=>{
+            if (!Object.prototype.hasOwnProperty.call(autocaptureAugmentProperties, key)) autocaptureAugmentProperties[key] = value;
+        });
+    });
+    if (explicitNoCapture) return {
+        props: {},
+        explicitNoCapture
+    };
+    if (controlIndex > 0) {
+        target = targetElementList[controlIndex];
+        elementsJson.splice(0, controlIndex);
+    }
+    if (!maskAllText) if ((0, element_utils_js_namespaceObject.isTag)(target, 'a') || (0, element_utils_js_namespaceObject.isTag)(target, 'button')) elementsJson[0]['$el_text'] = (0, autocapture_utils_js_namespaceObject.getDirectAndNestedSpanText)(target);
+    else elementsJson[0]['$el_text'] = (0, autocapture_utils_js_namespaceObject.getSafeText)(target);
+    let externalHref;
+    if (href) {
+        elementsJson[0]['attr__href'] = href;
+        const hrefHost = (0, convert_to_url_js_namespaceObject.convertToURL)(href)?.host;
+        const locationHost = getWindow()?.location?.host;
+        if (hrefHost && locationHost && hrefHost !== locationHost) externalHref = href;
+    }
+    const props = (0, general_utils_js_namespaceObject.extend)(getDefaultProperties(e.type), elementsChainAsString ? {} : {
+        $elements: elementsJson
+    }, {
+        $elements_chain: (0, autocapture_utils_js_namespaceObject.getElementsChainString)(elementsJson)
+    }, elementsJson[0]?.['$el_text'] ? {
+        $el_text: elementsJson[0]?.['$el_text']
+    } : {}, externalHref && 'click' === e.type ? {
+        $external_click_url: externalHref
+    } : {}, autocaptureAugmentProperties);
+    return {
+        props,
+        target
+    };
+}
+const AutocaptureExtension = 'autocapture';
+class Autocapture {
+    _clearPointer() {
+        this._pointerDown = void 0;
+        clearTimeout(this._pointerExpiry);
+        this._pointerExpiry = void 0;
+    }
+    _isExcludedPointerTarget(target) {
+        if (!(0, autocapture_utils_js_namespaceObject.shouldCaptureElement)(target)) return true;
+        const ignorelist = this._refreshConfig().css_selector_ignorelist ?? autocapture_utils_js_namespaceObject.DEFAULT_AUTOCAPTURE_IGNORE_LIST;
+        const seen = new Set();
+        let el = target;
+        while(el){
+            if (seen.size >= autocapture_utils_js_namespaceObject.MAX_DOM_ANCESTOR_DEPTH || seen.has(el)) return true;
+            seen.add(el);
+            const current = el;
+            const classes = (0, autocapture_utils_js_namespaceObject.getClassNames)(current);
+            if ((0, core_namespaceObject.includes)(classes, 'ph-no-capture') || (0, core_namespaceObject.includes)(classes, 'ph-sensitive') || (0, autocapture_utils_js_namespaceObject.isSensitiveElement)(current) || ignorelist.some((selector)=>(0, autocapture_utils_js_namespaceObject.elementMatchesCSSSelector)(current, selector))) return true;
+            const parent = el.parentNode;
+            el = (0, element_utils_js_namespaceObject.isShadowRoot)(parent) ? parent.host : parent && (0, element_utils_js_namespaceObject.isElementNode)(parent) ? parent : null;
+        }
+        return false;
+    }
+    _trackPointer(e) {
+        if (!this.isEnabled || 'pointercancel' === e.type) return void this._clearPointer();
+        if ('pointerdown' === e.type) {
+            this._clearPointer();
+            const target = (0, autocapture_utils_js_namespaceObject.getEventTarget)(e);
+            if (e.isPrimary && 0 === e.button && !e.ctrlKey && target && (0, element_utils_js_namespaceObject.isElementNode)(target)) this._pointerDown = {
+                target,
+                excluded: this._isExcludedPointerTarget(target),
+                id: e.pointerId,
+                x: e.clientX,
+                y: e.clientY,
+                released: false,
+                distinctId: this._client?.distinctId
+            };
+            return;
+        }
+        const down = this._pointerDown;
+        if (!down) return;
+        if (e.pointerId !== down.id || Math.abs(e.clientX - down.x) > 5 || Math.abs(e.clientY - down.y) > 5) this._clearPointer();
+        else if ('pointerup' === e.type) {
+            down.released = true;
+            this._pointerExpiry = setTimeout(()=>this._clearPointer(), 0);
+        }
+    }
+    _recoverClickTarget(e) {
+        const down = this._pointerDown;
+        this._clearPointer();
+        const target = (0, autocapture_utils_js_namespaceObject.getEventTarget)(e);
+        if (down?.released && down.target.isConnected && down.distinctId === this._client?.distinctId && e.pointerId === down.id && (e.detail > 0 || 'touch' === e.pointerType || 'pen' === e.pointerType) && 0 === e.button && Math.abs(e.clientX - down.x) <= 5 && Math.abs(e.clientY - down.y) <= 5 && target && ((0, element_utils_js_namespaceObject.isTag)(target, 'html') || (0, element_utils_js_namespaceObject.isTag)(target, 'body'))) {
+            if (down.excluded) return null;
+            const ignorelist = this._refreshConfig().css_selector_ignorelist ?? autocapture_utils_js_namespaceObject.DEFAULT_AUTOCAPTURE_IGNORE_LIST;
+            const excludedRoot = [
+                target,
+                getDocument()?.documentElement,
+                getDocument()?.body
+            ].some((root)=>{
+                if (!root) return false;
+                const classes = (0, autocapture_utils_js_namespaceObject.getClassNames)(root);
+                return (0, core_namespaceObject.includes)(classes, 'ph-no-capture') || (0, core_namespaceObject.includes)(classes, 'ph-sensitive') || !(0, autocapture_utils_js_namespaceObject.shouldCaptureElement)(root) || (0, autocapture_utils_js_namespaceObject.isSensitiveElement)(root) || ignorelist.some((selector)=>(0, autocapture_utils_js_namespaceObject.elementMatchesCSSSelector)(root, selector));
+            });
+            if (excludedRoot) return null;
+            return down.target;
+        }
+    }
+    constructor(_configSource){
+        this._configSource = _configSource;
+        this.name = AutocaptureExtension;
+        this._initialized = false;
+        this._isDisabledServerSide = null;
+        this._hasReceivedConfigResponse = false;
+        this._elementSelectorsByOwner = new Map();
+        this._elementsChainAsString = false;
+        this._config = {
+            enabled: false,
+            rageclick: false,
+            maskAllElementAttributes: false,
+            maskAllText: false,
+            disableCaptureUrlHashes: false,
+            remoteRequestsDisabled: false
+        };
+        this._disposed = false;
+        this._configSource.refresh(this._config);
+        this.rageclicks = new (external_rageclick_js_default())(this._config.rageclick);
+        this._elementSelectors = null;
+    }
+    setup(client) {
+        this._compileUrlPatterns();
+        this._client = client;
+        const subscription = client.onRemoteConfig(this.onRemoteConfig.bind(this));
+        if (this._disposed) return void subscription.dispose();
+        this._remoteConfigSubscription = subscription;
+        this.startIfEnabled();
+    }
+    dispose() {
+        if (this._disposed) return;
+        this._disposed = true;
+        this._client = void 0;
+        this._remoteConfigSubscription?.dispose();
+        this._remoteConfigSubscription = void 0;
+        this._elementSelectorsByOwner.clear();
+        this._elementSelectors = null;
+        this._removeDomEventHandlers();
+    }
+    _refreshConfig() {
+        this._configSource.refresh(this._config);
+        return this._config;
+    }
+    _compileUrlPatterns() {
+        this._refreshConfig();
+        this._config.url_allowlist = this._config.url_allowlist?.map((url)=>new RegExp(url));
+        this._config.url_ignorelist = this._config.url_ignorelist?.map((url)=>new RegExp(url));
+        return this._config;
+    }
+    _addDomEventHandlers() {
+        const window1 = getWindow();
+        const document1 = getDocument();
+        if (!this.isBrowserSupported()) return void logger.info('Disabling Automatic Event Collection because this browser is not supported');
+        if (!window1 || !document1) return;
+        this._listenerWindow = window1;
+        this._listenerDocument = document1;
+        const handler = this._domEventHandler = (e)=>{
+            e = e || window1?.event;
+            try {
+                if ('blur' === e.type) return void this._clearPointer();
+                if (0 === e.type.indexOf('pointer')) return void this._trackPointer(e);
+                const target = 'click' === e.type ? this._recoverClickTarget(e) : void 0;
+                if ((0, core_namespaceObject.isNull)(target)) return;
+                this._captureEvent(e, '$autocapture', target);
+            } catch (error) {
+                logger.error('Failed to capture event', error);
+            }
+        };
+        (0, general_utils_js_namespaceObject.addEventListener)(window1, 'blur', handler);
+        (0, general_utils_js_namespaceObject.addEventListener)(document1, 'submit', handler, {
+            capture: true
+        });
+        (0, general_utils_js_namespaceObject.addEventListener)(document1, 'change', handler, {
+            capture: true
+        });
+        (0, general_utils_js_namespaceObject.addEventListener)(document1, 'click', handler, {
+            capture: true
+        });
+        (0, general_utils_js_namespaceObject.each)([
+            'pointerdown',
+            'pointermove',
+            'pointerup',
+            'pointercancel'
+        ], (type)=>{
+            (0, general_utils_js_namespaceObject.addEventListener)(document1, type, handler, {
+                capture: true
+            });
+        });
+        if (this._refreshConfig().capture_copied_text) {
+            const copiedTextHandler = this._copiedTextHandler = (e)=>{
+                e = e || window1?.event;
+                try {
+                    this._captureEvent(e, COPY_AUTOCAPTURE_EVENT);
+                } catch (error) {
+                    logger.error('Failed to capture clipboard event', error);
+                }
+            };
+            (0, general_utils_js_namespaceObject.addEventListener)(document1, 'copy', copiedTextHandler, {
+                capture: true
+            });
+            (0, general_utils_js_namespaceObject.addEventListener)(document1, 'cut', copiedTextHandler, {
+                capture: true
+            });
+            (0, general_utils_js_namespaceObject.addEventListener)(document1, 'paste', copiedTextHandler, {
+                capture: true
+            });
+        }
+    }
+    _removeDomEventHandlers() {
+        const window1 = this._listenerWindow;
+        const document1 = this._listenerDocument;
+        this._clearPointer();
+        if (this._domEventHandler) {
+            window1?.removeEventListener('blur', this._domEventHandler);
+            (0, general_utils_js_namespaceObject.each)([
+                'pointerdown',
+                'pointermove',
+                'pointerup',
+                'pointercancel'
+            ], (type)=>{
+                document1?.removeEventListener(type, this._domEventHandler, true);
+            });
+            document1?.removeEventListener('submit', this._domEventHandler, true);
+            document1?.removeEventListener('change', this._domEventHandler, true);
+            document1?.removeEventListener('click', this._domEventHandler, true);
+            this._domEventHandler = void 0;
+        }
+        if (this._copiedTextHandler) {
+            document1?.removeEventListener('copy', this._copiedTextHandler, true);
+            document1?.removeEventListener('cut', this._copiedTextHandler, true);
+            document1?.removeEventListener('paste', this._copiedTextHandler, true);
+            this._copiedTextHandler = void 0;
+        }
+        this._listenerWindow = void 0;
+        this._listenerDocument = void 0;
+        this._initialized = false;
+    }
+    startIfEnabled() {
+        if (!this.isEnabled) this._clearPointer();
+        if (!this._disposed && this._client && this.isEnabled && !this._initialized) {
+            this._addDomEventHandlers();
+            this._initialized = true;
+        }
+    }
+    onRemoteConfig(result) {
+        if (this._disposed) return;
+        this._hasReceivedConfigResponse = true;
+        if (!result.ok) return void this.startIfEnabled();
+        const response = result.config;
+        if (response.elementsChainAsString) this._elementsChainAsString = response.elementsChainAsString;
+        const optOut = response['autocapture_opt_out'];
+        if ((0, core_namespaceObject.isBoolean)(optOut)) {
+            this._client?.kv.set(external_constants_js_namespaceObject.AUTOCAPTURE_DISABLED_SERVER_SIDE, optOut);
+            this._isDisabledServerSide = optOut;
+        }
+        this.startIfEnabled();
+    }
+    setElementSelectors(selectors, owner = this) {
+        if (this._disposed) return;
+        if (selectors.size) this._elementSelectorsByOwner.set(owner, new Set(selectors));
+        else this._elementSelectorsByOwner.delete(owner);
+        const combined = new Set();
+        this._elementSelectorsByOwner.forEach((contribution)=>{
+            contribution.forEach((selector)=>combined.add(selector));
+        });
+        this._elementSelectors = combined;
+    }
+    getElementSelectors(element, additionalElement) {
+        const elementSelectors = [];
+        this._elementSelectors?.forEach((selector)=>{
+            const matchedElements = getDocument()?.querySelectorAll(selector);
+            matchedElements?.forEach((matchedElement)=>{
+                if ((element === matchedElement || additionalElement === matchedElement) && !(0, core_namespaceObject.includes)(elementSelectors, selector)) elementSelectors.push(selector);
+            });
+        });
+        return elementSelectors;
+    }
+    get isEnabled() {
+        if (this._disposed) return false;
+        const persistedServerDisabled = this._client?.kv.get(external_constants_js_namespaceObject.AUTOCAPTURE_DISABLED_SERVER_SIDE);
+        const memoryDisabled = this._isDisabledServerSide;
+        const config = this._refreshConfig();
+        if (!config.remoteRequestsDisabled && !this._hasReceivedConfigResponse) return false;
+        const clientConfigOnly = config.remoteRequestsDisabled && !this._hasReceivedConfigResponse;
+        if ((0, core_namespaceObject.isNull)(memoryDisabled) && !(0, core_namespaceObject.isBoolean)(persistedServerDisabled) && !clientConfigOnly) return false;
+        const disabledServer = this._isDisabledServerSide ?? !!persistedServerDisabled;
+        const disabledClient = !config.enabled;
+        return !disabledClient && !disabledServer;
+    }
+    _captureEvent(e, eventName = '$autocapture', targetOverride) {
+        if (!this.isEnabled) return void this._clearPointer();
+        let target = targetOverride || (0, autocapture_utils_js_namespaceObject.getEventTarget)(e);
+        if ((0, element_utils_js_namespaceObject.isTextNode)(target)) target = target.parentNode || null;
+        const config = this._compileUrlPatterns();
+        if ('$autocapture' === eventName && 'click' === e.type && e instanceof MouseEvent) {
+            if (!!config.rageclick && this.rageclicks?.isRageClick(e.clientX, e.clientY, e.timeStamp || new Date().getTime())) {
+                if ((0, autocapture_utils_js_namespaceObject.shouldCaptureRageclick)(target, config.rageclick)) this._captureEvent(e, '$rageclick', targetOverride);
+            }
+        }
+        const isClipboardAutocapture = eventName === COPY_AUTOCAPTURE_EVENT;
+        const eventConfig = isClipboardAutocapture ? {
+            ...config,
+            dom_event_allowlist: void 0
+        } : config;
+        if (target && (0, autocapture_utils_js_namespaceObject.shouldCaptureDomEvent)(target, e, eventConfig, isClipboardAutocapture, isClipboardAutocapture ? [
+            'copy',
+            'cut',
+            'paste'
+        ] : void 0, {
+            config: {
+                get_current_url: config.getCurrentUrl
+            }
+        })) {
+            const { props, explicitNoCapture, target: attributedTarget } = autocapturePropertiesForElement(target, {
+                e,
+                maskAllElementAttributes: config.maskAllElementAttributes,
+                maskAllText: config.maskAllText,
+                elementAttributeIgnoreList: config.element_attribute_ignorelist,
+                elementsChainAsString: this._elementsChainAsString,
+                disableCaptureUrlHashes: config.disableCaptureUrlHashes
+            });
+            if (explicitNoCapture) return false;
+            const elementSelectors = this.getElementSelectors(target, attributedTarget);
+            if (elementSelectors && elementSelectors.length > 0) props['$element_selectors'] = elementSelectors;
+            if (eventName === COPY_AUTOCAPTURE_EVENT) {
+                const clipType = e.type || 'clipboard';
+                if ('paste' !== clipType) {
+                    const selectedText = getWindow()?.getSelection()?.toString();
+                    const selectedContent = (0, autocapture_utils_js_namespaceObject.makeSafeText)(selectedText);
+                    if (!selectedContent) return false;
+                    props['$selected_content'] = selectedContent;
+                    props['$clipboard_text_length'] = selectedText?.length ?? 0;
+                }
+                props['$copy_type'] = clipType;
+            }
+            this._client?.capture(eventName, props);
+            return true;
+        }
+    }
+    isBrowserSupported() {
+        return (0, core_namespaceObject.isFunction)(getDocument()?.querySelectorAll);
+    }
+}
+exports.Autocapture = __webpack_exports__.Autocapture;
+exports.AutocaptureExtension = __webpack_exports__.AutocaptureExtension;
+exports.autocapturePropertiesForElement = __webpack_exports__.autocapturePropertiesForElement;
+exports.getAugmentPropertiesFromElement = __webpack_exports__.getAugmentPropertiesFromElement;
+exports.getDefaultProperties = __webpack_exports__.getDefaultProperties;
+exports.getPropertiesFromElement = __webpack_exports__.getPropertiesFromElement;
+exports.previousElementSibling = __webpack_exports__.previousElementSibling;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Autocapture",
+    "AutocaptureExtension",
+    "autocapturePropertiesForElement",
+    "getAugmentPropertiesFromElement",
+    "getDefaultProperties",
+    "getPropertiesFromElement",
+    "previousElementSibling"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});