@posthog/browser-common 0.1.0 → 0.2.1

package/dist/utils/autocapture-utils.mjs

@@ -0,0 +1,385 @@
+import { each, entries } from "./general-utils.mjs";
+import { includes, isArray, isBoolean, isNullish, isString, isUndefined, trim } from "@posthog/core";
+import { logger } from "./logger.mjs";
+import { window as external_globals_mjs_window } from "./globals.mjs";
+import { getTargetingUrl } from "./url-targeting-utils.mjs";
+import { isElementNode, isShadowRoot, isTag, isTextNode } from "./element-utils.mjs";
+const MAX_DOM_ANCESTOR_DEPTH = 1000;
+function splitClassString(s) {
+    return s ? trim(s).split(/\s+/) : [];
+}
+function checkForURLMatches(urlsList, instance) {
+    const url = getTargetingUrl(instance);
+    return !!(url && urlsList && urlsList.some((regex)=>url.match(regex)));
+}
+function getClassNames(el) {
+    let className = '';
+    switch(typeof el.className){
+        case 'string':
+            className = el.className;
+            break;
+        case 'object':
+            className = (el.className && 'baseVal' in el.className ? el.className.baseVal : null) || el.getAttribute('class') || '';
+            break;
+        default:
+            className = '';
+    }
+    return splitClassString(className);
+}
+function makeSafeText(s) {
+    if (isNullish(s)) return null;
+    return trim(s).split(/(\s+)/).filter((s)=>shouldCaptureValue(s)).join('').replace(/[\r\n]/g, ' ').replace(/[ ]+/g, ' ').substring(0, 255);
+}
+function getSafeText(el) {
+    let elText = '';
+    if (shouldCaptureElement(el) && !isSensitiveElement(el) && el.childNodes && el.childNodes.length) each(el.childNodes, function(child) {
+        if (isTextNode(child) && child.textContent) elText += makeSafeText(child.textContent) ?? '';
+    });
+    return trim(elText);
+}
+function getEventTarget(e) {
+    if (isUndefined(e.target)) return e.srcElement || null;
+    if (e.target?.shadowRoot) return e.composedPath()[0] || null;
+    return e.target || null;
+}
+const autocaptureCompatibleElements = [
+    'a',
+    'button',
+    'form',
+    'input',
+    'select',
+    'textarea',
+    'label'
+];
+function checkIfElementTreePassesElementAllowList(elements, autocaptureConfig) {
+    const allowlist = autocaptureConfig?.element_allowlist;
+    if (isUndefined(allowlist)) return true;
+    for (const el of elements)if (allowlist.some((elementType)=>el.tagName.toLowerCase() === elementType)) return true;
+    return false;
+}
+function elementMatchesCSSSelector(el, selector) {
+    const matches = el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector;
+    try {
+        return matches ? matches.call(el, selector) : false;
+    } catch  {
+        return false;
+    }
+}
+function checkIfElementsMatchCSSSelector(elements, selectorList) {
+    if (isUndefined(selectorList)) return true;
+    for (const el of elements)if (selectorList.some((selector)=>elementMatchesCSSSelector(el, selector))) return true;
+    return false;
+}
+function getParentElement(curEl) {
+    const parentNode = curEl.parentNode;
+    if (!parentNode || !isElementNode(parentNode)) return false;
+    return parentNode;
+}
+const DEFAULT_AUTOCAPTURE_IGNORE_LIST = [
+    '.ph-no-autocapture',
+    '[data-ph-no-autocapture]'
+];
+const DEFAULT_CONTENT_IGNORELIST = [
+    'next',
+    'previous',
+    'prev',
+    '>',
+    '<'
+];
+const DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS = [
+    ...DEFAULT_CONTENT_IGNORELIST,
+    '+',
+    '-',
+    "\u2212",
+    "\u2013"
+];
+const MAX_CONTENT_IGNORELIST_ENTRIES = 10;
+const matchesContentKeyword = (text, keyword)=>/[a-z0-9]/i.test(keyword) ? text.includes(keyword) : text === keyword;
+function shouldIgnoreByContent(contentIgnorelist, elementsWithText) {
+    if (false === contentIgnorelist || isUndefined(contentIgnorelist)) return false;
+    let keywords;
+    if (true === contentIgnorelist) keywords = DEFAULT_CONTENT_IGNORELIST;
+    else {
+        if (!isArray(contentIgnorelist)) return false;
+        if (contentIgnorelist.length > MAX_CONTENT_IGNORELIST_ENTRIES) {
+            logger.error(`[PostHog] content_ignorelist array cannot exceed ${MAX_CONTENT_IGNORELIST_ENTRIES} items. Use css_selector_ignorelist for more complex matching.`);
+            return false;
+        }
+        keywords = contentIgnorelist.map((k)=>k.toLowerCase());
+    }
+    return elementsWithText.some(({ safeText, ariaLabel })=>keywords.some((keyword)=>matchesContentKeyword(safeText, keyword) || matchesContentKeyword(ariaLabel, keyword)));
+}
+const DEFAULT_DEAD_CLICK_IGNORE_LIST = [
+    '.ph-no-deadclick',
+    '.ph-no-capture'
+];
+function shouldCaptureDeadClick(el, _config) {
+    if (!external_globals_mjs_window || cannotCheckForAutocapture(el)) return false;
+    const selectorIgnoreList = isBoolean(_config) ? DEFAULT_DEAD_CLICK_IGNORE_LIST : _config?.css_selector_ignorelist ?? DEFAULT_DEAD_CLICK_IGNORE_LIST;
+    const { targetElementList } = getElementAndParentsForElement(el, false);
+    return !checkIfElementsMatchCSSSelector(targetElementList, selectorIgnoreList);
+}
+const DEFAULT_RAGE_CLICK_IGNORE_LIST = [
+    '.ph-no-rageclick',
+    '.ph-no-capture'
+];
+const TEXT_SELECTION_INPUT_TYPES = [
+    '',
+    'text',
+    'search',
+    'email',
+    'password',
+    'url',
+    'tel',
+    'number'
+];
+function isContentEditableTarget(el) {
+    if (el.isContentEditable) return true;
+    const contentEditable = el.getAttribute?.('contenteditable');
+    return 'true' === contentEditable || '' === contentEditable;
+}
+function isTextSelectionTarget(el) {
+    if (!el || !isElementNode(el)) return false;
+    if (isTag(el, 'textarea')) return true;
+    if (isTag(el, 'input')) return includes(TEXT_SELECTION_INPUT_TYPES, (el.getAttribute('type') || '').toLowerCase());
+    return isContentEditableTarget(el);
+}
+function shouldCaptureRageclick(el, _config) {
+    if (!external_globals_mjs_window || cannotCheckForAutocapture(el)) return false;
+    let selectorIgnoreList;
+    let contentIgnorelist;
+    let ignoreTextSelection;
+    if (isBoolean(_config)) {
+        selectorIgnoreList = _config ? DEFAULT_RAGE_CLICK_IGNORE_LIST : false;
+        contentIgnorelist = void 0;
+        ignoreTextSelection = false;
+    } else {
+        selectorIgnoreList = _config?.css_selector_ignorelist ?? DEFAULT_RAGE_CLICK_IGNORE_LIST;
+        contentIgnorelist = _config?.content_ignorelist;
+        ignoreTextSelection = _config?.ignore_text_selection ?? false;
+    }
+    if (false === selectorIgnoreList) return false;
+    if (ignoreTextSelection && isTextSelectionTarget(el)) return false;
+    const { targetElementList } = getElementAndParentsForElement(el, false);
+    const elementsWithText = targetElementList.map((element)=>({
+            safeText: getSafeText(element).toLowerCase(),
+            ariaLabel: element.getAttribute('aria-label')?.toLowerCase().trim() || ''
+        }));
+    if (shouldIgnoreByContent(contentIgnorelist, elementsWithText)) return false;
+    return !checkIfElementsMatchCSSSelector(targetElementList, selectorIgnoreList);
+}
+const cannotCheckForAutocapture = (el)=>!el || isTag(el, 'html') || !isElementNode(el);
+const getElementAndParentsForElement = (el, captureOnAnyElement)=>{
+    if (!external_globals_mjs_window || cannotCheckForAutocapture(el)) return {
+        parentIsUsefulElement: false,
+        targetElementList: []
+    };
+    let parentIsUsefulElement = false;
+    const targetElementList = [
+        el
+    ];
+    let curEl = el;
+    while(curEl.parentNode && !isTag(curEl, 'body')){
+        if (isShadowRoot(curEl.parentNode)) {
+            targetElementList.push(curEl.parentNode.host);
+            curEl = curEl.parentNode.host;
+            continue;
+        }
+        const parentNode = getParentElement(curEl);
+        if (!parentNode) break;
+        if (captureOnAnyElement || autocaptureCompatibleElements.indexOf(parentNode.tagName.toLowerCase()) > -1) parentIsUsefulElement = true;
+        else try {
+            const compStyles = external_globals_mjs_window.getComputedStyle(parentNode);
+            if (compStyles && 'pointer' === compStyles.getPropertyValue('cursor')) parentIsUsefulElement = true;
+        } catch  {}
+        targetElementList.push(parentNode);
+        curEl = parentNode;
+    }
+    return {
+        parentIsUsefulElement,
+        targetElementList
+    };
+};
+function shouldSkipDeadClick(el) {
+    if (!external_globals_mjs_window || cannotCheckForAutocapture(el)) return false;
+    const { targetElementList } = getElementAndParentsForElement(el, false);
+    return targetElementList.some((node)=>isTag(node, 'a'));
+}
+function shouldCaptureDomEvent(el, event, autocaptureConfig, captureOnAnyElement, allowedEventTypes, instance) {
+    if (!external_globals_mjs_window || cannotCheckForAutocapture(el)) return false;
+    if (autocaptureConfig?.url_allowlist) {
+        if (!checkForURLMatches(autocaptureConfig.url_allowlist, instance)) return false;
+    }
+    if (autocaptureConfig?.url_ignorelist) {
+        if (checkForURLMatches(autocaptureConfig.url_ignorelist, instance)) return false;
+    }
+    if (autocaptureConfig?.dom_event_allowlist) {
+        const allowlist = autocaptureConfig.dom_event_allowlist;
+        if (allowlist && !allowlist.some((eventType)=>event.type === eventType)) return false;
+    }
+    const { parentIsUsefulElement, targetElementList } = getElementAndParentsForElement(el, captureOnAnyElement);
+    if (!checkIfElementTreePassesElementAllowList(targetElementList, autocaptureConfig)) return false;
+    if (!checkIfElementsMatchCSSSelector(targetElementList, autocaptureConfig?.css_selector_allowlist)) return false;
+    const selectorIgnoreList = autocaptureConfig?.css_selector_ignorelist ?? DEFAULT_AUTOCAPTURE_IGNORE_LIST;
+    if (checkIfElementsMatchCSSSelector(targetElementList, selectorIgnoreList)) return false;
+    try {
+        const compStyles = external_globals_mjs_window.getComputedStyle(el);
+        if (compStyles && 'pointer' === compStyles.getPropertyValue('cursor') && 'click' === event.type) return true;
+    } catch  {}
+    const tag = el.tagName.toLowerCase();
+    switch(tag){
+        case 'html':
+            return false;
+        case 'form':
+            return (allowedEventTypes || [
+                'submit'
+            ]).indexOf(event.type) >= 0;
+        case 'input':
+        case 'select':
+        case 'textarea':
+            return (allowedEventTypes || [
+                'change',
+                'click'
+            ]).indexOf(event.type) >= 0;
+        default:
+            if (parentIsUsefulElement) return (allowedEventTypes || [
+                'click'
+            ]).indexOf(event.type) >= 0;
+            return (allowedEventTypes || [
+                'click'
+            ]).indexOf(event.type) >= 0 && (autocaptureCompatibleElements.indexOf(tag) > -1 || 'true' === el.getAttribute('contenteditable'));
+    }
+}
+function shouldCaptureElement(el) {
+    const seen = new Set();
+    let depth = 0;
+    for(let curEl = el; curEl.parentNode && !isTag(curEl, 'body'); curEl = curEl.parentNode){
+        if (depth++ >= MAX_DOM_ANCESTOR_DEPTH || seen.has(curEl)) return false;
+        seen.add(curEl);
+        const classes = getClassNames(curEl);
+        if (includes(classes, 'ph-sensitive') || includes(classes, 'ph-no-capture')) return false;
+    }
+    if (includes(getClassNames(el), 'ph-include')) return true;
+    const type = el.type || '';
+    if (isString(type)) switch(type.toLowerCase()){
+        case 'hidden':
+            return false;
+        case 'password':
+            return false;
+    }
+    const name = el.name || el.id || '';
+    if (isString(name)) {
+        const sensitiveNameRegex = /^cc|cardnum|ccnum|creditcard|csc|cvc|cvv|exp|pass|pwd|routing|seccode|securitycode|securitynum|socialsec|socsec|ssn/i;
+        if (sensitiveNameRegex.test(name.replace(/[^a-zA-Z0-9]/g, ''))) return false;
+    }
+    return true;
+}
+function isSensitiveElement(el) {
+    const allowedInputTypes = [
+        'button',
+        'checkbox',
+        'submit',
+        'reset'
+    ];
+    if (isTag(el, 'input') && !allowedInputTypes.includes(el.type) || isTag(el, 'select') || isTag(el, 'textarea') || 'true' === el.getAttribute('contenteditable')) return true;
+    return false;
+}
+const coreCCPattern = "(4[0-9]{12}(?:[0-9]{3})?)|(5[1-5][0-9]{14})|(6(?:011|5[0-9]{2})[0-9]{12})|(3[47][0-9]{13})|(3(?:0[0-5]|[68][0-9])[0-9]{11})|((?:2131|1800|35[0-9]{3})[0-9]{11})";
+const anchoredCCRegex = new RegExp(`^(?:${coreCCPattern})$`);
+const unanchoredCCRegex = new RegExp(coreCCPattern);
+const coreSSNPattern = "\\d{3}-?\\d{2}-?\\d{4}";
+const anchoredSSNRegex = new RegExp(`^(${coreSSNPattern})$`);
+const unanchoredSSNRegex = new RegExp(`(${coreSSNPattern})`);
+function shouldCaptureValue(value, anchorRegexes = true) {
+    if (isNullish(value)) return false;
+    if (isString(value)) {
+        value = trim(value);
+        const ccRegex = anchorRegexes ? anchoredCCRegex : unanchoredCCRegex;
+        if (ccRegex.test((value || '').replace(/[- ]/g, ''))) return false;
+        const ssnRegex = anchorRegexes ? anchoredSSNRegex : unanchoredSSNRegex;
+        if (ssnRegex.test(value)) return false;
+    }
+    return true;
+}
+function isAngularStyleAttr(attributeName) {
+    if (isString(attributeName)) return '_ngcontent' === attributeName.substring(0, 10) || '_nghost' === attributeName.substring(0, 7);
+    return false;
+}
+function getDirectAndNestedSpanText(target) {
+    let text = getSafeText(target);
+    text = `${text} ${getNestedSpanText(target)}`.trim();
+    return shouldCaptureValue(text) ? text : '';
+}
+function getNestedSpanText(target) {
+    let text = '';
+    if (target && target.childNodes && target.childNodes.length) each(target.childNodes, function(child) {
+        if (child && child.tagName?.toLowerCase() === 'span') try {
+            const spanText = getSafeText(child);
+            text = `${text} ${spanText}`.trim();
+            if (child.childNodes && child.childNodes.length) text = `${text} ${getNestedSpanText(child)}`.trim();
+        } catch (e) {
+            logger.error('[AutoCapture]', e);
+        }
+    });
+    return text;
+}
+function getElementsChainString(elements) {
+    return elementsToString(extractElements(elements));
+}
+function escapeQuotes(input) {
+    return input.replace(/"|\\"/g, '\\"');
+}
+function elementsToString(elements) {
+    const ret = elements.map((element)=>{
+        let el_string = '';
+        if (element.tag_name) el_string += element.tag_name;
+        if (element.attr_class) {
+            element.attr_class.sort();
+            for (const single_class of element.attr_class)el_string += `.${single_class.replace(/"/g, '')}`;
+        }
+        const attributes = {
+            ...element.text ? {
+                text: element.text
+            } : {},
+            'nth-child': element.nth_child ?? 0,
+            'nth-of-type': element.nth_of_type ?? 0,
+            ...element.href ? {
+                href: element.href
+            } : {},
+            ...element.attr_id ? {
+                attr_id: element.attr_id
+            } : {},
+            ...element.attributes
+        };
+        const sortedAttributes = {};
+        entries(attributes).sort(([a], [b])=>a.localeCompare(b)).forEach(([key, value])=>sortedAttributes[escapeQuotes(key.toString())] = escapeQuotes(value.toString()));
+        el_string += ':';
+        el_string += entries(sortedAttributes).map(([key, value])=>`${key}="${value}"`).join('');
+        return el_string;
+    });
+    return ret.join(';');
+}
+function extractElements(elements) {
+    return elements.map((el)=>{
+        const attributes = {};
+        const response = {
+            text: el['$el_text']?.slice(0, 400),
+            tag_name: el['tag_name'],
+            href: el['attr__href']?.slice(0, 2048),
+            attr_class: extractAttrClass(el),
+            attr_id: el['attr__id'],
+            nth_child: el['nth_child'],
+            nth_of_type: el['nth_of_type'],
+            attributes
+        };
+        entries(el).filter(([key])=>0 === key.indexOf('attr__')).forEach(([key, value])=>response.attributes[key] = value);
+        return response;
+    });
+}
+function extractAttrClass(el) {
+    const attr_class = el['attr__class'];
+    if (!attr_class) return;
+    if (isArray(attr_class)) return attr_class;
+    return splitClassString(attr_class);
+}
+export { DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS, MAX_DOM_ANCESTOR_DEPTH, autocaptureCompatibleElements, getClassNames, getDirectAndNestedSpanText, getElementsChainString, getEventTarget, getNestedSpanText, getParentElement, getSafeText, isAngularStyleAttr, isSensitiveElement, isTextSelectionTarget, makeSafeText, shouldCaptureDeadClick, shouldCaptureDomEvent, shouldCaptureElement, shouldCaptureRageclick, shouldCaptureValue, shouldSkipDeadClick, splitClassString };

