@posthog/browser-common 0.1.0 → 0.2.1

package/dist/utils/globals.mjs

@@ -0,0 +1,14 @@
+const win = 'undefined' != typeof window ? window : void 0;
+const global = 'undefined' != typeof globalThis ? globalThis : win;
+const globals_navigator = global?.navigator;
+const globals_document = global?.document;
+const globals_location = global?.location;
+const fetch = global?.fetch;
+const XMLHttpRequest = global?.XMLHttpRequest && 'withCredentials' in new global.XMLHttpRequest() ? global.XMLHttpRequest : void 0;
+const AbortController = global?.AbortController;
+const CompressionStream = global?.CompressionStream;
+const userAgent = globals_navigator?.userAgent;
+function isBrowserOnline() {
+    return !!(win && false !== win.navigator.onLine);
+}
+export { AbortController, CompressionStream, XMLHttpRequest, globals_document as document, fetch, isBrowserOnline, globals_location as location, globals_navigator as navigator, userAgent, win as window };

package/dist/utils/logger.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from '@posthog/types';
+export type CreateLoggerOptions = {
+    debugEnabled?: boolean;
+};
+export type PosthogJsLogger = Omit<Logger, 'createLogger' | 'debug' | 'info' | 'warn' | 'error' | 'trace' | 'fatal'> & {
+    _log: (level: 'debug' | 'log' | 'warn' | 'error', ...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    critical: (...args: any[]) => void;
+    uninitializedWarning: (methodName: string) => void;
+    createLogger: (prefix: string, options?: CreateLoggerOptions) => PosthogJsLogger;
+};
+export declare const logger: PosthogJsLogger;
+export declare const createLogger: (prefix: string, options?: CreateLoggerOptions) => PosthogJsLogger;

package/dist/utils/logger.js

@@ -0,0 +1,83 @@
+"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__, {
+    logger: ()=>logger_logger,
+    createLogger: ()=>createLogger
+});
+const external_config_js_namespaceObject = require("../config.js");
+var external_config_js_default = /*#__PURE__*/ __webpack_require__.n(external_config_js_namespaceObject);
+const core_namespaceObject = require("@posthog/core");
+const external_globals_js_namespaceObject = require("./globals.js");
+const _createLogger = (prefix, { debugEnabled } = {})=>{
+    const logger = {
+        _log: (level, ...args)=>{
+            if (external_globals_js_namespaceObject.window && (external_config_js_default().DEBUG || external_globals_js_namespaceObject.window.POSTHOG_DEBUG || debugEnabled) && !(0, core_namespaceObject.isUndefined)(external_globals_js_namespaceObject.window.console) && external_globals_js_namespaceObject.window.console) {
+                const consoleLog = '__rrweb_original__' in external_globals_js_namespaceObject.window.console[level] ? external_globals_js_namespaceObject.window.console[level]['__rrweb_original__'] : external_globals_js_namespaceObject.window.console[level];
+                consoleLog(prefix, ...args);
+            }
+        },
+        debug: (...args)=>{
+            logger._log('debug', ...args);
+        },
+        info: (...args)=>{
+            logger._log('log', ...args);
+        },
+        warn: (...args)=>{
+            logger._log('warn', ...args);
+        },
+        error: (...args)=>{
+            logger._log('error', ...args);
+        },
+        critical: (...args)=>{
+            console.error(prefix, ...args);
+        },
+        uninitializedWarning: (methodName)=>{
+            logger.error(`You must initialize PostHog before calling ${methodName}`);
+        },
+        createLogger: (additionalPrefix, options)=>_createLogger(`${prefix} ${additionalPrefix}`, options)
+    };
+    return logger;
+};
+const logger_logger = _createLogger('[PostHog.js]');
+const createLogger = logger_logger.createLogger;
+exports.createLogger = __webpack_exports__.createLogger;
+exports.logger = __webpack_exports__.logger;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createLogger",
+    "logger"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/logger.mjs

