@posthog/browser-common 0.1.0 → 0.2.1

package/dist/utils/element-utils.js

@@ -0,0 +1,67 @@
+"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__, {
+    isTag: ()=>isTag,
+    isElementInToolbar: ()=>isElementInToolbar,
+    isShadowRoot: ()=>isShadowRoot,
+    isTextNode: ()=>isTextNode,
+    isElementNode: ()=>isElementNode
+});
+const external_constants_js_namespaceObject = require("../constants.js");
+const NODE_TYPE_ELEMENT = 1;
+const NODE_TYPE_TEXT = 3;
+const NODE_TYPE_DOCUMENT_FRAGMENT = 11;
+function isElementInToolbar(el) {
+    if (el instanceof Element) return el.id === external_constants_js_namespaceObject.TOOLBAR_ID || !!el.closest?.('.' + external_constants_js_namespaceObject.TOOLBAR_CONTAINER_CLASS);
+    return false;
+}
+function isElementNode(el) {
+    return !!el && el.nodeType === NODE_TYPE_ELEMENT;
+}
+function isTag(el, tag) {
+    return !!el && !!el.tagName && el.tagName.toLowerCase() === tag.toLowerCase();
+}
+function isTextNode(el) {
+    return !!el && el.nodeType === NODE_TYPE_TEXT;
+}
+function isShadowRoot(el) {
+    return !!el && el.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT && isElementNode(el.host);
+}
+exports.isElementInToolbar = __webpack_exports__.isElementInToolbar;
+exports.isElementNode = __webpack_exports__.isElementNode;
+exports.isShadowRoot = __webpack_exports__.isShadowRoot;
+exports.isTag = __webpack_exports__.isTag;
+exports.isTextNode = __webpack_exports__.isTextNode;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isElementInToolbar",
+    "isElementNode",
+    "isShadowRoot",
+    "isTag",
+    "isTextNode"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/element-utils.mjs

@@ -0,0 +1,21 @@
+import { TOOLBAR_CONTAINER_CLASS, TOOLBAR_ID } from "../constants.mjs";
+const NODE_TYPE_ELEMENT = 1;
+const NODE_TYPE_TEXT = 3;
+const NODE_TYPE_DOCUMENT_FRAGMENT = 11;
+function isElementInToolbar(el) {
+    if (el instanceof Element) return el.id === TOOLBAR_ID || !!el.closest?.('.' + TOOLBAR_CONTAINER_CLASS);
+    return false;
+}
+function isElementNode(el) {
+    return !!el && el.nodeType === NODE_TYPE_ELEMENT;
+}
+function isTag(el, tag) {
+    return !!el && !!el.tagName && el.tagName.toLowerCase() === tag.toLowerCase();
+}
+function isTextNode(el) {
+    return !!el && el.nodeType === NODE_TYPE_TEXT;
+}
+function isShadowRoot(el) {
+    return !!el && el.nodeType === NODE_TYPE_DOCUMENT_FRAGMENT && isElementNode(el.host);
+}
+export { isElementInToolbar, isElementNode, isShadowRoot, isTag, isTextNode };

package/dist/utils/elements-chain-utils.d.ts

@@ -0,0 +1,4 @@
+export declare function extractHref(elementsChain: string): string;
+export declare function extractTexts(elementsChain: string): string[];
+export declare function matchString(value: string | undefined | null, pattern: string, matching: 'exact' | 'contains' | 'regex'): boolean;
+export declare function matchTexts(texts: string[], pattern: string, matching: 'exact' | 'contains' | 'regex'): boolean;

package/dist/utils/elements-chain-utils.js

