@posthog/browser-common 0.1.0 → 0.2.0

package/dist/utils/request-utils.js

@@ -0,0 +1,153 @@
+"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__, {
+    jsonStringify: ()=>jsonStringify,
+    formDataToQuery: ()=>formDataToQuery,
+    getQueryParam: ()=>getQueryParam,
+    _getHashParam: ()=>_getHashParam,
+    convertToURL: ()=>convertToURL,
+    isLocalhost: ()=>isLocalhost,
+    updateStatusZeroFailureCount: ()=>updateStatusZeroFailureCount,
+    isStatusZeroFailureCircuitBreakerTripped: ()=>isStatusZeroFailureCircuitBreakerTripped,
+    maskQueryParams: ()=>maskQueryParams
+});
+const core_namespaceObject = require("@posthog/core");
+const external_general_utils_js_namespaceObject = require("./general-utils.js");
+const external_globals_js_namespaceObject = require("./globals.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+const localDomains = [
+    'localhost',
+    '127.0.0.1'
+];
+const jsonStringify = (data, space)=>{
+    try {
+        return JSON.stringify(data, (_, value)=>'bigint' == typeof value ? value.toString() : value, space);
+    } catch  {
+        return (0, core_namespaceObject.safeJsonStringify)(data);
+    }
+};
+const convertToURL = (url)=>{
+    const location = external_globals_js_namespaceObject.document?.createElement('a');
+    if ((0, core_namespaceObject.isUndefined)(location)) return null;
+    location.href = url;
+    return location;
+};
+const formDataToQuery = function(formdata, arg_separator = '&') {
+    let use_val;
+    let use_key;
+    const tph_arr = [];
+    (0, external_general_utils_js_namespaceObject.each)(formdata, function(val, key) {
+        if ((0, core_namespaceObject.isUndefined)(val) || (0, core_namespaceObject.isUndefined)(key) || 'undefined' === key) return;
+        use_val = encodeURIComponent((0, core_namespaceObject.isFile)(val) ? val.name : val.toString());
+        use_key = encodeURIComponent(key);
+        tph_arr[tph_arr.length] = use_key + '=' + use_val;
+    });
+    return tph_arr.join(arg_separator);
+};
+const getQueryParam = function(url, param) {
+    const withoutHash = url.split('#')[0] || '';
+    const queryParams = withoutHash.split(/\?(.*)/)[1] || '';
+    const cleanedQueryParams = queryParams.replace(/^\?+/g, '');
+    const queryParts = cleanedQueryParams.split('&');
+    let keyValuePair;
+    for(let i = 0; i < queryParts.length; i++){
+        const parts = queryParts[i].split('=');
+        if (parts[0] === param) {
+            keyValuePair = parts;
+            break;
+        }
+    }
+    if (!(0, core_namespaceObject.isArray)(keyValuePair) || keyValuePair.length < 2) return '';
+    {
+        let result = keyValuePair[1];
+        try {
+            result = decodeURIComponent(result);
+        } catch  {
+            external_logger_js_namespaceObject.logger.error('Skipping decoding for malformed query param: ' + result);
+        }
+        return result.replace(/\+/g, ' ');
+    }
+};
+const maskQueryParams = function(url, maskedParams, mask) {
+    if (!url || !maskedParams || !maskedParams.length) return url;
+    const splitHash = url.split('#');
+    const withoutHash = splitHash[0] || '';
+    const hash = splitHash[1];
+    const splitQuery = withoutHash.split('?');
+    const queryString = splitQuery[1];
+    const urlWithoutQueryAndHash = splitQuery[0];
+    const queryParts = (queryString || '').split('&');
+    const paramStrings = [];
+    for(let i = 0; i < queryParts.length; i++){
+        const keyValuePair = queryParts[i].split('=');
+        if ((0, core_namespaceObject.isArray)(keyValuePair)) if (maskedParams.includes(keyValuePair[0])) paramStrings.push(keyValuePair[0] + '=' + mask);
+        else paramStrings.push(queryParts[i]);
+    }
+    let result = urlWithoutQueryAndHash;
+    if (null != queryString) result += '?' + paramStrings.join('&');
+    if (null != hash) result += '#' + hash;
+    return result;
+};
+const _getHashParam = function(hash, param) {
+    const matches = hash.match(new RegExp(param + '=([^&]*)'));
+    return matches ? matches[1] : null;
+};
+const isLocalhost = ()=>localDomains.includes(external_globals_js_namespaceObject.location.hostname);
+const isStatusZeroFailureCircuitBreakerTripped = (consecutiveStatusZeroFailures, maxConsecutiveStatusZeroFailures)=>consecutiveStatusZeroFailures >= maxConsecutiveStatusZeroFailures && (0, external_globals_js_namespaceObject.isBrowserOnline)();
+const updateStatusZeroFailureCount = (statusCode, consecutiveStatusZeroFailures, maxConsecutiveStatusZeroFailures, onCircuitBreakerTripped)=>{
+    if (0 === statusCode) {
+        if ((0, external_globals_js_namespaceObject.isBrowserOnline)()) {
+            const updatedConsecutiveStatusZeroFailures = consecutiveStatusZeroFailures + 1;
+            if (updatedConsecutiveStatusZeroFailures === maxConsecutiveStatusZeroFailures) onCircuitBreakerTripped();
+            return updatedConsecutiveStatusZeroFailures;
+        }
+        return consecutiveStatusZeroFailures;
+    }
+    return 0;
+};
+exports._getHashParam = __webpack_exports__._getHashParam;
+exports.convertToURL = __webpack_exports__.convertToURL;
+exports.formDataToQuery = __webpack_exports__.formDataToQuery;
+exports.getQueryParam = __webpack_exports__.getQueryParam;
+exports.isLocalhost = __webpack_exports__.isLocalhost;
+exports.isStatusZeroFailureCircuitBreakerTripped = __webpack_exports__.isStatusZeroFailureCircuitBreakerTripped;
+exports.jsonStringify = __webpack_exports__.jsonStringify;
+exports.maskQueryParams = __webpack_exports__.maskQueryParams;
+exports.updateStatusZeroFailureCount = __webpack_exports__.updateStatusZeroFailureCount;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "_getHashParam",
+    "convertToURL",
+    "formDataToQuery",
+    "getQueryParam",
+    "isLocalhost",
+    "isStatusZeroFailureCircuitBreakerTripped",
+    "jsonStringify",
+    "maskQueryParams",
+    "updateStatusZeroFailureCount"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/request-utils.mjs