@@ -0,0 +1,36 @@
+import config from "../config.mjs";
+import { isUndefined } from "@posthog/core";
+import { window as external_globals_mjs_window } from "./globals.mjs";
+const _createLogger = (prefix, { debugEnabled } = {})=>{
+    const logger = {
+        _log: (level, ...args)=>{
+            if (external_globals_mjs_window && (config.DEBUG || external_globals_mjs_window.POSTHOG_DEBUG || debugEnabled) && !isUndefined(external_globals_mjs_window.console) && external_globals_mjs_window.console) {
+                const consoleLog = '__rrweb_original__' in external_globals_mjs_window.console[level] ? external_globals_mjs_window.console[level]['__rrweb_original__'] : external_globals_mjs_window.console[level];
+                consoleLog(prefix, ...args);
+            }
+        },
+        debug: (...args)=>{
+            logger._log('debug', ...args);
+        },
+        info: (...args)=>{
+            logger._log('log', ...args);
+        },
+        warn: (...args)=>{
+            logger._log('warn', ...args);
+        },
+        error: (...args)=>{
+            logger._log('error', ...args);
+        },
+        critical: (...args)=>{
+            console.error(prefix, ...args);
+        },
+        uninitializedWarning: (methodName)=>{
+            logger.error(`You must initialize PostHog before calling ${methodName}`);
+        },
+        createLogger: (additionalPrefix, options)=>_createLogger(`${prefix} ${additionalPrefix}`, options)
+    };
+    return logger;
+};
+const logger_logger = _createLogger('[PostHog.js]');
+const createLogger = logger_logger.createLogger;
+export { createLogger, logger_logger as logger };

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

@@ -0,0 +1,3 @@
+import { type PropertyMatchType } from './property-utils';
+export declare function doesDeviceTypeMatch(deviceTypes?: string[], matchType?: PropertyMatchType): boolean;
+export declare function hasPeriodPassed(periodDays?: number, lastSeenDate?: string | Date | null): boolean;

package/dist/utils/matcher-utils.js

@@ -0,0 +1,63 @@
+"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__, {
+    hasPeriodPassed: ()=>hasPeriodPassed,
+    doesDeviceTypeMatch: ()=>doesDeviceTypeMatch
+});
+const core_namespaceObject = require("@posthog/core");
+const external_globals_js_namespaceObject = require("./globals.js");
+const external_property_utils_js_namespaceObject = require("./property-utils.js");
+function doesDeviceTypeMatch(deviceTypes, matchType) {
+    if (!deviceTypes || 0 === deviceTypes.length) return true;
+    if (!external_globals_js_namespaceObject.userAgent) return false;
+    const deviceType = (0, core_namespaceObject.detectDeviceType)(external_globals_js_namespaceObject.userAgent, {
+        userAgentDataPlatform: external_globals_js_namespaceObject.navigator?.userAgentData?.platform,
+        maxTouchPoints: external_globals_js_namespaceObject.navigator?.maxTouchPoints,
+        screenWidth: external_globals_js_namespaceObject.window?.screen?.width,
+        screenHeight: external_globals_js_namespaceObject.window?.screen?.height,
+        devicePixelRatio: external_globals_js_namespaceObject.window?.devicePixelRatio
+    });
+    return external_property_utils_js_namespaceObject.propertyComparisons[matchType ?? 'icontains'](deviceTypes, [
+        deviceType
+    ]);
+}
+function hasPeriodPassed(periodDays, lastSeenDate) {
+    if (!periodDays || !lastSeenDate) return true;
+    const date = 'string' == typeof lastSeenDate ? new Date(lastSeenDate) : lastSeenDate;
+    const now = new Date();
+    const diffMs = Math.abs(now.getTime() - date.getTime());
+    const diffDays = Math.ceil(diffMs / 86400000);
+    return diffDays > periodDays;
+}
+exports.doesDeviceTypeMatch = __webpack_exports__.doesDeviceTypeMatch;
+exports.hasPeriodPassed = __webpack_exports__.hasPeriodPassed;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "doesDeviceTypeMatch",
+    "hasPeriodPassed"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/matcher-utils.mjs