package/dist/utils/blocked-uas.d.ts

@@ -0,0 +1,17 @@
+export { DEFAULT_BLOCKED_UA_STRS, isBlockedUA } from '@posthog/core';
+export interface NavigatorUAData {
+    brands?: {
+        brand: string;
+        version: string;
+    }[];
+    platform?: string;
+    getHighEntropyValues?: (hints: string[]) => Promise<{
+        model?: string;
+    }>;
+}
+declare global {
+    interface Navigator {
+        userAgentData?: NavigatorUAData;
+    }
+}
+export declare const isLikelyBot: (navigator: Navigator | undefined, customBlockedUserAgents: string[]) => boolean;

package/dist/utils/blocked-uas.js

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != 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__, {
+    DEFAULT_BLOCKED_UA_STRS: ()=>core_namespaceObject.DEFAULT_BLOCKED_UA_STRS,
+    isBlockedUA: ()=>core_namespaceObject.isBlockedUA,
+    isLikelyBot: ()=>isLikelyBot
+});
+const core_namespaceObject = require("@posthog/core");
+const isLikelyBot = function(navigator, customBlockedUserAgents) {
+    if (!navigator) return false;
+    const ua = navigator.userAgent;
+    if (ua) {
+        if ((0, core_namespaceObject.isBlockedUA)(ua, customBlockedUserAgents)) return true;
+    }
+    try {
+        const uaData = navigator?.userAgentData;
+        if (uaData?.brands && uaData.brands.some((brandObj)=>(0, core_namespaceObject.isBlockedUA)(brandObj?.brand, customBlockedUserAgents))) return true;
+    } catch  {}
+    return !!navigator.webdriver;
+};
+exports.DEFAULT_BLOCKED_UA_STRS = __webpack_exports__.DEFAULT_BLOCKED_UA_STRS;
+exports.isBlockedUA = __webpack_exports__.isBlockedUA;
+exports.isLikelyBot = __webpack_exports__.isLikelyBot;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_BLOCKED_UA_STRS",
+    "isBlockedUA",
+    "isLikelyBot"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/blocked-uas.mjs