@@ -0,0 +1,95 @@
+import { isArray, isFile, isUndefined, safeJsonStringify } from "@posthog/core";
+import { each } from "./general-utils.mjs";
+import { document as external_globals_mjs_document, isBrowserOnline, location as external_globals_mjs_location } from "./globals.mjs";
+import { logger } from "./logger.mjs";
+const localDomains = [
+    'localhost',
+    '127.0.0.1'
+];
+const jsonStringify = (data, space)=>{
+    try {
+        return JSON.stringify(data, (_, value)=>'bigint' == typeof value ? value.toString() : value, space);
+    } catch  {
+        return safeJsonStringify(data);
+    }
+};
+const convertToURL = (url)=>{
+    const location = external_globals_mjs_document?.createElement('a');
+    if (isUndefined(location)) return null;
+    location.href = url;
+    return location;
+};
+const formDataToQuery = function(formdata, arg_separator = '&') {
+    let use_val;
+    let use_key;
+    const tph_arr = [];
+    each(formdata, function(val, key) {
+        if (isUndefined(val) || isUndefined(key) || 'undefined' === key) return;
+        use_val = encodeURIComponent(isFile(val) ? val.name : val.toString());
+        use_key = encodeURIComponent(key);
+        tph_arr[tph_arr.length] = use_key + '=' + use_val;
+    });
+    return tph_arr.join(arg_separator);
+};
+const getQueryParam = function(url, param) {
+    const withoutHash = url.split('#')[0] || '';
+    const queryParams = withoutHash.split(/\?(.*)/)[1] || '';
+    const cleanedQueryParams = queryParams.replace(/^\?+/g, '');
+    const queryParts = cleanedQueryParams.split('&');
+    let keyValuePair;
+    for(let i = 0; i < queryParts.length; i++){
+        const parts = queryParts[i].split('=');
+        if (parts[0] === param) {
+            keyValuePair = parts;
+            break;
+        }
+    }
+    if (!isArray(keyValuePair) || keyValuePair.length < 2) return '';
+    {
+        let result = keyValuePair[1];
+        try {
+            result = decodeURIComponent(result);
+        } catch  {
+            logger.error('Skipping decoding for malformed query param: ' + result);
+        }
+        return result.replace(/\+/g, ' ');
+    }
+};
+const maskQueryParams = function(url, maskedParams, mask) {
+    if (!url || !maskedParams || !maskedParams.length) return url;
+    const splitHash = url.split('#');
+    const withoutHash = splitHash[0] || '';
+    const hash = splitHash[1];
+    const splitQuery = withoutHash.split('?');
+    const queryString = splitQuery[1];
+    const urlWithoutQueryAndHash = splitQuery[0];
+    const queryParts = (queryString || '').split('&');
+    const paramStrings = [];
+    for(let i = 0; i < queryParts.length; i++){
+        const keyValuePair = queryParts[i].split('=');
+        if (isArray(keyValuePair)) if (maskedParams.includes(keyValuePair[0])) paramStrings.push(keyValuePair[0] + '=' + mask);
+        else paramStrings.push(queryParts[i]);
+    }
+    let result = urlWithoutQueryAndHash;
+    if (null != queryString) result += '?' + paramStrings.join('&');
+    if (null != hash) result += '#' + hash;
+    return result;
+};
+const _getHashParam = function(hash, param) {
+    const matches = hash.match(new RegExp(param + '=([^&]*)'));
+    return matches ? matches[1] : null;
+};
+const isLocalhost = ()=>localDomains.includes(external_globals_mjs_location.hostname);
+const isStatusZeroFailureCircuitBreakerTripped = (consecutiveStatusZeroFailures, maxConsecutiveStatusZeroFailures)=>consecutiveStatusZeroFailures >= maxConsecutiveStatusZeroFailures && isBrowserOnline();
+const updateStatusZeroFailureCount = (statusCode, consecutiveStatusZeroFailures, maxConsecutiveStatusZeroFailures, onCircuitBreakerTripped)=>{
+    if (0 === statusCode) {
+        if (isBrowserOnline()) {
+            const updatedConsecutiveStatusZeroFailures = consecutiveStatusZeroFailures + 1;
+            if (updatedConsecutiveStatusZeroFailures === maxConsecutiveStatusZeroFailures) onCircuitBreakerTripped();
+            return updatedConsecutiveStatusZeroFailures;
+        }
+        return consecutiveStatusZeroFailures;
+    }
+    return 0;
+};
+export { _getHashParam, convertToURL, formDataToQuery, getQueryParam, isLocalhost, isStatusZeroFailureCircuitBreakerTripped, jsonStringify, maskQueryParams, updateStatusZeroFailureCount };

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