@@ -0,0 +1,79 @@
+"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__, {
+    matchString: ()=>matchString,
+    extractHref: ()=>extractHref,
+    extractTexts: ()=>extractTexts,
+    matchTexts: ()=>matchTexts
+});
+const core_namespaceObject = require("@posthog/core");
+function extractHref(elementsChain) {
+    const match = elementsChain.match(/(?::|")href="(.*?)"/);
+    return match ? match[1] : '';
+}
+function extractTexts(elementsChain) {
+    const texts = [];
+    const regex = /(?::|")text="(.*?)"/g;
+    let match;
+    while(!(0, core_namespaceObject.isNullish)(match = regex.exec(elementsChain)))if (!texts.includes(match[1])) texts.push(match[1]);
+    return texts;
+}
+function matchString(value, pattern, matching) {
+    if ((0, core_namespaceObject.isNullish)(value)) return false;
+    switch(matching){
+        case 'exact':
+            return value === pattern;
+        case 'contains':
+            {
+                const likePattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/_/g, '.').replace(/%/g, '.*');
+                return new RegExp(likePattern, 'i').test(value);
+            }
+        case 'regex':
+            try {
+                return new RegExp(pattern).test(value);
+            } catch  {
+                return false;
+            }
+        default:
+            return false;
+    }
+}
+function matchTexts(texts, pattern, matching) {
+    return texts.some((text)=>matchString(text, pattern, matching));
+}
+exports.extractHref = __webpack_exports__.extractHref;
+exports.extractTexts = __webpack_exports__.extractTexts;
+exports.matchString = __webpack_exports__.matchString;
+exports.matchTexts = __webpack_exports__.matchTexts;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "extractHref",
+    "extractTexts",
+    "matchString",
+    "matchTexts"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/elements-chain-utils.mjs

@@ -0,0 +1,36 @@
+import { isNullish } from "@posthog/core";
+function extractHref(elementsChain) {
+    const match = elementsChain.match(/(?::|")href="(.*?)"/);
+    return match ? match[1] : '';
+}
+function extractTexts(elementsChain) {
+    const texts = [];
+    const regex = /(?::|")text="(.*?)"/g;
+    let match;
+    while(!isNullish(match = regex.exec(elementsChain)))if (!texts.includes(match[1])) texts.push(match[1]);
+    return texts;
+}
+function matchString(value, pattern, matching) {
+    if (isNullish(value)) return false;
+    switch(matching){
+        case 'exact':
+            return value === pattern;
+        case 'contains':
+            {
+                const likePattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/_/g, '.').replace(/%/g, '.*');
+                return new RegExp(likePattern, 'i').test(value);
+            }
+        case 'regex':
+            try {
+                return new RegExp(pattern).test(value);
+            } catch  {
+                return false;
+            }
+        default:
+            return false;
+    }
+}
+function matchTexts(texts, pattern, matching) {
+    return texts.some((text)=>matchString(text, pattern, matching));
+}
+export { extractHref, extractTexts, matchString, matchTexts };

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

@@ -0,0 +1,8 @@
+/**
+ * UTF-8 safe base64 encoding.
+ * Uses encodeURIComponent to handle Unicode, then converts percent-encoded bytes
+ * back to characters that btoa can handle.
+ */
+export declare function _base64Encode(data: null): null;
+export declare function _base64Encode(data: undefined): undefined;
+export declare function _base64Encode(data: string): string;

package/dist/utils/encode-utils.js

@@ -0,0 +1,39 @@
+"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__, {
+    _base64Encode: ()=>_base64Encode
+});
+function _base64Encode(data) {
+    if (!data) return data;
+    return btoa(encodeURIComponent(data).replace(/%([0-9A-F]{2})/g, (_, p1)=>String.fromCharCode(parseInt(p1, 16))));
+}
+exports._base64Encode = __webpack_exports__._base64Encode;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "_base64Encode"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/encode-utils.mjs

@@ -0,0 +1,5 @@
+function _base64Encode(data) {
+    if (!data) return data;
+    return btoa(encodeURIComponent(data).replace(/%([0-9A-F]{2})/g, (_, p1)=>String.fromCharCode(parseInt(p1, 16))));
+}
+export { _base64Encode };

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

@@ -0,0 +1,24 @@
+import type { Properties } from '@posthog/types';
+import type { BrowserDetectionHints } from '@posthog/core';
+export declare const PERSONAL_DATA_CAMPAIGN_PARAMS: string[];
+export declare const CAMPAIGN_PARAMS: string[];
+export declare const EVENT_TO_PERSON_PROPERTIES: string[];
+export declare const MASKED = "<masked>";
+export declare const COOKIE_CAMPAIGN_PARAMS: string[];
+export declare function getCampaignParams(customTrackedParams?: string[], maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[] | undefined): Record<string, string>;
+export declare function getSearchInfo(): Record<string, any>;
+export declare function getBrowserLanguage(): string | undefined;
+export declare function getBrowserLanguagePrefix(): string | undefined;
+export declare function getReferrer(): string;
+export declare function getReferringDomain(): string;
+export declare function getReferrerInfo(): Record<string, any>;
+export declare function getPersonInfo(maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[], disableCaptureUrlHashes?: boolean): {
+    r: string;
+    u: string | undefined;
+};
+export declare function getPersonPropsFromInfo(info: Record<string, any>, disableCaptureUrlHashes?: boolean): Record<string, any>;
+export declare function getInitialPersonPropsFromInfo(info: Record<string, any>, disableCaptureUrlHashes?: boolean): Record<string, any>;
+export declare function getTimezone(): string | undefined;
+export declare function getTimezoneOffset(): number | undefined;
+export declare function getBrowserDetectionHints(): BrowserDetectionHints;
+export declare function getEventProperties(maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[], detectGoogleSearchApp?: boolean, disableCaptureUrlHashes?: boolean): Properties;

package/dist/utils/event-utils.js

@@ -0,0 +1,344 @@
+"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, 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__, {
+    getCampaignParams: ()=>getCampaignParams,
+    getReferrerInfo: ()=>getReferrerInfo,
+    getEventProperties: ()=>getEventProperties,
+    getPersonPropsFromInfo: ()=>getPersonPropsFromInfo,
+    COOKIE_CAMPAIGN_PARAMS: ()=>COOKIE_CAMPAIGN_PARAMS,
+    getReferrer: ()=>getReferrer,
+    getReferringDomain: ()=>getReferringDomain,
+    getTimezone: ()=>getTimezone,
+    getBrowserDetectionHints: ()=>getBrowserDetectionHints,
+    getBrowserLanguagePrefix: ()=>getBrowserLanguagePrefix,
+    getInitialPersonPropsFromInfo: ()=>getInitialPersonPropsFromInfo,
+    MASKED: ()=>MASKED,
+    getPersonInfo: ()=>getPersonInfo,
+    CAMPAIGN_PARAMS: ()=>CAMPAIGN_PARAMS,
+    getBrowserLanguage: ()=>getBrowserLanguage,
+    PERSONAL_DATA_CAMPAIGN_PARAMS: ()=>PERSONAL_DATA_CAMPAIGN_PARAMS,
+    getSearchInfo: ()=>getSearchInfo,
+    getTimezoneOffset: ()=>getTimezoneOffset,
+    EVENT_TO_PERSON_PROPERTIES: ()=>EVENT_TO_PERSON_PROPERTIES
+});
+const external_request_utils_js_namespaceObject = require("./request-utils.js");
+const core_namespaceObject = require("@posthog/core");
+const external_config_js_namespaceObject = require("../config.js");
+var external_config_js_default = /*#__PURE__*/ __webpack_require__.n(external_config_js_namespaceObject);
+const external_constants_js_namespaceObject = require("../constants.js");
+const external_general_utils_js_namespaceObject = require("./general-utils.js");
+const external_globals_js_namespaceObject = require("./globals.js");
+const external_cookie_utils_js_namespaceObject = require("./cookie-utils.js");
+const URL_REGEX_PREFIX = 'https?://(.*)';
+const PERSONAL_DATA_CAMPAIGN_PARAMS = [
+    'gclid',
+    'gclsrc',
+    'dclid',
+    'gbraid',
+    'wbraid',
+    'fbclid',
+    'msclkid',
+    'twclid',
+    'li_fat_id',
+    'igshid',
+    'ttclid',
+    'rdt_cid',
+    'epik',
+    'qclid',
+    'sccid',
+    'irclid',
+    '_kx'
+];
+const CAMPAIGN_PARAMS = [
+    'utm_source',
+    'utm_medium',
+    'utm_campaign',
+    'utm_content',
+    'utm_term',
+    'gad_source',
+    'mc_cid',
+    ...PERSONAL_DATA_CAMPAIGN_PARAMS
+];
+const EVENT_TO_PERSON_PROPERTIES = [
+    '$app_build',
+    '$app_name',
+    '$app_namespace',
+    '$app_version',
+    '$browser',
+    '$browser_version',
+    '$device_type',
+    '$current_url',
+    '$pathname',
+    '$os',
+    '$os_name',
+    '$os_version',
+    '$referring_domain',
+    '$referrer',
+    '$screen_height',
+    '$screen_width',
+    '$viewport_height',
+    '$viewport_width',
+    '$raw_user_agent'
+];
+const MASKED = '<masked>';
+const COOKIE_CAMPAIGN_PARAMS = [
+    'li_fat_id'
+];
+function getCampaignParams(customTrackedParams, maskPersonalDataProperties, customPersonalDataProperties) {
+    if (!external_globals_js_namespaceObject.document) return {};
+    const paramsToMask = maskPersonalDataProperties ? [
+        ...PERSONAL_DATA_CAMPAIGN_PARAMS,
+        ...customPersonalDataProperties || []
+    ] : [];
+    const urlCampaignParams = _getCampaignParamsFromUrl((0, external_request_utils_js_namespaceObject.maskQueryParams)(external_globals_js_namespaceObject.document.URL, paramsToMask, MASKED), customTrackedParams);
+    const cookieCampaignParams = _getCampaignParamsFromCookie();
+    return (0, external_general_utils_js_namespaceObject.extend)(cookieCampaignParams, urlCampaignParams);
+}
+function _getCampaignParamsFromUrl(url, customParams) {
+    const campaign_keywords = CAMPAIGN_PARAMS.concat(customParams || []);
+    const params = {};
+    (0, external_general_utils_js_namespaceObject.each)(campaign_keywords, function(kwkey) {
+        const kw = (0, external_request_utils_js_namespaceObject.getQueryParam)(url, kwkey);
+        params[kwkey] = kw ? kw : null;
+    });
+    return params;
+}
+function _getCampaignParamsFromCookie() {
+    const params = {};
+    (0, external_general_utils_js_namespaceObject.each)(COOKIE_CAMPAIGN_PARAMS, function(kwkey) {
+        const kw = (0, external_cookie_utils_js_namespaceObject.getCookieValue)(kwkey);
+        params[kwkey] = kw ? kw : null;
+    });
+    return params;
+}
+function _getSearchEngine(referrer) {
+    if (!referrer) return null;
+    if (0 === referrer.search(URL_REGEX_PREFIX + 'google.([^/?]*)')) return 'google';
+    if (0 === referrer.search(URL_REGEX_PREFIX + 'bing.com')) return 'bing';
+    if (0 === referrer.search(URL_REGEX_PREFIX + 'yahoo.com')) return 'yahoo';
+    if (0 === referrer.search(URL_REGEX_PREFIX + 'duckduckgo.com')) return 'duckduckgo';
+    else return null;
+}
+function _getSearchInfoFromReferrer(referrer) {
+    const search = _getSearchEngine(referrer);
+    const param = 'yahoo' != search ? 'q' : 'p';
+    const ret = {};
+    if (!(0, core_namespaceObject.isNull)(search)) {
+        ret['$search_engine'] = search;
+        const keyword = external_globals_js_namespaceObject.document ? (0, external_request_utils_js_namespaceObject.getQueryParam)(external_globals_js_namespaceObject.document.referrer, param) : '';
+        if (keyword.length) ret['ph_keyword'] = keyword;
+    }
+    return ret;
+}
+function getSearchInfo() {
+    const referrer = external_globals_js_namespaceObject.document?.referrer;
+    if (!referrer) return {};
+    return _getSearchInfoFromReferrer(referrer);
+}
+function getBrowserLanguage() {
+    return navigator.language || navigator.userLanguage;
+}
+function getBrowserLanguagePrefix() {
+    const lang = getBrowserLanguage();
+    return 'string' == typeof lang ? lang.split('-')[0] : void 0;
+}
+const DIRECT = '$direct';
+function getReferrer() {
+    return external_globals_js_namespaceObject.document?.referrer || DIRECT;
+}
+function getReferringDomain() {
+    if (!external_globals_js_namespaceObject.document?.referrer) return DIRECT;
+    return (0, external_request_utils_js_namespaceObject.convertToURL)(external_globals_js_namespaceObject.document.referrer)?.host || DIRECT;
+}
+function getReferrerInfo() {
+    return {
+        $referrer: getReferrer(),
+        $referring_domain: getReferringDomain()
+    };
+}
+function getPersonInfo(maskPersonalDataProperties, customPersonalDataProperties, disableCaptureUrlHashes = false) {
+    const paramsToMask = maskPersonalDataProperties ? [
+        ...PERSONAL_DATA_CAMPAIGN_PARAMS,
+        ...customPersonalDataProperties || []
+    ] : [];
+    const href = disableCaptureUrlHashes ? (0, core_namespaceObject.stripUrlHash)(external_globals_js_namespaceObject.location?.href) : external_globals_js_namespaceObject.location?.href;
+    const url = href?.substring(0, 1000);
+    return {
+        r: getReferrer().substring(0, 1000),
+        u: url ? (0, external_request_utils_js_namespaceObject.maskQueryParams)(url, paramsToMask, MASKED) : void 0
+    };
+}
+function getPersonPropsFromInfo(info, disableCaptureUrlHashes = false) {
+    const { r: referrer, u } = info;
+    const url = disableCaptureUrlHashes ? (0, core_namespaceObject.stripUrlHash)(u) : u;
+    const referring_domain = null == referrer ? void 0 : referrer == DIRECT ? DIRECT : (0, external_request_utils_js_namespaceObject.convertToURL)(referrer)?.host;
+    const props = {
+        $referrer: referrer,
+        $referring_domain: referring_domain
+    };
+    if (url) {
+        props['$current_url'] = url;
+        const location = (0, external_request_utils_js_namespaceObject.convertToURL)(url);
+        props['$host'] = location?.host;
+        props['$pathname'] = location?.pathname;
+        const campaignParams = _getCampaignParamsFromUrl(url);
+        (0, external_general_utils_js_namespaceObject.extend)(props, campaignParams);
+    }
+    if (referrer) {
+        const searchInfo = _getSearchInfoFromReferrer(referrer);
+        (0, external_general_utils_js_namespaceObject.extend)(props, searchInfo);
+    }
+    return props;
+}
+function getInitialPersonPropsFromInfo(info, disableCaptureUrlHashes = false) {
+    const personProps = getPersonPropsFromInfo(info, disableCaptureUrlHashes);
+    const props = {};
+    (0, external_general_utils_js_namespaceObject.each)(personProps, function(val, key) {
+        props[`$initial_${(0, core_namespaceObject.stripLeadingDollar)(key)}`] = val;
+    });
+    return props;
+}
+function getTimezone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch  {
+        return;
+    }
+}
+function getTimezoneOffset() {
+    try {
+        return new Date().getTimezoneOffset();
+    } catch  {
+        return;
+    }
+}
+function getBrowserDetectionHints() {
+    const nav = 'undefined' != typeof navigator ? navigator : void 0;
+    return nav?.brave ? {
+        brave: true
+    } : {};
+}
+function getEventProperties(maskPersonalDataProperties, customPersonalDataProperties, detectGoogleSearchApp, disableCaptureUrlHashes = false) {
+    if (!external_globals_js_namespaceObject.userAgent) return {};
+    const paramsToMask = maskPersonalDataProperties ? [
+        ...PERSONAL_DATA_CAMPAIGN_PARAMS,
+        ...customPersonalDataProperties || []
+    ] : [];
+    const [os_name, os_version] = (0, core_namespaceObject.detectOS)(external_globals_js_namespaceObject.userAgent);
+    const browserHints = getBrowserDetectionHints();
+    const browserOptions = {};
+    if (!(0, core_namespaceObject.isUndefined)(detectGoogleSearchApp)) browserOptions.detectGoogleSearchApp = detectGoogleSearchApp;
+    const deviceOptions = {};
+    const userAgentDataPlatform = navigator?.userAgentData?.platform;
+    const maxTouchPoints = navigator?.maxTouchPoints;
+    const screenWidth = external_globals_js_namespaceObject.window?.screen?.width;
+    const screenHeight = external_globals_js_namespaceObject.window?.screen?.height;
+    const devicePixelRatio = external_globals_js_namespaceObject.window?.devicePixelRatio;
+    if (!(0, core_namespaceObject.isUndefined)(userAgentDataPlatform)) deviceOptions.userAgentDataPlatform = userAgentDataPlatform;
+    if (!(0, core_namespaceObject.isUndefined)(maxTouchPoints)) deviceOptions.maxTouchPoints = maxTouchPoints;
+    if (!(0, core_namespaceObject.isUndefined)(screenWidth)) deviceOptions.screenWidth = screenWidth;
+    if (!(0, core_namespaceObject.isUndefined)(screenHeight)) deviceOptions.screenHeight = screenHeight;
+    if (!(0, core_namespaceObject.isUndefined)(devicePixelRatio)) deviceOptions.devicePixelRatio = devicePixelRatio;
+    const properties = (0, external_general_utils_js_namespaceObject.extend)((0, external_general_utils_js_namespaceObject.stripEmptyProperties)({
+        $os: os_name,
+        $os_version: os_version,
+        $browser: (0, core_namespaceObject.detectBrowser)(external_globals_js_namespaceObject.userAgent, navigator.vendor, browserHints, browserOptions),
+        $device: (0, core_namespaceObject.detectDevice)(external_globals_js_namespaceObject.userAgent),
+        $device_type: (0, core_namespaceObject.detectDeviceType)(external_globals_js_namespaceObject.userAgent, deviceOptions),
+        $timezone: getTimezone(),
+        $timezone_offset: getTimezoneOffset()
+    }), {
+        $current_url: (0, external_request_utils_js_namespaceObject.maskQueryParams)(disableCaptureUrlHashes ? (0, core_namespaceObject.stripUrlHash)(external_globals_js_namespaceObject.location?.href) : external_globals_js_namespaceObject.location?.href, paramsToMask, MASKED),
+        $host: external_globals_js_namespaceObject.location?.host,
+        $pathname: external_globals_js_namespaceObject.location?.pathname,
+        $raw_user_agent: external_globals_js_namespaceObject.userAgent.length > 1000 ? external_globals_js_namespaceObject.userAgent.substring(0, 997) + '...' : external_globals_js_namespaceObject.userAgent,
+        $browser_version: (0, core_namespaceObject.detectBrowserVersion)(external_globals_js_namespaceObject.userAgent, navigator.vendor, browserHints, browserOptions),
+        $browser_language: getBrowserLanguage(),
+        $browser_language_prefix: getBrowserLanguagePrefix(),
+        $screen_height: external_globals_js_namespaceObject.window?.screen.height,
+        $screen_width: external_globals_js_namespaceObject.window?.screen.width,
+        $viewport_height: external_globals_js_namespaceObject.window?.innerHeight,
+        $viewport_width: external_globals_js_namespaceObject.window?.innerWidth,
+        $lib: external_config_js_default().LIB_NAME,
+        $lib_version: external_config_js_default().LIB_VERSION,
+        $insert_id: Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10),
+        $time: Date.now() / 1000
+    });
+    if (external_config_js_default().SDK_DIST_CHANNEL) properties[external_constants_js_namespaceObject.SDK_DIST_CHANNEL] = external_config_js_default().SDK_DIST_CHANNEL;
+    return properties;
+}
+exports.CAMPAIGN_PARAMS = __webpack_exports__.CAMPAIGN_PARAMS;
+exports.COOKIE_CAMPAIGN_PARAMS = __webpack_exports__.COOKIE_CAMPAIGN_PARAMS;
+exports.EVENT_TO_PERSON_PROPERTIES = __webpack_exports__.EVENT_TO_PERSON_PROPERTIES;
+exports.MASKED = __webpack_exports__.MASKED;
+exports.PERSONAL_DATA_CAMPAIGN_PARAMS = __webpack_exports__.PERSONAL_DATA_CAMPAIGN_PARAMS;
+exports.getBrowserDetectionHints = __webpack_exports__.getBrowserDetectionHints;
+exports.getBrowserLanguage = __webpack_exports__.getBrowserLanguage;
+exports.getBrowserLanguagePrefix = __webpack_exports__.getBrowserLanguagePrefix;
+exports.getCampaignParams = __webpack_exports__.getCampaignParams;
+exports.getEventProperties = __webpack_exports__.getEventProperties;
+exports.getInitialPersonPropsFromInfo = __webpack_exports__.getInitialPersonPropsFromInfo;
+exports.getPersonInfo = __webpack_exports__.getPersonInfo;
+exports.getPersonPropsFromInfo = __webpack_exports__.getPersonPropsFromInfo;
+exports.getReferrer = __webpack_exports__.getReferrer;
+exports.getReferrerInfo = __webpack_exports__.getReferrerInfo;
+exports.getReferringDomain = __webpack_exports__.getReferringDomain;
+exports.getSearchInfo = __webpack_exports__.getSearchInfo;
+exports.getTimezone = __webpack_exports__.getTimezone;
+exports.getTimezoneOffset = __webpack_exports__.getTimezoneOffset;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "CAMPAIGN_PARAMS",
+    "COOKIE_CAMPAIGN_PARAMS",
+    "EVENT_TO_PERSON_PROPERTIES",
+    "MASKED",
+    "PERSONAL_DATA_CAMPAIGN_PARAMS",
+    "getBrowserDetectionHints",
+    "getBrowserLanguage",
+    "getBrowserLanguagePrefix",
+    "getCampaignParams",
+    "getEventProperties",
+    "getInitialPersonPropsFromInfo",
+    "getPersonInfo",
+    "getPersonPropsFromInfo",
+    "getReferrer",
+    "getReferrerInfo",
+    "getReferringDomain",
+    "getSearchInfo",
+    "getTimezone",
+    "getTimezoneOffset"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});