@@ -0,0 +1,26 @@
+import { detectDeviceType } from "@posthog/core";
+import { navigator as external_globals_mjs_navigator, userAgent, window as external_globals_mjs_window } from "./globals.mjs";
+import { propertyComparisons } from "./property-utils.mjs";
+function doesDeviceTypeMatch(deviceTypes, matchType) {
+    if (!deviceTypes || 0 === deviceTypes.length) return true;
+    if (!userAgent) return false;
+    const deviceType = detectDeviceType(userAgent, {
+        userAgentDataPlatform: external_globals_mjs_navigator?.userAgentData?.platform,
+        maxTouchPoints: external_globals_mjs_navigator?.maxTouchPoints,
+        screenWidth: external_globals_mjs_window?.screen?.width,
+        screenHeight: external_globals_mjs_window?.screen?.height,
+        devicePixelRatio: external_globals_mjs_window?.devicePixelRatio
+    });
+    return propertyComparisons[matchType ?? 'icontains'](deviceTypes, [
+        deviceType
+    ]);
+}
+function hasPeriodPassed(periodDays, lastSeenDate) {
+    if (!periodDays || !lastSeenDate) return true;
+    const date = 'string' == typeof lastSeenDate ? new Date(lastSeenDate) : lastSeenDate;
+    const now = new Date();
+    const diffMs = Math.abs(now.getTime() - date.getTime());
+    const diffDays = Math.ceil(diffMs / 86400000);
+    return diffDays > periodDays;
+}
+export { doesDeviceTypeMatch, hasPeriodPassed };

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

@@ -0,0 +1,23 @@
+import type { Properties } from '@posthog/types';
+export type PropertyMatchType = 'exact' | 'is_not' | 'regex' | 'not_regex' | 'icontains' | 'not_icontains';
+export type PropertyOperator = PropertyMatchType | 'gt' | 'lt';
+export type PropertyFilters = {
+    [propertyName: string]: {
+        values: string[];
+        operator: PropertyOperator;
+    };
+};
+export interface SessionRecordingTriggerPropertyFilter {
+    key: string;
+    value?: string | number | boolean | (string | number | boolean)[] | null;
+    operator?: PropertyOperator | null;
+    type?: string | null;
+}
+export declare function getPersonPropertiesHash(distinct_id: string, userPropertiesToSet?: Properties, userPropertiesToSetOnce?: Properties): string;
+export declare const propertyComparisons: Record<PropertyOperator, (targets: string[], values: string[]) => boolean>;
+/**
+ * Evaluate trigger property filters (WHERE clauses) against event and person properties.
+ * All filters must match (implicit AND). Returns true if no filters are present.
+ */
+export declare function matchTriggerPropertyFilters(filters: SessionRecordingTriggerPropertyFilter[] | undefined, eventProperties: Properties | undefined, personProperties: Properties | undefined): boolean;
+export declare function matchPropertyFilters(propertyFilters: PropertyFilters | undefined, eventProperties: Properties | undefined): boolean;

package/dist/utils/property-utils.js

