@posthog/browser-common 0.9.3 → 0.9.5

package/dist/logs.mjs

@@ -0,0 +1,428 @@
+import { PostHogLogs, PostHogPersistedProperty, buildOtlpLogsPayload, buildResourceAttributes, isNullish } from "@posthog/core";
+import { continueWith } from "./utils/promise-utils.mjs";
+import { addEventListener } from "./utils/general-utils.mjs";
+import { createLogger } from "./utils/logger.mjs";
+import { resolveLogsConfig } from "./logs-config.mjs";
+import { BUFFERED_CONSOLE_LEVELS } from "./logs-types.mjs";
+import { patch } from "./utils/patch.mjs";
+import { originalConsoleMethod } from "./utils/console-original.mjs";
+import { isStatusZeroFailureCircuitBreakerTripped, updateStatusZeroFailureCount } from "./utils/request-reachability.mjs";
+const RECORDER_MAX_AGE_MS = 30000;
+const CONSOLE_SCOPE_NAME = 'console';
+const LOGS_SEND_TIMEOUT_MS = 90000;
+const MAX_CONSECUTIVE_STATUS_ZERO_FAILURES = 3;
+const HANDLED_LOGS_REQUEST_ERROR = '__posthogHandledLogsRequestError';
+const markLogsRequestErrorAsHandled = (error, fallbackMessage)=>{
+    const handledError = error instanceof Error ? error : new Error(fallbackMessage);
+    handledError[HANDLED_LOGS_REQUEST_ERROR] = true;
+    return handledError;
+};
+const isHandledLogsRequestError = (error)=>!!error && 'object' == typeof error && true === error[HANDLED_LOGS_REQUEST_ERROR];
+class logs_PostHogLogs {
+    get _coreLogger() {
+        return {
+            ...this._logger,
+            error: (...args)=>{
+                if (!args.some(isHandledLogsRequestError)) this._logger.error(...args);
+            }
+        };
+    }
+    constructor(_configSource, _getSdkContext){
+        this._configSource = _configSource;
+        this._getSdkContext = _getSdkContext;
+        this.name = 'logs';
+        this._isLogsEnabled = false;
+        this._isLoaded = false;
+        this._isLoading = false;
+        this._logger = createLogger('[logs]');
+        this._queue = [];
+        this._consoleQueue = [];
+        this._consecutiveStatusZeroFailures = 0;
+        this._setupStarted = false;
+        this._disposed = false;
+        this._consoleBuffer = [];
+        this._consoleRecorderUnpatchers = [];
+        this._isRecordingConsole = false;
+        this._isRecordingConsoleEntry = false;
+        this._listeningForReconnect = false;
+        this._onReconnect = ()=>{
+            if (this._disposed) return;
+            this._consecutiveStatusZeroFailures = 0;
+            this._core?.onReconnect();
+            this._consoleCore?.onReconnect();
+        };
+        this._isLogsEnabled = !!_configSource.get()?.captureConsoleLogs;
+    }
+    get _isRequestReady() {
+        return true;
+    }
+    _getConsoleLoader() {}
+    _listenForReconnect() {
+        if (this._listeningForReconnect) return;
+        try {
+            this._window = "u" < typeof window ? void 0 : window;
+        } catch  {
+            this._window = void 0;
+        }
+        if (this._window) {
+            addEventListener(this._window, 'online', this._onReconnect);
+            this._listeningForReconnect = true;
+        }
+    }
+    _buildCore(getQueue, setQueue, opts, scopeName) {
+        this._listenForReconnect();
+        const config = resolveLogsConfig(this._configSource.get(), opts);
+        const core = new PostHogLogs(this._createHost(getQueue, setQueue), config, this._coreLogger, ()=>this._getSdkContext(), (fn)=>fn(), void 0, scopeName);
+        return [
+            core,
+            config
+        ];
+    }
+    _getCore() {
+        const logsConfig = this._configSource.get();
+        if (!this._core || this._resolvedFrom !== logsConfig) {
+            this._core?.reset();
+            this._resolvedFrom = logsConfig;
+            [this._core, this._resolvedConfig] = this._buildCore(()=>this._queue, (q)=>{
+                this._queue = q;
+            });
+        }
+        return this._core;
+    }
+    _getConsoleCore() {
+        const logsConfig = this._configSource.get();
+        if (!this._consoleCore || this._consoleResolvedFrom !== logsConfig) {
+            this._consoleCore?.reset();
+            this._consoleResolvedFrom = logsConfig;
+            [this._consoleCore, this._consoleResolvedConfig] = this._buildCore(()=>this._consoleQueue, (q)=>{
+                this._consoleQueue = q;
+            }, {
+                serviceNameDefault: 'posthog-browser-logs',
+                consoleCapture: true
+            }, CONSOLE_SCOPE_NAME);
+        }
+        return this._consoleCore;
+    }
+    setup(client) {
+        if (this._disposed || this._setupStarted) return;
+        this._setupStarted = true;
+        this._client = client;
+        this._logger = client.logger.createLogger('[logs]');
+        return continueWith(client.kv.initialize(), ()=>{
+            if (!this._disposed) this._finishSetup(client);
+        });
+    }
+    _finishSetup(client) {
+        this._listenForReconnect();
+        if (this._configSource.get()?.captureConsoleLogs) this._isLogsEnabled = true;
+        if (this._isLogsEnabled || this._configSource.remoteConfigWillArrive && client.kv.get(this._configSource.captureHintKey)) this._startConsoleRecorder();
+        let replayedEnabledConfig = false;
+        const subscription = client.onRemoteConfig((result)=>{
+            replayedEnabledConfig = result.ok && result.config.logs?.captureConsoleLogs === true;
+            this.onRemoteConfig(result);
+        });
+        if (this._disposed) return void subscription.dispose();
+        this._remoteConfigSubscription = subscription;
+        if (!replayedEnabledConfig) this.loadIfEnabled();
+    }
+    dispose() {
+        if (this._disposed) return;
+        this._disposed = true;
+        this._stopConsoleRecorder();
+        this._remoteConfigSubscription?.dispose();
+        this._remoteConfigSubscription = void 0;
+        this._client = void 0;
+        this._isLoading = false;
+        this._window?.removeEventListener('online', this._onReconnect);
+        this._consoleLogsDispose?.();
+        this._consoleLogsDispose = void 0;
+        this._core?.clearQueue();
+        this._consoleCore?.clearQueue();
+        this._core?.reset();
+        this._consoleCore?.reset();
+    }
+    onRemoteConfig(result) {
+        if (this._disposed) return;
+        const logCapture = result.ok ? result.config.logs?.captureConsoleLogs : void 0;
+        if (isNullish(logCapture)) return void this._stopRecorderStartedByPersistedHint();
+        this._client?.kv.set(this._configSource.captureHintKey, !!logCapture);
+        if (!logCapture) return void this._stopRecorderStartedByPersistedHint();
+        this._isLogsEnabled = true;
+        if (!this._isLoaded) this._startConsoleRecorder();
+        this.loadIfEnabled();
+    }
+    reset() {
+        this._stopConsoleRecorder();
+        this._core?.clearQueue();
+        this._queue = [];
+        this._core?.reset();
+        this._consoleCore?.clearQueue();
+        this._consoleQueue = [];
+        this._consoleCore?.reset();
+        this._consecutiveStatusZeroFailures = 0;
+    }
+    captureLog(options) {
+        if (!this._disposed && this._client) this._getCore().captureLog(options);
+    }
+    captureConsoleLog(options) {
+        if (!this._disposed && this._client) this._getConsoleCore().captureLog(options);
+    }
+    captureBufferedConsoleLog(options, context, occurredAtMs) {
+        if (!this._disposed && this._client) this._getConsoleCore().captureLog(options, {
+            context,
+            occurredAtMs
+        });
+    }
+    _onOptOut() {
+        this._stopConsoleRecorder();
+        this._consoleCore?.clearQueue();
+        this._consoleQueue = [];
+    }
+    _stopRecorderStartedByPersistedHint() {
+        if (this._isLogsEnabled) return;
+        this._stopConsoleRecorder();
+    }
+    _startConsoleRecorder() {
+        if (this._isRecordingConsole || !this._window?.console) return;
+        const maxBufferSize = resolveLogsConfig(this._configSource.get()).maxBufferSize;
+        let active = true;
+        this._consoleRecorderUnpatchers.push(()=>{
+            active = false;
+        });
+        for (const level of BUFFERED_CONSOLE_LEVELS){
+            let trueOriginal;
+            try {
+                trueOriginal = originalConsoleMethod(this._window.console[level]);
+            } catch  {
+                continue;
+            }
+            if (trueOriginal) this._consoleRecorderUnpatchers.push(patch(this._window.console, level, (next)=>{
+                const wrapped = (...args)=>{
+                    try {
+                        if (active) this._recordConsoleEntry(level, args, maxBufferSize);
+                    } catch  {}
+                    return next.apply(this._window.console, args);
+                };
+                wrapped.__rrweb_original__ = trueOriginal;
+                return wrapped;
+            }));
+        }
+        this._isRecordingConsole = true;
+        this._consoleRecorderTimeout = setTimeout(()=>{
+            this._stopConsoleRecorder();
+        }, RECORDER_MAX_AGE_MS);
+    }
+    _recordConsoleEntry(level, args, maxBufferSize) {
+        if (!this._isRecordingConsole || this._isRecordingConsoleEntry || 0 === args.length) return;
+        if (!this._client?.canCapture) return void this._stopConsoleRecorder();
+        if (this._consoleBuffer.length >= maxBufferSize) return;
+        this._isRecordingConsoleEntry = true;
+        try {
+            this._consoleBuffer.push({
+                level,
+                args,
+                occurredAtMs: Date.now(),
+                context: this._getSdkContext()
+            });
+        } finally{
+            this._isRecordingConsoleEntry = false;
+        }
+    }
+    _stopConsoleRecorder() {
+        this._consoleBuffer = [];
+        if (!this._isRecordingConsole) return;
+        this._isRecordingConsole = false;
+        if (this._consoleRecorderTimeout) {
+            clearTimeout(this._consoleRecorderTimeout);
+            this._consoleRecorderTimeout = void 0;
+        }
+        for (const unpatch of this._consoleRecorderUnpatchers)unpatch();
+        this._consoleRecorderUnpatchers = [];
+    }
+    _takeConsoleBuffer() {
+        const buffered = this._consoleBuffer;
+        this._stopConsoleRecorder();
+        return buffered;
+    }
+    get logger() {
+        if (!this._capture_logger) this._capture_logger = {
+            trace: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'trace',
+                    attributes
+                }),
+            debug: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'debug',
+                    attributes
+                }),
+            info: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'info',
+                    attributes
+                }),
+            warn: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'warn',
+                    attributes
+                }),
+            error: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'error',
+                    attributes
+                }),
+            fatal: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'fatal',
+                    attributes
+                })
+        };
+        return this._capture_logger;
+    }
+    flushLogs(transport) {
+        if (!this._client) return;
+        if (transport) return void this._flushViaTransport(transport);
+        if (this._core) this._core.flush().catch((err)=>this._logFlushError(err));
+        if (this._consoleCore) this._consoleCore.flush().catch((err)=>this._logFlushError(err));
+    }
+    async flush() {
+        const programmatic = this._core?.flush().catch((error)=>this._logFlushError(error));
+        const console = this._consoleCore?.flush().catch((error)=>this._logFlushError(error));
+        await programmatic;
+        await console;
+    }
+    _logFlushError(error) {
+        if (!isHandledLogsRequestError(error)) this._logger.error('PostHog logs flush failed:', error);
+    }
+    loadIfEnabled() {
+        if (this._disposed || !this._isLogsEnabled || this._isLoaded || this._isLoading) return;
+        const loadConsole = this._getConsoleLoader();
+        if (!loadConsole) return void this._stopConsoleRecorder();
+        this._isLoading = true;
+        try {
+            loadConsole((err, logsExtension)=>{
+                this._isLoading = false;
+                if (this._disposed || !this._isLogsEnabled) return;
+                if (err || !logsExtension) {
+                    this._logger.error("Could not load logs script", err);
+                    this._stopConsoleRecorder();
+                } else {
+                    const buffered = this._takeConsoleBuffer();
+                    this._consoleLogsDispose = logsExtension.initialize(this._client);
+                    this._isLoaded = true;
+                    if (buffered.length > 0) logsExtension.replay(this._client, buffered);
+                }
+            });
+        } catch (error) {
+            this._isLoading = false;
+            throw error;
+        }
+    }
+    _createHost(getQueue, setQueue) {
+        const client = this._client;
+        return {
+            get isDisabled () {
+                return false;
+            },
+            get optedOut () {
+                return !client.canCapture;
+            },
+            getPersistedProperty: (key)=>key === PostHogPersistedProperty.LogsQueue ? getQueue() : void 0,
+            setPersistedProperty: (key, value)=>{
+                if (key === PostHogPersistedProperty.LogsQueue) setQueue(value ?? []);
+            },
+            _sendLogsBatch: (payload)=>this._sendLogsBatch(payload),
+            getLibraryId: ()=>client.library.name,
+            getLibraryVersion: ()=>client.library.version
+        };
+    }
+    _sendLogsBatch(payload) {
+        return new Promise((resolve)=>{
+            if (isStatusZeroFailureCircuitBreakerTripped(this._consecutiveStatusZeroFailures, MAX_CONSECUTIVE_STATUS_ZERO_FAILURES)) return void resolve({
+                kind: 'fatal',
+                error: markLogsRequestErrorAsHandled(void 0, 'logs endpoint is unreachable, dropping batch')
+            });
+            let settled = false;
+            const settle = (outcome)=>{
+                if (settled) return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(outcome);
+            };
+            const timer = setTimeout(()=>{
+                this._logger.warn('Logs request timed out before receiving a response');
+                settle({
+                    kind: 'retry-later',
+                    error: markLogsRequestErrorAsHandled(void 0, 'logs request timed out')
+                });
+            }, LOGS_SEND_TIMEOUT_MS);
+            const isRequestReady = this._isRequestReady;
+            this._client.sendRequest('/i/v1/logs', {
+                method: 'POST',
+                query: {
+                    token: this._client.projectToken
+                },
+                body: payload,
+                compression: 'best-available',
+                timeoutMs: 60000
+            }).then((response)=>{
+                const status = response.statusCode;
+                this._trackEndpointReachability(status, isRequestReady);
+                if (status >= 200 && status < 300) settle({
+                    kind: 'ok'
+                });
+                else if (413 === status) settle({
+                    kind: 'too-large'
+                });
+                else if (0 === status || 408 === status || 429 === status || status >= 500) if (0 === status) {
+                    if (!response.error) this._logger.warn('Logs request failed before receiving an HTTP response');
+                    settle({
+                        kind: 'retry-later',
+                        error: markLogsRequestErrorAsHandled(response.error, 'logs request failed before receiving an HTTP response')
+                    });
+                } else settle({
+                    kind: 'retry-later',
+                    error: response.error ?? new Error(`logs request failed with status ${status}`)
+                });
+                else settle({
+                    kind: 'fatal',
+                    error: new Error(`logs request failed with status ${status}`)
+                });
+            }, (error)=>{
+                settle({
+                    kind: 'retry-later',
+                    error
+                });
+            });
+        });
+    }
+    _trackEndpointReachability(statusCode, isRequestReady) {
+        if (0 === statusCode && !isRequestReady) return;
+        this._consecutiveStatusZeroFailures = updateStatusZeroFailureCount(statusCode, this._consecutiveStatusZeroFailures, MAX_CONSECUTIVE_STATUS_ZERO_FAILURES, ()=>this._logger.warn('Log requests are failing before receiving an HTTP response; this can happen due to network issues, CORS, browser blocking, or ad blockers. Stopped sending logs; will try again when connectivity changes.'));
+    }
+    _flushViaTransport(transport) {
+        if (this._queue.length > 0) this._drainQueueViaTransport(transport, this._queue, this._resolvedConfig, this._client.library.name, (q)=>{
+            this._queue = q;
+        });
+        if (this._consoleQueue.length > 0) this._drainQueueViaTransport(transport, this._consoleQueue, this._consoleResolvedConfig, CONSOLE_SCOPE_NAME, (q)=>{
+            this._consoleQueue = q;
+        });
+    }
+    _drainQueueViaTransport(transport, queue, config, scopeName, setQueue) {
+        if (0 === queue.length) return;
+        const records = queue.map((e)=>e.record);
+        setQueue([]);
+        const payload = buildOtlpLogsPayload(records, buildResourceAttributes(config, this._client.library.name, this._client.library.version), scopeName, this._client.library.version);
+        this._client.sendRequest('/i/v1/logs', {
+            method: 'POST',
+            query: {
+                token: this._client.projectToken
+            },
+            body: payload,
+            compression: 'best-available',
+            transport,
+            timeoutMs: 60000
+        }).catch((error)=>this._logFlushError(error));
+    }
+}
+export { RECORDER_MAX_AGE_MS, logs_PostHogLogs as PostHogLogs };