@@ -0,0 +1,5 @@
+export declare class SimpleEventEmitter {
+    private _events;
+    on(event: string, listener: (...args: any[]) => void): () => void;
+    emit(event: string, payload: any): void;
+}

package/dist/utils/simple-event-emitter.js

@@ -0,0 +1,51 @@
+"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__, {
+    SimpleEventEmitter: ()=>SimpleEventEmitter
+});
+class SimpleEventEmitter {
+    on(event, listener) {
+        if (!this._events[event]) this._events[event] = [];
+        this._events[event].push(listener);
+        return ()=>{
+            this._events[event] = this._events[event].filter((x)=>x !== listener);
+        };
+    }
+    emit(event, payload) {
+        for (const listener of this._events[event] || [])listener(payload);
+        for (const listener of this._events['*'] || [])listener(event, payload);
+    }
+    constructor(){
+        this._events = {};
+    }
+}
+exports.SimpleEventEmitter = __webpack_exports__.SimpleEventEmitter;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "SimpleEventEmitter"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/simple-event-emitter.mjs

@@ -0,0 +1,17 @@
+class SimpleEventEmitter {
+    on(event, listener) {
+        if (!this._events[event]) this._events[event] = [];
+        this._events[event].push(listener);
+        return ()=>{
+            this._events[event] = this._events[event].filter((x)=>x !== listener);
+        };
+    }
+    emit(event, payload) {
+        for (const listener of this._events[event] || [])listener(payload);
+        for (const listener of this._events['*'] || [])listener(event, payload);
+    }
+    constructor(){
+        this._events = {};
+    }
+}
+export { SimpleEventEmitter };

package/dist/utils/stylesheet-loader.d.ts

@@ -0,0 +1,7 @@
+export type StylesheetPreparer = (stylesheet: HTMLStyleElement) => HTMLStyleElement | null;
+export type StylesheetPreparationContext = StylesheetPreparer | {
+    config?: {
+        prepare_external_dependency_stylesheet?: StylesheetPreparer;
+    };
+};
+export declare const prepareStylesheet: (document: Document, innerText: string, context?: StylesheetPreparationContext) => HTMLStyleElement | null;

package/dist/utils/stylesheet-loader.js