@@ -0,0 +1,108 @@
+"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__, {
+    matchPropertyFilters: ()=>matchPropertyFilters,
+    propertyComparisons: ()=>propertyComparisons,
+    getPersonPropertiesHash: ()=>getPersonPropertiesHash,
+    matchTriggerPropertyFilters: ()=>matchTriggerPropertyFilters
+});
+const core_namespaceObject = require("@posthog/core");
+const external_request_utils_js_namespaceObject = require("./request-utils.js");
+const external_regex_utils_js_namespaceObject = require("./regex-utils.js");
+function getPersonPropertiesHash(distinct_id, userPropertiesToSet, userPropertiesToSetOnce) {
+    return (0, external_request_utils_js_namespaceObject.jsonStringify)({
+        distinct_id,
+        userPropertiesToSet,
+        userPropertiesToSetOnce
+    });
+}
+const propertyComparisons = {
+    exact: (targets, values)=>values.some((value)=>targets.some((target)=>value === target)),
+    is_not: (targets, values)=>values.every((value)=>targets.every((target)=>value !== target)),
+    regex: (targets, values)=>values.some((value)=>targets.some((target)=>(0, external_regex_utils_js_namespaceObject.isMatchingRegex)(value, target))),
+    not_regex: (targets, values)=>values.every((value)=>targets.every((target)=>!(0, external_regex_utils_js_namespaceObject.isMatchingRegex)(value, target))),
+    icontains: (targets, values)=>values.map(toLowerCase).some((value)=>targets.map(toLowerCase).some((target)=>value.includes(target))),
+    not_icontains: (targets, values)=>values.map(toLowerCase).every((value)=>targets.map(toLowerCase).every((target)=>!value.includes(target))),
+    gt: (targets, values)=>values.some((value)=>{
+            const numValue = parseFloat(value);
+            return !isNaN(numValue) && targets.some((t)=>numValue > parseFloat(t));
+        }),
+    lt: (targets, values)=>values.some((value)=>{
+            const numValue = parseFloat(value);
+            return !isNaN(numValue) && targets.some((t)=>numValue < parseFloat(t));
+        })
+};
+const toLowerCase = (v)=>v.toLowerCase();
+const NEGATIVE_OPERATORS = new Set([
+    'is_not',
+    'not_icontains',
+    'not_regex'
+]);
+function matchTriggerPropertyFilters(filters, eventProperties, personProperties) {
+    if (!filters || 0 === filters.length) return true;
+    return filters.every((filter)=>{
+        const source = 'person' === filter.type ? personProperties : eventProperties;
+        const propertyValue = source?.[filter.key];
+        const operator = filter.operator || 'exact';
+        if ((0, core_namespaceObject.isUndefined)(propertyValue) || (0, core_namespaceObject.isNull)(propertyValue)) return NEGATIVE_OPERATORS.has(operator);
+        const comparisonFunction = propertyComparisons[operator];
+        if (!comparisonFunction) return false;
+        if ((0, core_namespaceObject.isUndefined)(filter.value) || (0, core_namespaceObject.isNull)(filter.value)) return false;
+        const targetValues = (0, core_namespaceObject.isArray)(filter.value) ? filter.value.map(String) : [
+            String(filter.value)
+        ];
+        const actualValues = (0, core_namespaceObject.isArray)(propertyValue) ? propertyValue.map(String) : [
+            String(propertyValue)
+        ];
+        return comparisonFunction(targetValues, actualValues);
+    });
+}
+function matchPropertyFilters(propertyFilters, eventProperties) {
+    if (!propertyFilters) return true;
+    return Object.entries(propertyFilters).every(([propertyName, filter])=>{
+        const eventPropertyValue = eventProperties?.[propertyName];
+        if ((0, core_namespaceObject.isUndefined)(eventPropertyValue) || (0, core_namespaceObject.isNull)(eventPropertyValue)) return false;
+        const eventValues = [
+            String(eventPropertyValue)
+        ];
+        const comparisonFunction = propertyComparisons[filter.operator];
+        if (!comparisonFunction) return false;
+        return comparisonFunction(filter.values, eventValues);
+    });
+}
+exports.getPersonPropertiesHash = __webpack_exports__.getPersonPropertiesHash;
+exports.matchPropertyFilters = __webpack_exports__.matchPropertyFilters;
+exports.matchTriggerPropertyFilters = __webpack_exports__.matchTriggerPropertyFilters;
+exports.propertyComparisons = __webpack_exports__.propertyComparisons;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getPersonPropertiesHash",
+    "matchPropertyFilters",
+    "matchTriggerPropertyFilters",
+    "propertyComparisons"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/property-utils.mjs

