@pratham.raval/browser-core 6.22.3

package/src/domain/trackingConsent.ts

@@ -0,0 +1,34 @@
+import { Observable } from '../tools/observable'
+
+export const TrackingConsent = {
+  GRANTED: 'granted',
+  NOT_GRANTED: 'not-granted',
+} as const
+export type TrackingConsent = (typeof TrackingConsent)[keyof typeof TrackingConsent]
+
+export interface TrackingConsentState {
+  tryToInit: (trackingConsent: TrackingConsent) => void
+  update: (trackingConsent: TrackingConsent) => void
+  isGranted: () => boolean
+  observable: Observable<void>
+}
+
+export function createTrackingConsentState(currentConsent?: TrackingConsent): TrackingConsentState {
+  const observable = new Observable<void>()
+
+  return {
+    tryToInit(trackingConsent: TrackingConsent) {
+      if (!currentConsent) {
+        currentConsent = trackingConsent
+      }
+    },
+    update(trackingConsent: TrackingConsent) {
+      currentConsent = trackingConsent
+      observable.notify()
+    },
+    isGranted() {
+      return currentConsent === TrackingConsent.GRANTED
+    },
+    observable,
+  }
+}

package/src/index.ts

@@ -0,0 +1,164 @@
+export type { Configuration, InitConfiguration, EndpointBuilder, ProxyFn } from './domain/configuration'
+export {
+  validateAndBuildConfiguration,
+  DefaultPrivacyLevel,
+  TraceContextInjection,
+  serializeConfiguration,
+  isSampleRate,
+  buildEndpointHost,
+  isIntakeUrl,
+} from './domain/configuration'
+export * from './domain/intakeSites'
+export type { TrackingConsentState } from './domain/trackingConsent'
+export { TrackingConsent, createTrackingConsentState } from './domain/trackingConsent'
+export {
+  isExperimentalFeatureEnabled,
+  addExperimentalFeatures,
+  resetExperimentalFeatures,
+  getExperimentalFeatures,
+  initFeatureFlags,
+  ExperimentalFeature,
+} from './tools/experimentalFeatures'
+export { trackRuntimeError } from './domain/error/trackRuntimeError'
+export type { StackTrace } from './tools/stackTrace/computeStackTrace'
+export { computeStackTrace } from './tools/stackTrace/computeStackTrace'
+export type { PublicApi } from './boot/init'
+export { defineGlobal, makePublicApi } from './boot/init'
+export { displayAlreadyInitializedError } from './boot/displayAlreadyInitializedError'
+export { initReportObservable, RawReportType } from './domain/report/reportObservable'
+export type {
+  Telemetry,
+  RawTelemetryEvent,
+  RawTelemetryConfiguration,
+  TelemetryEvent,
+  TelemetryErrorEvent,
+  TelemetryDebugEvent,
+  TelemetryConfigurationEvent,
+  TelemetryUsageEvent,
+  RawTelemetryUsage,
+  RawTelemetryUsageFeature,
+} from './domain/telemetry'
+export {
+  startTelemetry,
+  addTelemetryDebug,
+  addTelemetryError,
+  resetTelemetry,
+  TelemetryService,
+  TelemetryMetrics,
+  addTelemetryConfiguration,
+  addTelemetryUsage,
+  addTelemetryMetrics,
+} from './domain/telemetry'
+export { monitored, monitor, callMonitored, setDebugMode, monitorError } from './tools/monitor'
+export type { Subscription } from './tools/observable'
+export { Observable, BufferedObservable } from './tools/observable'
+export type { SessionManager } from './domain/session/sessionManager'
+export { startSessionManager, stopSessionManager } from './domain/session/sessionManager'
+export {
+  SESSION_TIME_OUT_DELAY, // Exposed for tests
+  SESSION_NOT_TRACKED,
+  SessionPersistence,
+} from './domain/session/sessionConstants'
+export type { BandwidthStats, HttpRequest, HttpRequestEvent, Payload, FlushEvent, FlushReason } from './transport'
+export {
+  createHttpRequest,
+  canUseEventBridge,
+  getEventBridge,
+  bridgeSupports,
+  BridgeCapability,
+  createBatch,
+  createFlushController,
+} from './transport'
+export * from './tools/display'
+export type { Encoder, EncoderResult } from './tools/encoder'
+export { createIdentityEncoder } from './tools/encoder'
+export * from './tools/utils/urlPolyfill'
+export * from './tools/utils/timeUtils'
+export * from './tools/utils/arrayUtils'
+export * from './tools/serialisation/sanitize'
+export * from './tools/globalObject'
+export { AbstractLifeCycle } from './tools/abstractLifeCycle'
+export * from './domain/eventRateLimiter/createEventRateLimiter'
+export * from './tools/utils/browserDetection'
+export { sendToExtension } from './tools/sendToExtension'
+export { runOnReadyState, asyncRunOnReadyState } from './browser/runOnReadyState'
+export { getZoneJsOriginalValue } from './tools/getZoneJsOriginalValue'
+export type { InstrumentedMethodCall } from './tools/instrumentMethod'
+export { instrumentMethod, instrumentSetter } from './tools/instrumentMethod'
+export {
+  computeRawError,
+  getFileFromStackTraceString,
+  isError,
+  NO_ERROR_STACK_PRESENT_MESSAGE,
+} from './domain/error/error'
+export { NonErrorPrefix } from './domain/error/error.types'
+export type { Context, ContextArray, ContextValue } from './tools/serialisation/context'
+export {
+  areCookiesAuthorized,
+  getCookie,
+  getInitCookie,
+  setCookie,
+  deleteCookie,
+  resetInitCookies,
+} from './browser/cookie'
+export type { CookieStore, WeakRef, WeakRefConstructor } from './browser/browser.types'
+export type { XhrCompleteContext, XhrStartContext } from './browser/xhrObservable'
+export { initXhrObservable } from './browser/xhrObservable'
+export type { FetchResolveContext, FetchStartContext, FetchContext } from './browser/fetchObservable'
+export { initFetchObservable, resetFetchObservable } from './browser/fetchObservable'
+export type { PageMayExitEvent } from './browser/pageMayExitObservable'
+export { createPageMayExitObservable, PageExitReason, isPageExitReason } from './browser/pageMayExitObservable'
+export * from './browser/addEventListener'
+export { requestIdleCallback } from './tools/requestIdleCallback'
+export * from './tools/taskQueue'
+export * from './tools/timer'
+export type { ConsoleLog } from './domain/console/consoleObservable'
+export { initConsoleObservable, resetConsoleObservable } from './domain/console/consoleObservable'
+export type { BoundedBuffer } from './tools/boundedBuffer'
+export { createBoundedBuffer } from './tools/boundedBuffer'
+export { catchUserErrors } from './tools/catchUserErrors'
+export type { ContextManager } from './domain/context/contextManager'
+export { createContextManager } from './domain/context/contextManager'
+export { defineContextMethod, bufferContextCalls } from './domain/context/defineContextMethod'
+export { storeContextManager, removeStorageListeners } from './domain/context/storeContextManager'
+export { startAccountContext, buildAccountContextManager } from './domain/contexts/accountContext'
+export { startGlobalContext, buildGlobalContextManager } from './domain/contexts/globalContext'
+export { startUserContext, buildUserContextManager } from './domain/contexts/userContext'
+export type { User } from './domain/contexts/userContext'
+export type { Account } from './domain/contexts/accountContext'
+export type { RumInternalContext } from './domain/contexts/rumInternalContext.type'
+export { CustomerDataType, CustomerContextKey, ContextManagerMethod } from './domain/context/contextConstants'
+export type { ValueHistory, ValueHistoryEntry } from './tools/valueHistory'
+export { createValueHistory, CLEAR_OLD_VALUES_INTERVAL } from './tools/valueHistory'
+export { readBytesFromStream } from './tools/readBytesFromStream'
+export type { SessionState } from './domain/session/sessionState'
+export { STORAGE_POLL_DELAY } from './domain/session/sessionStore'
+export { SESSION_STORE_KEY } from './domain/session/storeStrategies/sessionStoreStrategy'
+export {
+  willSyntheticsInjectRum,
+  getSyntheticsTestId,
+  getSyntheticsResultId,
+  isSyntheticsTest,
+} from './domain/synthetics/syntheticsWorkerValues'
+export { checkContext } from './domain/context/contextUtils'
+export * from './domain/resourceUtils'
+export * from './domain/bufferedData'
+export * from './tools/utils/polyfills'
+export * from './tools/utils/timezone'
+export * from './tools/utils/numberUtils'
+export * from './tools/utils/byteUtils'
+export * from './tools/utils/objectUtils'
+export * from './tools/utils/functionUtils'
+export * from './tools/serialisation/jsonStringify'
+export * from './tools/mergeInto'
+export * from './tools/utils/stringUtils'
+export * from './tools/matchOption'
+export * from './tools/utils/responseUtils'
+export * from './tools/utils/typeUtils'
+export type { RawError, RawErrorCause, ErrorWithCause, Csp } from './domain/error/error.types'
+export { ErrorHandling, ErrorSource } from './domain/error/error.types'
+export * from './domain/deflate'
+export * from './domain/connectivity'
+export * from './tools/stackTrace/handlingStack'
+export * from './tools/abstractHooks'
+export * from './domain/tags'

