@posthog/browser-common 0.9.2 → 0.9.4

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/types/feature-flags.d.ts

@@ -0,0 +1,18 @@
+import type { FeatureFlagDetail, JsonType } from '@posthog/types';
+import type { RemoteConfig } from './remote-config';
+/**
+ * Flags returns feature flags and their payloads
+ */
+export interface FlagsResponse extends RemoteConfig {
+    featureFlags: Record<string, string | boolean>;
+    featureFlagPayloads: Record<string, JsonType>;
+    errorsWhileComputingFlags: boolean;
+    requestId?: string;
+    flags: Record<string, FeatureFlagDetail>;
+    evaluatedAt?: number;
+    /**
+     * Server-controlled gate for minimal `$feature_flag_called` events. `true` only when the
+     * project opted in; omitted otherwise. Absence always means full events.
+     */
+    minimalFlagCalledEvents?: boolean;
+}

package/dist/types/feature-flags.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/feature-flags.mjs

@@ -0,0 +1 @@
+export { };

package/dist/types/index.d.ts

@@ -2,3 +2,4 @@ export * from './compression';
 export * from './network-recording';
 export * from './remote-config';
 export * from './surveys';
+export * from './feature-flags';

package/dist/types/index.js

@@ -3,6 +3,9 @@ var __webpack_modules__ = {
     "./compression" (module) {
         module.exports = require("./compression.js");
     },
+    "./feature-flags" (module) {
+        module.exports = require("./feature-flags.js");
+    },
     "./network-recording" (module) {
         module.exports = require("./network-recording.js");
     },
@@ -76,6 +79,10 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _surveys__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_surveys__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _feature_flags__rspack_import_4 = __webpack_require__("./feature-flags");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _feature_flags__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_feature_flags__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/types/index.mjs

@@ -2,3 +2,4 @@ export * from "./compression.mjs";
 export * from "./network-recording.mjs";
 export * from "./remote-config.mjs";
 export * from "./surveys.mjs";
+export * from "./feature-flags.mjs";

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.d.ts

@@ -1,3 +1,4 @@
+export { getTimezone } from './timezone';
 import type { Properties } from '@posthog/types';
 import type { BrowserDetectionHints } from '@posthog/core';
 export declare const PERSONAL_DATA_CAMPAIGN_PARAMS: string[];
@@ -18,7 +19,6 @@ export declare function getPersonInfo(maskPersonalDataProperties?: boolean, cust
 };
 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

@@ -54,9 +54,10 @@ __webpack_require__.d(__webpack_exports__, {
     getReferrerInfo: ()=>getReferrerInfo,
     getReferringDomain: ()=>getReferringDomain,
     getSearchInfo: ()=>getSearchInfo,
-    getTimezone: ()=>getTimezone,
+    getTimezone: ()=>external_timezone_js_namespaceObject.getTimezone,
     getTimezoneOffset: ()=>getTimezoneOffset
 });
+const external_timezone_js_namespaceObject = require("./timezone.js");
 const external_request_utils_js_namespaceObject = require("./request-utils.js");
 const core_namespaceObject = require("@posthog/core");
 const external_config_js_namespaceObject = require("../config.js");
@@ -235,13 +236,6 @@ function getInitialPersonPropsFromInfo(info, disableCaptureUrlHashes = false) {
     });
     return props;
 }
-function getTimezone() {
-    try {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone;
-    } catch  {
-        return;
-    }
-}
 function getTimezoneOffset() {
     try {
         return new Date().getTimezoneOffset();
@@ -285,7 +279,7 @@ function getEventProperties(maskPersonalDataProperties, customPersonalDataProper
         $webview_app_version: webviewAppVersion,
         $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: (0, external_timezone_js_namespaceObject.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),

package/dist/utils/event-utils.mjs

@@ -1,3 +1,4 @@
+import { getTimezone } from "./timezone.mjs";
 import { convertToURL, getQueryParam, maskQueryParams } from "./request-utils.mjs";
 import { detectBrowser, detectBrowserVersion, detectDevice, detectDeviceType, detectOS, detectWebviewApp, isNull, isUndefined, stripLeadingDollar, stripUrlHash } from "@posthog/core";
 import config from "../config.mjs";
@@ -175,13 +176,6 @@ function getInitialPersonPropsFromInfo(info, disableCaptureUrlHashes = false) {
     });
     return props;
 }
-function getTimezone() {
-    try {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone;
-    } catch  {
-        return;
-    }
-}
 function getTimezoneOffset() {
     try {
         return new Date().getTimezoneOffset();

package/dist/utils/logger.js

@@ -43,12 +43,17 @@ __webpack_require__.d(__webpack_exports__, {
 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];
+            let browserWindow;
+            try {
+                browserWindow = "u" < typeof window ? void 0 : window;
+            } catch  {
+                return;
+            }
+            if (browserWindow && (external_config_js_default().DEBUG || browserWindow.POSTHOG_DEBUG || debugEnabled) && !(0, core_namespaceObject.isUndefined)(browserWindow.console) && browserWindow.console) {
+                const consoleLog = '__rrweb_original__' in browserWindow.console[level] ? browserWindow.console[level]['__rrweb_original__'] : browserWindow.console[level];
                 consoleLog(prefix, ...args);
             }
         },