@@ -0,0 +1,65 @@
+import { isArray, isNull, isUndefined } from "@posthog/core";
+import { jsonStringify } from "./request-utils.mjs";
+import { isMatchingRegex } from "./regex-utils.mjs";
+function getPersonPropertiesHash(distinct_id, userPropertiesToSet, userPropertiesToSetOnce) {
+    return jsonStringify({
+        distinct_id,
+        userPropertiesToSet,
+        userPropertiesToSetOnce
+    });
+}
+const propertyComparisons = {
+    exact: (targets, values)=>values.some((value)=>targets.some((target)=>value === target)),
+    is_not: (targets, values)=>values.every((value)=>targets.every((target)=>value !== target)),
+    regex: (targets, values)=>values.some((value)=>targets.some((target)=>isMatchingRegex(value, target))),
+    not_regex: (targets, values)=>values.every((value)=>targets.every((target)=>!isMatchingRegex(value, target))),
+    icontains: (targets, values)=>values.map(toLowerCase).some((value)=>targets.map(toLowerCase).some((target)=>value.includes(target))),
+    not_icontains: (targets, values)=>values.map(toLowerCase).every((value)=>targets.map(toLowerCase).every((target)=>!value.includes(target))),
+    gt: (targets, values)=>values.some((value)=>{
+            const numValue = parseFloat(value);
+            return !isNaN(numValue) && targets.some((t)=>numValue > parseFloat(t));
+        }),
+    lt: (targets, values)=>values.some((value)=>{
+            const numValue = parseFloat(value);
+            return !isNaN(numValue) && targets.some((t)=>numValue < parseFloat(t));
+        })
+};
+const toLowerCase = (v)=>v.toLowerCase();
+const NEGATIVE_OPERATORS = new Set([
+    'is_not',
+    'not_icontains',
+    'not_regex'
+]);
+function matchTriggerPropertyFilters(filters, eventProperties, personProperties) {
+    if (!filters || 0 === filters.length) return true;
+    return filters.every((filter)=>{
+        const source = 'person' === filter.type ? personProperties : eventProperties;
+        const propertyValue = source?.[filter.key];
+        const operator = filter.operator || 'exact';
+        if (isUndefined(propertyValue) || isNull(propertyValue)) return NEGATIVE_OPERATORS.has(operator);
+        const comparisonFunction = propertyComparisons[operator];
+        if (!comparisonFunction) return false;
+        if (isUndefined(filter.value) || isNull(filter.value)) return false;
+        const targetValues = isArray(filter.value) ? filter.value.map(String) : [
+            String(filter.value)
+        ];
+        const actualValues = isArray(propertyValue) ? propertyValue.map(String) : [
+            String(propertyValue)
+        ];
+        return comparisonFunction(targetValues, actualValues);
+    });
+}
+function matchPropertyFilters(propertyFilters, eventProperties) {
+    if (!propertyFilters) return true;
+    return Object.entries(propertyFilters).every(([propertyName, filter])=>{
+        const eventPropertyValue = eventProperties?.[propertyName];
+        if (isUndefined(eventPropertyValue) || isNull(eventPropertyValue)) return false;
+        const eventValues = [
+            String(eventPropertyValue)
+        ];
+        const comparisonFunction = propertyComparisons[filter.operator];
+        if (!comparisonFunction) return false;
+        return comparisonFunction(filter.values, eventValues);
+    });
+}
+export { getPersonPropertiesHash, matchPropertyFilters, matchTriggerPropertyFilters, propertyComparisons };

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

@@ -0,0 +1,7 @@
+interface NativeImplementationsCache {
+    MutationObserver: typeof MutationObserver;
+}
+type BrowserWindow = Window & typeof globalThis;
+export declare function getNativeImplementation<T extends keyof NativeImplementationsCache>(name: T, assignableWindow: BrowserWindow): NativeImplementationsCache[T];
+export declare function getNativeMutationObserverImplementation(assignableWindow: BrowserWindow): typeof MutationObserver;
+export {};

package/dist/utils/prototype-utils.js

@@ -0,0 +1,64 @@
+"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__, {
+    getNativeImplementation: ()=>getNativeImplementation,
+    getNativeMutationObserverImplementation: ()=>getNativeMutationObserverImplementation
+});
+const core_namespaceObject = require("@posthog/core");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_type_utils_js_namespaceObject = require("./type-utils.js");
+const cachedImplementations = {};
+function getNativeImplementation(name, assignableWindow) {
+    const cached = cachedImplementations[name];
+    if (cached) return cached;
+    let impl = assignableWindow[name];
+    if ((0, core_namespaceObject.isNativeFunction)(impl) && !(0, external_type_utils_js_namespaceObject.isAngularZonePresent)()) return cachedImplementations[name] = impl.bind(assignableWindow);
+    const document = assignableWindow.document;
+    if (document && (0, core_namespaceObject.isFunction)(document.createElement)) try {
+        const sandbox = document.createElement('iframe');
+        sandbox.hidden = true;
+        document.head.appendChild(sandbox);
+        const contentWindow = sandbox.contentWindow;
+        if (contentWindow && contentWindow[name]) impl = contentWindow[name];
+        document.head.removeChild(sandbox);
+    } catch (e) {
+        external_logger_js_namespaceObject.logger.warn(`Could not create sandbox iframe for ${name} check, bailing to assignableWindow.${name}: `, e);
+    }
+    if (!impl || !(0, core_namespaceObject.isFunction)(impl)) return impl;
+    return cachedImplementations[name] = impl.bind(assignableWindow);
+}
+function getNativeMutationObserverImplementation(assignableWindow) {
+    return getNativeImplementation('MutationObserver', assignableWindow);
+}
+exports.getNativeImplementation = __webpack_exports__.getNativeImplementation;
+exports.getNativeMutationObserverImplementation = __webpack_exports__.getNativeMutationObserverImplementation;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getNativeImplementation",
+    "getNativeMutationObserverImplementation"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/prototype-utils.mjs

