@myinterview/widget-react 1.0.57-ada6b21 → 1.0.57

package/dist/esm/index.js

@@ -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";
@@ -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');
@@ -18717,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;
     }
 
@@ -18742,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()) || {};
 
@@ -19236,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);
 
@@ -19264,18 +19287,23 @@ function setupIntegrations(integrations) {
   const integrationIndex = {};
 
   integrations.forEach(integration => {
-    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}`);
-    }
+    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.
  *
@@ -19709,6 +19737,13 @@ class BaseClient {
     }
   }
 
+  /**
+   * @inheritDoc
+   */
+   addIntegration(integration) {
+    setupIntegration(integration, this._integrations);
+  }
+
   /**
    * @inheritDoc
    */
@@ -20100,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 = {};
 
@@ -20145,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;
         },
       );
 
@@ -20180,7 +20218,7 @@ function getEventForEnvelopeItem(item, type) {
   return Array.isArray(item) ? (item )[1] : undefined;
 }
 
-const SDK_VERSION = '7.29.0';
+const SDK_VERSION = '7.30.0';
 
 let originalFunctionToString;
 
@@ -22132,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 };
       }
@@ -29402,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,
 ) {
@@ -29412,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;
@@ -29454,6 +29498,9 @@ function isEventWithTarget(event) {
 
 let _LAST_BREADCRUMB = null;
 
+/**
+ * An event handler to handle scope changes.
+ */
 function handleScope(scope) {
   const newBreadcrumb = scope.getLastBreadcrumb();
 
@@ -29476,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 );
@@ -29612,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;
@@ -29633,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;
@@ -29652,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]) };
     }
 
@@ -29965,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) ;
 }
@@ -29986,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;
 
@@ -30000,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;
@@ -30023,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;
 
@@ -30045,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);
@@ -30072,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) {
@@ -30102,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];
@@ -30131,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;}
@@ -30141,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.
@@ -30155,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
@@ -30169,6 +30228,9 @@ class EventBufferCompressionWorker  {
     return this._sendEventToWorker(event);
   }
 
+  /**
+   * Finish the event buffer and return the compressed data.
+   */
    finish() {
     return this._finishRequest(this._getAndIncrementId());
   }
@@ -30219,6 +30281,9 @@ class EventBufferCompressionWorker  {
     });
   }
 
+  /**
+   * Send the event to the worker.
+   */
    _sendEventToWorker(event) {
     const promise = this._postMessage({
       id: this._getAndIncrementId(),
@@ -30232,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: [] });
 
@@ -30241,6 +30309,7 @@ class EventBufferCompressionWorker  {
     return promise ;
   }
 
+  /** Get the current ID and increment it for the next call. */
    _getAndIncrementId() {
     return this._id++;
   }
@@ -30298,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) {
@@ -30452,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,
 }
@@ -30479,6 +30574,10 @@ 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,
   recordingData,
@@ -30563,41 +30662,11 @@ function debounce(func, wait, options) {
   return debounced;
 }
 
-async function getReplayEvent({
-  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.29.0",
-    name,
-  };
-
-  return preparedEvent;
-}
-
 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();
 
@@ -30623,6 +30692,9 @@ function overwriteRecordDroppedEvent(errorIds) {
   _originalRecordDroppedEvent = _originalCallback;
 }
 
+/**
+ * Restore the original method.
+ * */
 function restoreRecordDroppedEvent() {
   const client = getCurrentHub().getClient();
 
@@ -30633,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
 
 /**
@@ -30642,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;}
 
@@ -31484,7 +31595,7 @@ class ReplayContainer  {
     includeReplayStartTimestamp,
     eventContext,
   }) {
-    const payloadWithSequence = createPayload({
+    const recordingData = createRecordingData({
       events,
       headers: {
         segment_id,
@@ -31501,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;
     }
 
@@ -31515,9 +31626,10 @@ 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) {
       // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions
@@ -31530,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]),
     };
 
     /*
@@ -31549,6 +31660,7 @@ class ReplayContainer  {
         ],
         "replay_id": "eventId",
         "segment_id": 3,
+        "replay_type": "error",
         "platform": "javascript",
         "event_id": "eventId",
         "environment": "production",
@@ -31564,12 +31676,11 @@ 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 await transport.send(envelope);
@@ -31578,6 +31689,9 @@ class ReplayContainer  {
     }
   }
 
+  /**
+   * Reset the counter of retries for sending replays.
+   */
   resetRetries() {
     this._retryCount = 0;
     this._retryInterval = BASE_RETRY_INTERVAL;
@@ -31652,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
@@ -31676,14 +31801,6 @@ class Replay  {
    * Options to pass to `rrweb.record()`
    */
 
-   get _isInitialized() {
-    return _initialized;
-  }
-
-   set _isInitialized(value) {
-    _initialized = value;
-  }
-
   constructor({
     flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,
     flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,
@@ -31765,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
@@ -31819,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();