@@ -0,0 +1,53 @@
+"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__, {
+    prepareStylesheet: ()=>prepareStylesheet
+});
+const core_namespaceObject = require("@posthog/core");
+const external_logger_js_namespaceObject = require("./logger.js");
+const logger = (0, external_logger_js_namespaceObject.createLogger)('[Stylesheet Loader]');
+const getStylesheetPreparer = (context)=>{
+    if ((0, core_namespaceObject.isFunction)(context)) return context;
+    return context?.config?.prepare_external_dependency_stylesheet;
+};
+const prepareStylesheet = (document, innerText, context)=>{
+    let stylesheet = document.createElement('style');
+    stylesheet.innerText = innerText;
+    const prepareExternalDependencyStylesheet = getStylesheetPreparer(context);
+    if (prepareExternalDependencyStylesheet) stylesheet = prepareExternalDependencyStylesheet(stylesheet);
+    if (!stylesheet) {
+        logger.error('prepare_external_dependency_stylesheet returned null');
+        return null;
+    }
+    return stylesheet;
+};
+exports.prepareStylesheet = __webpack_exports__.prepareStylesheet;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "prepareStylesheet"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/stylesheet-loader.mjs

@@ -0,0 +1,19 @@
+import { isFunction } from "@posthog/core";
+import { createLogger } from "./logger.mjs";
+const logger = createLogger('[Stylesheet Loader]');
+const getStylesheetPreparer = (context)=>{
+    if (isFunction(context)) return context;
+    return context?.config?.prepare_external_dependency_stylesheet;
+};
+const prepareStylesheet = (document, innerText, context)=>{
+    let stylesheet = document.createElement('style');
+    stylesheet.innerText = innerText;
+    const prepareExternalDependencyStylesheet = getStylesheetPreparer(context);
+    if (prepareExternalDependencyStylesheet) stylesheet = prepareExternalDependencyStylesheet(stylesheet);
+    if (!stylesheet) {
+        logger.error('prepare_external_dependency_stylesheet returned null');
+        return null;
+    }
+    return stylesheet;
+};
+export { prepareStylesheet };

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

@@ -0,0 +1,2 @@
+export declare const isAngularZonePresent: () => boolean;
+export declare const isDocument: (x: unknown) => x is Document;

package/dist/utils/type-utils.js

@@ -0,0 +1,41 @@
+"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__, {
+    isAngularZonePresent: ()=>isAngularZonePresent,
+    isDocument: ()=>isDocument
+});
+const external_globals_js_namespaceObject = require("./globals.js");
+const isAngularZonePresent = ()=>!!external_globals_js_namespaceObject.window?.Zone;
+const isDocument = (x)=>'undefined' != typeof Document && x instanceof Document;
+exports.isAngularZonePresent = __webpack_exports__.isAngularZonePresent;
+exports.isDocument = __webpack_exports__.isDocument;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "isAngularZonePresent",
+    "isDocument"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/type-utils.mjs

@@ -0,0 +1,4 @@
+import { window as external_globals_mjs_window } from "./globals.mjs";
+const isAngularZonePresent = ()=>!!external_globals_mjs_window?.Zone;
+const isDocument = (x)=>'undefined' != typeof Document && x instanceof Document;
+export { isAngularZonePresent, isDocument };

package/dist/utils/url-targeting-utils.d.ts

@@ -0,0 +1,28 @@
+import type { PostHogConfig } from '@posthog/types';
+export type UrlTargetingInstance = {
+    config: Pick<PostHogConfig, 'get_current_url'>;
+};
+/**
+ * Applies the `get_current_url` config hook to an already-resolved URL. Returns `defaultUrl`
+ * unchanged when no override is configured, or if the override throws or returns a
+ * non-string/empty value.
+ *
+ * Use this when the caller already has its own URL source (e.g. web experiments read
+ * `window.location` via a mockable indirection); otherwise prefer `getTargetingUrl`.
+ */
+export declare function applyUrlTargetingOverride(instance: UrlTargetingInstance | undefined, defaultUrl: string): string;
+/**
+ * Resolves the URL used for client-side URL targeting: session replay URL triggers, the
+ * session replay URL blocklist, survey URL conditions, product tour URL conditions, and web
+ * experiment URL conditions.
+ *
+ * Defaults to `window.location.href`, but honors the `get_current_url` config hook so apps
+ * that rewrite their URL (e.g. Electron/desktop builds, or `$current_url` rewrites in
+ * `before_send`) can make targeting match the logical URL instead of the raw browser URL.
+ *
+ * Returns `undefined` when there is no URL available (e.g. non-browser environments).
+ *
+ * Called on every rrweb event by the replay URL triggers/blocklist, so a configured
+ * `get_current_url` override should stay cheap.
+ */
+export declare function getTargetingUrl(instance: UrlTargetingInstance | undefined): string | undefined;