@@ -0,0 +1,27 @@
+import { isFunction, isNativeFunction } from "@posthog/core";
+import { logger } from "./logger.mjs";
+import { isAngularZonePresent } from "./type-utils.mjs";
+const cachedImplementations = {};
+function getNativeImplementation(name, assignableWindow) {
+    const cached = cachedImplementations[name];
+    if (cached) return cached;
+    let impl = assignableWindow[name];
+    if (isNativeFunction(impl) && !isAngularZonePresent()) return cachedImplementations[name] = impl.bind(assignableWindow);
+    const document = assignableWindow.document;
+    if (document && isFunction(document.createElement)) try {
+        const sandbox = document.createElement('iframe');
+        sandbox.hidden = true;
+        document.head.appendChild(sandbox);
+        const contentWindow = sandbox.contentWindow;
+        if (contentWindow && contentWindow[name]) impl = contentWindow[name];
+        document.head.removeChild(sandbox);
+    } catch (e) {
+        logger.warn(`Could not create sandbox iframe for ${name} check, bailing to assignableWindow.${name}: `, e);
+    }
+    if (!impl || !isFunction(impl)) return impl;
+    return cachedImplementations[name] = impl.bind(assignableWindow);
+}
+function getNativeMutationObserverImplementation(assignableWindow) {
+    return getNativeImplementation('MutationObserver', assignableWindow);
+}
+export { getNativeImplementation, getNativeMutationObserverImplementation };

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

@@ -0,0 +1,2 @@
+export declare const isValidRegex: (str: string) => boolean;
+export declare const isMatchingRegex: (value: string, pattern: string) => boolean;

package/dist/utils/regex-utils.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__, {
+    isMatchingRegex: ()=>isMatchingRegex,
+    isValidRegex: ()=>isValidRegex
+});
+const isValidRegex = function(str) {
+    try {
+        new RegExp(str);
+    } catch  {
+        return false;
+    }
+    return true;
+};
+const isMatchingRegex = function(value, pattern) {
+    if (!isValidRegex(pattern)) return false;
+    try {
+        return new RegExp(pattern).test(value);
+    } catch  {
+        return false;
+    }
+};
+exports.isMatchingRegex = __webpack_exports__.isMatchingRegex;
+exports.isValidRegex = __webpack_exports__.isValidRegex;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isMatchingRegex",
+    "isValidRegex"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/regex-utils.mjs

@@ -0,0 +1,17 @@
+const isValidRegex = function(str) {
+    try {
+        new RegExp(str);
+    } catch  {
+        return false;
+    }
+    return true;
+};
+const isMatchingRegex = function(value, pattern) {
+    if (!isValidRegex(pattern)) return false;
+    try {
+        return new RegExp(pattern).test(value);
+    } catch  {
+        return false;
+    }
+};
+export { isMatchingRegex, isValidRegex };

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

@@ -0,0 +1,15 @@
+export declare const jsonStringify: (data: any, space?: string | number) => string;
+/**
+ * IE11 doesn't support `new URL`
+ * so we can create an anchor element and use that to parse the URL
+ * there's a lot of overlap between HTMLHyperlinkElementUtils and URL
+ * meaning useful properties like `pathname` are available on both
+ */
+export declare const convertToURL: (url: string) => HTMLAnchorElement | null;
+export declare const formDataToQuery: (formdata: Record<string, any> | FormData, arg_separator?: string) => string;
+export declare const getQueryParam: (url: string, param: string) => string;
+export declare const maskQueryParams: <T extends string | undefined>(url: T, maskedParams: string[] | undefined, mask: string) => T extends string ? string : undefined;
+export declare const _getHashParam: (hash: string, param: string) => string | null;
+export declare const isLocalhost: () => boolean;
+export declare const isStatusZeroFailureCircuitBreakerTripped: (consecutiveStatusZeroFailures: number, maxConsecutiveStatusZeroFailures: number) => boolean;
+export declare const updateStatusZeroFailureCount: (statusCode: number, consecutiveStatusZeroFailures: number, maxConsecutiveStatusZeroFailures: number, onCircuitBreakerTripped: () => void) => number;