@@ -0,0 +1,14 @@
+import { DEFAULT_BLOCKED_UA_STRS, isBlockedUA } from "@posthog/core";
+const isLikelyBot = function(navigator, customBlockedUserAgents) {
+    if (!navigator) return false;
+    const ua = navigator.userAgent;
+    if (ua) {
+        if (isBlockedUA(ua, customBlockedUserAgents)) return true;
+    }
+    try {
+        const uaData = navigator?.userAgentData;
+        if (uaData?.brands && uaData.brands.some((brandObj)=>isBlockedUA(brandObj?.brand, customBlockedUserAgents))) return true;
+    } catch  {}
+    return !!navigator.webdriver;
+};
+export { DEFAULT_BLOCKED_UA_STRS, isBlockedUA, isLikelyBot };

package/dist/utils/cookie-utils.d.ts

@@ -0,0 +1 @@
+export declare const getCookieValue: (name: string) => string | null | undefined;

package/dist/utils/cookie-utils.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != 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__, {
+    getCookieValue: ()=>getCookieValue
+});
+const external_globals_js_namespaceObject = require("./globals.js");
+const getCookieValue = (name)=>{
+    if (!external_globals_js_namespaceObject.document) return;
+    try {
+        const nameEQ = name + '=';
+        const cookies = external_globals_js_namespaceObject.document.cookie.split(';').filter((cookie)=>cookie.length);
+        for(let i = 0; i < cookies.length; i++){
+            let cookie = cookies[i];
+            while(' ' == cookie.charAt(0))cookie = cookie.substring(1, cookie.length);
+            if (0 === cookie.indexOf(nameEQ)) return decodeURIComponent(cookie.substring(nameEQ.length, cookie.length));
+        }
+    } catch  {}
+    return null;
+};
+exports.getCookieValue = __webpack_exports__.getCookieValue;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getCookieValue"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/cookie-utils.mjs