package/src/tools/abstractHooks.ts

@@ -0,0 +1,72 @@
+import { combine } from './mergeInto'
+
+export const enum HookNames {
+  Assemble,
+  AssembleTelemetry,
+}
+
+// This is a workaround for an issue occurring when the Browser SDK is included in a TypeScript
+// project configured with `isolatedModules: true`. Even if the const enum is declared in this
+// module, we cannot use it directly to define the EventMap interface keys (TS error: "Cannot access
+// ambient const enums when the '--isolatedModules' flag is provided.").
+export declare const HookNamesAsConst: {
+  ASSEMBLE: HookNames.Assemble
+  ASSEMBLE_TELEMETRY: HookNames.AssembleTelemetry
+}
+
+export type RecursivePartial<T> = {
+  [P in keyof T]?: T[P] extends Array<infer U>
+    ? Array<RecursivePartial<U>>
+    : T[P] extends object | undefined
+      ? RecursivePartial<T[P]>
+      : T[P]
+}
+
+// Discards the event from being sent
+export const DISCARDED = 'DISCARDED'
+// Skips from the assembly of the event
+export const SKIPPED = 'SKIPPED'
+
+export type DISCARDED = typeof DISCARDED
+export type SKIPPED = typeof SKIPPED
+
+export type AbstractHooks = ReturnType<typeof abstractHooks>
+
+export function abstractHooks<T extends { [K in HookNames]: (...args: any[]) => unknown }>() {
+  const callbacks: { [K in HookNames]?: Array<T[K]> } = {}
+
+  return {
+    register<K extends HookNames>(hookName: K, callback: T[K]) {
+      if (!callbacks[hookName]) {
+        callbacks[hookName] = []
+      }
+      callbacks[hookName]!.push(callback)
+      return {
+        unregister: () => {
+          callbacks[hookName] = callbacks[hookName]!.filter((cb) => cb !== callback)
+        },
+      }
+    },
+    triggerHook<K extends HookNames>(
+      hookName: K,
+      param: Parameters<T[K]>[0]
+    ): Exclude<ReturnType<T[K]>, SKIPPED> | DISCARDED | undefined {
+      const hookCallbacks = callbacks[hookName] || []
+      const results: any[] = []
+
+      for (const callback of hookCallbacks) {
+        const result = callback(param)
+        if (result === DISCARDED) {
+          return DISCARDED
+        }
+        if (result === SKIPPED) {
+          continue
+        }
+
+        results.push(result)
+      }
+
+      return combine(...(results as [any, any])) as Exclude<ReturnType<T[K]>, SKIPPED>
+    },
+  }
+}