package/dist/token.d.ts

@@ -6,7 +6,7 @@ declare const extensionTokenType: unique symbol;
  * Tokens are plain strings at runtime, so independently compiled scripts can
  * share them without a registry or object-identity contract. The generic brand
  * lets `Client.getExtension` infer the extension type. A token's string
- * value must exactly match its extension's stable `name`.
+ * value must match an installed extension's stable `name` or one of its `bindings` keys.
  */
 export type ExtensionToken<T> = string & {
     readonly [extensionTokenType]: T;

package/dist/utils/console-original.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Walks the `__rrweb_original__` markers console plugins leave behind to reach the
+ * real console method. Shared by the main bundle's recorder and the logs entrypoint
+ * so a change to the marker protocol can't be applied to only one of them.
+ */
+export declare const originalConsoleMethod: (method: any) => any;

package/dist/utils/console-original.js

@@ -0,0 +1,43 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const originalConsoleMethod = (method)=>{
+    while(method?.__rrweb_original__)method = method.__rrweb_original__;
+    return method;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    originalConsoleMethod: originalConsoleMethod
+});
+exports.originalConsoleMethod = __webpack_exports__.originalConsoleMethod;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "originalConsoleMethod"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/console-original.mjs

@@ -0,0 +1,5 @@
+const originalConsoleMethod = (method)=>{
+    while(method?.__rrweb_original__)method = method.__rrweb_original__;
+    return method;
+};
+export { originalConsoleMethod };