@@ -0,0 +1,15 @@
+import { document as external_globals_mjs_document } from "./globals.mjs";
+const getCookieValue = (name)=>{
+    if (!external_globals_mjs_document) return;
+    try {
+        const nameEQ = name + '=';
+        const cookies = external_globals_mjs_document.cookie.split(';').filter((cookie)=>cookie.length);
+        for(let i = 0; i < cookies.length; i++){
+            let cookie = cookies[i];
+            while(' ' == cookie.charAt(0))cookie = cookie.substring(1, cookie.length);
+            if (0 === cookie.indexOf(nameEQ)) return decodeURIComponent(cookie.substring(nameEQ.length, cookie.length));
+        }
+    } catch  {}
+    return null;
+};
+export { getCookieValue };

package/dist/utils/device-model-utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads the hardware model from `navigator.userAgentData.getHighEntropyValues(['model'])`.
+ *
+ * Only meaningful on Android Chromium — `undefined` on Safari/Firefox and an empty string on desktop
+ * (both treated as absent). A Permissions-Policy block rejects with `NotAllowedError`, which we catch
+ * and return `undefined`.
+ */
+export declare function getDeviceModel(): Promise<string | undefined>;

package/dist/utils/device-model-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != 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__, {
+    getDeviceModel: ()=>getDeviceModel
+});
+const core_namespaceObject = require("@posthog/core");
+const external_globals_js_namespaceObject = require("./globals.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+async function getDeviceModel() {
+    const uaData = external_globals_js_namespaceObject.navigator?.userAgentData;
+    if (!uaData?.getHighEntropyValues) return;
+    try {
+        const hints = await uaData.getHighEntropyValues([
+            'model'
+        ]);
+        const model = hints?.model;
+        return (0, core_namespaceObject.isString)(model) && model.length > 0 ? model : void 0;
+    } catch (e) {
+        external_logger_js_namespaceObject.logger.info('Unable to resolve $device_model from userAgentData.getHighEntropyValues', e);
+        return;
+    }
+}
+exports.getDeviceModel = __webpack_exports__.getDeviceModel;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getDeviceModel"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/device-model-utils.mjs

@@ -0,0 +1,18 @@
+import { isString } from "@posthog/core";
+import { navigator as external_globals_mjs_navigator } from "./globals.mjs";
+import { logger } from "./logger.mjs";
+async function getDeviceModel() {
+    const uaData = external_globals_mjs_navigator?.userAgentData;
+    if (!uaData?.getHighEntropyValues) return;
+    try {
+        const hints = await uaData.getHighEntropyValues([
+            'model'
+        ]);
+        const model = hints?.model;
+        return isString(model) && model.length > 0 ? model : void 0;
+    } catch (e) {
+        logger.info('Unable to resolve $device_model from userAgentData.getHighEntropyValues', e);
+        return;
+    }
+}
+export { getDeviceModel };

package/dist/utils/element-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function isElementInToolbar(el: EventTarget | null): boolean;
+export declare function isElementNode(el: Node | Element | undefined | null): el is Element;
+export declare function isTag(el: Element | undefined | null, tag: string): el is HTMLElement;
+export declare function isTextNode(el: Element | undefined | null): el is HTMLElement;
+export declare function isShadowRoot(el: Node | ParentNode | undefined | null): el is ShadowRoot;