package/src/tools/abstractLifeCycle.ts

@@ -0,0 +1,46 @@
+import type { Subscription } from './observable'
+
+/**
+ * Type helper to extract event types that have "void" data. This allows to call `notify` without a
+ * second argument. Ex:
+ *
+ * ```
+ * interface EventMap {
+ *   foo: void
+ * }
+ * const LifeCycle = AbstractLifeCycle<EventMap>
+ * new LifeCycle().notify('foo')
+ * ```
+ */
+type EventTypesWithoutData<EventMap> = {
+  [K in keyof EventMap]: EventMap[K] extends void ? K : never
+}[keyof EventMap]
+
+// eslint-disable-next-line no-restricted-syntax
+export class AbstractLifeCycle<EventMap> {
+  private callbacks: { [key in keyof EventMap]?: Array<(data: any) => void> } = {}
+
+  notify<EventType extends EventTypesWithoutData<EventMap>>(eventType: EventType): void
+  notify<EventType extends keyof EventMap>(eventType: EventType, data: EventMap[EventType]): void
+  notify(eventType: keyof EventMap, data?: unknown) {
+    const eventCallbacks = this.callbacks[eventType]
+    if (eventCallbacks) {
+      eventCallbacks.forEach((callback) => callback(data))
+    }
+  }
+
+  subscribe<EventType extends keyof EventMap>(
+    eventType: EventType,
+    callback: (data: EventMap[EventType]) => void
+  ): Subscription {
+    if (!this.callbacks[eventType]) {
+      this.callbacks[eventType] = []
+    }
+    this.callbacks[eventType]!.push(callback)
+    return {
+      unsubscribe: () => {
+        this.callbacks[eventType] = this.callbacks[eventType]!.filter((other) => callback !== other)
+      },
+    }
+  }
+}