package/dist/utils/url-targeting-utils.js

@@ -0,0 +1,56 @@
+"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__, {
+    getTargetingUrl: ()=>getTargetingUrl,
+    applyUrlTargetingOverride: ()=>applyUrlTargetingOverride
+});
+const core_namespaceObject = require("@posthog/core");
+const external_globals_js_namespaceObject = require("./globals.js");
+const external_logger_js_namespaceObject = require("./logger.js");
+function applyUrlTargetingOverride(instance, defaultUrl) {
+    const override = instance?.config?.get_current_url;
+    if (!(0, core_namespaceObject.isFunction)(override)) return defaultUrl;
+    try {
+        const result = override(defaultUrl);
+        return (0, core_namespaceObject.isString)(result) && result ? result : defaultUrl;
+    } catch (e) {
+        external_logger_js_namespaceObject.logger.error('Error in get_current_url, falling back to window.location.href', e);
+        return defaultUrl;
+    }
+}
+function getTargetingUrl(instance) {
+    const defaultUrl = external_globals_js_namespaceObject.window?.location?.href;
+    return (0, core_namespaceObject.isUndefined)(defaultUrl) ? void 0 : applyUrlTargetingOverride(instance, defaultUrl);
+}
+exports.applyUrlTargetingOverride = __webpack_exports__.applyUrlTargetingOverride;
+exports.getTargetingUrl = __webpack_exports__.getTargetingUrl;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "applyUrlTargetingOverride",
+    "getTargetingUrl"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/url-targeting-utils.mjs

@@ -0,0 +1,19 @@
+import { isFunction, isString, isUndefined } from "@posthog/core";
+import { window as external_globals_mjs_window } from "./globals.mjs";
+import { logger } from "./logger.mjs";
+function applyUrlTargetingOverride(instance, defaultUrl) {
+    const override = instance?.config?.get_current_url;
+    if (!isFunction(override)) return defaultUrl;
+    try {
+        const result = override(defaultUrl);
+        return isString(result) && result ? result : defaultUrl;
+    } catch (e) {
+        logger.error('Error in get_current_url, falling back to window.location.href', e);
+        return defaultUrl;
+    }
+}
+function getTargetingUrl(instance) {
+    const defaultUrl = external_globals_mjs_window?.location?.href;
+    return isUndefined(defaultUrl) ? void 0 : applyUrlTargetingOverride(instance, defaultUrl);
+}
+export { applyUrlTargetingOverride, getTargetingUrl };

package/dist/utils/uuidv7.d.ts

@@ -0,0 +1,43 @@
+/**
+ * uuidv7: An experimental implementation of the proposed UUID Version 7
+ *
+ * @license Apache-2.0
+ * @copyright 2021-2023 LiosK
+ * @packageDocumentation
+ *
+ * from https://github.com/LiosK/uuidv7/blob/e501462ea3d23241de13192ceae726956f9b3b7d/src/index.ts
+ */
+/** Represents a UUID as a 16-byte byte array. */
+export declare class UUID {
+    readonly bytes: Readonly<Uint8Array>;
+    /** @param bytes - The 16-byte byte array representation. */
+    constructor(bytes: Readonly<Uint8Array>);
+    /**
+     * Builds a byte array from UUIDv7 field values.
+     *
+     * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
+     * @param randA - A 12-bit `rand_a` field value.
+     * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
+     * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
+     */
+    static fromFieldsV7(unixTsMs: number, randA: number, randBHi: number, randBLo: number): UUID;
+    /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
+    toString(): string;
+    /** Creates an object from `this`. */
+    clone(): UUID;
+    /** Returns true if `this` is equivalent to `other`. */
+    equals(other: UUID): boolean;
+    /**
+     * Returns a negative integer, zero, or positive integer if `this` is less
+     * than, equal to, or greater than `other`, respectively.
+     */
+    compareTo(other: UUID): number;
+}
+/**
+ * Generates a UUIDv7 string.
+ *
+ * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+ * ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
+ */
+export declare const uuidv7: () => string;
+export declare const uuid7ToTimestampMs: (uuid: string) => number;