@myinterview/widget-react 1.0.56 → 1.0.57

package/dist/esm/index.js

@@ -2,7 +2,7 @@ import * as React from 'react';
 import React__default, { createContext, forwardRef, useRef, useEffect, useState, useLayoutEffect, useImperativeHandle, useDebugValue, useContext, createElement, useCallback, useMemo, isValidElement, cloneElement } from 'react';
 import { createPortal } from 'react-dom';
 
-var commonjsGlobal$1 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -7630,7 +7630,7 @@ function useMachine(getMachine) {
                 ? State.create(options.state)
                 : service.machine.initialState);
         }
-        return service.state;
+        return service.getSnapshot();
     }, [service]);
     var isEqual = useCallback(function (prevState, nextState) {
         if (service.status === InterpreterStatus.NotStarted) {
@@ -7662,6 +7662,42 @@ function useMachine(getMachine) {
     return [storeSnapshot, service.send, service];
 }
 
+(undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+(undefined && undefined.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+function getServiceSnapshot(service) {
+    return service.status !== 0
+        ? service.getSnapshot()
+        : service.machine.initialState;
+}
+function isService(actor) {
+    return 'state' in actor && 'machine' in actor;
+}
+
 function isActorWithState(actorRef) {
     return 'state' in actorRef;
 }
@@ -7670,7 +7706,9 @@ function isDeferredActor(actorRef) {
 }
 function defaultGetSnapshot(actorRef) {
     return 'getSnapshot' in actorRef
-        ? actorRef.getSnapshot()
+        ? isService(actorRef)
+            ? getServiceSnapshot(actorRef)
+            : actorRef.getSnapshot()
         : isActorWithState(actorRef)
             ? actorRef.state
             : undefined;
@@ -7719,34 +7757,6 @@ function useActor(actorRef, getSnapshot) {
     return [storeSnapshot, send];
 }
 
-(undefined && undefined.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-(undefined && undefined.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-
 var SPEED_TEST_LEVEL;
 (function (SPEED_TEST_LEVEL) {
     SPEED_TEST_LEVEL[SPEED_TEST_LEVEL["LOW"] = 0] = "LOW";
@@ -8802,7 +8812,7 @@ var platform$1 = {exports: {}};
 	  var freeModule = module && !module.nodeType && module;
 
 	  /** Detect free variable `global` from Node.js or Browserified code and use it as `root`. */
-	  var freeGlobal = freeExports && freeModule && typeof commonjsGlobal$1 == 'object' && commonjsGlobal$1;
+	  var freeGlobal = freeExports && freeModule && typeof commonjsGlobal == 'object' && commonjsGlobal;
 	  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
 	    root = freeGlobal;
 	  }
@@ -10015,7 +10025,7 @@ var platform$1 = {exports: {}};
 	    // Export to the global object.
 	    root.platform = platform;
 	  }
-	}.call(commonjsGlobal$1));
+	}.call(commonjsGlobal));
 } (platform$1, platform$1.exports));
 
 var platform = platform$1.exports;
@@ -14944,7 +14954,7 @@ const Explanation = ({ isVideoQuestion, thinkingTime }) => {
 };
 
 // eslint-disable-next-line @typescript-eslint/unbound-method
-const objectToString$1 = Object.prototype.toString;
+const objectToString = Object.prototype.toString;
 
 /**
  * Checks whether given value's type is one of a few Error or Error-like
@@ -14954,7 +14964,7 @@ const objectToString$1 = Object.prototype.toString;
  * @returns A boolean representing the result.
  */
 function isError(wat) {
-  switch (objectToString$1.call(wat)) {
+  switch (objectToString.call(wat)) {
     case '[object Error]':
     case '[object Exception]':
     case '[object DOMException]':
@@ -14971,7 +14981,7 @@ function isError(wat) {
  * @returns A boolean representing the result.
  */
 function isBuiltin(wat, className) {
-  return objectToString$1.call(wat) === `[object ${className}]`;
+  return objectToString.call(wat) === `[object ${className}]`;
 }
 
 /**
@@ -15688,9 +15698,7 @@ function urlEncode(object) {
  * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor
  *  an Error.
  */
-function convertToPlainObject(
-  value,
-)
+function convertToPlainObject(value)
 
  {
   if (isError(value)) {
@@ -15883,6 +15891,14 @@ function createStackParser(...parsers) {
     const frames = [];
 
     for (const line of stack.split('\n').slice(skipFirst)) {
+      // Ignore lines over 1kb as they are unlikely to be stack frames.
+      // Many of the regular expressions use backtracking which results in run time that increases exponentially with
+      // input size. Huge strings can result in hangs/Denial of Service:
+      // https://github.com/getsentry/sentry-javascript/issues/2286
+      if (line.length > 1024) {
+        continue;
+      }
+
       // https://github.com/getsentry/sentry-javascript/issues/5459
       // Remove webpack (error: *) wrappers
       const cleanedLine = line.replace(/\(error: (.*)\)/, '$1');
@@ -17697,6 +17713,8 @@ const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
   client_report: 'internal',
   user_report: 'default',
   profile: 'profile',
+  replay_event: 'replay_event',
+  replay_recording: 'replay_recording',
 };
 
 /**
@@ -18715,7 +18733,7 @@ class Hub  {
    */
    captureEvent(event, hint) {
     const eventId = hint && hint.event_id ? hint.event_id : uuid4();
-    if (event.type !== 'transaction') {
+    if (!event.type) {
       this._lastEventId = eventId;
     }
 
@@ -18740,7 +18758,6 @@ class Hub  {
 
     if (!scope || !client) return;
 
-    // eslint-disable-next-line @typescript-eslint/unbound-method
     const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =
       (client.getOptions && client.getOptions()) || {};
 
@@ -19234,7 +19251,15 @@ function createEventEnvelope(
   tunnel,
 ) {
   const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
-  const eventType = event.type || 'event';
+
+  /*
+    Note: Due to TS, event.type may be `replay_event`, theoretically.
+    In practice, we never call `createEventEnvelope` with `replay_event` type,
+    and we'd have to adjut a looot of types to make this work properly.
+    We want to avoid casting this around, as that could lead to bugs (e.g. when we add another type)
+    So the safe choice is to really guard against the replay_event type here.
+  */
+  const eventType = event.type && event.type !== 'replay_event' ? event.type : 'event';
 
   enhanceEventWithSdkInfo(event, metadata && metadata.sdk);
 
@@ -19262,16 +19287,209 @@ function setupIntegrations(integrations) {
   const integrationIndex = {};
 
   integrations.forEach(integration => {
-    integrationIndex[integration.name] = integration;
+    setupIntegration(integration, integrationIndex);
+  });
+
+  return integrationIndex;
+}
+
+/** Setup a single integration.  */
+function setupIntegration(integration, integrationIndex) {
+  integrationIndex[integration.name] = integration;
+
+  if (installedIntegrations.indexOf(integration.name) === -1) {
+    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);
+    installedIntegrations.push(integration.name);
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Integration installed: ${integration.name}`);
+  }
+}
+
+/**
+ * Adds common information to events.
+ *
+ * The information includes release and environment from `options`,
+ * breadcrumbs and context (extra, tags and user) from the scope.
+ *
+ * Information that is already present in the event is never overwritten. For
+ * nested objects, such as the context, keys are merged.
+ *
+ * Note: This also triggers callbacks for `addGlobalEventProcessor`, but not `beforeSend`.
+ *
+ * @param event The original event.
+ * @param hint May contain additional information about the original exception.
+ * @param scope A scope containing event metadata.
+ * @returns A new event with more information.
+ * @hidden
+ */
+function prepareEvent(
+  options,
+  event,
+  hint,
+  scope,
+) {
+  const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = options;
+  const prepared = {
+    ...event,
+    event_id: event.event_id || hint.event_id || uuid4(),
+    timestamp: event.timestamp || dateTimestampInSeconds(),
+  };
+
+  applyClientOptions(prepared, options);
+  applyIntegrationsMetadata(
+    prepared,
+    options.integrations.map(i => i.name),
+  );
+
+  // If we have scope given to us, use it as the base for further modifications.
+  // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.
+  let finalScope = scope;
+  if (hint.captureContext) {
+    finalScope = Scope.clone(finalScope).update(hint.captureContext);
+  }
+
+  // We prepare the result here with a resolved Event.
+  let result = resolvedSyncPromise(prepared);
 
-    if (installedIntegrations.indexOf(integration.name) === -1) {
-      integration.setupOnce(addGlobalEventProcessor, getCurrentHub);
-      installedIntegrations.push(integration.name);
-      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Integration installed: ${integration.name}`);
+  // This should be the last thing called, since we want that
+  // {@link Hub.addEventProcessor} gets the finished prepared event.
+  //
+  // We need to check for the existence of `finalScope.getAttachments`
+  // because `getAttachments` can be undefined if users are using an older version
+  // of `@sentry/core` that does not have the `getAttachments` method.
+  // See: https://github.com/getsentry/sentry-javascript/issues/5229
+  if (finalScope) {
+    // Collect attachments from the hint and scope
+    if (finalScope.getAttachments) {
+      const attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];
+
+      if (attachments.length) {
+        hint.attachments = attachments;
+      }
     }
+
+    // In case we have a hub we reassign it.
+    result = finalScope.applyToEvent(prepared, hint);
+  }
+
+  return result.then(evt => {
+    if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
+      return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
+    }
+    return evt;
   });
+}
 
-  return integrationIndex;
+/**
+ *  Enhances event using the client configuration.
+ *  It takes care of all "static" values like environment, release and `dist`,
+ *  as well as truncating overly long values.
+ * @param event event instance to be enhanced
+ */
+function applyClientOptions(event, options) {
+  const { environment, release, dist, maxValueLength = 250 } = options;
+
+  if (!('environment' in event)) {
+    event.environment = 'environment' in options ? environment : 'production';
+  }
+
+  if (event.release === undefined && release !== undefined) {
+    event.release = release;
+  }
+
+  if (event.dist === undefined && dist !== undefined) {
+    event.dist = dist;
+  }
+
+  if (event.message) {
+    event.message = truncate(event.message, maxValueLength);
+  }
+
+  const exception = event.exception && event.exception.values && event.exception.values[0];
+  if (exception && exception.value) {
+    exception.value = truncate(exception.value, maxValueLength);
+  }
+
+  const request = event.request;
+  if (request && request.url) {
+    request.url = truncate(request.url, maxValueLength);
+  }
+}
+
+/**
+ * This function adds all used integrations to the SDK info in the event.
+ * @param event The event that will be filled with all integrations.
+ */
+function applyIntegrationsMetadata(event, integrationNames) {
+  if (integrationNames.length > 0) {
+    event.sdk = event.sdk || {};
+    event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationNames];
+  }
+}
+
+/**
+ * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.
+ * Normalized keys:
+ * - `breadcrumbs.data`
+ * - `user`
+ * - `contexts`
+ * - `extra`
+ * @param event Event
+ * @returns Normalized event
+ */
+function normalizeEvent(event, depth, maxBreadth) {
+  if (!event) {
+    return null;
+  }
+
+  const normalized = {
+    ...event,
+    ...(event.breadcrumbs && {
+      breadcrumbs: event.breadcrumbs.map(b => ({
+        ...b,
+        ...(b.data && {
+          data: normalize(b.data, depth, maxBreadth),
+        }),
+      })),
+    }),
+    ...(event.user && {
+      user: normalize(event.user, depth, maxBreadth),
+    }),
+    ...(event.contexts && {
+      contexts: normalize(event.contexts, depth, maxBreadth),
+    }),
+    ...(event.extra && {
+      extra: normalize(event.extra, depth, maxBreadth),
+    }),
+  };
+
+  // event.contexts.trace stores information about a Transaction. Similarly,
+  // event.spans[] stores information about child Spans. Given that a
+  // Transaction is conceptually a Span, normalization should apply to both
+  // Transactions and Spans consistently.
+  // For now the decision is to skip normalization of Transactions and Spans,
+  // so this block overwrites the normalized event to add back the original
+  // Transaction information prior to normalization.
+  if (event.contexts && event.contexts.trace && normalized.contexts) {
+    normalized.contexts.trace = event.contexts.trace;
+
+    // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it
+    if (event.contexts.trace.data) {
+      normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);
+    }
+  }
+
+  // event.spans[].data may contain circular/dangerous data so we need to normalize it
+  if (event.spans) {
+    normalized.spans = event.spans.map(span => {
+      // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable
+      if (span.data) {
+        span.data = normalize(span.data, depth, maxBreadth);
+      }
+      return span;
+    });
+  }
+
+  return normalized;
 }
 
 const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
@@ -19448,6 +19666,15 @@ class BaseClient {
     return this._options;
   }
 
+  /**
+   * @see SdkMetadata in @sentry/types
+   *
+   * @return The metadata of the SDK
+   */
+   getSdkMetadata() {
+    return this._options._metadata;
+  }
+
   /**
    * @inheritDoc
    */
@@ -19510,6 +19737,13 @@ class BaseClient {
     }
   }
 
+  /**
+   * @inheritDoc
+   */
+   addIntegration(integration) {
+    setupIntegration(integration, this._integrations);
+  }
+
   /**
    * @inheritDoc
    */
@@ -19548,7 +19782,7 @@ class BaseClient {
     // Note: we use `event` in replay, where we overwrite this hook.
 
     if (this._options.sendClientReports) {
-      // We want to track each category (error, transaction, session) separately
+      // We want to track each category (error, transaction, session, replay_event) separately
       // but still keep the distinction between different type of outcomes.
       // We could use nested maps, but it's much easier to read and type this way.
       // A correct type for map-based implementation if we want to go that route
@@ -19645,166 +19879,8 @@ class BaseClient {
    * @returns A new event with more information.
    */
    _prepareEvent(event, hint, scope) {
-    const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = this.getOptions();
-    const prepared = {
-      ...event,
-      event_id: event.event_id || hint.event_id || uuid4(),
-      timestamp: event.timestamp || dateTimestampInSeconds(),
-    };
-
-    this._applyClientOptions(prepared);
-    this._applyIntegrationsMetadata(prepared);
-
-    // If we have scope given to us, use it as the base for further modifications.
-    // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.
-    let finalScope = scope;
-    if (hint.captureContext) {
-      finalScope = Scope.clone(finalScope).update(hint.captureContext);
-    }
-
-    // We prepare the result here with a resolved Event.
-    let result = resolvedSyncPromise(prepared);
-
-    // This should be the last thing called, since we want that
-    // {@link Hub.addEventProcessor} gets the finished prepared event.
-    //
-    // We need to check for the existence of `finalScope.getAttachments`
-    // because `getAttachments` can be undefined if users are using an older version
-    // of `@sentry/core` that does not have the `getAttachments` method.
-    // See: https://github.com/getsentry/sentry-javascript/issues/5229
-    if (finalScope && finalScope.getAttachments) {
-      // Collect attachments from the hint and scope
-      const attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];
-
-      if (attachments.length) {
-        hint.attachments = attachments;
-      }
-
-      // In case we have a hub we reassign it.
-      result = finalScope.applyToEvent(prepared, hint);
-    }
-
-    return result.then(evt => {
-      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
-        return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
-      }
-      return evt;
-    });
-  }
-
-  /**
-   * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.
-   * Normalized keys:
-   * - `breadcrumbs.data`
-   * - `user`
-   * - `contexts`
-   * - `extra`
-   * @param event Event
-   * @returns Normalized event
-   */
-   _normalizeEvent(event, depth, maxBreadth) {
-    if (!event) {
-      return null;
-    }
-
-    const normalized = {
-      ...event,
-      ...(event.breadcrumbs && {
-        breadcrumbs: event.breadcrumbs.map(b => ({
-          ...b,
-          ...(b.data && {
-            data: normalize(b.data, depth, maxBreadth),
-          }),
-        })),
-      }),
-      ...(event.user && {
-        user: normalize(event.user, depth, maxBreadth),
-      }),
-      ...(event.contexts && {
-        contexts: normalize(event.contexts, depth, maxBreadth),
-      }),
-      ...(event.extra && {
-        extra: normalize(event.extra, depth, maxBreadth),
-      }),
-    };
-
-    // event.contexts.trace stores information about a Transaction. Similarly,
-    // event.spans[] stores information about child Spans. Given that a
-    // Transaction is conceptually a Span, normalization should apply to both
-    // Transactions and Spans consistently.
-    // For now the decision is to skip normalization of Transactions and Spans,
-    // so this block overwrites the normalized event to add back the original
-    // Transaction information prior to normalization.
-    if (event.contexts && event.contexts.trace && normalized.contexts) {
-      normalized.contexts.trace = event.contexts.trace;
-
-      // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it
-      if (event.contexts.trace.data) {
-        normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);
-      }
-    }
-
-    // event.spans[].data may contain circular/dangerous data so we need to normalize it
-    if (event.spans) {
-      normalized.spans = event.spans.map(span => {
-        // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable
-        if (span.data) {
-          span.data = normalize(span.data, depth, maxBreadth);
-        }
-        return span;
-      });
-    }
-
-    return normalized;
-  }
-
-  /**
-   *  Enhances event using the client configuration.
-   *  It takes care of all "static" values like environment, release and `dist`,
-   *  as well as truncating overly long values.
-   * @param event event instance to be enhanced
-   */
-   _applyClientOptions(event) {
     const options = this.getOptions();
-    const { environment, release, dist, maxValueLength = 250 } = options;
-
-    if (!('environment' in event)) {
-      event.environment = 'environment' in options ? environment : 'production';
-    }
-
-    if (event.release === undefined && release !== undefined) {
-      event.release = release;
-    }
-
-    if (event.dist === undefined && dist !== undefined) {
-      event.dist = dist;
-    }
-
-    if (event.message) {
-      event.message = truncate(event.message, maxValueLength);
-    }
-
-    const exception = event.exception && event.exception.values && event.exception.values[0];
-    if (exception && exception.value) {
-      exception.value = truncate(exception.value, maxValueLength);
-    }
-
-    const request = event.request;
-    if (request && request.url) {
-      request.url = truncate(request.url, maxValueLength);
-    }
-  }
-
-  /**
-   * This function adds all used integrations to the SDK info in the event.
-   * @param event The event that will be filled with all integrations.
-   */
-   _applyIntegrationsMetadata(event) {
-    const integrationsArray = Object.keys(this._integrations);
-    if (integrationsArray.length > 0) {
-      event.sdk = event.sdk || {};
-      event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];
-    }
+    return prepareEvent(options, event, hint, scope);
   }
 
   /**
@@ -20059,7 +20135,9 @@ const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
 function createTransport(
   options,
   makeRequest,
-  buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),
+  buffer = makePromiseBuffer(
+    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,
+  ),
 ) {
   let rateLimits = {};
 
@@ -20104,10 +20182,11 @@ function createTransport(
           }
 
           rateLimits = updateRateLimits(rateLimits, response);
+          return response;
         },
         error => {
-          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Failed while sending event:', error);
           recordEnvelopeLoss('network_error');
+          throw error;
         },
       );
 
@@ -20139,7 +20218,7 @@ function getEventForEnvelopeItem(item, type) {
   return Array.isArray(item) ? (item )[1] : undefined;
 }
 
-const SDK_VERSION = '7.28.1';
+const SDK_VERSION = '7.30.0';
 
 let originalFunctionToString;
 
@@ -22091,7 +22170,7 @@ class HttpContext  {constructor() { HttpContext.prototype.__init.call(this); }
           ...(referrer && { Referer: referrer }),
           ...(userAgent && { 'User-Agent': userAgent }),
         };
-        const request = { ...(url && { url }), headers };
+        const request = { ...event.request, ...(url && { url }), headers };
 
         return { ...event, request };
       }
@@ -22348,387 +22427,12 @@ const DEFAULT_SESSION_SAMPLE_RATE = 0.1;
 const DEFAULT_ERROR_SAMPLE_RATE = 1.0;
 
 /** The select to use for the `maskAllText` option  */
-const MASK_ALL_TEXT_SELECTOR = 'body *:not(style,script)';
-
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-/**
- * lodash (Custom Build) <https://lodash.com/>
- * Build: `lodash modularize exports="npm" -o ./`
- * Copyright jQuery Foundation and other contributors <https://jquery.org/>
- * Released under MIT license <https://lodash.com/license>
- * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
- * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
- */
-
-/** Used as the `TypeError` message for "Functions" methods. */
-var FUNC_ERROR_TEXT = 'Expected a function';
-
-/** Used as references for various `Number` constants. */
-var NAN = 0 / 0;
-
-/** `Object#toString` result references. */
-var symbolTag = '[object Symbol]';
+const MASK_ALL_TEXT_SELECTOR = 'body *:not(style), body *:not(script)';
 
-/** Used to match leading and trailing whitespace. */
-var reTrim = /^\s+|\s+$/g;
-
-/** Used to detect bad signed hexadecimal string values. */
-var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
-
-/** Used to detect binary string values. */
-var reIsBinary = /^0b[01]+$/i;
-
-/** Used to detect octal string values. */
-var reIsOctal = /^0o[0-7]+$/i;
-
-/** Built-in method references without a dependency on `root`. */
-var freeParseInt = parseInt;
-
-/** Detect free variable `global` from Node.js. */
-var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
-
-/** Detect free variable `self`. */
-var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
-
-/** Used as a reference to the global object. */
-var root = freeGlobal || freeSelf;
-
-/** Used for built-in method references. */
-var objectProto = Object.prototype;
-
-/**
- * Used to resolve the
- * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
- * of values.
- */
-var objectToString = objectProto.toString;
-
-/* Built-in method references for those with the same name as other `lodash` methods. */
-var nativeMax = Math.max,
-    nativeMin = Math.min;
-
-/**
- * Gets the timestamp of the number of milliseconds that have elapsed since
- * the Unix epoch (1 January 1970 00:00:00 UTC).
- *
- * @static
- * @memberOf _
- * @since 2.4.0
- * @category Date
- * @returns {number} Returns the timestamp.
- * @example
- *
- * _.defer(function(stamp) {
- *   console.log(_.now() - stamp);
- * }, _.now());
- * // => Logs the number of milliseconds it took for the deferred invocation.
- */
-var now = function() {
-  return root.Date.now();
-};
-
-/**
- * Creates a debounced function that delays invoking `func` until after `wait`
- * milliseconds have elapsed since the last time the debounced function was
- * invoked. The debounced function comes with a `cancel` method to cancel
- * delayed `func` invocations and a `flush` method to immediately invoke them.
- * Provide `options` to indicate whether `func` should be invoked on the
- * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
- * with the last arguments provided to the debounced function. Subsequent
- * calls to the debounced function return the result of the last `func`
- * invocation.
- *
- * **Note:** If `leading` and `trailing` options are `true`, `func` is
- * invoked on the trailing edge of the timeout only if the debounced function
- * is invoked more than once during the `wait` timeout.
- *
- * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
- * until to the next tick, similar to `setTimeout` with a timeout of `0`.
- *
- * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
- * for details over the differences between `_.debounce` and `_.throttle`.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Function
- * @param {Function} func The function to debounce.
- * @param {number} [wait=0] The number of milliseconds to delay.
- * @param {Object} [options={}] The options object.
- * @param {boolean} [options.leading=false]
- *  Specify invoking on the leading edge of the timeout.
- * @param {number} [options.maxWait]
- *  The maximum time `func` is allowed to be delayed before it's invoked.
- * @param {boolean} [options.trailing=true]
- *  Specify invoking on the trailing edge of the timeout.
- * @returns {Function} Returns the new debounced function.
- * @example
- *
- * // Avoid costly calculations while the window size is in flux.
- * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
- *
- * // Invoke `sendMail` when clicked, debouncing subsequent calls.
- * jQuery(element).on('click', _.debounce(sendMail, 300, {
- *   'leading': true,
- *   'trailing': false
- * }));
- *
- * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
- * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
- * var source = new EventSource('/stream');
- * jQuery(source).on('message', debounced);
- *
- * // Cancel the trailing debounced invocation.
- * jQuery(window).on('popstate', debounced.cancel);
- */
-function debounce(func, wait, options) {
-  var lastArgs,
-      lastThis,
-      maxWait,
-      result,
-      timerId,
-      lastCallTime,
-      lastInvokeTime = 0,
-      leading = false,
-      maxing = false,
-      trailing = true;
-
-  if (typeof func != 'function') {
-    throw new TypeError(FUNC_ERROR_TEXT);
-  }
-  wait = toNumber(wait) || 0;
-  if (isObject$1(options)) {
-    leading = !!options.leading;
-    maxing = 'maxWait' in options;
-    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
-    trailing = 'trailing' in options ? !!options.trailing : trailing;
-  }
-
-  function invokeFunc(time) {
-    var args = lastArgs,
-        thisArg = lastThis;
-
-    lastArgs = lastThis = undefined;
-    lastInvokeTime = time;
-    result = func.apply(thisArg, args);
-    return result;
-  }
-
-  function leadingEdge(time) {
-    // Reset any `maxWait` timer.
-    lastInvokeTime = time;
-    // Start the timer for the trailing edge.
-    timerId = setTimeout(timerExpired, wait);
-    // Invoke the leading edge.
-    return leading ? invokeFunc(time) : result;
-  }
-
-  function remainingWait(time) {
-    var timeSinceLastCall = time - lastCallTime,
-        timeSinceLastInvoke = time - lastInvokeTime,
-        result = wait - timeSinceLastCall;
-
-    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
-  }
-
-  function shouldInvoke(time) {
-    var timeSinceLastCall = time - lastCallTime,
-        timeSinceLastInvoke = time - lastInvokeTime;
-
-    // Either this is the first call, activity has stopped and we're at the
-    // trailing edge, the system time has gone backwards and we're treating
-    // it as the trailing edge, or we've hit the `maxWait` limit.
-    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
-      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
-  }
-
-  function timerExpired() {
-    var time = now();
-    if (shouldInvoke(time)) {
-      return trailingEdge(time);
-    }
-    // Restart the timer.
-    timerId = setTimeout(timerExpired, remainingWait(time));
-  }
-
-  function trailingEdge(time) {
-    timerId = undefined;
-
-    // Only invoke if we have `lastArgs` which means `func` has been
-    // debounced at least once.
-    if (trailing && lastArgs) {
-      return invokeFunc(time);
-    }
-    lastArgs = lastThis = undefined;
-    return result;
-  }
-
-  function cancel() {
-    if (timerId !== undefined) {
-      clearTimeout(timerId);
-    }
-    lastInvokeTime = 0;
-    lastArgs = lastCallTime = lastThis = timerId = undefined;
-  }
-
-  function flush() {
-    return timerId === undefined ? result : trailingEdge(now());
-  }
-
-  function debounced() {
-    var time = now(),
-        isInvoking = shouldInvoke(time);
-
-    lastArgs = arguments;
-    lastThis = this;
-    lastCallTime = time;
-
-    if (isInvoking) {
-      if (timerId === undefined) {
-        return leadingEdge(lastCallTime);
-      }
-      if (maxing) {
-        // Handle invocations in a tight loop.
-        timerId = setTimeout(timerExpired, wait);
-        return invokeFunc(lastCallTime);
-      }
-    }
-    if (timerId === undefined) {
-      timerId = setTimeout(timerExpired, wait);
-    }
-    return result;
-  }
-  debounced.cancel = cancel;
-  debounced.flush = flush;
-  return debounced;
-}
-
-/**
- * Checks if `value` is the
- * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
- * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is an object, else `false`.
- * @example
- *
- * _.isObject({});
- * // => true
- *
- * _.isObject([1, 2, 3]);
- * // => true
- *
- * _.isObject(_.noop);
- * // => true
- *
- * _.isObject(null);
- * // => false
- */
-function isObject$1(value) {
-  var type = typeof value;
-  return !!value && (type == 'object' || type == 'function');
-}
-
-/**
- * Checks if `value` is object-like. A value is object-like if it's not `null`
- * and has a `typeof` result of "object".
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
- * @example
- *
- * _.isObjectLike({});
- * // => true
- *
- * _.isObjectLike([1, 2, 3]);
- * // => true
- *
- * _.isObjectLike(_.noop);
- * // => false
- *
- * _.isObjectLike(null);
- * // => false
- */
-function isObjectLike(value) {
-  return !!value && typeof value == 'object';
-}
-
-/**
- * Checks if `value` is classified as a `Symbol` primitive or object.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to check.
- * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
- * @example
- *
- * _.isSymbol(Symbol.iterator);
- * // => true
- *
- * _.isSymbol('abc');
- * // => false
- */
-function isSymbol(value) {
-  return typeof value == 'symbol' ||
-    (isObjectLike(value) && objectToString.call(value) == symbolTag);
-}
-
-/**
- * Converts `value` to a number.
- *
- * @static
- * @memberOf _
- * @since 4.0.0
- * @category Lang
- * @param {*} value The value to process.
- * @returns {number} Returns the number.
- * @example
- *
- * _.toNumber(3.2);
- * // => 3.2
- *
- * _.toNumber(Number.MIN_VALUE);
- * // => 5e-324
- *
- * _.toNumber(Infinity);
- * // => Infinity
- *
- * _.toNumber('3.2');
- * // => 3.2
- */
-function toNumber(value) {
-  if (typeof value == 'number') {
-    return value;
-  }
-  if (isSymbol(value)) {
-    return NAN;
-  }
-  if (isObject$1(value)) {
-    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
-    value = isObject$1(other) ? (other + '') : other;
-  }
-  if (typeof value != 'string') {
-    return value === 0 ? value : +value;
-  }
-  value = value.replace(reTrim, '');
-  var isBinary = reIsBinary.test(value);
-  return (isBinary || reIsOctal.test(value))
-    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
-    : (reIsBadHex.test(value) ? NAN : +value);
-}
-
-var lodash_debounce = debounce;
+/** Default flush delays */
+const DEFAULT_FLUSH_MIN_DELAY = 5000;
+const DEFAULT_FLUSH_MAX_DELAY = 15000;
+const INITIAL_FLUSH_DELAY = 5000;
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -29736,6 +29440,9 @@ var fdt = new u8(32);
 for (var i = 0; i < 32; ++i)
     fdt[i] = 5;
 
+/**
+ * Create a breadcrumb for a replay.
+ */
 function createBreadcrumb(
   breadcrumb,
 ) {
@@ -29746,6 +29453,9 @@ function createBreadcrumb(
   };
 }
 
+/**
+ * An event handler to react to DOM events.
+ */
 function handleDom(handlerData) {
   // Taken from https://github.com/getsentry/sentry-javascript/blob/master/packages/browser/src/integrations/breadcrumbs.ts#L112
   let target;
@@ -29788,6 +29498,9 @@ function isEventWithTarget(event) {
 
 let _LAST_BREADCRUMB = null;
 
+/**
+ * An event handler to handle scope changes.
+ */
 function handleScope(scope) {
   const newBreadcrumb = scope.getLastBreadcrumb();
 
@@ -29810,6 +29523,9 @@ function handleScope(scope) {
   return createBreadcrumb(newBreadcrumb);
 }
 
+/**
+ * An event handler to react to breadcrumbs.
+ */
 function breadcrumbHandler(type, handlerData) {
   if (type === 'scope') {
     return handleScope(handlerData );
@@ -29946,6 +29662,9 @@ function handleFetchSpanListener(replay) {
   };
 }
 
+/**
+ * Returns true if we think the given event is an error originating inside of rrweb.
+ */
 function isRrwebError(event) {
   if (event.type || !_optionalChain([event, 'access', _ => _.exception, 'optionalAccess', _2 => _2.values, 'optionalAccess', _3 => _3.length])) {
     return false;
@@ -29967,10 +29686,7 @@ function isRrwebError(event) {
 function handleGlobalEventListener(replay) {
   return (event) => {
     // Do not apply replayId to the root event
-    if (
-      // @ts-ignore new event type
-      event.type === REPLAY_EVENT_NAME
-    ) {
+    if (event.type === REPLAY_EVENT_NAME) {
       // Replays have separate set of breadcrumbs, do not include breadcrumbs
       // from core SDK
       delete event.breadcrumbs;
@@ -29986,7 +29702,7 @@ function handleGlobalEventListener(replay) {
 
     // Only tag transactions with replayId if not waiting for an error
     // @ts-ignore private
-    if (event.type !== 'transaction' || replay.recordingMode === 'session') {
+    if (!event.type || replay.recordingMode === 'session') {
       event.tags = { ...event.tags, replayId: _optionalChain([replay, 'access', _5 => _5.session, 'optionalAccess', _6 => _6.id]) };
     }
 
@@ -30299,9 +30015,12 @@ const ENTRY_TYPES = {
   // @ts-ignore TODO: entry type does not fit the create* functions entry type
   navigation: createNavigationEntry,
   // @ts-ignore TODO: entry type does not fit the create* functions entry type
-  ['largest-contentful-paint']: createLargestContentfulPaint,
+  'largest-contentful-paint': createLargestContentfulPaint,
 };
 
+/**
+ * Create replay performance entries from the browser performance entries.
+ */
 function createPerformanceEntries(entries) {
   return entries.map(createPerformanceEntry).filter(Boolean) ;
 }
@@ -30320,8 +30039,6 @@ function getAbsoluteTime(time) {
   return ((browserPerformanceTimeOrigin || WINDOW.performance.timeOrigin) + time) / 1000;
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function createPaintEntry(entry) {
   const { duration, entryType, name, startTime } = entry;
 
@@ -30334,8 +30051,6 @@ function createPaintEntry(entry) {
   };
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function createNavigationEntry(entry) {
   // TODO: There looks to be some more interesting bits in here (domComplete, domContentLoaded)
   const { entryType, name, duration, domComplete, startTime, transferSize, type } = entry;
@@ -30357,8 +30072,6 @@ function createNavigationEntry(entry) {
   };
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function createResourceEntry(entry) {
   const { entryType, initiatorType, name, responseEnd, startTime, encodedBodySize, transferSize } = entry;
 
@@ -30379,9 +30092,9 @@ function createResourceEntry(entry) {
   };
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createLargestContentfulPaint(entry) {
+function createLargestContentfulPaint(
+  entry,
+) {
   const { duration, entryType, startTime, size } = entry;
 
   const start = getAbsoluteTime(startTime);
@@ -30406,6 +30119,9 @@ function t(t){let e=t.length;for(;--e>=0;)t[e]=0}const e=new Uint8Array([0,0,0,0
 
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 
+/**
+ * Create an event buffer for replays.
+ */
 function createEventBuffer({ useCompression }) {
   // eslint-disable-next-line no-restricted-globals
   if (useCompression && window.Worker) {
@@ -30436,14 +30152,14 @@ class EventBufferArray  {
     this._events = [];
   }
 
-   destroy() {
-    this._events = [];
-  }
-
    get length() {
     return this._events.length;
   }
 
+   destroy() {
+    this._events = [];
+  }
+
    addEvent(event, isCheckout) {
     if (isCheckout) {
       this._events = [event];
@@ -30465,7 +30181,10 @@ class EventBufferArray  {
   }
 }
 
-// exporting for testing
+/**
+ * Event buffer that uses a web worker to compress events.
+ * Exported only for testing.
+ */
 class EventBufferCompressionWorker  {
 
    __init() {this._eventBufferItemLength = 0;}
@@ -30475,12 +30194,6 @@ class EventBufferCompressionWorker  {
     this._worker = worker;
   }
 
-   destroy() {
-    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Replay] Destroying compression worker');
-    _optionalChain([this, 'access', _ => _._worker, 'optionalAccess', _2 => _2.terminate, 'call', _3 => _3()]);
-    this._worker = null;
-  }
-
   /**
    * Note that this may not reflect what is actually in the event buffer. This
    * is only a local count of the buffer size since `addEvent` is async.
@@ -30489,6 +30202,18 @@ class EventBufferCompressionWorker  {
     return this._eventBufferItemLength;
   }
 
+  /**
+   * Destroy the event buffer.
+   */
+   destroy() {
+    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Replay] Destroying compression worker');
+    _optionalChain([this, 'access', _ => _._worker, 'optionalAccess', _2 => _2.terminate, 'call', _3 => _3()]);
+    this._worker = null;
+  }
+
+  /**
+   * Add an event to the event buffer.
+   */
    async addEvent(event, isCheckout) {
     if (isCheckout) {
       // This event is a checkout, make sure worker buffer is cleared before
@@ -30503,6 +30228,9 @@ class EventBufferCompressionWorker  {
     return this._sendEventToWorker(event);
   }
 
+  /**
+   * Finish the event buffer and return the compressed data.
+   */
    finish() {
     return this._finishRequest(this._getAndIncrementId());
   }
@@ -30553,6 +30281,9 @@ class EventBufferCompressionWorker  {
     });
   }
 
+  /**
+   * Send the event to the worker.
+   */
    _sendEventToWorker(event) {
     const promise = this._postMessage({
       id: this._getAndIncrementId(),
@@ -30566,6 +30297,9 @@ class EventBufferCompressionWorker  {
     return promise;
   }
 
+  /**
+   * Finish the request and return the compressed data from the worker.
+   */
    async _finishRequest(id) {
     const promise = this._postMessage({ id, method: 'finish', args: [] });
 
@@ -30575,6 +30309,7 @@ class EventBufferCompressionWorker  {
     return promise ;
   }
 
+  /** Get the current ID and increment it for the next call. */
    _getAndIncrementId() {
     return this._id++;
   }
@@ -30632,6 +30367,9 @@ function isSessionExpired(session, idleTimeout, targetTime = +new Date()) {
   );
 }
 
+/**
+ * Save a session to session storage.
+ */
 function saveSession(session) {
   const hasSessionStorage = 'sessionStorage' in WINDOW;
   if (!hasSessionStorage) {
@@ -30786,7 +30524,30 @@ function addMemoryEntry(replay) {
   }
 }
 
-function createPayload({
+function createMemoryEntry(memoryEntry) {
+  const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;
+  // we don't want to use `getAbsoluteTime` because it adds the event time to the
+  // time origin, so we get the current timestamp instead
+  const time = new Date().getTime() / 1000;
+  return {
+    type: 'memory',
+    name: 'memory',
+    start: time,
+    end: time,
+    data: {
+      memory: {
+        jsHeapSizeLimit,
+        totalJSHeapSize,
+        usedJSHeapSize,
+      },
+    },
+  };
+}
+
+/**
+ * Create the recording data ready to be sent.
+ */
+function createRecordingData({
   events,
   headers,
 }
@@ -30813,59 +30574,99 @@ function createPayload({
   return payloadWithSequence;
 }
 
+/**
+ * Create a replay envelope ready to be sent.
+ * This includes both the replay event, as well as the recording data.
+ */
 function createReplayEnvelope(
   replayEvent,
-  payloadWithSequence,
+  recordingData,
   dsn,
   tunnel,
 ) {
   return createEnvelope(
     createEventEnvelopeHeaders(replayEvent, getSdkMetadataForEnvelopeHeader(replayEvent), tunnel, dsn),
     [
-      // @ts-ignore New types
       [{ type: 'replay_event' }, replayEvent],
       [
         {
-          // @ts-ignore setting envelope
           type: 'replay_recording',
-          length: payloadWithSequence.length,
+          length: recordingData.length,
         },
-        // @ts-ignore: Type 'string' is not assignable to type 'ClientReport'.ts(2322)
-        payloadWithSequence,
+        recordingData,
       ],
     ],
   );
 }
 
-async function getReplayEvent({
-  client,
-  scope,
-  replayId: event_id,
-  event,
-}
+/**
+ * Heavily simplified debounce function based on lodash.debounce.
+ *
+ * This function takes a callback function (@param fun) and delays its invocation
+ * by @param wait milliseconds. Optionally, a maxWait can be specified in @param options,
+ * which ensures that the callback is invoked at least once after the specified max. wait time.
+ *
+ * @param func the function whose invocation is to be debounced
+ * @param wait the minimum time until the function is invoked after it was called once
+ * @param options the options object, which can contain the `maxWait` property
+ *
+ * @returns the debounced version of the function, which needs to be called at least once to start the
+ *          debouncing process. Subsequent calls will reset the debouncing timer and, in case @paramfunc
+ *          was already invoked in the meantime, return @param func's return value.
+ *          The debounced function has two additional properties:
+ *          - `flush`: Invokes the debounced function immediately and returns its return value
+ *          - `cancel`: Cancels the debouncing process and resets the debouncing timer
+ */
+function debounce(func, wait, options) {
+  let callbackReturnValue;
 
-) {
-  // XXX: This event does not trigger `beforeSend` in SDK
-  // @ts-ignore private api
-  const preparedEvent = await client._prepareEvent(event, { event_id }, scope);
+  let timerId;
+  let maxTimerId;
 
-  if (preparedEvent) {
-    // extract the SDK name because `client._prepareEvent` doesn't add it to the event
-    const metadata = client.getOptions() && client.getOptions()._metadata;
-    const { name } = (metadata && metadata.sdk) || {};
+  const maxWait = options && options.maxWait ? Math.max(options.maxWait, wait) : 0;
 
-    preparedEvent.sdk = {
-      ...preparedEvent.sdk,
-      version: "7.28.1",
-      name,
-    };
+  function invokeFunc() {
+    cancelTimers();
+    callbackReturnValue = func();
+    return callbackReturnValue;
   }
 
-  return preparedEvent;
+  function cancelTimers() {
+    timerId !== undefined && clearTimeout(timerId);
+    maxTimerId !== undefined && clearTimeout(maxTimerId);
+    timerId = maxTimerId = undefined;
+  }
+
+  function flush() {
+    if (timerId !== undefined || maxTimerId !== undefined) {
+      return invokeFunc();
+    }
+    return callbackReturnValue;
+  }
+
+  function debounced() {
+    if (timerId) {
+      clearTimeout(timerId);
+    }
+    timerId = setTimeout(invokeFunc, wait);
+
+    if (maxWait && maxTimerId === undefined) {
+      maxTimerId = setTimeout(invokeFunc, maxWait);
+    }
+
+    return callbackReturnValue;
+  }
+
+  debounced.cancel = cancelTimers;
+  debounced.flush = flush;
+  return debounced;
 }
 
 let _originalRecordDroppedEvent;
 
+/**
+ * Overwrite the `recordDroppedEvent` method on the client, so we can find out which events were dropped.
+ * */
 function overwriteRecordDroppedEvent(errorIds) {
   const client = getCurrentHub().getClient();
 
@@ -30880,7 +30681,7 @@ function overwriteRecordDroppedEvent(errorIds) {
     category,
     event,
   ) => {
-    if (event && event.event_id) {
+    if (event && !event.type && event.event_id) {
       errorIds.delete(event.event_id);
     }
 
@@ -30891,6 +30692,9 @@ function overwriteRecordDroppedEvent(errorIds) {
   _originalRecordDroppedEvent = _originalCallback;
 }
 
+/**
+ * Restore the original method.
+ * */
 function restoreRecordDroppedEvent() {
   const client = getCurrentHub().getClient();
 
@@ -30901,6 +30705,42 @@ function restoreRecordDroppedEvent() {
   client.recordDroppedEvent = _originalRecordDroppedEvent;
 }
 
+/**
+ * Prepare a replay event & enrich it with the SDK metadata.
+ */
+async function prepareReplayEvent({
+  client,
+  scope,
+  replayId: event_id,
+  event,
+}
+
+) {
+  const preparedEvent = (await prepareEvent(client.getOptions(), event, { event_id }, scope)) ;
+
+  // If e.g. a global event processor returned null
+  if (!preparedEvent) {
+    return null;
+  }
+
+  // This normally happens in browser client "_prepareEvent"
+  // but since we do not use this private method from the client, but rather the plain import
+  // we need to do this manually.
+  preparedEvent.platform = preparedEvent.platform || 'javascript';
+
+  // extract the SDK name because `client._prepareEvent` doesn't add it to the event
+  const metadata = client.getSdkMetadata && client.getSdkMetadata();
+  const name = (metadata && metadata.sdk && metadata.sdk.name) || 'sentry.javascript.unknown';
+
+  preparedEvent.sdk = {
+    ...preparedEvent.sdk,
+    version: "7.30.0",
+    name,
+  };
+
+  return preparedEvent;
+}
+
 /* eslint-disable max-lines */ // TODO: We might want to split this file up
 
 /**
@@ -30910,6 +30750,9 @@ function restoreRecordDroppedEvent() {
 const BASE_RETRY_INTERVAL = 5000;
 const MAX_RETRY_COUNT = 3;
 
+/**
+ * The main replay container class, which holds all the state and methods for recording and sending replays.
+ */
 class ReplayContainer  {
    __init() {this.eventBuffer = null;}
 
@@ -30977,7 +30820,7 @@ class ReplayContainer  {
     this._recordingOptions = recordingOptions;
     this._options = options;
 
-    this._debouncedFlush = lodash_debounce(() => this.flush(), this._options.flushMinDelay, {
+    this._debouncedFlush = debounce(() => this.flush(), this._options.flushMinDelay, {
       maxWait: this._options.flushMaxDelay,
     });
   }
@@ -31706,7 +31549,6 @@ class ReplayContainer  {
     // A flush is about to happen, cancel any queued flushes
     _optionalChain([this, 'access', _30 => _30._debouncedFlush, 'optionalAccess', _31 => _31.cancel, 'call', _32 => _32()]);
 
-    // No existing flush in progress, proceed with flushing.
     // this._flushLock acts as a lock so that future calls to `flush()`
     // will be blocked until this promise resolves
     if (!this._flushLock) {
@@ -31739,8 +31581,8 @@ class ReplayContainer  {
    */
   flushImmediate() {
     this._debouncedFlush();
-    // `.flush` is provided by lodash.debounce
-    return this._debouncedFlush.flush();
+    // `.flush` is provided by the debounced function, analogously to lodash.debounce
+    return this._debouncedFlush.flush() ;
   }
 
   /**
@@ -31753,7 +31595,7 @@ class ReplayContainer  {
     includeReplayStartTimestamp,
     eventContext,
   }) {
-    const payloadWithSequence = createPayload({
+    const recordingData = createRecordingData({
       events,
       headers: {
         segment_id,
@@ -31770,7 +31612,7 @@ class ReplayContainer  {
     const transport = client && client.getTransport();
     const dsn = _optionalChain([client, 'optionalAccess', _33 => _33.getDsn, 'call', _34 => _34()]);
 
-    if (!client || !scope || !transport || !dsn) {
+    if (!client || !scope || !transport || !dsn || !this.session || !this.session.sampled) {
       return;
     }
 
@@ -31784,12 +31626,15 @@ class ReplayContainer  {
       urls,
       replay_id: replayId,
       segment_id,
+      replay_type: this.session.sampled,
     };
 
-    const replayEvent = await getReplayEvent({ scope, client, replayId, event: baseEvent });
+    const replayEvent = await prepareReplayEvent({ scope, client, replayId, event: baseEvent });
 
     if (!replayEvent) {
-      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] An event processor returned null, will not send replay.');
+      // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions
+      client.recordDroppedEvent('event_processor', 'replay_event', baseEvent);
+      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('An event processor returned `null`, will not send event.');
       return;
     }
 
@@ -31797,7 +31642,6 @@ class ReplayContainer  {
       ...replayEvent.tags,
       sessionSampleRate: this._options.sessionSampleRate,
       errorSampleRate: this._options.errorSampleRate,
-      replayType: _optionalChain([this, 'access', _35 => _35.session, 'optionalAccess', _36 => _36.sampled]),
     };
 
     /*
@@ -31816,6 +31660,7 @@ class ReplayContainer  {
         ],
         "replay_id": "eventId",
         "segment_id": 3,
+        "replay_type": "error",
         "platform": "javascript",
         "event_id": "eventId",
         "environment": "production",
@@ -31831,20 +31676,22 @@ class ReplayContainer  {
         "tags": {
             "sessionSampleRate": 1,
             "errorSampleRate": 0,
-            "replayType": "error"
         }
     }
     */
 
-    const envelope = createReplayEnvelope(replayEvent, payloadWithSequence, dsn, client.getOptions().tunnel);
+    const envelope = createReplayEnvelope(replayEvent, recordingData, dsn, client.getOptions().tunnel);
 
     try {
-      return transport.send(envelope);
+      return await transport.send(envelope);
     } catch (e) {
       throw new Error(UNABLE_TO_SEND_REPLAY);
     }
   }
 
+  /**
+   * Reset the counter of retries for sending replays.
+   */
   resetRetries() {
     this._retryCount = 0;
     this._retryInterval = BASE_RETRY_INTERVAL;
@@ -31919,15 +31766,26 @@ class ReplayContainer  {
   }
 }
 
+/**
+ * Returns true if we are in the browser.
+ */
 function isBrowser() {
   // eslint-disable-next-line no-restricted-globals
-  return typeof window !== 'undefined' && !isNodeEnv();
+  return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());
+}
+
+// Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them
+function isElectronNodeRenderer() {
+  return typeof process !== 'undefined' && (process ).type === 'renderer';
 }
 
 const MEDIA_SELECTORS = 'img,image,svg,path,rect,area,video,object,picture,embed,map,audio';
 
 let _initialized = false;
 
+/**
+ * The main replay integration class, to be passed to `init({  integrations: [] })`.
+ */
 class Replay  {
   /**
    * @inheritDoc
@@ -31943,23 +31801,16 @@ class Replay  {
    * Options to pass to `rrweb.record()`
    */
 
-   get _isInitialized() {
-    return _initialized;
-  }
-
-   set _isInitialized(value) {
-    _initialized = value;
-  }
-
   constructor({
-    flushMinDelay = 5000,
-    flushMaxDelay = 15000,
-    initialFlushDelay = 5000,
+    flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,
+    flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,
+    initialFlushDelay = INITIAL_FLUSH_DELAY,
     stickySession = true,
     useCompression = true,
     sessionSampleRate,
     errorSampleRate,
-    maskAllText = true,
+    maskAllText,
+    maskTextSelector,
     maskAllInputs = true,
     blockAllMedia = true,
     _experiments = {},
@@ -31974,6 +31825,7 @@ class Replay  {
       blockClass,
       ignoreClass,
       maskTextClass,
+      maskTextSelector,
       blockSelector,
       ...recordingOptions,
     };
@@ -31986,7 +31838,7 @@ class Replay  {
       sessionSampleRate: DEFAULT_SESSION_SAMPLE_RATE,
       errorSampleRate: DEFAULT_ERROR_SAMPLE_RATE,
       useCompression,
-      maskAllText,
+      maskAllText: typeof maskAllText === 'boolean' ? maskAllText : !maskTextSelector,
       blockAllMedia,
       _experiments,
     };
@@ -32030,13 +31882,23 @@ Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
         : `${this.recordingOptions.blockSelector},${MEDIA_SELECTORS}`;
     }
 
-    if (isBrowser() && this._isInitialized) {
+    if (this._isInitialized && isBrowser()) {
       throw new Error('Multiple Sentry Session Replay instances are not supported');
     }
 
     this._isInitialized = true;
   }
 
+  /** If replay has already been initialized */
+   get _isInitialized() {
+    return _initialized;
+  }
+
+  /** Update _isInitialized */
+   set _isInitialized(value) {
+    _initialized = value;
+  }
+
   /**
    * We previously used to create a transaction in `setupOnce` and it would
    * potentially create a transaction before some native SDK integrations have run
@@ -32084,6 +31946,7 @@ Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
     this._replay.stop();
   }
 
+  /** Setup the integration. */
    _setup() {
     // Client is not available in constructor, so we need to wait until setupOnce
     this._loadReplayOptionsFromClient();
@@ -37955,7 +37818,7 @@ var Preview = /*#__PURE__*/(0, _react.lazy)(function () {
   });
 });
 var IS_BROWSER = typeof window !== 'undefined' && window.document;
-var IS_GLOBAL = typeof commonjsGlobal$1 !== 'undefined' && commonjsGlobal$1.window && commonjsGlobal$1.window.document;
+var IS_GLOBAL = typeof commonjsGlobal !== 'undefined' && commonjsGlobal.window && commonjsGlobal.window.document;
 var SUPPORTED_PROPS = Object.keys(_props.propTypes); // Return null when rendering on the server
 // as Suspense is not supported yet