package/src/tools/boundedBuffer.ts

@@ -0,0 +1,45 @@
+import { removeItem } from './utils/arrayUtils'
+
+const BUFFER_LIMIT = 500
+
+/**
+ * BoundedBuffer is a deprecated interface.
+ *
+ * @deprecated Use `BufferedObservable` instead.
+ */
+export interface BoundedBuffer<T = void> {
+  add: (callback: (arg: T) => void) => void
+  remove: (callback: (arg: T) => void) => void
+  drain: (arg: T) => void
+}
+
+/**
+ * createBoundedBuffer creates a BoundedBuffer.
+ *
+ * @deprecated Use `BufferedObservable` instead.
+ */
+export function createBoundedBuffer<T = void>(): BoundedBuffer<T> {
+  const buffer: Array<(arg: T) => void> = []
+
+  const add: BoundedBuffer<T>['add'] = (callback: (arg: T) => void) => {
+    const length = buffer.push(callback)
+    if (length > BUFFER_LIMIT) {
+      buffer.splice(0, 1)
+    }
+  }
+
+  const remove: BoundedBuffer<T>['remove'] = (callback: (arg: T) => void) => {
+    removeItem(buffer, callback)
+  }
+
+  const drain = (arg: T) => {
+    buffer.forEach((callback) => callback(arg))
+    buffer.length = 0
+  }
+
+  return {
+    add,
+    remove,
+    drain,
+  }
+}

package/src/tools/catchUserErrors.ts

@@ -0,0 +1,11 @@
+import { display } from './display'
+
+export function catchUserErrors<Args extends any[], R>(fn: (...args: Args) => R, errorMsg: string) {
+  return (...args: Args) => {
+    try {
+      return fn(...args)
+    } catch (err) {
+      display.error(errorMsg, err)
+    }
+  }
+}

package/src/tools/display.ts