package/dist/utils/event-utils.js

@@ -84,6 +84,7 @@ const PERSONAL_DATA_CAMPAIGN_PARAMS = [
     'qclid',
     'sccid',
     'oppref',
+    'bfcid',
     'irclid',
     '_kx'
 ];

package/dist/utils/event-utils.mjs

@@ -24,6 +24,7 @@ const PERSONAL_DATA_CAMPAIGN_PARAMS = [
     'qclid',
     'sccid',
     'oppref',
+    'bfcid',
     'irclid',
     '_kx'
 ];

package/dist/utils/patch.d.ts

@@ -0,0 +1,3 @@
+export declare function patch(source: {
+    [key: string]: any;
+}, name: string, replacement: (...args: unknown[]) => unknown): () => void;

package/dist/utils/patch.js

@@ -0,0 +1,90 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    patch: ()=>patch
+});
+const core_namespaceObject = require("@posthog/core");
+const noop = ()=>{};
+const spliceableLayer = (method)=>{
+    if (!(0, core_namespaceObject.isFunction)(method)) return;
+    return method.__posthog_layer__ ?? method.__rrweb_layer__;
+};
+function patch(source, name, replacement) {
+    try {
+        if (!(name in source)) return noop;
+        const original = source[name];
+        const layer = {
+            next: original
+        };
+        const callNext = function(...args) {
+            return layer.next.apply(this, args);
+        };
+        const wrapped = replacement(callNext);
+        if ((0, core_namespaceObject.isFunction)(wrapped)) {
+            wrapped.prototype = wrapped.prototype || {};
+            Object.defineProperties(wrapped, {
+                __posthog_wrapped__: {
+                    enumerable: false,
+                    value: true
+                },
+                __posthog_layer__: {
+                    enumerable: false,
+                    value: layer
+                }
+            });
+        }
+        source[name] = wrapped;
+        return ()=>{
+            if (source[name] === wrapped) {
+                source[name] = layer.next;
+                return;
+            }
+            let current = source[name];
+            let currentLayer = spliceableLayer(current);
+            while(currentLayer){
+                if (currentLayer.next === wrapped) {
+                    currentLayer.next = layer.next;
+                    return;
+                }
+                current = currentLayer.next;
+                currentLayer = spliceableLayer(current);
+            }
+        };
+    } catch  {
+        return noop;
+    }
+}
+exports.patch = __webpack_exports__.patch;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "patch"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/patch.mjs