@@ -0,0 +1,56 @@
+/* eslint-disable local-rules/disallow-side-effects */
+/**
+ * Keep references on console methods to avoid triggering patched behaviors
+ *
+ * NB: in some setup, console could already be patched by another SDK.
+ * In this case, some display messages can be sent by the other SDK
+ * but we should be safe from infinite loop nonetheless.
+ */
+
+export const ConsoleApiName = {
+  log: 'log',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warn',
+  error: 'error',
+} as const
+
+export type ConsoleApiName = (typeof ConsoleApiName)[keyof typeof ConsoleApiName]
+
+interface Display {
+  debug: typeof console.debug
+  log: typeof console.log
+  info: typeof console.info
+  warn: typeof console.warn
+  error: typeof console.error
+}
+
+/**
+ * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove
+ * "console.*" references. This causes some issue as we expect `console.*` to be defined.
+ * As a workaround, let's use a variable alias, so those expressions won't be taken into account by
+ * simple static analysis.
+ *
+ * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/
+ * [2]: https://github.com/terser/terser#compress-options (look for drop_console)
+ */
+export const globalConsole = console
+
+export const originalConsoleMethods = {} as Display
+Object.keys(ConsoleApiName).forEach((name) => {
+  originalConsoleMethods[name as ConsoleApiName] = globalConsole[name as ConsoleApiName]
+})
+
+const PREFIX = 'Datadog Browser SDK:'
+
+export const display: Display = {
+  debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),
+  log: originalConsoleMethods.log.bind(globalConsole, PREFIX),
+  info: originalConsoleMethods.info.bind(globalConsole, PREFIX),
+  warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),
+  error: originalConsoleMethods.error.bind(globalConsole, PREFIX),
+}
+
+export const DOCS_ORIGIN = 'https://docs.datadoghq.com'
+export const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/real_user_monitoring/browser/troubleshooting`
+export const MORE_DETAILS = 'More details:'

package/src/tools/encoder.ts

@@ -0,0 +1,103 @@
+import type { Uint8ArrayBuffer } from './utils/byteUtils'
+import { computeBytesCount } from './utils/byteUtils'
+
+export interface Encoder<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
+  /**
+   * Whether this encoder might call the provided callbacks asynchronously
+   */
+  isAsync: boolean
+
+  /**
+   * Whether some data has been written since the last finish() or finishSync() call
+   */
+  isEmpty: boolean
+
+  /**
+   * Write a string to be encoded.
+   *
+   * This operation can be synchronous or asynchronous depending on the encoder implementation.
+   *
+   * If specified, the callback will be invoked when the operation finishes, unless the operation is
+   * asynchronous and finish() or finishSync() is called in the meantime.
+   */
+  write(data: string, callback?: (additionalEncodedBytesCount: number) => void): void
+
+  /**
+   * Waits for pending data to be encoded and resets the encoder state.
+   *
+   * This operation can be synchronous or asynchronous depending on the encoder implementation.
+   *
+   * The callback will be invoked when the operation finishes, unless the operation is asynchronous
+   * and another call to finish() or finishSync() occurs in the meantime.
+   */
+  finish(callback: (result: EncoderResult<Output>) => void): void
+
+  /**
+   * Resets the encoder state then returns the encoded data and any potential pending data directly,
+   * discarding all pending write operations and finish() callbacks.
+   */
+  finishSync(): EncoderResult<Output> & { pendingData: string }
+
+  /**
+   * Returns a rough estimation of the bytes count if the data was encoded.
+   */
+  estimateEncodedBytesCount(data: string): number
+}
+
+export interface EncoderResult<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
+  output: Output
+  outputBytesCount: number
+
+  /**
+   * An encoding type supported by HTTP Content-Encoding, if applicable.
+   * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding#directives
+   */
+  encoding?: 'deflate'
+
+  /**
+   * Total bytes count of the input strings encoded to UTF-8.
+   */
+  rawBytesCount: number
+}
+
+export function createIdentityEncoder(): Encoder<string> {
+  let output = ''
+  let outputBytesCount = 0
+
+  return {
+    isAsync: false,
+
+    get isEmpty() {
+      return !output
+    },
+
+    write(data, callback) {
+      const additionalEncodedBytesCount = computeBytesCount(data)
+      outputBytesCount += additionalEncodedBytesCount
+      output += data
+      if (callback) {
+        callback(additionalEncodedBytesCount)
+      }
+    },
+
+    finish(callback) {
+      callback(this.finishSync())
+    },
+
+    finishSync() {
+      const result = {
+        output,
+        outputBytesCount,
+        rawBytesCount: outputBytesCount,
+        pendingData: '',
+      }
+      output = ''
+      outputBytesCount = 0
+      return result
+    },
+
+    estimateEncodedBytesCount(data) {
+      return data.length
+    },
+  }
+}

package/src/tools/experimentalFeatures.ts

@@ -0,0 +1,51 @@
+/**
+ * LIMITATION:
+ * For NPM setup, this feature flag singleton is shared between RUM and Logs product.
+ * This means that an experimental flag set on the RUM product will be set on the Logs product.
+ * So keep in mind that in certain configurations, your experimental feature flag may affect other products.
+ *
+ * FORMAT:
+ * All feature flags should be snake_cased
+ */
+// We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary
+// string is an expected feature flag
+
+import { objectHasValue } from './utils/objectUtils'
+
+// eslint-disable-next-line no-restricted-syntax
+export enum ExperimentalFeature {
+  TRACK_INTAKE_REQUESTS = 'track_intake_requests',
+  USE_TREE_WALKER_FOR_ACTION_NAME = 'use_tree_walker_for_action_name',
+  FEATURE_OPERATION_VITAL = 'feature_operation_vital',
+  SHORT_SESSION_INVESTIGATION = 'short_session_investigation',
+}
+
+const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()
+
+export function initFeatureFlags(enableExperimentalFeatures: string[] | undefined) {
+  if (Array.isArray(enableExperimentalFeatures)) {
+    addExperimentalFeatures(
+      enableExperimentalFeatures.filter((flag): flag is ExperimentalFeature =>
+        objectHasValue(ExperimentalFeature, flag)
+      )
+    )
+  }
+}
+
+export function addExperimentalFeatures(enabledFeatures: ExperimentalFeature[]): void {
+  enabledFeatures.forEach((flag) => {
+    enabledExperimentalFeatures.add(flag)
+  })
+}
+
+export function isExperimentalFeatureEnabled(featureName: ExperimentalFeature): boolean {
+  return enabledExperimentalFeatures.has(featureName)
+}
+
+export function resetExperimentalFeatures(): void {
+  enabledExperimentalFeatures.clear()
+}
+
+export function getExperimentalFeatures(): Set<ExperimentalFeature> {
+  return enabledExperimentalFeatures
+}

package/src/tools/getZoneJsOriginalValue.ts

@@ -0,0 +1,38 @@
+import { getGlobalObject } from './globalObject'
+
+export interface BrowserWindowWithZoneJs extends Window {
+  Zone?: {
+    // All Zone.js versions expose the __symbol__ method, but we observed that some website have a
+    // 'Zone' global variable unrelated to Zone.js, so let's consider this method optional
+    // nonetheless.
+    __symbol__?: (name: string) => string
+  }
+}
+
+/**
+ * Gets the original value for a DOM API that was potentially patched by Zone.js.
+ *
+ * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original
+ * value of the patched functions/constructors/methods in a hidden property prefixed by
+ * __zone_symbol__.
+ *
+ * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to
+ * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to
+ * use the original DOM API instead of the one patched by Zone.js.
+ *
+ * [1]: https://github.com/angular/angular/tree/main/packages/zone.js
+ */
+export function getZoneJsOriginalValue<Target, Name extends keyof Target & string>(
+  target: Target,
+  name: Name
+): Target[Name] {
+  const browserWindow = getGlobalObject<BrowserWindowWithZoneJs>()
+  let original: Target[Name] | undefined
+  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {
+    original = (target as any)[browserWindow.Zone.__symbol__(name)]
+  }
+  if (!original) {
+    original = target[name]
+  }
+  return original
+}

package/src/tools/globalObject.ts

@@ -0,0 +1,51 @@
+/**
+ * inspired by https://mathiasbynens.be/notes/globalthis
+ */
+
+// Extend/Create the WorkerGlobalScope interface to avoid issues when used in a non-browser tsconfig environment
+interface WorkerGlobalScope {
+  empty: never
+}
+
+// Utility type to enforce that exactly one of the two types is used
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
+type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U
+
+export type GlobalObject = XOR<Window, WorkerGlobalScope>
+
+export function getGlobalObject<T = typeof globalThis>(): T {
+  if (typeof globalThis === 'object') {
+    return globalThis as unknown as T
+  }
+  Object.defineProperty(Object.prototype, '_dd_temp_', {
+    get() {
+      return this as object
+    },
+    configurable: true,
+  })
+  // @ts-ignore _dd_temp is defined using defineProperty
+  let globalObject: unknown = _dd_temp_
+  // @ts-ignore _dd_temp is defined using defineProperty
+  delete Object.prototype._dd_temp_
+  if (typeof globalObject !== 'object') {
+    // on safari _dd_temp_ is available on window but not globally
+    // fallback on other browser globals check
+    if (typeof self === 'object') {
+      globalObject = self
+    } else if (typeof window === 'object') {
+      globalObject = window
+    } else {
+      globalObject = {}
+    }
+  }
+  return globalObject as T
+}
+
+/**
+ * Cached reference to the global object so it can be imported and re-used without
+ * re-evaluating the heavyweight fallback logic in `getGlobalObject()`.
+ */
+// eslint-disable-next-line local-rules/disallow-side-effects
+export const globalObject = getGlobalObject<GlobalObject>()
+
+export const isWorkerEnvironment = 'WorkerGlobalScope' in globalObject