@@ -0,0 +1,52 @@
+import { isFunction } from "@posthog/core";
+const noop = ()=>{};
+const spliceableLayer = (method)=>{
+    if (!isFunction(method)) return;
+    return method.__posthog_layer__ ?? method.__rrweb_layer__;
+};
+function patch(source, name, replacement) {
+    try {
+        if (!(name in source)) return noop;
+        const original = source[name];
+        const layer = {
+            next: original
+        };
+        const callNext = function(...args) {
+            return layer.next.apply(this, args);
+        };
+        const wrapped = replacement(callNext);
+        if (isFunction(wrapped)) {
+            wrapped.prototype = wrapped.prototype || {};
+            Object.defineProperties(wrapped, {
+                __posthog_wrapped__: {
+                    enumerable: false,
+                    value: true
+                },
+                __posthog_layer__: {
+                    enumerable: false,
+                    value: layer
+                }
+            });
+        }
+        source[name] = wrapped;
+        return ()=>{
+            if (source[name] === wrapped) {
+                source[name] = layer.next;
+                return;
+            }
+            let current = source[name];
+            let currentLayer = spliceableLayer(current);
+            while(currentLayer){
+                if (currentLayer.next === wrapped) {
+                    currentLayer.next = layer.next;
+                    return;
+                }
+                current = currentLayer.next;
+                currentLayer = spliceableLayer(current);
+            }
+        };
+    } catch  {
+        return noop;
+    }
+}
+export { patch };

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

@@ -0,0 +1,11 @@
+/** Selects the URL components retained for capture. */
+export interface UrlCaptureOptions {
+    /** Retain the pathname. Defaults to true. */
+    path?: boolean;
+    /** Retain query parameters. Defaults to false. */
+    search?: boolean;
+    /** Retain the fragment. Defaults to false. */
+    hash?: boolean;
+}
+/** Shape an absolute URL for capture without modifying the input. Invalid URLs are omitted. */
+export declare function sanitizeUrl(url: URL | string, options: UrlCaptureOptions): string | undefined;