pcm-agents 0.6.86-beta.0 → 0.6.86-beta.2

package/dist/cjs/{app-globals-BS7h0Qoe.js → app-globals-BIO4q6tX.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var exports$1 = require('./exports-DrFTdXnx.js');
+var exports$1 = require('./exports-Dc-pQh4A.js');
 
 /**
  * Parse a sample rate from a given value.
@@ -13,10 +13,12 @@ function parseSampleRate(sampleRate) {
   if (typeof sampleRate === 'boolean') {
     return Number(sampleRate);
   }
+
   const rate = typeof sampleRate === 'string' ? parseFloat(sampleRate) : sampleRate;
   if (typeof rate !== 'number' || isNaN(rate) || rate < 0 || rate > 1) {
     return undefined;
   }
+
   return rate;
 }
 
@@ -27,7 +29,7 @@ const instrumented = {};
 /** Add a handler function. */
 function addHandler(type, handler) {
   handlers[type] = handlers[type] || [];
-  handlers[type].push(handler);
+  (handlers[type] ).push(handler);
 }
 
 /** Maybe run an instrumentation function, unless it was already called. */
@@ -48,11 +50,16 @@ function triggerHandlers(type, data) {
   if (!typeHandlers) {
     return;
   }
+
   for (const handler of typeHandlers) {
     try {
       handler(data);
     } catch (e) {
-      exports$1.DEBUG_BUILD && exports$1.logger.error(`Error while triggering instrumentation handler.\nType: ${type}\nName: ${exports$1.getFunctionName(handler)}\nError:`, e);
+      exports$1.DEBUG_BUILD &&
+        exports$1.logger.error(
+          `Error while triggering instrumentation handler.\nType: ${type}\nName: ${exports$1.getFunctionName(handler)}\nError:`,
+          e,
+        );
     }
   }
 }
@@ -70,26 +77,36 @@ function addGlobalErrorInstrumentationHandler(handler) {
   addHandler(type, handler);
   maybeInstrument(type, instrumentError);
 }
+
 function instrumentError() {
   _oldOnErrorHandler = exports$1.GLOBAL_OBJ.onerror;
 
   // Note: The reason we are doing window.onerror instead of window.addEventListener('error')
   // is that we are using this handler in the Loader Script, to handle buffered errors consistently
-  exports$1.GLOBAL_OBJ.onerror = function (msg, url, line, column, error) {
+  exports$1.GLOBAL_OBJ.onerror = function (
+    msg,
+    url,
+    line,
+    column,
+    error,
+  ) {
     const handlerData = {
       column,
       error,
       line,
       msg,
-      url
+      url,
     };
     triggerHandlers('error', handlerData);
+
     if (_oldOnErrorHandler) {
       // eslint-disable-next-line prefer-rest-params
       return _oldOnErrorHandler.apply(this, arguments);
     }
+
     return false;
   };
+
   exports$1.GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;
 }
 
@@ -101,11 +118,14 @@ let _oldOnUnhandledRejectionHandler = null;
  * Use at your own risk, this might break without changelog notice, only used internally.
  * @hidden
  */
-function addGlobalUnhandledRejectionInstrumentationHandler(handler) {
+function addGlobalUnhandledRejectionInstrumentationHandler(
+  handler,
+) {
   const type = 'unhandledrejection';
   addHandler(type, handler);
   maybeInstrument(type, instrumentUnhandledRejection);
 }
+
 function instrumentUnhandledRejection() {
   _oldOnUnhandledRejectionHandler = exports$1.GLOBAL_OBJ.onunhandledrejection;
 
@@ -114,12 +134,15 @@ function instrumentUnhandledRejection() {
   exports$1.GLOBAL_OBJ.onunhandledrejection = function (e) {
     const handlerData = e;
     triggerHandlers('unhandledrejection', handlerData);
+
     if (_oldOnUnhandledRejectionHandler) {
       // eslint-disable-next-line prefer-rest-params
       return _oldOnUnhandledRejectionHandler.apply(this, arguments);
     }
+
     return true;
   };
+
   exports$1.GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;
 }
 
@@ -129,7 +152,7 @@ function instrumentUnhandledRejection() {
  * so that the envelope types resolve correctly.
  */
 function createEnvelope(headers, items = []) {
-  return [headers, items];
+  return [headers, items] ;
 }
 
 /**
@@ -139,7 +162,7 @@ function createEnvelope(headers, items = []) {
  */
 function addItemToEnvelope(envelope, newItem) {
   const [headers, items] = envelope;
-  return [headers, [...items, newItem]];
+  return [headers, [...items, newItem]] ;
 }
 
 /**
@@ -148,15 +171,21 @@ function addItemToEnvelope(envelope, newItem) {
  *
  * If the callback returns true, the rest of the items will be skipped.
  */
-function forEachEnvelopeItem(envelope, callback) {
+function forEachEnvelopeItem(
+  envelope,
+  callback,
+) {
   const envelopeItems = envelope[1];
+
   for (const envelopeItem of envelopeItems) {
     const envelopeItemType = envelopeItem[0].type;
     const result = callback(envelopeItem, envelopeItemType);
+
     if (result) {
       return true;
     }
   }
+
   return false;
 }
 
@@ -175,6 +204,7 @@ function serializeEnvelope(envelope) {
   const [envHeaders, items] = envelope;
   // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data
   let parts = JSON.stringify(envHeaders);
+
   function append(next) {
     if (typeof parts === 'string') {
       parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts), next];
@@ -182,9 +212,12 @@ function serializeEnvelope(envelope) {
       parts.push(typeof next === 'string' ? encodeUTF8(next) : next);
     }
   }
+
   for (const item of items) {
     const [itemHeaders, payload] = item;
+
     append(`\n${JSON.stringify(itemHeaders)}\n`);
+
     if (typeof payload === 'string' || payload instanceof Uint8Array) {
       append(payload);
     } else {
@@ -200,16 +233,20 @@ function serializeEnvelope(envelope) {
       append(stringifiedPayload);
     }
   }
+
   return typeof parts === 'string' ? parts : concatBuffers(parts);
 }
+
 function concatBuffers(buffers) {
   const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);
+
   const merged = new Uint8Array(totalLength);
   let offset = 0;
   for (const buffer of buffers) {
     merged.set(buffer, offset);
     offset += buffer.length;
   }
+
   return merged;
 }
 
@@ -218,14 +255,19 @@ function concatBuffers(buffers) {
  */
 function createAttachmentEnvelopeItem(attachment) {
   const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data) : attachment.data;
-  return [{
-    type: 'attachment',
-    length: buffer.length,
-    filename: attachment.filename,
-    content_type: attachment.contentType,
-    attachment_type: attachment.attachmentType
-  }, buffer];
+
+  return [
+    {
+      type: 'attachment',
+      length: buffer.length,
+      filename: attachment.filename,
+      content_type: attachment.contentType,
+      attachment_type: attachment.attachmentType,
+    },
+    buffer,
+  ];
 }
+
 const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
   session: 'session',
   sessions: 'session',
@@ -242,7 +284,7 @@ const ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
   feedback: 'feedback',
   span: 'span',
   raw_security: 'security',
-  log: 'log_item'
+  log: 'log_item',
 };
 
 /**
@@ -257,34 +299,29 @@ function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
   if (!metadataOrEvent?.sdk) {
     return;
   }
-  const {
-    name,
-    version
-  } = metadataOrEvent.sdk;
-  return {
-    name,
-    version
-  };
+  const { name, version } = metadataOrEvent.sdk;
+  return { name, version };
 }
 
 /**
  * Creates event envelope headers, based on event, sdk info and tunnel
  * Note: This function was extracted from the core package to make it available in Replay
  */
-function createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) {
+function createEventEnvelopeHeaders(
+  event,
+  sdkInfo,
+  tunnel,
+  dsn,
+) {
   const dynamicSamplingContext = event.sdkProcessingMetadata?.dynamicSamplingContext;
   return {
-    event_id: event.event_id,
+    event_id: event.event_id ,
     sent_at: new Date().toISOString(),
-    ...(sdkInfo && {
-      sdk: sdkInfo
-    }),
-    ...(!!tunnel && dsn && {
-      dsn: exports$1.dsnToString(dsn)
-    }),
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && dsn && { dsn: exports$1.dsnToString(dsn) }),
     ...(dynamicSamplingContext && {
-      trace: dynamicSamplingContext
-    })
+      trace: dynamicSamplingContext,
+    }),
   };
 }
 
@@ -305,29 +342,34 @@ function enhanceEventWithSdkInfo(event, sdkInfo) {
 }
 
 /** Creates an envelope from a Session */
-function createSessionEnvelope(session, dsn, metadata, tunnel) {
+function createSessionEnvelope(
+  session,
+  dsn,
+  metadata,
+  tunnel,
+) {
   const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
   const envelopeHeaders = {
     sent_at: new Date().toISOString(),
-    ...(sdkInfo && {
-      sdk: sdkInfo
-    }),
-    ...(!!tunnel && dsn && {
-      dsn: exports$1.dsnToString(dsn)
-    })
+    ...(sdkInfo && { sdk: sdkInfo }),
+    ...(!!tunnel && dsn && { dsn: exports$1.dsnToString(dsn) }),
   };
-  const envelopeItem = 'aggregates' in session ? [{
-    type: 'sessions'
-  }, session] : [{
-    type: 'session'
-  }, session.toJSON()];
+
+  const envelopeItem =
+    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session.toJSON()];
+
   return createEnvelope(envelopeHeaders, [envelopeItem]);
 }
 
 /**
  * Create an Envelope from an event.
  */
-function createEventEnvelope(event, dsn, metadata, tunnel) {
+function createEventEnvelope(
+  event,
+  dsn,
+  metadata,
+  tunnel,
+) {
   const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
 
   /*
@@ -338,7 +380,9 @@ function createEventEnvelope(event, dsn, metadata, tunnel) {
     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?.sdk);
+
   const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);
 
   // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to
@@ -346,9 +390,8 @@ function createEventEnvelope(event, dsn, metadata, tunnel) {
   // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid
   // of this `delete`, lest we miss putting it back in the next time the property is in use.)
   delete event.sdkProcessingMetadata;
-  const eventItem = [{
-    type: eventType
-  }, event];
+
+  const eventItem = [{ type: eventType }, event];
   return createEnvelope(envelopeHeaders, [eventItem]);
 }
 
@@ -369,16 +412,19 @@ function _getIngestEndpoint(dsn) {
 /** Returns a URL-encoded string with auth config suitable for a query string. */
 function _encodedAuth(dsn, sdkInfo) {
   const params = {
-    sentry_version: SENTRY_API_VERSION
+    sentry_version: SENTRY_API_VERSION,
   };
+
   if (dsn.publicKey) {
     // We send only the minimum set of required information. See
     // https://github.com/getsentry/sentry-javascript/issues/2572.
     params.sentry_key = dsn.publicKey;
   }
+
   if (sdkInfo) {
     params.sentry_client = `${sdkInfo.name}/${sdkInfo.version}`;
   }
+
   return new URLSearchParams(params).toString();
 }
 
@@ -403,10 +449,10 @@ const installedIntegrations = [];
  */
 function filterDuplicates(integrations) {
   const integrationsByName = {};
-  integrations.forEach(currentInstance => {
-    const {
-      name
-    } = currentInstance;
+
+  integrations.forEach((currentInstance) => {
+    const { name } = currentInstance;
+
     const existingInstance = integrationsByName[name];
 
     // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a
@@ -414,8 +460,10 @@ function filterDuplicates(integrations) {
     if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {
       return;
     }
+
     integrationsByName[name] = currentInstance;
   });
+
   return Object.values(integrationsByName);
 }
 
@@ -425,10 +473,12 @@ function getIntegrationsToSetup(options) {
   const userIntegrations = options.integrations;
 
   // We flag default instances, so that later we can tell them apart from any user-created instances of the same class
-  defaultIntegrations.forEach(integration => {
+  defaultIntegrations.forEach((integration) => {
     integration.isDefaultInstance = true;
   });
+
   let integrations;
+
   if (Array.isArray(userIntegrations)) {
     integrations = [...defaultIntegrations, ...userIntegrations];
   } else if (typeof userIntegrations === 'function') {
@@ -437,6 +487,7 @@ function getIntegrationsToSetup(options) {
   } else {
     integrations = defaultIntegrations;
   }
+
   return filterDuplicates(integrations);
 }
 
@@ -448,12 +499,14 @@ function getIntegrationsToSetup(options) {
  */
 function setupIntegrations(client, integrations) {
   const integrationIndex = {};
-  integrations.forEach(integration => {
+
+  integrations.forEach((integration) => {
     // guard against empty provided integrations
     if (integration) {
       setupIntegration(client, integration, integrationIndex);
     }
   });
+
   return integrationIndex;
 }
 
@@ -487,17 +540,22 @@ function setupIntegration(client, integration, integrationIndex) {
   if (integration.setup && typeof integration.setup === 'function') {
     integration.setup(client);
   }
+
   if (typeof integration.preprocessEvent === 'function') {
-    const callback = integration.preprocessEvent.bind(integration);
+    const callback = integration.preprocessEvent.bind(integration) ;
     client.on('preprocessEvent', (event, hint) => callback(event, hint, client));
   }
+
   if (typeof integration.processEvent === 'function') {
-    const callback = integration.processEvent.bind(integration);
+    const callback = integration.processEvent.bind(integration) ;
+
     const processor = Object.assign((event, hint) => callback(event, hint, client), {
-      id: integration.name
+      id: integration.name,
     });
+
     client.addEventProcessor(processor);
   }
+
   exports$1.DEBUG_BUILD && exports$1.logger.log(`Integration installed: ${integration.name}`);
 }
 
@@ -514,9 +572,11 @@ function defineIntegration(fn) {
  */
 function getPossibleEventMessages(event) {
   const possibleMessages = [];
+
   if (event.message) {
     possibleMessages.push(event.message);
   }
+
   try {
     // @ts-expect-error Try catching to save bundle size
     const lastException = event.exception.values[event.exception.values.length - 1];
@@ -529,6 +589,7 @@ function getPossibleEventMessages(event) {
   } catch (e) {
     // ignore errors here
   }
+
   return possibleMessages;
 }
 
@@ -536,15 +597,8 @@ function getPossibleEventMessages(event) {
  * Converts a transaction event to a span JSON object.
  */
 function convertTransactionEventToSpanJson(event) {
-  const {
-    trace_id,
-    parent_span_id,
-    span_id,
-    status,
-    origin,
-    data,
-    op
-  } = event.contexts?.trace ?? {};
+  const { trace_id, parent_span_id, span_id, status, origin, data, op } = event.contexts?.trace ?? {};
+
   return {
     data: data ?? {},
     description: event.transaction,
@@ -556,10 +610,10 @@ function convertTransactionEventToSpanJson(event) {
     timestamp: event.timestamp,
     trace_id: trace_id ?? '',
     origin,
-    profile_id: data?.[exports$1.SEMANTIC_ATTRIBUTE_PROFILE_ID],
-    exclusive_time: data?.[exports$1.SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME],
+    profile_id: data?.[exports$1.SEMANTIC_ATTRIBUTE_PROFILE_ID] ,
+    exclusive_time: data?.[exports$1.SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME] ,
     measurements: event.measurements,
-    is_segment: true
+    is_segment: true,
   };
 }
 
@@ -582,16 +636,12 @@ function convertSpanJsonToTransactionEvent(span) {
         origin: span.origin,
         data: {
           ...span.data,
-          ...(span.profile_id && {
-            [exports$1.SEMANTIC_ATTRIBUTE_PROFILE_ID]: span.profile_id
-          }),
-          ...(span.exclusive_time && {
-            [exports$1.SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: span.exclusive_time
-          })
-        }
-      }
+          ...(span.profile_id && { [exports$1.SEMANTIC_ATTRIBUTE_PROFILE_ID]: span.profile_id }),
+          ...(span.exclusive_time && { [exports$1.SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: span.exclusive_time }),
+        },
+      },
     },
-    measurements: span.measurements
+    measurements: span.measurements,
   };
 }
 
@@ -600,39 +650,47 @@ function convertSpanJsonToTransactionEvent(span) {
  * @param discarded_events An array of discard events
  * @param dsn A DSN that can be set on the header. Optional.
  */
-function createClientReportEnvelope(discarded_events, dsn, timestamp) {
-  const clientReportItem = [{
-    type: 'client_report'
-  }, {
-    timestamp: exports$1.dateTimestampInSeconds(),
-    discarded_events
-  }];
-  return createEnvelope(dsn ? {
-    dsn
-  } : {}, [clientReportItem]);
+function createClientReportEnvelope(
+  discarded_events,
+  dsn,
+  timestamp,
+) {
+  const clientReportItem = [
+    { type: 'client_report' },
+    {
+      timestamp: exports$1.dateTimestampInSeconds(),
+      discarded_events,
+    },
+  ];
+  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);
 }
 
 /* eslint-disable max-lines */
 
 const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
 const MISSING_RELEASE_FOR_SESSION_ERROR = 'Discarded session because of missing or non-string release';
+
 const INTERNAL_ERROR_SYMBOL = Symbol.for('SentryInternalError');
 const DO_NOT_SEND_EVENT_SYMBOL = Symbol.for('SentryDoNotSendEventError');
+
 function _makeInternalError(message) {
   return {
     message,
-    [INTERNAL_ERROR_SYMBOL]: true
+    [INTERNAL_ERROR_SYMBOL]: true,
   };
 }
+
 function _makeDoNotSendEventError(message) {
   return {
     message,
-    [DO_NOT_SEND_EVENT_SYMBOL]: true
+    [DO_NOT_SEND_EVENT_SYMBOL]: true,
   };
 }
+
 function _isInternalError(error) {
   return !!error && typeof error === 'object' && INTERNAL_ERROR_SYMBOL in error;
 }
+
 function _isDoNotSendEventError(error) {
   return !!error && typeof error === 'object' && DO_NOT_SEND_EVENT_SYMBOL in error;
 }
@@ -686,25 +744,31 @@ class Client {
    *
    * @param options Options for the client.
    */
-  constructor(options) {
+   constructor(options) {
     this._options = options;
     this._integrations = {};
     this._numProcessing = 0;
     this._outcomes = {};
     this._hooks = {};
     this._eventProcessors = [];
+
     if (options.dsn) {
       this._dsn = exports$1.makeDsn(options.dsn);
     } else {
       exports$1.DEBUG_BUILD && exports$1.logger.warn('No DSN provided, client will not send events.');
     }
+
     if (this._dsn) {
-      const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options.tunnel, options._metadata ? options._metadata.sdk : undefined);
+      const url = getEnvelopeEndpointWithUrlEncodedAuth(
+        this._dsn,
+        options.tunnel,
+        options._metadata ? options._metadata.sdk : undefined,
+      );
       this._transport = options.transport({
         tunnel: this._options.tunnel,
         recordDroppedEvent: this.recordDroppedEvent.bind(this),
         ...options.transportOptions,
-        url
+        url,
       });
     }
   }
@@ -714,7 +778,7 @@ class Client {
    *
    * Unlike `captureException` exported from every SDK, this method requires that you pass it the current scope.
    */
-  captureException(exception, hint, scope) {
+   captureException(exception, hint, scope) {
     const eventId = exports$1.uuid4();
 
     // ensure we haven't captured this very object before
@@ -722,11 +786,18 @@ class Client {
       exports$1.DEBUG_BUILD && exports$1.logger.log(ALREADY_SEEN_ERROR);
       return eventId;
     }
+
     const hintWithEventId = {
       event_id: eventId,
-      ...hint
+      ...hint,
     };
-    this._process(this.eventFromException(exception, hintWithEventId).then(event => this._captureEvent(event, hintWithEventId, scope)));
+
+    this._process(
+      this.eventFromException(exception, hintWithEventId).then(event =>
+        this._captureEvent(event, hintWithEventId, scope),
+      ),
+    );
+
     return hintWithEventId.event_id;
   }
 
@@ -735,14 +806,25 @@ class Client {
    *
    * Unlike `captureMessage` exported from every SDK, this method requires that you pass it the current scope.
    */
-  captureMessage(message, level, hint, currentScope) {
+   captureMessage(
+    message,
+    level,
+    hint,
+    currentScope,
+  ) {
     const hintWithEventId = {
       event_id: exports$1.uuid4(),
-      ...hint
+      ...hint,
     };
+
     const eventMessage = exports$1.isParameterizedString(message) ? message : String(message);
-    const promisedEvent = exports$1.isPrimitive(message) ? this.eventFromMessage(eventMessage, level, hintWithEventId) : this.eventFromException(message, hintWithEventId);
+
+    const promisedEvent = exports$1.isPrimitive(message)
+      ? this.eventFromMessage(eventMessage, level, hintWithEventId)
+      : this.eventFromException(message, hintWithEventId);
+
     this._process(promisedEvent.then(event => this._captureEvent(event, hintWithEventId, currentScope)));
+
     return hintWithEventId.event_id;
   }
 
@@ -751,7 +833,7 @@ class Client {
    *
    * Unlike `captureEvent` exported from every SDK, this method requires that you pass it the current scope.
    */
-  captureEvent(event, hint, currentScope) {
+   captureEvent(event, hint, currentScope) {
     const eventId = exports$1.uuid4();
 
     // ensure we haven't captured this very object before
@@ -759,26 +841,30 @@ class Client {
       exports$1.DEBUG_BUILD && exports$1.logger.log(ALREADY_SEEN_ERROR);
       return eventId;
     }
+
     const hintWithEventId = {
       event_id: eventId,
-      ...hint
+      ...hint,
     };
+
     const sdkProcessingMetadata = event.sdkProcessingMetadata || {};
     const capturedSpanScope = sdkProcessingMetadata.capturedSpanScope;
     const capturedSpanIsolationScope = sdkProcessingMetadata.capturedSpanIsolationScope;
-    this._process(this._captureEvent(event, hintWithEventId, capturedSpanScope || currentScope, capturedSpanIsolationScope));
+
+    this._process(
+      this._captureEvent(event, hintWithEventId, capturedSpanScope || currentScope, capturedSpanIsolationScope),
+    );
+
     return hintWithEventId.event_id;
   }
 
   /**
    * Captures a session.
    */
-  captureSession(session) {
+   captureSession(session) {
     this.sendSession(session);
     // After sending, we set init false to indicate it's not the first occurrence
-    exports$1.updateSession(session, {
-      init: false
-    });
+    exports$1.updateSession(session, { init: false });
   }
 
   /**
@@ -794,14 +880,14 @@ class Client {
   /**
    * Get the current Dsn.
    */
-  getDsn() {
+   getDsn() {
     return this._dsn;
   }
 
   /**
    * Get the current options.
    */
-  getOptions() {
+   getOptions() {
     return this._options;
   }
 
@@ -809,7 +895,7 @@ class Client {
    * Get the SDK metadata.
    * @see SdkMetadata
    */
-  getSdkMetadata() {
+   getSdkMetadata() {
     return this._options._metadata;
   }
 
@@ -817,7 +903,7 @@ class Client {
    * Returns the transport that is used by the client.
    * Please note that the transport gets lazy initialized so it will only be there once the first event has been sent.
    */
-  getTransport() {
+   getTransport() {
     return this._transport;
   }
 
@@ -829,7 +915,7 @@ class Client {
    * @returns A promise that will resolve with `true` if all events are sent before the timeout, or `false` if there are
    * still events in the queue when the timeout is reached.
    */
-  flush(timeout) {
+   flush(timeout) {
     const transport = this._transport;
     if (transport) {
       this.emit('flush');
@@ -849,7 +935,7 @@ class Client {
    * @returns {Promise<boolean>} A promise which resolves to `true` if the flush completes successfully before the timeout, or `false` if
    * it doesn't.
    */
-  close(timeout) {
+   close(timeout) {
     return this.flush(timeout).then(result => {
       this.getOptions().enabled = false;
       this.emit('close');
@@ -860,14 +946,14 @@ class Client {
   /**
    * Get all installed event processors.
    */
-  getEventProcessors() {
+   getEventProcessors() {
     return this._eventProcessors;
   }
 
   /**
    * Adds an event processor that applies to any event processed by this client.
    */
-  addEventProcessor(eventProcessor) {
+   addEventProcessor(eventProcessor) {
     this._eventProcessors.push(eventProcessor);
   }
 
@@ -875,16 +961,16 @@ class Client {
    * Initialize this client.
    * Call this after the client was set on a scope.
    */
-  init() {
-    if (this._isEnabled() ||
-    // Force integrations to be setup even if no DSN was set when we have
-    // Spotlight enabled. This is particularly important for browser as we
-    // don't support the `spotlight` option there and rely on the users
-    // adding the `spotlightBrowserIntegration()` to their integrations which
-    // wouldn't get initialized with the check below when there's no DSN set.
-    this._options.integrations.some(({
-      name
-    }) => name.startsWith('Spotlight'))) {
+   init() {
+    if (
+      this._isEnabled() ||
+      // Force integrations to be setup even if no DSN was set when we have
+      // Spotlight enabled. This is particularly important for browser as we
+      // don't support the `spotlight` option there and rely on the users
+      // adding the `spotlightBrowserIntegration()` to their integrations which
+      // wouldn't get initialized with the check below when there's no DSN set.
+      this._options.integrations.some(({ name }) => name.startsWith('Spotlight'))
+    ) {
       this._setupIntegrations();
     }
   }
@@ -894,8 +980,8 @@ class Client {
    *
    * @returns {Integration|undefined} The installed integration or `undefined` if no integration with that `name` was installed.
    */
-  getIntegrationByName(integrationName) {
-    return this._integrations[integrationName];
+   getIntegrationByName(integrationName) {
+    return this._integrations[integrationName] ;
   }
 
   /**
@@ -905,7 +991,7 @@ class Client {
    * and you're better off just passing the integrations via `integrations: []` at initialization time.
    * However, if you find the need to conditionally load & add an integration, you can use `addIntegration` to do so.
    */
-  addIntegration(integration) {
+   addIntegration(integration) {
     const isAlreadyInstalled = this._integrations[integration.name];
 
     // This hook takes care of only installing if not already installed
@@ -919,12 +1005,15 @@ class Client {
   /**
    * Send a fully prepared event to Sentry.
    */
-  sendEvent(event, hint = {}) {
+   sendEvent(event, hint = {}) {
     this.emit('beforeSendEvent', event, hint);
+
     let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
+
     for (const attachment of hint.attachments || []) {
       env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment));
     }
+
     const promise = this.sendEnvelope(env);
     if (promise) {
       promise.then(sendResponse => this.emit('afterSendEvent', event, sendResponse), null);
@@ -934,12 +1023,9 @@ class Client {
   /**
    * Send a session or session aggregrates to Sentry.
    */
-  sendSession(session) {
+   sendSession(session) {
     // Backfill release and environment on session
-    const {
-      release: clientReleaseOption,
-      environment: clientEnvironmentOption = exports$1.DEFAULT_ENVIRONMENT
-    } = this._options;
+    const { release: clientReleaseOption, environment: clientEnvironmentOption = exports$1.DEFAULT_ENVIRONMENT } = this._options;
     if ('aggregates' in session) {
       const sessionAttrs = session.attrs || {};
       if (!sessionAttrs.release && !clientReleaseOption) {
@@ -957,7 +1043,9 @@ class Client {
       session.release = session.release || clientReleaseOption;
       session.environment = session.environment || clientEnvironmentOption;
     }
+
     this.emit('beforeSendSession', session);
+
     const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
 
     // sendEnvelope should not throw
@@ -968,7 +1056,7 @@ class Client {
   /**
    * Record on the client that an event got dropped (ie, an event that will not be sent to Sentry).
    */
-  recordDroppedEvent(reason, category, count = 1) {
+   recordDroppedEvent(reason, category, count = 1) {
     if (this._options.sendClientReports) {
       // We want to track each category (error, transaction, session, replay_event) separately
       // but still keep the distinction between different type of outcomes.
@@ -992,8 +1080,8 @@ class Client {
   /**
    * Register a hook on this client.
    */
-  on(hook, callback) {
-    const hooks = this._hooks[hook] = this._hooks[hook] || [];
+   on(hook, callback) {
+    const hooks = (this._hooks[hook] = this._hooks[hook] || []);
 
     // @ts-expect-error We assume the types are correct
     hooks.push(callback);
@@ -1016,7 +1104,7 @@ class Client {
   /**
    * Emit a hook that was previously registered via `on()`.
    */
-  emit(hook, ...rest) {
+   emit(hook, ...rest) {
     const callbacks = this._hooks[hook];
     if (callbacks) {
       callbacks.forEach(callback => callback(...rest));
@@ -1026,36 +1114,39 @@ class Client {
   /**
    * Send an envelope to Sentry.
    */
-  sendEnvelope(envelope) {
+   sendEnvelope(envelope) {
     this.emit('beforeEnvelope', envelope);
+
     if (this._isEnabled() && this._transport) {
       return this._transport.send(envelope).then(null, reason => {
         exports$1.DEBUG_BUILD && exports$1.logger.error('Error while sending envelope:', reason);
         return reason;
       });
     }
+
     exports$1.DEBUG_BUILD && exports$1.logger.error('Transport disabled');
+
     return exports$1.resolvedSyncPromise({});
   }
 
   /* eslint-enable @typescript-eslint/unified-signatures */
 
   /** Setup integrations for this client. */
-  _setupIntegrations() {
-    const {
-      integrations
-    } = this._options;
+   _setupIntegrations() {
+    const { integrations } = this._options;
     this._integrations = setupIntegrations(this, integrations);
     afterSetupIntegrations(this, integrations);
   }
 
   /** Updates existing session based on the provided event */
-  _updateSessionFromEvent(session, event) {
+   _updateSessionFromEvent(session, event) {
     let crashed = event.level === 'fatal';
     let errored = false;
     const exceptions = event.exception?.values;
+
     if (exceptions) {
       errored = true;
+
       for (const ex of exceptions) {
         const mechanism = ex.mechanism;
         if (mechanism?.handled === false) {
@@ -1069,13 +1160,12 @@ class Client {
     // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update
     // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update
     const sessionNonTerminal = session.status === 'ok';
-    const shouldUpdateAndSend = sessionNonTerminal && session.errors === 0 || sessionNonTerminal && crashed;
+    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);
+
     if (shouldUpdateAndSend) {
       exports$1.updateSession(session, {
-        ...(crashed && {
-          status: 'crashed'
-        }),
-        errors: session.errors || Number(errored || crashed)
+        ...(crashed && { status: 'crashed' }),
+        errors: session.errors || Number(errored || crashed),
       });
       this.captureSession(session);
     }
@@ -1091,10 +1181,11 @@ class Client {
    * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and
    * `false` otherwise
    */
-  _isClientDoneProcessing(timeout) {
+   _isClientDoneProcessing(timeout) {
     return new exports$1.SyncPromise(resolve => {
       let ticked = 0;
       const tick = 1;
+
       const interval = setInterval(() => {
         if (this._numProcessing == 0) {
           clearInterval(interval);
@@ -1111,7 +1202,7 @@ class Client {
   }
 
   /** Determines whether this SDK is enabled and a transport is present. */
-  _isEnabled() {
+   _isEnabled() {
     return this.getOptions().enabled !== false && this._transport !== undefined;
   }
 
@@ -1129,30 +1220,43 @@ class Client {
    * @param currentScope A scope containing event metadata.
    * @returns A new event with more information.
    */
-  _prepareEvent(event, hint, currentScope, isolationScope) {
+   _prepareEvent(
+    event,
+    hint,
+    currentScope,
+    isolationScope,
+  ) {
     const options = this.getOptions();
     const integrations = Object.keys(this._integrations);
     if (!hint.integrations && integrations?.length) {
       hint.integrations = integrations;
     }
+
     this.emit('preprocessEvent', event, hint);
+
     if (!event.type) {
       isolationScope.setLastEventId(event.event_id || hint.event_id);
     }
+
     return exports$1.prepareEvent(options, event, hint, currentScope, this, isolationScope).then(evt => {
       if (evt === null) {
         return evt;
       }
+
       this.emit('postprocessEvent', evt, hint);
+
       evt.contexts = {
         trace: exports$1.getTraceContextFromScope(currentScope),
-        ...evt.contexts
+        ...evt.contexts,
       };
+
       const dynamicSamplingContext = exports$1.getDynamicSamplingContextFromScope(this, currentScope);
+
       evt.sdkProcessingMetadata = {
         dynamicSamplingContext,
-        ...evt.sdkProcessingMetadata
+        ...evt.sdkProcessingMetadata,
       };
+
       return evt;
     });
   }
@@ -1163,24 +1267,33 @@ class Client {
    * @param hint
    * @param scope
    */
-  _captureEvent(event, hint = {}, currentScope = exports$1.getCurrentScope(), isolationScope = exports$1.getIsolationScope()) {
+   _captureEvent(
+    event,
+    hint = {},
+    currentScope = exports$1.getCurrentScope(),
+    isolationScope = exports$1.getIsolationScope(),
+  ) {
     if (exports$1.DEBUG_BUILD && isErrorEvent(event)) {
       exports$1.logger.log(`Captured error event \`${getPossibleEventMessages(event)[0] || '<unknown>'}\``);
     }
-    return this._processEvent(event, hint, currentScope, isolationScope).then(finalEvent => {
-      return finalEvent.event_id;
-    }, reason => {
-      if (exports$1.DEBUG_BUILD) {
-        if (_isDoNotSendEventError(reason)) {
-          exports$1.logger.log(reason.message);
-        } else if (_isInternalError(reason)) {
-          exports$1.logger.warn(reason.message);
-        } else {
-          exports$1.logger.warn(reason);
+
+    return this._processEvent(event, hint, currentScope, isolationScope).then(
+      finalEvent => {
+        return finalEvent.event_id;
+      },
+      reason => {
+        if (exports$1.DEBUG_BUILD) {
+          if (_isDoNotSendEventError(reason)) {
+            exports$1.logger.log(reason.message);
+          } else if (_isInternalError(reason)) {
+            exports$1.logger.warn(reason.message);
+          } else {
+            exports$1.logger.warn(reason);
+          }
         }
-      }
-      return undefined;
-    });
+        return undefined;
+      },
+    );
   }
 
   /**
@@ -1196,11 +1309,15 @@ class Client {
    * @param currentScope A scope containing event metadata.
    * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
    */
-  _processEvent(event, hint, currentScope, isolationScope) {
+   _processEvent(
+    event,
+    hint,
+    currentScope,
+    isolationScope,
+  ) {
     const options = this.getOptions();
-    const {
-      sampleRate
-    } = options;
+    const { sampleRate } = options;
+
     const isTransaction = isTransactionEvent(event);
     const isError = isErrorEvent(event);
     const eventType = event.type || 'error';
@@ -1212,97 +1329,118 @@ class Client {
     const parsedSampleRate = typeof sampleRate === 'undefined' ? undefined : parseSampleRate(sampleRate);
     if (isError && typeof parsedSampleRate === 'number' && Math.random() > parsedSampleRate) {
       this.recordDroppedEvent('sample_rate', 'error');
-      return exports$1.rejectedSyncPromise(_makeDoNotSendEventError(`Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`));
+      return exports$1.rejectedSyncPromise(
+        _makeDoNotSendEventError(
+          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,
+        ),
+      );
     }
-    const dataCategory = eventType === 'replay_event' ? 'replay' : eventType;
-    return this._prepareEvent(event, hint, currentScope, isolationScope).then(prepared => {
-      if (prepared === null) {
-        this.recordDroppedEvent('event_processor', dataCategory);
-        throw _makeDoNotSendEventError('An event processor returned `null`, will not send event.');
-      }
-      const isInternalException = hint.data && hint.data.__sentry__ === true;
-      if (isInternalException) {
-        return prepared;
-      }
-      const result = processBeforeSend(this, options, prepared, hint);
-      return _validateBeforeSendResult(result, beforeSendLabel);
-    }).then(processedEvent => {
-      if (processedEvent === null) {
-        this.recordDroppedEvent('before_send', dataCategory);
+
+    const dataCategory = (eventType === 'replay_event' ? 'replay' : eventType) ;
+
+    return this._prepareEvent(event, hint, currentScope, isolationScope)
+      .then(prepared => {
+        if (prepared === null) {
+          this.recordDroppedEvent('event_processor', dataCategory);
+          throw _makeDoNotSendEventError('An event processor returned `null`, will not send event.');
+        }
+
+        const isInternalException = hint.data && (hint.data ).__sentry__ === true;
+        if (isInternalException) {
+          return prepared;
+        }
+
+        const result = processBeforeSend(this, options, prepared, hint);
+        return _validateBeforeSendResult(result, beforeSendLabel);
+      })
+      .then(processedEvent => {
+        if (processedEvent === null) {
+          this.recordDroppedEvent('before_send', dataCategory);
+          if (isTransaction) {
+            const spans = event.spans || [];
+            // the transaction itself counts as one span, plus all the child spans that are added
+            const spanCount = 1 + spans.length;
+            this.recordDroppedEvent('before_send', 'span', spanCount);
+          }
+          throw _makeDoNotSendEventError(`${beforeSendLabel} returned \`null\`, will not send event.`);
+        }
+
+        const session = currentScope.getSession() || isolationScope.getSession();
+        if (isError && session) {
+          this._updateSessionFromEvent(session, processedEvent);
+        }
+
         if (isTransaction) {
-          const spans = event.spans || [];
-          // the transaction itself counts as one span, plus all the child spans that are added
-          const spanCount = 1 + spans.length;
-          this.recordDroppedEvent('before_send', 'span', spanCount);
+          const spanCountBefore = processedEvent.sdkProcessingMetadata?.spanCountBeforeProcessing || 0;
+          const spanCountAfter = processedEvent.spans ? processedEvent.spans.length : 0;
+
+          const droppedSpanCount = spanCountBefore - spanCountAfter;
+          if (droppedSpanCount > 0) {
+            this.recordDroppedEvent('before_send', 'span', droppedSpanCount);
+          }
         }
-        throw _makeDoNotSendEventError(`${beforeSendLabel} returned \`null\`, will not send event.`);
-      }
-      const session = currentScope.getSession() || isolationScope.getSession();
-      if (isError && session) {
-        this._updateSessionFromEvent(session, processedEvent);
-      }
-      if (isTransaction) {
-        const spanCountBefore = processedEvent.sdkProcessingMetadata?.spanCountBeforeProcessing || 0;
-        const spanCountAfter = processedEvent.spans ? processedEvent.spans.length : 0;
-        const droppedSpanCount = spanCountBefore - spanCountAfter;
-        if (droppedSpanCount > 0) {
-          this.recordDroppedEvent('before_send', 'span', droppedSpanCount);
+
+        // None of the Sentry built event processor will update transaction name,
+        // so if the transaction name has been changed by an event processor, we know
+        // it has to come from custom event processor added by a user
+        const transactionInfo = processedEvent.transaction_info;
+        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {
+          const source = 'custom';
+          processedEvent.transaction_info = {
+            ...transactionInfo,
+            source,
+          };
         }
-      }
 
-      // None of the Sentry built event processor will update transaction name,
-      // so if the transaction name has been changed by an event processor, we know
-      // it has to come from custom event processor added by a user
-      const transactionInfo = processedEvent.transaction_info;
-      if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {
-        const source = 'custom';
-        processedEvent.transaction_info = {
-          ...transactionInfo,
-          source
-        };
-      }
-      this.sendEvent(processedEvent, hint);
-      return processedEvent;
-    }).then(null, reason => {
-      if (_isDoNotSendEventError(reason) || _isInternalError(reason)) {
-        throw reason;
-      }
-      this.captureException(reason, {
-        data: {
-          __sentry__: true
-        },
-        originalException: reason
+        this.sendEvent(processedEvent, hint);
+        return processedEvent;
+      })
+      .then(null, reason => {
+        if (_isDoNotSendEventError(reason) || _isInternalError(reason)) {
+          throw reason;
+        }
+
+        this.captureException(reason, {
+          data: {
+            __sentry__: true,
+          },
+          originalException: reason,
+        });
+        throw _makeInternalError(
+          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\nReason: ${reason}`,
+        );
       });
-      throw _makeInternalError(`Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\nReason: ${reason}`);
-    });
   }
 
   /**
    * Occupies the client with processing and event
    */
-  _process(promise) {
+   _process(promise) {
     this._numProcessing++;
-    void promise.then(value => {
-      this._numProcessing--;
-      return value;
-    }, reason => {
-      this._numProcessing--;
-      return reason;
-    });
+    void promise.then(
+      value => {
+        this._numProcessing--;
+        return value;
+      },
+      reason => {
+        this._numProcessing--;
+        return reason;
+      },
+    );
   }
 
   /**
    * Clears outcomes on this client and returns them.
    */
-  _clearOutcomes() {
+   _clearOutcomes() {
     const outcomes = this._outcomes;
     this._outcomes = {};
     return Object.entries(outcomes).map(([key, quantity]) => {
-      const [reason, category] = key.split(':');
+      const [reason, category] = key.split(':') ;
       return {
         reason,
         category,
-        quantity
+        quantity,
       };
     });
   }
@@ -1310,9 +1448,11 @@ class Client {
   /**
    * Sends client reports as an envelope.
    */
-  _flushOutcomes() {
+   _flushOutcomes() {
     exports$1.DEBUG_BUILD && exports$1.logger.log('Flushing outcomes...');
+
     const outcomes = this._clearOutcomes();
+
     if (outcomes.length === 0) {
       exports$1.DEBUG_BUILD && exports$1.logger.log('No outcomes to send');
       return;
@@ -1323,7 +1463,9 @@ class Client {
       exports$1.DEBUG_BUILD && exports$1.logger.log('No dsn provided, will not send outcomes');
       return;
     }
+
     exports$1.DEBUG_BUILD && exports$1.logger.log('Sending outcomes:', outcomes);
+
     const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && exports$1.dsnToString(this._dsn));
 
     // sendEnvelope should not throw
@@ -1334,22 +1476,29 @@ class Client {
   /**
    * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
    */
+
 }
 
 /**
  * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.
  */
-function _validateBeforeSendResult(beforeSendResult, beforeSendLabel) {
+function _validateBeforeSendResult(
+  beforeSendResult,
+  beforeSendLabel,
+) {
   const invalidValueError = `${beforeSendLabel} must return \`null\` or a valid event.`;
   if (exports$1.isThenable(beforeSendResult)) {
-    return beforeSendResult.then(event => {
-      if (!exports$1.isPlainObject(event) && event !== null) {
-        throw _makeInternalError(invalidValueError);
-      }
-      return event;
-    }, e => {
-      throw _makeInternalError(`${beforeSendLabel} rejected with ${e}`);
-    });
+    return beforeSendResult.then(
+      event => {
+        if (!exports$1.isPlainObject(event) && event !== null) {
+          throw _makeInternalError(invalidValueError);
+        }
+        return event;
+      },
+      e => {
+        throw _makeInternalError(`${beforeSendLabel} rejected with ${e}`);
+      },
+    );
   } else if (!exports$1.isPlainObject(beforeSendResult) && beforeSendResult !== null) {
     throw _makeInternalError(invalidValueError);
   }
@@ -1359,16 +1508,19 @@ function _validateBeforeSendResult(beforeSendResult, beforeSendLabel) {
 /**
  * Process the matching `beforeSendXXX` callback.
  */
-function processBeforeSend(client, options, event, hint) {
-  const {
-    beforeSend,
-    beforeSendTransaction,
-    beforeSendSpan
-  } = options;
+function processBeforeSend(
+  client,
+  options,
+  event,
+  hint,
+) {
+  const { beforeSend, beforeSendTransaction, beforeSendSpan } = options;
   let processedEvent = event;
+
   if (isErrorEvent(processedEvent) && beforeSend) {
     return beforeSend(processedEvent, hint);
   }
+
   if (isTransactionEvent(processedEvent)) {
     if (beforeSendSpan) {
       // process root span
@@ -1395,6 +1547,7 @@ function processBeforeSend(client, options, event, hint) {
         processedEvent.spans = processedSpans;
       }
     }
+
     if (beforeSendTransaction) {
       if (processedEvent.spans) {
         // We store the # of spans before processing in SDK metadata,
@@ -1402,17 +1555,20 @@ function processBeforeSend(client, options, event, hint) {
         const spanCountBefore = processedEvent.spans.length;
         processedEvent.sdkProcessingMetadata = {
           ...event.sdkProcessingMetadata,
-          spanCountBeforeProcessing: spanCountBefore
+          spanCountBeforeProcessing: spanCountBefore,
         };
       }
-      return beforeSendTransaction(processedEvent, hint);
+      return beforeSendTransaction(processedEvent , hint);
     }
   }
+
   return processedEvent;
 }
+
 function isErrorEvent(event) {
   return event.type === undefined;
 }
+
 function isTransactionEvent(event) {
   return event.type === 'transaction';
 }
@@ -1424,13 +1580,16 @@ function isTransactionEvent(event) {
  * @returns The created log container envelope item.
  */
 function createLogContainerEnvelopeItem(items) {
-  return [{
-    type: 'log',
-    item_count: items.length,
-    content_type: 'application/vnd.sentry.items.log+json'
-  }, {
-    items
-  }];
+  return [
+    {
+      type: 'log',
+      item_count: items.length,
+      content_type: 'application/vnd.sentry.items.log+json',
+    },
+    {
+      items,
+    },
+  ];
 }
 
 /**
@@ -1444,17 +1603,25 @@ function createLogContainerEnvelopeItem(items) {
  * @param dsn - The DSN to include in the envelope.
  * @returns The created envelope.
  */
-function createLogEnvelope(logs, metadata, tunnel, dsn) {
+function createLogEnvelope(
+  logs,
+  metadata,
+  tunnel,
+  dsn,
+) {
   const headers = {};
+
   if (metadata?.sdk) {
     headers.sdk = {
       name: metadata.sdk.name,
-      version: metadata.sdk.version
+      version: metadata.sdk.version,
     };
   }
+
   if (!!tunnel && !!dsn) {
     headers.dsn = exports$1.dsnToString(dsn);
   }
+
   return createEnvelope(headers, [createLogContainerEnvelopeItem(logs)]);
 }
 
@@ -1475,11 +1642,13 @@ function _INTERNAL_flushLogsBuffer(client, maybeLogBuffer) {
   if (logBuffer.length === 0) {
     return;
   }
+
   const clientOptions = client.getOptions();
   const envelope = createLogEnvelope(logBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn());
 
   // Clear the log buffer after envelopes have been constructed.
   exports$1.GLOBAL_OBJ._sentryClientToLogBufferMap?.set(client, []);
+
   client.emit('flushLogs');
 
   // sendEnvelope should not throw
@@ -1508,7 +1677,10 @@ function _INTERNAL_getLogBuffer(client) {
  * @param clientClass The client class to instantiate.
  * @param options Options to pass to the client.
  */
-function initAndBind(clientClass, options) {
+function initAndBind(
+  clientClass,
+  options,
+) {
   if (options.debug === true) {
     if (exports$1.DEBUG_BUILD) {
       exports$1.logger.enable();
@@ -1522,6 +1694,7 @@ function initAndBind(clientClass, options) {
   }
   const scope = exports$1.getCurrentScope();
   scope.update(options.initialScope);
+
   const client = new clientClass(options);
   setCurrentClient(client);
   client.init();
@@ -1543,6 +1716,7 @@ const SENTRY_BUFFER_FULL_ERROR = Symbol.for('SentryBufferFullError');
  */
 function makePromiseBuffer(limit) {
   const buffer = [];
+
   function isReady() {
     return limit === undefined || buffer.length < limit;
   }
@@ -1577,13 +1751,16 @@ function makePromiseBuffer(limit) {
     if (buffer.indexOf(task) === -1) {
       buffer.push(task);
     }
-    void task.then(() => remove(task))
-    // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`
-    // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't
-    // have promises, so TS has to polyfill when down-compiling.)
-    .then(null, () => remove(task).then(null, () => {
-      // We have to add another catch here because `remove()` starts a new promise chain.
-    }));
+    void task
+      .then(() => remove(task))
+      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`
+      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't
+      // have promises, so TS has to polyfill when down-compiling.)
+      .then(null, () =>
+        remove(task).then(null, () => {
+          // We have to add another catch here because `remove()` starts a new promise chain.
+        }),
+      );
     return task;
   }
 
@@ -1599,6 +1776,7 @@ function makePromiseBuffer(limit) {
   function drain(timeout) {
     return new exports$1.SyncPromise((resolve, reject) => {
       let counter = buffer.length;
+
       if (!counter) {
         return resolve(true);
       }
@@ -1613,7 +1791,7 @@ function makePromiseBuffer(limit) {
       // if all promises resolve in time, cancel the timer and resolve to `true`
       buffer.forEach(item => {
         void exports$1.resolvedSyncPromise(item).then(() => {
-          if (! --counter) {
+          if (!--counter) {
             clearTimeout(capturedSetTimeout);
             resolve(true);
           }
@@ -1621,10 +1799,11 @@ function makePromiseBuffer(limit) {
       });
     });
   }
+
   return {
     $: buffer,
     add,
-    drain
+    drain,
   };
 }
 
@@ -1643,10 +1822,12 @@ function parseRetryAfterHeader(header, now = Date.now()) {
   if (!isNaN(headerDelay)) {
     return headerDelay * 1000;
   }
+
   const headerDate = Date.parse(`${header}`);
   if (!isNaN(headerDate)) {
     return headerDate - now;
   }
+
   return DEFAULT_RETRY_AFTER;
 }
 
@@ -1673,18 +1854,20 @@ function isRateLimited(limits, dataCategory, now = Date.now()) {
  *
  * @return the updated RateLimits object.
  */
-function updateRateLimits(limits, {
-  statusCode,
-  headers
-}, now = Date.now()) {
+function updateRateLimits(
+  limits,
+  { statusCode, headers },
+  now = Date.now(),
+) {
   const updatedRateLimits = {
-    ...limits
+    ...limits,
   };
 
   // "The name is case-insensitive."
   // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
   const rateLimitHeader = headers?.['x-sentry-rate-limits'];
   const retryAfterHeader = headers?.['retry-after'];
+
   if (rateLimitHeader) {
     /**
      * rate limit headers are of the form
@@ -1701,7 +1884,7 @@ function updateRateLimits(limits, {
      *         Only present if rate limit applies to the metric_bucket data category.
      */
     for (const limit of rateLimitHeader.trim().split(',')) {
-      const [retryAfter, categories,,, namespaces] = limit.split(':', 5);
+      const [retryAfter, categories, , , namespaces] = limit.split(':', 5) ;
       const headerDelay = parseInt(retryAfter, 10);
       const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default
       if (!categories) {
@@ -1724,6 +1907,7 @@ function updateRateLimits(limits, {
   } else if (statusCode === 429) {
     updatedRateLimits.all = now + 60 * 1000;
   }
+
   return updatedRateLimits;
 }
 
@@ -1735,9 +1919,16 @@ const DEFAULT_TRANSPORT_BUFFER_SIZE = 64;
  * @param options
  * @param makeRequest
  */
-function createTransport(options, makeRequest, buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE)) {
+function createTransport(
+  options,
+  makeRequest,
+  buffer = makePromiseBuffer(
+    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,
+  ),
+) {
   let rateLimits = {};
-  const flush = timeout => buffer.drain(timeout);
+  const flush = (timeout) => buffer.drain(timeout);
+
   function send(envelope) {
     const filteredEnvelopeItems = [];
 
@@ -1755,41 +1946,51 @@ function createTransport(options, makeRequest, buffer = makePromiseBuffer(option
     if (filteredEnvelopeItems.length === 0) {
       return exports$1.resolvedSyncPromise({});
     }
-    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems);
+
+    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );
 
     // Creates client report for each item in an envelope
-    const recordEnvelopeLoss = reason => {
+    const recordEnvelopeLoss = (reason) => {
       forEachEnvelopeItem(filteredEnvelope, (item, type) => {
         options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));
       });
     };
-    const requestTask = () => makeRequest({
-      body: serializeEnvelope(filteredEnvelope)
-    }).then(response => {
-      // We don't want to throw on NOK responses, but we want to at least log them
-      if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {
-        exports$1.DEBUG_BUILD && exports$1.logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
-      }
-      rateLimits = updateRateLimits(rateLimits, response);
-      return response;
-    }, error => {
-      recordEnvelopeLoss('network_error');
-      exports$1.DEBUG_BUILD && exports$1.logger.error('Encountered error running transport request:', error);
-      throw error;
-    });
-    return buffer.add(requestTask).then(result => result, error => {
-      if (error === SENTRY_BUFFER_FULL_ERROR) {
-        exports$1.DEBUG_BUILD && exports$1.logger.error('Skipped sending event because buffer is full.');
-        recordEnvelopeLoss('queue_overflow');
-        return exports$1.resolvedSyncPromise({});
-      } else {
-        throw error;
-      }
-    });
+
+    const requestTask = () =>
+      makeRequest({ body: serializeEnvelope(filteredEnvelope) }).then(
+        response => {
+          // We don't want to throw on NOK responses, but we want to at least log them
+          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {
+            exports$1.DEBUG_BUILD && exports$1.logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
+          }
+
+          rateLimits = updateRateLimits(rateLimits, response);
+          return response;
+        },
+        error => {
+          recordEnvelopeLoss('network_error');
+          exports$1.DEBUG_BUILD && exports$1.logger.error('Encountered error running transport request:', error);
+          throw error;
+        },
+      );
+
+    return buffer.add(requestTask).then(
+      result => result,
+      error => {
+        if (error === SENTRY_BUFFER_FULL_ERROR) {
+          exports$1.DEBUG_BUILD && exports$1.logger.error('Skipped sending event because buffer is full.');
+          recordEnvelopeLoss('queue_overflow');
+          return exports$1.resolvedSyncPromise({});
+        } else {
+          throw error;
+        }
+      },
+    );
   }
+
   return {
     send,
-    flush
+    flush,
   };
 }
 
@@ -1804,7 +2005,7 @@ function addAutoIpAddressToUser(objWithMaybeUser) {
   if (objWithMaybeUser.user?.ip_address === undefined) {
     objWithMaybeUser.user = {
       ...objWithMaybeUser.user,
-      ip_address: '{{auto}}'
+      ip_address: '{{auto}}',
     };
   }
 }
@@ -1817,7 +2018,7 @@ function addAutoIpAddressToSession(session) {
     if (session.attrs?.['ip_address'] === undefined) {
       session.attrs = {
         ...session.attrs,
-        ip_address: '{{auto}}'
+        ip_address: '{{auto}}',
       };
     }
   } else {
@@ -1842,16 +2043,18 @@ function addAutoIpAddressToSession(session) {
  */
 function applySdkMetadata(options, name, names = [name], source = 'npm') {
   const metadata = options._metadata || {};
+
   if (!metadata.sdk) {
     metadata.sdk = {
       name: `sentry.javascript.${name}`,
       packages: names.map(name => ({
         name: `${source}:@sentry/${name}`,
-        version: exports$1.SDK_VERSION
+        version: exports$1.SDK_VERSION,
       })),
-      version: exports$1.SDK_VERSION
+      version: exports$1.SDK_VERSION,
     };
   }
+
   options._metadata = metadata;
 }
 
@@ -1870,29 +2073,35 @@ const DEFAULT_BREADCRUMBS = 100;
 function addBreadcrumb(breadcrumb, hint) {
   const client = exports$1.getClient();
   const isolationScope = exports$1.getIsolationScope();
+
   if (!client) return;
-  const {
-    beforeBreadcrumb = null,
-    maxBreadcrumbs = DEFAULT_BREADCRUMBS
-  } = client.getOptions();
+
+  const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } = client.getOptions();
+
   if (maxBreadcrumbs <= 0) return;
+
   const timestamp = exports$1.dateTimestampInSeconds();
-  const mergedBreadcrumb = {
-    timestamp,
-    ...breadcrumb
-  };
-  const finalBreadcrumb = beforeBreadcrumb ? exports$1.consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) : mergedBreadcrumb;
+  const mergedBreadcrumb = { timestamp, ...breadcrumb };
+  const finalBreadcrumb = beforeBreadcrumb
+    ? (exports$1.consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )
+    : mergedBreadcrumb;
+
   if (finalBreadcrumb === null) return;
+
   if (client.emit) {
     client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);
   }
+
   isolationScope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
 }
 
 let originalFunctionToString;
+
 const INTEGRATION_NAME$6 = 'FunctionToString';
+
 const SETUP_CLIENTS = new WeakMap();
-const _functionToStringIntegration = () => {
+
+const _functionToStringIntegration = (() => {
   return {
     name: INTEGRATION_NAME$6,
     setupOnce() {
@@ -1902,9 +2111,10 @@ const _functionToStringIntegration = () => {
       // intrinsics (like Function.prototype) might be immutable in some environments
       // e.g. Node with --frozen-intrinsics, XS (an embedded JavaScript engine) or SES (a JavaScript proposal)
       try {
-        Function.prototype.toString = function (...args) {
+        Function.prototype.toString = function ( ...args) {
           const originalFunction = exports$1.getOriginalFunction(this);
-          const context = SETUP_CLIENTS.has(exports$1.getClient()) && originalFunction !== undefined ? originalFunction : this;
+          const context =
+            SETUP_CLIENTS.has(exports$1.getClient() ) && originalFunction !== undefined ? originalFunction : this;
           return originalFunctionToString.apply(context, args);
         };
       } catch {
@@ -1913,9 +2123,9 @@ const _functionToStringIntegration = () => {
     },
     setup(client) {
       SETUP_CLIENTS.set(client, true);
-    }
+    },
   };
-};
+}) ;
 
 /**
  * Patch toString calls to return proper name for wrapped functions.
@@ -1932,23 +2142,18 @@ const functionToStringIntegration = defineIntegration(_functionToStringIntegrati
 
 // "Script error." is hard coded into browsers for errors that it can't read.
 // this is the result of a script being pulled in from an external domain and CORS.
-const DEFAULT_IGNORE_ERRORS = [/^Script error\.?$/, /^Javascript error: Script error\.? on line 0$/, /^ResizeObserver loop completed with undelivered notifications.$/,
-// The browser logs this when a ResizeObserver handler takes a bit longer. Usually this is not an actual issue though. It indicates slowness.
-/^Cannot redefine property: googletag$/,
-// This is thrown when google tag manager is used in combination with an ad blocker
-/^Can't find variable: gmo$/,
-// Error from Google Search App https://issuetracker.google.com/issues/396043331
-/^undefined is not an object \(evaluating 'a\.[A-Z]'\)$/,
-// Random error that happens but not actionable or noticeable to end-users.
-'can\'t redefine non-configurable property "solana"',
-// Probably a browser extension or custom browser (Brave) throwing this error
-"vv().getRestrictions is not a function. (In 'vv().getRestrictions(1,a)', 'vv().getRestrictions' is undefined)",
-// Error thrown by GTM, seemingly not affecting end-users
-"Can't find variable: _AutofillCallbackHandler",
-// Unactionable error in instagram webview https://developers.facebook.com/community/threads/320013549791141/
-/^Non-Error promise rejection captured with value: Object Not Found Matching Id:\d+, MethodName:simulateEvent, ParamCount:\d+$/,
-// unactionable error from CEFSharp, a .NET library that embeds chromium in .NET apps
-/^Java exception was raised during method invocation$/ // error from Facebook Mobile browser (https://github.com/getsentry/sentry-javascript/issues/15065)
+const DEFAULT_IGNORE_ERRORS = [
+  /^Script error\.?$/,
+  /^Javascript error: Script error\.? on line 0$/,
+  /^ResizeObserver loop completed with undelivered notifications.$/, // The browser logs this when a ResizeObserver handler takes a bit longer. Usually this is not an actual issue though. It indicates slowness.
+  /^Cannot redefine property: googletag$/, // This is thrown when google tag manager is used in combination with an ad blocker
+  /^Can't find variable: gmo$/, // Error from Google Search App https://issuetracker.google.com/issues/396043331
+  /^undefined is not an object \(evaluating 'a\.[A-Z]'\)$/, // Random error that happens but not actionable or noticeable to end-users.
+  'can\'t redefine non-configurable property "solana"', // Probably a browser extension or custom browser (Brave) throwing this error
+  "vv().getRestrictions is not a function. (In 'vv().getRestrictions(1,a)', 'vv().getRestrictions' is undefined)", // Error thrown by GTM, seemingly not affecting end-users
+  "Can't find variable: _AutofillCallbackHandler", // Unactionable error in instagram webview https://developers.facebook.com/community/threads/320013549791141/
+  /^Non-Error promise rejection captured with value: Object Not Found Matching Id:\d+, MethodName:simulateEvent, ParamCount:\d+$/, // unactionable error from CEFSharp, a .NET library that embeds chromium in .NET apps
+  /^Java exception was raised during method invocation$/, // error from Facebook Mobile browser (https://github.com/getsentry/sentry-javascript/issues/15065)
 ];
 
 /** Options for the EventFilters integration */
@@ -1982,7 +2187,7 @@ const eventFiltersIntegration = defineIntegration((options = {}) => {
         mergedOptions = _mergeOptions(options, clientOptions);
       }
       return _shouldDropEvent$1(event, mergedOptions) ? null : event;
-    }
+    },
   };
 });
 
@@ -2002,62 +2207,97 @@ const eventFiltersIntegration = defineIntegration((options = {}) => {
  * @deprecated this integration was renamed and will be removed in a future major version.
  * Use `eventFiltersIntegration` instead.
  */
-const inboundFiltersIntegration = defineIntegration((options = {}) => {
+const inboundFiltersIntegration = defineIntegration(((options = {}) => {
   return {
     ...eventFiltersIntegration(options),
-    name: 'InboundFilters'
+    name: 'InboundFilters',
   };
-});
-function _mergeOptions(internalOptions = {}, clientOptions = {}) {
+}) );
+
+function _mergeOptions(
+  internalOptions = {},
+  clientOptions = {},
+) {
   return {
     allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],
     denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],
-    ignoreErrors: [...(internalOptions.ignoreErrors || []), ...(clientOptions.ignoreErrors || []), ...(internalOptions.disableErrorDefaults ? [] : DEFAULT_IGNORE_ERRORS)],
-    ignoreTransactions: [...(internalOptions.ignoreTransactions || []), ...(clientOptions.ignoreTransactions || [])]
+    ignoreErrors: [
+      ...(internalOptions.ignoreErrors || []),
+      ...(clientOptions.ignoreErrors || []),
+      ...(internalOptions.disableErrorDefaults ? [] : DEFAULT_IGNORE_ERRORS),
+    ],
+    ignoreTransactions: [...(internalOptions.ignoreTransactions || []), ...(clientOptions.ignoreTransactions || [])],
   };
 }
+
 function _shouldDropEvent$1(event, options) {
   if (!event.type) {
     // Filter errors
     if (_isIgnoredError(event, options.ignoreErrors)) {
-      exports$1.DEBUG_BUILD && exports$1.logger.warn(`Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${exports$1.getEventDescription(event)}`);
+      exports$1.DEBUG_BUILD &&
+        exports$1.logger.warn(
+          `Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${exports$1.getEventDescription(event)}`,
+        );
       return true;
     }
     if (_isUselessError(event)) {
-      exports$1.DEBUG_BUILD && exports$1.logger.warn(`Event dropped due to not having an error message, error type or stacktrace.\nEvent: ${exports$1.getEventDescription(event)}`);
+      exports$1.DEBUG_BUILD &&
+        exports$1.logger.warn(
+          `Event dropped due to not having an error message, error type or stacktrace.\nEvent: ${exports$1.getEventDescription(
+            event,
+          )}`,
+        );
       return true;
     }
     if (_isDeniedUrl(event, options.denyUrls)) {
-      exports$1.DEBUG_BUILD && exports$1.logger.warn(`Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${exports$1.getEventDescription(event)}.\nUrl: ${_getEventFilterUrl(event)}`);
+      exports$1.DEBUG_BUILD &&
+        exports$1.logger.warn(
+          `Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${exports$1.getEventDescription(
+            event,
+          )}.\nUrl: ${_getEventFilterUrl(event)}`,
+        );
       return true;
     }
     if (!_isAllowedUrl(event, options.allowUrls)) {
-      exports$1.DEBUG_BUILD && exports$1.logger.warn(`Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${exports$1.getEventDescription(event)}.\nUrl: ${_getEventFilterUrl(event)}`);
+      exports$1.DEBUG_BUILD &&
+        exports$1.logger.warn(
+          `Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${exports$1.getEventDescription(
+            event,
+          )}.\nUrl: ${_getEventFilterUrl(event)}`,
+        );
       return true;
     }
   } else if (event.type === 'transaction') {
     // Filter transactions
 
     if (_isIgnoredTransaction(event, options.ignoreTransactions)) {
-      exports$1.DEBUG_BUILD && exports$1.logger.warn(`Event dropped due to being matched by \`ignoreTransactions\` option.\nEvent: ${exports$1.getEventDescription(event)}`);
+      exports$1.DEBUG_BUILD &&
+        exports$1.logger.warn(
+          `Event dropped due to being matched by \`ignoreTransactions\` option.\nEvent: ${exports$1.getEventDescription(event)}`,
+        );
       return true;
     }
   }
   return false;
 }
+
 function _isIgnoredError(event, ignoreErrors) {
   if (!ignoreErrors?.length) {
     return false;
   }
+
   return getPossibleEventMessages(event).some(message => exports$1.stringMatchesSomePattern(message, ignoreErrors));
 }
+
 function _isIgnoredTransaction(event, ignoreTransactions) {
   if (!ignoreTransactions?.length) {
     return false;
   }
+
   const name = event.transaction;
   return name ? exports$1.stringMatchesSomePattern(name, ignoreTransactions) : false;
 }
+
 function _isDeniedUrl(event, denyUrls) {
   if (!denyUrls?.length) {
     return false;
@@ -2065,6 +2305,7 @@ function _isDeniedUrl(event, denyUrls) {
   const url = _getEventFilterUrl(event);
   return !url ? false : exports$1.stringMatchesSomePattern(url, denyUrls);
 }
+
 function _isAllowedUrl(event, allowUrls) {
   if (!allowUrls?.length) {
     return true;
@@ -2072,20 +2313,26 @@ function _isAllowedUrl(event, allowUrls) {
   const url = _getEventFilterUrl(event);
   return !url ? true : exports$1.stringMatchesSomePattern(url, allowUrls);
 }
+
 function _getLastValidUrl(frames = []) {
   for (let i = frames.length - 1; i >= 0; i--) {
     const frame = frames[i];
+
     if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {
       return frame.filename || null;
     }
   }
+
   return null;
 }
+
 function _getEventFilterUrl(event) {
   try {
     // If there are linked exceptions or exception aggregates we only want to match against the top frame of the "root" (the main exception)
     // The root always comes last in linked exceptions
-    const rootException = [...(event.exception?.values ?? [])].reverse().find(value => value.mechanism?.parent_id === undefined && value.stacktrace?.frames?.length);
+    const rootException = [...(event.exception?.values ?? [])]
+      .reverse()
+      .find(value => value.mechanism?.parent_id === undefined && value.stacktrace?.frames?.length);
     const frames = rootException?.stacktrace?.frames;
     return frames ? _getLastValidUrl(frames) : null;
   } catch (oO) {
@@ -2093,39 +2340,69 @@ function _getEventFilterUrl(event) {
     return null;
   }
 }
+
 function _isUselessError(event) {
   // We only want to consider events for dropping that actually have recorded exception values.
   if (!event.exception?.values?.length) {
     return false;
   }
+
   return (
     // No top-level message
     !event.message &&
     // There are no exception values that have a stacktrace, a non-generic-Error type or value
-    !event.exception.values.some(value => value.stacktrace || value.type && value.type !== 'Error' || value.value)
+    !event.exception.values.some(value => value.stacktrace || (value.type && value.type !== 'Error') || value.value)
   );
 }
 
 /**
  * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.
  */
-function applyAggregateErrorsToEvent(exceptionFromErrorImplementation, parser, key, limit, event, hint) {
+function applyAggregateErrorsToEvent(
+  exceptionFromErrorImplementation,
+  parser,
+  key,
+  limit,
+  event,
+  hint,
+) {
   if (!event.exception?.values || !hint || !exports$1.isInstanceOf(hint.originalException, Error)) {
     return;
   }
 
   // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error
-  const originalException = event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;
+  const originalException =
+    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;
 
   // We only create exception grouping if there is an exception in the event.
   if (originalException) {
-    event.exception.values = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, hint.originalException, key, event.exception.values, originalException, 0);
-  }
-}
-function aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error, key, prevExceptions, exception, exceptionId) {
+    event.exception.values = aggregateExceptionsFromError(
+      exceptionFromErrorImplementation,
+      parser,
+      limit,
+      hint.originalException ,
+      key,
+      event.exception.values,
+      originalException,
+      0,
+    );
+  }
+}
+
+function aggregateExceptionsFromError(
+  exceptionFromErrorImplementation,
+  parser,
+  limit,
+  error,
+  key,
+  prevExceptions,
+  exception,
+  exceptionId,
+) {
   if (prevExceptions.length >= limit + 1) {
     return prevExceptions;
   }
+
   let newExceptions = [...prevExceptions];
 
   // Recursively call this function in order to walk down a chain of errors
@@ -2134,7 +2411,16 @@ function aggregateExceptionsFromError(exceptionFromErrorImplementation, parser,
     const newException = exceptionFromErrorImplementation(parser, error[key]);
     const newExceptionId = newExceptions.length;
     applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);
-    newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error[key], key, [newException, ...newExceptions], newException, newExceptionId);
+    newExceptions = aggregateExceptionsFromError(
+      exceptionFromErrorImplementation,
+      parser,
+      limit,
+      error[key],
+      key,
+      [newException, ...newExceptions],
+      newException,
+      newExceptionId,
+    );
   }
 
   // This will create exception grouping for AggregateErrors
@@ -2146,38 +2432,49 @@ function aggregateExceptionsFromError(exceptionFromErrorImplementation, parser,
         const newException = exceptionFromErrorImplementation(parser, childError);
         const newExceptionId = newExceptions.length;
         applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);
-        newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, childError, key, [newException, ...newExceptions], newException, newExceptionId);
+        newExceptions = aggregateExceptionsFromError(
+          exceptionFromErrorImplementation,
+          parser,
+          limit,
+          childError,
+          key,
+          [newException, ...newExceptions],
+          newException,
+          newExceptionId,
+        );
       }
     });
   }
+
   return newExceptions;
 }
+
 function applyExceptionGroupFieldsForParentException(exception, exceptionId) {
   // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.
-  exception.mechanism = exception.mechanism || {
-    type: 'generic',
-    handled: true
-  };
+  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };
+
   exception.mechanism = {
     ...exception.mechanism,
-    ...(exception.type === 'AggregateError' && {
-      is_exception_group: true
-    }),
-    exception_id: exceptionId
+    ...(exception.type === 'AggregateError' && { is_exception_group: true }),
+    exception_id: exceptionId,
   };
 }
-function applyExceptionGroupFieldsForChildException(exception, source, exceptionId, parentId) {
+
+function applyExceptionGroupFieldsForChildException(
+  exception,
+  source,
+  exceptionId,
+  parentId,
+) {
   // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.
-  exception.mechanism = exception.mechanism || {
-    type: 'generic',
-    handled: true
-  };
+  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };
+
   exception.mechanism = {
     ...exception.mechanism,
     type: 'chained',
     source,
     exception_id: exceptionId,
-    parent_id: parentId
+    parent_id: parentId,
   };
 }
 
@@ -2192,22 +2489,24 @@ function addConsoleInstrumentationHandler(handler) {
   addHandler(type, handler);
   maybeInstrument(type, instrumentConsole);
 }
+
 function instrumentConsole() {
   if (!('console' in exports$1.GLOBAL_OBJ)) {
     return;
   }
+
   exports$1.CONSOLE_LEVELS.forEach(function (level) {
     if (!(level in exports$1.GLOBAL_OBJ.console)) {
       return;
     }
+
     exports$1.fill(exports$1.GLOBAL_OBJ.console, level, function (originalConsoleMethod) {
       exports$1.originalConsoleMethods[level] = originalConsoleMethod;
+
       return function (...args) {
-        const handlerData = {
-          args,
-          level
-        };
+        const handlerData = { args, level };
         triggerHandlers('console', handlerData);
+
         const log = exports$1.originalConsoleMethods[level];
         log?.apply(exports$1.GLOBAL_OBJ.console, args);
       };
@@ -2222,12 +2521,16 @@ function instrumentConsole() {
  * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.
  */
 function severityLevelFromString(level) {
-  return level === 'warn' ? 'warning' : ['fatal', 'error', 'warning', 'log', 'info', 'debug'].includes(level) ? level : 'log';
+  return (
+    level === 'warn' ? 'warning' : ['fatal', 'error', 'warning', 'log', 'info', 'debug'].includes(level) ? level : 'log'
+  ) ;
 }
 
 const INTEGRATION_NAME$4 = 'Dedupe';
-const _dedupeIntegration = () => {
+
+const _dedupeIntegration = (() => {
   let previousEvent;
+
   return {
     name: INTEGRATION_NAME$4,
     processEvent(currentEvent) {
@@ -2245,10 +2548,10 @@ const _dedupeIntegration = () => {
         }
       } catch (_oO) {} // eslint-disable-line no-empty
 
-      return previousEvent = currentEvent;
-    }
+      return (previousEvent = currentEvent);
+    },
   };
-};
+}) ;
 
 /**
  * Deduplication filter.
@@ -2260,14 +2563,18 @@ function _shouldDropEvent(currentEvent, previousEvent) {
   if (!previousEvent) {
     return false;
   }
+
   if (_isSameMessageEvent(currentEvent, previousEvent)) {
     return true;
   }
+
   if (_isSameExceptionEvent(currentEvent, previousEvent)) {
     return true;
   }
+
   return false;
 }
+
 function _isSameMessageEvent(currentEvent, previousEvent) {
   const currentMessage = currentEvent.message;
   const previousMessage = previousEvent.message;
@@ -2278,37 +2585,48 @@ function _isSameMessageEvent(currentEvent, previousEvent) {
   }
 
   // If only one event has a stacktrace, but not the other one, they are not the same
-  if (currentMessage && !previousMessage || !currentMessage && previousMessage) {
+  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
     return false;
   }
+
   if (currentMessage !== previousMessage) {
     return false;
   }
+
   if (!_isSameFingerprint(currentEvent, previousEvent)) {
     return false;
   }
+
   if (!_isSameStacktrace(currentEvent, previousEvent)) {
     return false;
   }
+
   return true;
 }
+
 function _isSameExceptionEvent(currentEvent, previousEvent) {
   const previousException = _getExceptionFromEvent(previousEvent);
   const currentException = _getExceptionFromEvent(currentEvent);
+
   if (!previousException || !currentException) {
     return false;
   }
+
   if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
     return false;
   }
+
   if (!_isSameFingerprint(currentEvent, previousEvent)) {
     return false;
   }
+
   if (!_isSameStacktrace(currentEvent, previousEvent)) {
     return false;
   }
+
   return true;
 }
+
 function _isSameStacktrace(currentEvent, previousEvent) {
   let currentFrames = exports$1.getFramesFromEvent(currentEvent);
   let previousFrames = exports$1.getFramesFromEvent(previousEvent);
@@ -2319,11 +2637,12 @@ function _isSameStacktrace(currentEvent, previousEvent) {
   }
 
   // If only one event has a stacktrace, but not the other one, they are not the same
-  if (currentFrames && !previousFrames || !currentFrames && previousFrames) {
+  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
     return false;
   }
-  currentFrames = currentFrames;
-  previousFrames = previousFrames;
+
+  currentFrames = currentFrames ;
+  previousFrames = previousFrames ;
 
   // If number of frames differ, they are not the same
   if (previousFrames.length !== currentFrames.length) {
@@ -2336,12 +2655,20 @@ function _isSameStacktrace(currentEvent, previousEvent) {
     const frameA = previousFrames[i];
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const frameB = currentFrames[i];
-    if (frameA.filename !== frameB.filename || frameA.lineno !== frameB.lineno || frameA.colno !== frameB.colno || frameA.function !== frameB.function) {
+
+    if (
+      frameA.filename !== frameB.filename ||
+      frameA.lineno !== frameB.lineno ||
+      frameA.colno !== frameB.colno ||
+      frameA.function !== frameB.function
+    ) {
       return false;
     }
   }
+
   return true;
 }
+
 function _isSameFingerprint(currentEvent, previousEvent) {
   let currentFingerprint = currentEvent.fingerprint;
   let previousFingerprint = previousEvent.fingerprint;
@@ -2352,11 +2679,12 @@ function _isSameFingerprint(currentEvent, previousEvent) {
   }
 
   // If only one event has a fingerprint, but not the other one, they are not the same
-  if (currentFingerprint && !previousFingerprint || !currentFingerprint && previousFingerprint) {
+  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
     return false;
   }
-  currentFingerprint = currentFingerprint;
-  previousFingerprint = previousFingerprint;
+
+  currentFingerprint = currentFingerprint ;
+  previousFingerprint = previousFingerprint ;
 
   // Otherwise, compare the two
   try {
@@ -2365,6 +2693,7 @@ function _isSameFingerprint(currentEvent, previousEvent) {
     return false;
   }
 }
+
 function _getExceptionFromEvent(event) {
   return event.exception?.values && event.exception.values[0];
 }
@@ -2380,7 +2709,9 @@ function parseUrl(url) {
   if (!url) {
     return {};
   }
+
   const match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
+
   if (!match) {
     return {};
   }
@@ -2394,7 +2725,7 @@ function parseUrl(url) {
     protocol: match[2],
     search: query,
     hash: fragment,
-    relative: match[5] + query + fragment // everything minus origin
+    relative: match[5] + query + fragment, // everything minus origin
   };
 }
 
@@ -2414,7 +2745,7 @@ function getBreadcrumbLogLevelFromHttpStatusCode(statusCode) {
   }
 }
 
-const WINDOW$2 = exports$1.GLOBAL_OBJ;
+const WINDOW$2 = exports$1.GLOBAL_OBJ ;
 
 /**
  * Tells whether current environment supports History API
@@ -2425,10 +2756,12 @@ const WINDOW$2 = exports$1.GLOBAL_OBJ;
 function supportsHistory() {
   return 'history' in WINDOW$2 && !!WINDOW$2.history;
 }
+
 function _isFetchSupported() {
   if (!('fetch' in WINDOW$2)) {
     return false;
   }
+
   try {
     new Headers();
     new Request('http://www.example.com');
@@ -2457,6 +2790,7 @@ function supportsNativeFetch() {
   if (typeof EdgeRuntime === 'string') {
     return true;
   }
+
   if (!_isFetchSupported()) {
     return false;
   }
@@ -2472,7 +2806,7 @@ function supportsNativeFetch() {
   let result = false;
   const doc = WINDOW$2.document;
   // eslint-disable-next-line deprecation/deprecation
-  if (doc && typeof doc.createElement === 'function') {
+  if (doc && typeof (doc.createElement ) === 'function') {
     try {
       const sandbox = doc.createElement('iframe');
       sandbox.hidden = true;
@@ -2483,9 +2817,11 @@ function supportsNativeFetch() {
       }
       doc.head.removeChild(sandbox);
     } catch (err) {
-      exports$1.DEBUG_BUILD && exports$1.logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
+      exports$1.DEBUG_BUILD &&
+        exports$1.logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
     }
   }
+
   return result;
 }
 
@@ -2497,15 +2833,20 @@ function supportsNativeFetch() {
  * Use at your own risk, this might break without changelog notice, only used internally.
  * @hidden
  */
-function addFetchInstrumentationHandler(handler, skipNativeFetchCheck) {
+function addFetchInstrumentationHandler(
+  handler,
+  skipNativeFetchCheck,
+) {
   const type = 'fetch';
   addHandler(type, handler);
   maybeInstrument(type, () => instrumentFetch(undefined, skipNativeFetchCheck));
 }
+
 function instrumentFetch(onFetchResolved, skipNativeFetchCheck = false) {
   if (skipNativeFetchCheck && !supportsNativeFetch()) {
     return;
   }
+
   exports$1.fill(exports$1.GLOBAL_OBJ, 'fetch', function (originalFetch) {
     return function (...args) {
       // We capture the error right here and not in the Promise error callback because Safari (and probably other
@@ -2516,92 +2857,106 @@ function instrumentFetch(onFetchResolved, skipNativeFetchCheck = false) {
       //       have a stack trace, so the SDK backfilled the stack trace so
       //       you can see which fetch call failed.
       const virtualError = new Error();
-      const {
-        method,
-        url
-      } = parseFetchArgs(args);
+
+      const { method, url } = parseFetchArgs(args);
       const handlerData = {
         args,
         fetchData: {
           method,
-          url
+          url,
         },
         startTimestamp: exports$1.timestampInSeconds() * 1000,
         // // Adding the error to be able to fingerprint the failed fetch event in HttpClient instrumentation
         virtualError,
-        headers: getHeadersFromFetchArgs(args)
+        headers: getHeadersFromFetchArgs(args),
       };
 
       // if there is no callback, fetch is instrumented directly
       {
         triggerHandlers('fetch', {
-          ...handlerData
+          ...handlerData,
         });
       }
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      return originalFetch.apply(exports$1.GLOBAL_OBJ, args).then(async response => {
-        {
+      return originalFetch.apply(exports$1.GLOBAL_OBJ, args).then(
+        async (response) => {
+          {
+            triggerHandlers('fetch', {
+              ...handlerData,
+              endTimestamp: exports$1.timestampInSeconds() * 1000,
+              response,
+            });
+          }
+
+          return response;
+        },
+        (error) => {
           triggerHandlers('fetch', {
             ...handlerData,
             endTimestamp: exports$1.timestampInSeconds() * 1000,
-            response
+            error,
           });
-        }
-        return response;
-      }, error => {
-        triggerHandlers('fetch', {
-          ...handlerData,
-          endTimestamp: exports$1.timestampInSeconds() * 1000,
-          error
-        });
-        if (exports$1.isError(error) && error.stack === undefined) {
-          // NOTE: If you are a Sentry user, and you are seeing this stack frame,
-          //       it means the error, that was caused by your fetch call did not
-          //       have a stack trace, so the SDK backfilled the stack trace so
-          //       you can see which fetch call failed.
-          error.stack = virtualError.stack;
-          exports$1.addNonEnumerableProperty(error, 'framesToPop', 1);
-        }
 
-        // We enhance the not-so-helpful "Failed to fetch" error messages with the host
-        // Possible messages we handle here:
-        // * "Failed to fetch" (chromium)
-        // * "Load failed" (webkit)
-        // * "NetworkError when attempting to fetch resource." (firefox)
-        if (error instanceof TypeError && (error.message === 'Failed to fetch' || error.message === 'Load failed' || error.message === 'NetworkError when attempting to fetch resource.')) {
-          try {
-            const url = new URL(handlerData.fetchData.url);
-            error.message = `${error.message} (${url.host})`;
-          } catch {
-            // ignore it if errors happen here
+          if (exports$1.isError(error) && error.stack === undefined) {
+            // NOTE: If you are a Sentry user, and you are seeing this stack frame,
+            //       it means the error, that was caused by your fetch call did not
+            //       have a stack trace, so the SDK backfilled the stack trace so
+            //       you can see which fetch call failed.
+            error.stack = virtualError.stack;
+            exports$1.addNonEnumerableProperty(error, 'framesToPop', 1);
           }
-        }
 
-        // NOTE: If you are a Sentry user, and you are seeing this stack frame,
-        //       it means the sentry.javascript SDK caught an error invoking your application code.
-        //       This is expected behavior and NOT indicative of a bug with sentry.javascript.
-        throw error;
-      });
+          // We enhance the not-so-helpful "Failed to fetch" error messages with the host
+          // Possible messages we handle here:
+          // * "Failed to fetch" (chromium)
+          // * "Load failed" (webkit)
+          // * "NetworkError when attempting to fetch resource." (firefox)
+          if (
+            error instanceof TypeError &&
+            (error.message === 'Failed to fetch' ||
+              error.message === 'Load failed' ||
+              error.message === 'NetworkError when attempting to fetch resource.')
+          ) {
+            try {
+              const url = new URL(handlerData.fetchData.url);
+              error.message = `${error.message} (${url.host})`;
+            } catch {
+              // ignore it if errors happen here
+            }
+          }
+
+          // NOTE: If you are a Sentry user, and you are seeing this stack frame,
+          //       it means the sentry.javascript SDK caught an error invoking your application code.
+          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.
+          throw error;
+        },
+      );
     };
   });
 }
+
 function hasProp(obj, prop) {
-  return !!obj && typeof obj === 'object' && !!obj[prop];
+  return !!obj && typeof obj === 'object' && !!(obj )[prop];
 }
+
 function getUrlFromResource(resource) {
   if (typeof resource === 'string') {
     return resource;
   }
+
   if (!resource) {
     return '';
   }
+
   if (hasProp(resource, 'url')) {
     return resource.url;
   }
+
   if (resource.toString) {
     return resource.toString();
   }
+
   return '';
 }
 
@@ -2611,36 +2966,45 @@ function getUrlFromResource(resource) {
  */
 function parseFetchArgs(fetchArgs) {
   if (fetchArgs.length === 0) {
-    return {
-      method: 'GET',
-      url: ''
-    };
+    return { method: 'GET', url: '' };
   }
+
   if (fetchArgs.length === 2) {
-    const [url, options] = fetchArgs;
+    const [url, options] = fetchArgs ;
+
     return {
       url: getUrlFromResource(url),
-      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET'
+      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',
     };
   }
+
   const arg = fetchArgs[0];
   return {
-    url: getUrlFromResource(arg),
-    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET'
+    url: getUrlFromResource(arg ),
+    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',
   };
 }
+
 function getHeadersFromFetchArgs(fetchArgs) {
   const [requestArgument, optionsArgument] = fetchArgs;
+
   try {
-    if (typeof optionsArgument === 'object' && optionsArgument !== null && 'headers' in optionsArgument && optionsArgument.headers) {
-      return new Headers(optionsArgument.headers);
+    if (
+      typeof optionsArgument === 'object' &&
+      optionsArgument !== null &&
+      'headers' in optionsArgument &&
+      optionsArgument.headers
+    ) {
+      return new Headers(optionsArgument.headers );
     }
+
     if (exports$1.isRequest(requestArgument)) {
       return new Headers(requestArgument.headers);
     }
   } catch {
     // noop
   }
+
   return;
 }
 
@@ -2665,11 +3029,11 @@ function getHeadersFromFetchArgs(fetchArgs) {
  */
 function getSDKSource() {
   // This comment is used to identify this line in the CDN bundle build step and replace this with "return 'cdn';"
-  /* __SENTRY_SDK_SOURCE__ */
-  return 'npm';
+  /* __SENTRY_SDK_SOURCE__ */ return 'npm';
 }
 
-const WINDOW$1 = exports$1.GLOBAL_OBJ;
+const WINDOW$1 = exports$1.GLOBAL_OBJ ;
+
 let ignoreOnError = 0;
 
 /**
@@ -2701,7 +3065,12 @@ function ignoreNextOnError() {
  * @returns The wrapped function.
  * @hidden
  */
-function wrap(fn, options = {}) {
+function wrap(
+  fn,
+  options
+
+ = {},
+) {
   // for future readers what this does is wrap a function and then create
   // a bi-directional wrapping between them.
   //
@@ -2712,13 +3081,15 @@ function wrap(fn, options = {}) {
   function isFunction(fn) {
     return typeof fn === 'function';
   }
+
   if (!isFunction(fn)) {
     return fn;
   }
+
   try {
     // if we're dealing with a function that was previously wrapped, return
     // the original wrapper.
-    const wrapper = fn.__sentry_wrapped__;
+    const wrapper = (fn ).__sentry_wrapped__;
     if (wrapper) {
       if (typeof wrapper === 'function') {
         return wrapper;
@@ -2742,7 +3113,7 @@ function wrap(fn, options = {}) {
 
   // Wrap the function itself
   // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`
-  const sentryWrapped = function (...args) {
+  const sentryWrapped = function ( ...args) {
     try {
       // Also wrap arguments that are themselves functions
       const wrappedArguments = args.map(arg => wrap(arg, options));
@@ -2754,29 +3125,34 @@ function wrap(fn, options = {}) {
       return fn.apply(this, wrappedArguments);
     } catch (ex) {
       ignoreNextOnError();
+
       exports$1.withScope(scope => {
         scope.addEventProcessor(event => {
           if (options.mechanism) {
             exports$1.addExceptionTypeValue(event, undefined);
             exports$1.addExceptionMechanism(event, options.mechanism);
           }
+
           event.extra = {
             ...event.extra,
-            arguments: args
+            arguments: args,
           };
+
           return event;
         });
+
         exports$1.captureException(ex);
       });
+
       throw ex;
     }
-  };
+  } ;
 
   // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available
   try {
     for (const property in fn) {
       if (Object.prototype.hasOwnProperty.call(fn, property)) {
-        sentryWrapped[property] = fn[property];
+        sentryWrapped[property ] = fn[property ];
       }
     }
   } catch {
@@ -2787,6 +3163,7 @@ function wrap(fn, options = {}) {
   // Signal that this function has been wrapped/filled already
   // for both debugging and to prevent it to being wrapped/filled twice
   exports$1.markFunctionWrapped(sentryWrapped, fn);
+
   exports$1.addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);
 
   // Restore original function name (not all browsers allow that)
@@ -2797,13 +3174,14 @@ function wrap(fn, options = {}) {
       Object.defineProperty(sentryWrapped, 'name', {
         get() {
           return fn.name;
-        }
+        },
       });
     }
   } catch {
     // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.
     // to save some bytes we simply try-catch this
   }
+
   return sentryWrapped;
 }
 
@@ -2813,24 +3191,18 @@ function wrap(fn, options = {}) {
 function getHttpRequestData() {
   // grab as much info as exists and add it to the event
   const url = exports$1.getLocationHref();
-  const {
-    referrer
-  } = WINDOW$1.document || {};
-  const {
-    userAgent
-  } = WINDOW$1.navigator || {};
+  const { referrer } = WINDOW$1.document || {};
+  const { userAgent } = WINDOW$1.navigator || {};
+
   const headers = {
-    ...(referrer && {
-      Referer: referrer
-    }),
-    ...(userAgent && {
-      'User-Agent': userAgent
-    })
+    ...(referrer && { Referer: referrer }),
+    ...(userAgent && { 'User-Agent': userAgent }),
   };
   const request = {
     url,
-    headers
+    headers,
   };
+
   return request;
 }
 
@@ -2840,81 +3212,99 @@ function getHttpRequestData() {
 function exceptionFromError(stackParser, ex) {
   // Get the frames first since Opera can lose the stack if we touch anything else first
   const frames = parseStackFrames(stackParser, ex);
+
   const exception = {
     type: extractType(ex),
-    value: extractMessage(ex)
+    value: extractMessage(ex),
   };
+
   if (frames.length) {
-    exception.stacktrace = {
-      frames
-    };
+    exception.stacktrace = { frames };
   }
+
   if (exception.type === undefined && exception.value === '') {
     exception.value = 'Unrecoverable error caught';
   }
+
   return exception;
 }
-function eventFromPlainObject(stackParser, exception, syntheticException, isUnhandledRejection) {
+
+function eventFromPlainObject(
+  stackParser,
+  exception,
+  syntheticException,
+  isUnhandledRejection,
+) {
   const client = exports$1.getClient();
   const normalizeDepth = client?.getOptions().normalizeDepth;
 
   // If we can, we extract an exception from the object properties
   const errorFromProp = getErrorPropertyFromObject(exception);
+
   const extra = {
-    __serialized__: exports$1.normalizeToSize(exception, normalizeDepth)
+    __serialized__: exports$1.normalizeToSize(exception, normalizeDepth),
   };
+
   if (errorFromProp) {
     return {
       exception: {
-        values: [exceptionFromError(stackParser, errorFromProp)]
+        values: [exceptionFromError(stackParser, errorFromProp)],
       },
-      extra
+      extra,
     };
   }
+
   const event = {
     exception: {
-      values: [{
-        type: exports$1.isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
-        value: getNonErrorObjectExceptionValue(exception, {
-          isUnhandledRejection
-        })
-      }]
+      values: [
+        {
+          type: exports$1.isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',
+          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),
+        } ,
+      ],
     },
-    extra
-  };
+    extra,
+  } ;
+
   if (syntheticException) {
     const frames = parseStackFrames(stackParser, syntheticException);
     if (frames.length) {
       // event.exception.values[0] has been set above
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      event.exception.values[0].stacktrace = {
-        frames
-      };
+      event.exception.values[0].stacktrace = { frames };
     }
   }
+
   return event;
 }
+
 function eventFromError(stackParser, ex) {
   return {
     exception: {
-      values: [exceptionFromError(stackParser, ex)]
-    }
+      values: [exceptionFromError(stackParser, ex)],
+    },
   };
 }
 
 /** Parses stack frames from an error */
-function parseStackFrames(stackParser, ex) {
+function parseStackFrames(
+  stackParser,
+  ex,
+) {
   // Access and store the stacktrace property before doing ANYTHING
   // else to it because Opera is not very good at providing it
   // reliably in other circumstances.
   const stacktrace = ex.stacktrace || ex.stack || '';
+
   const skipLines = getSkipFirstStackStringLines(ex);
   const framesToPop = getPopFirstTopFrames(ex);
+
   try {
     return stackParser(stacktrace, skipLines, framesToPop);
   } catch (e) {
     // no-empty
   }
+
   return [];
 }
 
@@ -2930,6 +3320,7 @@ function getSkipFirstStackStringLines(ex) {
   if (ex && reactMinifiedRegexp.test(ex.message)) {
     return 1;
   }
+
   return 0;
 }
 
@@ -2945,6 +3336,7 @@ function getPopFirstTopFrames(ex) {
   if (typeof ex.framesToPop === 'number') {
     return ex.framesToPop;
   }
+
   return 0;
 }
 
@@ -2976,6 +3368,7 @@ function extractType(ex) {
     const hasTypeInMessage = ex.message && Array.isArray(ex.message) && ex.message.length == 2;
     return hasTypeInMessage ? ex.message[0] : 'WebAssembly.Exception';
   }
+
   return name;
 }
 
@@ -2986,6 +3379,7 @@ function extractType(ex) {
  */
 function extractMessage(ex) {
   const message = ex?.message;
+
   if (isWebAssemblyException(ex)) {
     // For Node 18, Emscripten sets array[type, message] to the "message" property on the WebAssembly.Exception object
     if (Array.isArray(ex.message) && ex.message.length == 2) {
@@ -2993,12 +3387,15 @@ function extractMessage(ex) {
     }
     return 'wasm exception';
   }
+
   if (!message) {
     return 'No error message';
   }
+
   if (message.error && typeof message.error.message === 'string') {
     return message.error.message;
   }
+
   return message;
 }
 
@@ -3006,7 +3403,12 @@ function extractMessage(ex) {
  * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
  * @hidden
  */
-function eventFromException(stackParser, exception, hint, attachStacktrace) {
+function eventFromException(
+  stackParser,
+  exception,
+  hint,
+  attachStacktrace,
+) {
   const syntheticException = hint?.syntheticException || undefined;
   const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);
   exports$1.addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
@@ -3021,7 +3423,13 @@ function eventFromException(stackParser, exception, hint, attachStacktrace) {
  * Builds and Event from a Message
  * @hidden
  */
-function eventFromMessage(stackParser, message, level = 'info', hint, attachStacktrace) {
+function eventFromMessage(
+  stackParser,
+  message,
+  level = 'info',
+  hint,
+  attachStacktrace,
+) {
   const syntheticException = hint?.syntheticException || undefined;
   const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);
   event.level = level;
@@ -3034,12 +3442,19 @@ function eventFromMessage(stackParser, message, level = 'info', hint, attachStac
 /**
  * @hidden
  */
-function eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace, isUnhandledRejection) {
+function eventFromUnknownInput(
+  stackParser,
+  exception,
+  syntheticException,
+  attachStacktrace,
+  isUnhandledRejection,
+) {
   let event;
-  if (exports$1.isErrorEvent(exception) && exception.error) {
+
+  if (exports$1.isErrorEvent(exception ) && (exception ).error) {
     // If it is an ErrorEvent with `error` property, extract it to get actual Error
-    const errorEvent = exception;
-    return eventFromError(stackParser, errorEvent.error);
+    const errorEvent = exception ;
+    return eventFromError(stackParser, errorEvent.error );
   }
 
   // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name
@@ -3049,10 +3464,11 @@ function eventFromUnknownInput(stackParser, exception, syntheticException, attac
   // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
   // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
   // https://webidl.spec.whatwg.org/#es-DOMException-specialness
-  if (exports$1.isDOMError(exception) || exports$1.isDOMException(exception)) {
-    const domException = exception;
-    if ('stack' in exception) {
-      event = eventFromError(stackParser, exception);
+  if (exports$1.isDOMError(exception) || exports$1.isDOMException(exception )) {
+    const domException = exception ;
+
+    if ('stack' in (exception )) {
+      event = eventFromError(stackParser, exception );
     } else {
       const name = domException.name || (exports$1.isDOMError(domException) ? 'DOMError' : 'DOMException');
       const message = domException.message ? `${name}: ${domException.message}` : name;
@@ -3061,11 +3477,9 @@ function eventFromUnknownInput(stackParser, exception, syntheticException, attac
     }
     if ('code' in domException) {
       // eslint-disable-next-line deprecation/deprecation
-      event.tags = {
-        ...event.tags,
-        'DOMException.code': `${domException.code}`
-      };
+      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };
     }
+
     return event;
   }
   if (exports$1.isError(exception)) {
@@ -3076,10 +3490,10 @@ function eventFromUnknownInput(stackParser, exception, syntheticException, attac
     // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize
     // it manually. This will allow us to group events based on top-level keys which is much better than creating a new
     // group on any key/value change.
-    const objectException = exception;
+    const objectException = exception ;
     event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);
     exports$1.addExceptionMechanism(event, {
-      synthetic: true
+      synthetic: true,
     });
     return event;
   }
@@ -3093,48 +3507,51 @@ function eventFromUnknownInput(stackParser, exception, syntheticException, attac
   // - a plain Object
   //
   // So bail out and capture it as a simple message:
-  event = eventFromString(stackParser, exception, syntheticException, attachStacktrace);
+  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);
   exports$1.addExceptionTypeValue(event, `${exception}`);
   exports$1.addExceptionMechanism(event, {
-    synthetic: true
+    synthetic: true,
   });
+
   return event;
 }
-function eventFromString(stackParser, message, syntheticException, attachStacktrace) {
+
+function eventFromString(
+  stackParser,
+  message,
+  syntheticException,
+  attachStacktrace,
+) {
   const event = {};
+
   if (attachStacktrace && syntheticException) {
     const frames = parseStackFrames(stackParser, syntheticException);
     if (frames.length) {
       event.exception = {
-        values: [{
-          value: message,
-          stacktrace: {
-            frames
-          }
-        }]
+        values: [{ value: message, stacktrace: { frames } }],
       };
     }
-    exports$1.addExceptionMechanism(event, {
-      synthetic: true
-    });
+    exports$1.addExceptionMechanism(event, { synthetic: true });
   }
+
   if (exports$1.isParameterizedString(message)) {
-    const {
-      __sentry_template_string__,
-      __sentry_template_values__
-    } = message;
+    const { __sentry_template_string__, __sentry_template_values__ } = message;
+
     event.logentry = {
       message: __sentry_template_string__,
-      params: __sentry_template_values__
+      params: __sentry_template_values__,
     };
     return event;
   }
+
   event.message = message;
   return event;
 }
-function getNonErrorObjectExceptionValue(exception, {
-  isUnhandledRejection
-}) {
+
+function getNonErrorObjectExceptionValue(
+  exception,
+  { isUnhandledRejection },
+) {
   const keys = exports$1.extractExceptionKeysForMessage(exception);
   const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';
 
@@ -3143,12 +3560,15 @@ function getNonErrorObjectExceptionValue(exception, {
   if (exports$1.isErrorEvent(exception)) {
     return `Event \`ErrorEvent\` captured as ${captureType} with message \`${exception.message}\``;
   }
+
   if (exports$1.isEvent(exception)) {
     const className = getObjectClassName(exception);
     return `Event \`${className}\` (type=${exception.type}) captured as ${captureType}`;
   }
+
   return `Object captured as ${captureType} with keys: ${keys}`;
 }
+
 function getObjectClassName(obj) {
   try {
     const prototype = Object.getPrototypeOf(obj);
@@ -3168,6 +3588,7 @@ function getErrorPropertyFromObject(obj) {
       }
     }
   }
+
   return undefined;
 }
 
@@ -3185,28 +3606,28 @@ const DEFAULT_FLUSH_INTERVAL = 5000;
  * @see SentryClient for usage documentation.
  */
 class BrowserClient extends Client {
+
   /**
    * Creates a new Browser SDK instance.
    *
    * @param options Configuration options for this SDK.
    */
-  constructor(options) {
+   constructor(options) {
     const opts = {
       // We default this to true, as it is the safer scenario
       parentSpanIsAlwaysRootSpan: true,
-      ...options
+      ...options,
     };
     const sdkSource = WINDOW$1.SENTRY_SDK_SOURCE || getSDKSource();
     applySdkMetadata(opts, 'browser', ['browser'], sdkSource);
+
     super(opts);
 
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const client = this;
-    const {
-      sendDefaultPii,
-      _experiments
-    } = client._options;
+    const { sendDefaultPii, _experiments } = client._options;
     const enableLogs = _experiments?.enableLogs;
+
     if (opts.sendClientReports && WINDOW$1.document) {
       WINDOW$1.document.addEventListener('visibilitychange', () => {
         if (WINDOW$1.document.visibilityState === 'hidden') {
@@ -3217,19 +3638,23 @@ class BrowserClient extends Client {
         }
       });
     }
+
     if (enableLogs) {
       client.on('flush', () => {
         _INTERNAL_flushLogsBuffer(client);
       });
+
       client.on('afterCaptureLog', () => {
         if (client._logFlushIdleTimeout) {
           clearTimeout(client._logFlushIdleTimeout);
         }
+
         client._logFlushIdleTimeout = setTimeout(() => {
           _INTERNAL_flushLogsBuffer(client);
         }, DEFAULT_FLUSH_INTERVAL);
       });
     }
+
     if (sendDefaultPii) {
       client.on('postprocessEvent', addAutoIpAddressToUser);
       client.on('beforeSendSession', addAutoIpAddressToSession);
@@ -3239,22 +3664,32 @@ class BrowserClient extends Client {
   /**
    * @inheritDoc
    */
-  eventFromException(exception, hint) {
+   eventFromException(exception, hint) {
     return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);
   }
 
   /**
    * @inheritDoc
    */
-  eventFromMessage(message, level = 'info', hint) {
+   eventFromMessage(
+    message,
+    level = 'info',
+    hint,
+  ) {
     return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);
   }
 
   /**
    * @inheritDoc
    */
-  _prepareEvent(event, hint, currentScope, isolationScope) {
+   _prepareEvent(
+    event,
+    hint,
+    currentScope,
+    isolationScope,
+  ) {
     event.platform = event.platform || 'javascript';
+
     return super._prepareEvent(event, hint, currentScope, isolationScope);
   }
 }
@@ -3264,11 +3699,14 @@ class BrowserClient extends Client {
  *
  * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
  */
-const DEBUG_BUILD$1 = typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__;
+const DEBUG_BUILD$1 = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
+
+const WINDOW = exports$1.GLOBAL_OBJ
 
-const WINDOW = exports$1.GLOBAL_OBJ;
+;
 
 const DEBOUNCE_DURATION = 1000;
+
 let debounceTimerID;
 let lastCapturedEventType;
 let lastCapturedEventTargetId;
@@ -3304,64 +3742,74 @@ function instrumentDOM() {
   // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler
   // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still
   // guaranteed to fire at least once.)
-  ['EventTarget', 'Node'].forEach(target => {
-    const globalObject = WINDOW;
+  ['EventTarget', 'Node'].forEach((target) => {
+    const globalObject = WINDOW ;
     const proto = globalObject[target]?.prototype;
 
     // eslint-disable-next-line no-prototype-builtins
     if (!proto?.hasOwnProperty?.('addEventListener')) {
       return;
     }
+
     exports$1.fill(proto, 'addEventListener', function (originalAddEventListener) {
-      return function (type, listener, options) {
+      return function ( type, listener, options) {
         if (type === 'click' || type == 'keypress') {
           try {
-            const handlers = this.__sentry_instrumentation_handlers__ = this.__sentry_instrumentation_handlers__ || {};
-            const handlerForType = handlers[type] = handlers[type] || {
-              refCount: 0
-            };
+            const handlers = (this.__sentry_instrumentation_handlers__ =
+              this.__sentry_instrumentation_handlers__ || {});
+            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });
+
             if (!handlerForType.handler) {
               const handler = makeDOMEventHandler(triggerDOMHandler);
               handlerForType.handler = handler;
               originalAddEventListener.call(this, type, handler, options);
             }
+
             handlerForType.refCount++;
           } catch (e) {
             // Accessing dom properties is always fragile.
             // Also allows us to skip `addEventListeners` calls with no proper `this` context.
           }
         }
+
         return originalAddEventListener.call(this, type, listener, options);
       };
     });
-    exports$1.fill(proto, 'removeEventListener', function (originalRemoveEventListener) {
-      return function (type, listener, options) {
-        if (type === 'click' || type == 'keypress') {
-          try {
-            const handlers = this.__sentry_instrumentation_handlers__ || {};
-            const handlerForType = handlers[type];
-            if (handlerForType) {
-              handlerForType.refCount--;
-              // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.
-              if (handlerForType.refCount <= 0) {
-                originalRemoveEventListener.call(this, type, handlerForType.handler, options);
-                handlerForType.handler = undefined;
-                delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
-              }
 
-              // If there are no longer any custom handlers of any type on this element, cleanup everything.
-              if (Object.keys(handlers).length === 0) {
-                delete this.__sentry_instrumentation_handlers__;
+    exports$1.fill(
+      proto,
+      'removeEventListener',
+      function (originalRemoveEventListener) {
+        return function ( type, listener, options) {
+          if (type === 'click' || type == 'keypress') {
+            try {
+              const handlers = this.__sentry_instrumentation_handlers__ || {};
+              const handlerForType = handlers[type];
+
+              if (handlerForType) {
+                handlerForType.refCount--;
+                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.
+                if (handlerForType.refCount <= 0) {
+                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);
+                  handlerForType.handler = undefined;
+                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete
+                }
+
+                // If there are no longer any custom handlers of any type on this element, cleanup everything.
+                if (Object.keys(handlers).length === 0) {
+                  delete this.__sentry_instrumentation_handlers__;
+                }
               }
+            } catch (e) {
+              // Accessing dom properties is always fragile.
+              // Also allows us to skip `addEventListeners` calls with no proper `this` context.
             }
-          } catch (e) {
-            // Accessing dom properties is always fragile.
-            // Also allows us to skip `addEventListeners` calls with no proper `this` context.
           }
-        }
-        return originalRemoveEventListener.call(this, type, listener, options);
-      };
-    });
+
+          return originalRemoveEventListener.call(this, type, listener, options);
+        };
+      },
+    );
   });
 }
 
@@ -3373,10 +3821,11 @@ function isSimilarToLastCapturedEvent(event) {
   if (event.type !== lastCapturedEventType) {
     return false;
   }
+
   try {
     // If both events have the same type, it's still possible that actions were performed on different targets.
     // e.g. 2 clicks on different buttons.
-    if (!event.target || event.target._sentryId !== lastCapturedEventTargetId) {
+    if (!event.target || (event.target )._sentryId !== lastCapturedEventTargetId) {
       return false;
     }
   } catch (e) {
@@ -3399,6 +3848,7 @@ function shouldSkipDOMEvent(eventType, target) {
   if (eventType !== 'keypress') {
     return false;
   }
+
   if (!target?.tagName) {
     return true;
   }
@@ -3408,20 +3858,25 @@ function shouldSkipDOMEvent(eventType, target) {
   if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
     return false;
   }
+
   return true;
 }
 
 /**
  * Wraps addEventListener to capture UI breadcrumbs
  */
-function makeDOMEventHandler(handler, globalListener = false) {
-  return event => {
+function makeDOMEventHandler(
+  handler,
+  globalListener = false,
+) {
+  return (event) => {
     // It's possible this handler might trigger multiple times for the same
     // event (e.g. event propagation through node ancestors).
     // Ignore if we've already captured that event.
     if (!event || event['_sentryCaptured']) {
       return;
     }
+
     const target = getEventTarget(event);
 
     // We always want to skip _some_ events.
@@ -3431,21 +3886,19 @@ function makeDOMEventHandler(handler, globalListener = false) {
 
     // Mark event as "seen"
     exports$1.addNonEnumerableProperty(event, '_sentryCaptured', true);
+
     if (target && !target._sentryId) {
       // Add UUID to event target so we can identify if
       exports$1.addNonEnumerableProperty(target, '_sentryId', exports$1.uuid4());
     }
+
     const name = event.type === 'keypress' ? 'input' : event.type;
 
     // If there is no last captured event, it means that we can safely capture the new event and store it for future comparisons.
     // If there is a last captured event, see if the new event is different enough to treat it as a unique one.
     // If that's the case, emit the previous event and store locally the newly-captured DOM event.
     if (!isSimilarToLastCapturedEvent(event)) {
-      const handlerData = {
-        event,
-        name,
-        global: globalListener
-      };
+      const handlerData = { event, name, global: globalListener };
       handler(handlerData);
       lastCapturedEventType = event.type;
       lastCapturedEventTargetId = target ? target._sentryId : undefined;
@@ -3459,9 +3912,10 @@ function makeDOMEventHandler(handler, globalListener = false) {
     }, DEBOUNCE_DURATION);
   };
 }
+
 function getEventTarget(event) {
   try {
-    return event.target;
+    return event.target ;
   } catch (e) {
     // just accessing `target` property can throw an exception in some rare circumstances
     // see: https://github.com/getsentry/sentry-javascript/issues/838
@@ -3496,13 +3950,12 @@ function instrumentHistory() {
     // keep track of the current URL state, as we always receive only the updated state
     const from = lastHref;
     lastHref = to;
+
     if (from === to) {
       return;
     }
-    const handlerData = {
-      from,
-      to
-    };
+
+    const handlerData = { from, to } ;
     triggerHandlers('history', handlerData);
   });
 
@@ -3510,8 +3963,9 @@ function instrumentHistory() {
   if (!supportsHistory()) {
     return;
   }
+
   function historyReplacementFunction(originalHistoryFunction) {
-    return function (...args) {
+    return function ( ...args) {
       const url = args.length > 2 ? args[2] : undefined;
       if (url) {
         const from = lastHref;
@@ -3525,21 +3979,22 @@ function instrumentHistory() {
 
         // keep track of the current URL state, as we always receive only the updated state
         lastHref = to;
+
         if (from === to) {
           return originalHistoryFunction.apply(this, args);
         }
-        const handlerData = {
-          from,
-          to
-        };
+
+        const handlerData = { from, to } ;
         triggerHandlers('history', handlerData);
       }
       return originalHistoryFunction.apply(this, args);
     };
   }
+
   exports$1.fill(WINDOW.history, 'pushState', historyReplacementFunction);
   exports$1.fill(WINDOW.history, 'replaceState', historyReplacementFunction);
 }
+
 function getAbsoluteUrl(urlOrPath) {
   try {
     const url = new URL(urlOrPath, WINDOW.location.origin);
@@ -3567,17 +4022,21 @@ const cachedImplementations = {};
  * - `setTimeout`: This can be wrapped by e.g. Angular, causing change detection to be triggered.
  * - `fetch`: This can be wrapped by e.g. ad-blockers, causing an infinite loop when a request is blocked.
  */
-function getNativeImplementation(name) {
+function getNativeImplementation(
+  name,
+) {
   const cached = cachedImplementations[name];
   if (cached) {
     return cached;
   }
-  let impl = WINDOW[name];
+
+  let impl = WINDOW[name] ;
 
   // Fast path to avoid DOM I/O
   if (isNativeFunction(impl)) {
-    return cachedImplementations[name] = impl.bind(WINDOW);
+    return (cachedImplementations[name] = impl.bind(WINDOW) );
   }
+
   const document = WINDOW.document;
   // eslint-disable-next-line deprecation/deprecation
   if (document && typeof document.createElement === 'function') {
@@ -3587,7 +4046,7 @@ function getNativeImplementation(name) {
       document.head.appendChild(sandbox);
       const contentWindow = sandbox.contentWindow;
       if (contentWindow?.[name]) {
-        impl = contentWindow[name];
+        impl = contentWindow[name] ;
       }
       document.head.removeChild(sandbox);
     } catch (e) {
@@ -3601,7 +4060,8 @@ function getNativeImplementation(name) {
   if (!impl) {
     return impl;
   }
-  return cachedImplementations[name] = impl.bind(WINDOW);
+
+  return (cachedImplementations[name] = impl.bind(WINDOW) );
 }
 
 /** Clear a cached implementation. */
@@ -3627,45 +4087,58 @@ function addXhrInstrumentationHandler(handler) {
 
 /** Exported only for tests. */
 function instrumentXHR() {
-  if (!WINDOW.XMLHttpRequest) {
+  if (!(WINDOW ).XMLHttpRequest) {
     return;
   }
+
   const xhrproto = XMLHttpRequest.prototype;
 
   // eslint-disable-next-line @typescript-eslint/unbound-method
   xhrproto.open = new Proxy(xhrproto.open, {
-    apply(originalOpen, xhrOpenThisArg, xhrOpenArgArray) {
+    apply(
+      originalOpen,
+      xhrOpenThisArg,
+      xhrOpenArgArray
+
+,
+    ) {
       // NOTE: If you are a Sentry user, and you are seeing this stack frame,
       //       it means the error, that was caused by your XHR call did not
       //       have a stack trace. If you are using HttpClient integration,
       //       this is the expected behavior, as we are using this virtual error to capture
       //       the location of your XHR call, and group your HttpClient events accordingly.
       const virtualError = new Error();
+
       const startTimestamp = exports$1.timestampInSeconds() * 1000;
 
       // open() should always be called with two or more arguments
       // But to be on the safe side, we actually validate this and bail out if we don't have a method & url
       const method = exports$1.isString(xhrOpenArgArray[0]) ? xhrOpenArgArray[0].toUpperCase() : undefined;
       const url = parseXhrUrlArg(xhrOpenArgArray[1]);
+
       if (!method || !url) {
         return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);
       }
+
       xhrOpenThisArg[SENTRY_XHR_DATA_KEY] = {
         method,
         url,
-        request_headers: {}
+        request_headers: {},
       };
 
       // if Sentry key appears in URL, don't capture it as a request
       if (method === 'POST' && url.match(/sentry_key/)) {
         xhrOpenThisArg.__sentry_own_request__ = true;
       }
+
       const onreadystatechangeHandler = () => {
         // For whatever reason, this is not the same instance here as from the outer method
         const xhrInfo = xhrOpenThisArg[SENTRY_XHR_DATA_KEY];
+
         if (!xhrInfo) {
           return;
         }
+
         if (xhrOpenThisArg.readyState === 4) {
           try {
             // touching statusCode in some platforms throws
@@ -3674,21 +4147,23 @@ function instrumentXHR() {
           } catch (e) {
             /* do nothing */
           }
+
           const handlerData = {
             endTimestamp: exports$1.timestampInSeconds() * 1000,
             startTimestamp,
             xhr: xhrOpenThisArg,
-            virtualError
+            virtualError,
           };
           triggerHandlers('xhr', handlerData);
         }
       };
+
       if ('onreadystatechange' in xhrOpenThisArg && typeof xhrOpenThisArg.onreadystatechange === 'function') {
         xhrOpenThisArg.onreadystatechange = new Proxy(xhrOpenThisArg.onreadystatechange, {
           apply(originalOnreadystatechange, onreadystatechangeThisArg, onreadystatechangeArgArray) {
             onreadystatechangeHandler();
             return originalOnreadystatechange.apply(onreadystatechangeThisArg, onreadystatechangeArgArray);
-          }
+          },
         });
       } else {
         xhrOpenThisArg.addEventListener('readystatechange', onreadystatechangeHandler);
@@ -3698,36 +4173,48 @@ function instrumentXHR() {
       // This will only work for user/library defined headers, not for the default/browser-assigned headers.
       // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.
       xhrOpenThisArg.setRequestHeader = new Proxy(xhrOpenThisArg.setRequestHeader, {
-        apply(originalSetRequestHeader, setRequestHeaderThisArg, setRequestHeaderArgArray) {
+        apply(
+          originalSetRequestHeader,
+          setRequestHeaderThisArg,
+          setRequestHeaderArgArray,
+        ) {
           const [header, value] = setRequestHeaderArgArray;
+
           const xhrInfo = setRequestHeaderThisArg[SENTRY_XHR_DATA_KEY];
+
           if (xhrInfo && exports$1.isString(header) && exports$1.isString(value)) {
             xhrInfo.request_headers[header.toLowerCase()] = value;
           }
+
           return originalSetRequestHeader.apply(setRequestHeaderThisArg, setRequestHeaderArgArray);
-        }
+        },
       });
+
       return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);
-    }
+    },
   });
 
   // eslint-disable-next-line @typescript-eslint/unbound-method
   xhrproto.send = new Proxy(xhrproto.send, {
     apply(originalSend, sendThisArg, sendArgArray) {
       const sentryXhrData = sendThisArg[SENTRY_XHR_DATA_KEY];
+
       if (!sentryXhrData) {
         return originalSend.apply(sendThisArg, sendArgArray);
       }
+
       if (sendArgArray[0] !== undefined) {
         sentryXhrData.body = sendArgArray[0];
       }
+
       const handlerData = {
         startTimestamp: exports$1.timestampInSeconds() * 1000,
-        xhr: sendThisArg
+        xhr: sendThisArg,
       };
       triggerHandlers('xhr', handlerData);
+
       return originalSend.apply(sendThisArg, sendArgArray);
-    }
+    },
   });
 }
 
@@ -3744,10 +4231,11 @@ function parseXhrUrlArg(url) {
   if (exports$1.isString(url)) {
     return url;
   }
+
   try {
     // If the passed in argument is not a string, it should have a `toString` method as a stringifier.
     // If that fails, we just return undefined (like in IE11 where URL is not available)
-    return url.toString();
+    return (url ).toString();
   } catch {} // eslint-disable-line no-empty
 
   return undefined;
@@ -3756,13 +4244,18 @@ function parseXhrUrlArg(url) {
 /**
  * Creates a Transport that uses the Fetch API to send events to Sentry.
  */
-function makeFetchTransport(options, nativeFetch = getNativeImplementation('fetch')) {
+function makeFetchTransport(
+  options,
+  nativeFetch = getNativeImplementation('fetch'),
+) {
   let pendingBodySize = 0;
   let pendingCount = 0;
+
   function makeRequest(request) {
     const requestSize = request.body.length;
     pendingBodySize += requestSize;
     pendingCount++;
+
     const requestOptions = {
       body: request.body,
       method: 'POST',
@@ -3780,12 +4273,14 @@ function makeFetchTransport(options, nativeFetch = getNativeImplementation('fetc
       // There is also a limit of requests that can be open at the same time, so we also limit this to 15
       // See https://github.com/getsentry/sentry-javascript/pull/7553 for details
       keepalive: pendingBodySize <= 60000 && pendingCount < 15,
-      ...options.fetchOptions
+      ...options.fetchOptions,
     };
+
     if (!nativeFetch) {
       clearCachedImplementation('fetch');
       return exports$1.rejectedSyncPromise('No fetch implementation available');
     }
+
     try {
       // TODO: This may need a `suppressTracing` call in the future when we switch the browser SDK to OTEL
       return nativeFetch(options.url, requestOptions).then(response => {
@@ -3795,8 +4290,8 @@ function makeFetchTransport(options, nativeFetch = getNativeImplementation('fetc
           statusCode: response.status,
           headers: {
             'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
-            'retry-after': response.headers.get('Retry-After')
-          }
+            'retry-after': response.headers.get('Retry-After'),
+          },
         };
       });
     } catch (e) {
@@ -3806,23 +4301,28 @@ function makeFetchTransport(options, nativeFetch = getNativeImplementation('fetc
       return exports$1.rejectedSyncPromise(e);
     }
   }
+
   return createTransport(options, makeRequest);
 }
 
 const CHROME_PRIORITY = 30;
 const GECKO_PRIORITY = 50;
+
 function createFrame(filename, func, lineno, colno) {
   const frame = {
     filename,
     function: func === '<anonymous>' ? exports$1.UNKNOWN_FUNCTION : func,
-    in_app: true // All browser frames are considered in_app
+    in_app: true, // All browser frames are considered in_app
   };
+
   if (lineno !== undefined) {
     frame.lineno = lineno;
   }
+
   if (colno !== undefined) {
     frame.colno = colno;
   }
+
   return frame;
 }
 
@@ -3832,7 +4332,9 @@ function createFrame(filename, func, lineno, colno) {
 const chromeRegexNoFnName = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i;
 
 // This regex matches all the frames that have a function name.
-const chromeRegex = /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+const chromeRegex =
+  /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+
 const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
 
 // Chromium based browsers: Chrome, Brave, new Opera, new Edge
@@ -3840,17 +4342,21 @@ const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
 // See: https://github.com/getsentry/sentry-javascript/issues/6880
 const chromeStackParserFn = line => {
   // If the stack line has no function name, we need to parse it differently
-  const noFnParts = chromeRegexNoFnName.exec(line);
+  const noFnParts = chromeRegexNoFnName.exec(line) ;
+
   if (noFnParts) {
     const [, filename, line, col] = noFnParts;
     return createFrame(filename, exports$1.UNKNOWN_FUNCTION, +line, +col);
   }
-  const parts = chromeRegex.exec(line);
+
+  const parts = chromeRegex.exec(line) ;
+
   if (parts) {
     const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
 
     if (isEval) {
-      const subMatch = chromeEvalRegex.exec(parts[2]);
+      const subMatch = chromeEvalRegex.exec(parts[2]) ;
+
       if (subMatch) {
         // throw out eval line/column and use top-most line/column number
         parts[2] = subMatch[1]; // url
@@ -3862,23 +4368,30 @@ const chromeStackParserFn = line => {
     // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now
     // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)
     const [func, filename] = extractSafariExtensionDetails(parts[1] || exports$1.UNKNOWN_FUNCTION, parts[2]);
+
     return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);
   }
+
   return;
 };
+
 const chromeStackLineParser = [CHROME_PRIORITY, chromeStackParserFn];
 
 // gecko regex: `(?:bundle|\d+\.js)`: `bundle` is for react native, `\d+\.js` also but specifically for ram bundles because it
 // generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js
 // We need this specific case for now because we want no other regex to match.
-const geckoREgex = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+const geckoREgex =
+  /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
 const geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+
 const gecko = line => {
-  const parts = geckoREgex.exec(line);
+  const parts = geckoREgex.exec(line) ;
+
   if (parts) {
     const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
     if (isEval) {
-      const subMatch = geckoEvalRegex.exec(parts[3]);
+      const subMatch = geckoEvalRegex.exec(parts[3]) ;
+
       if (subMatch) {
         // throw out eval line/column and use top-most line number
         parts[1] = parts[1] || 'eval';
@@ -3887,15 +4400,21 @@ const gecko = line => {
         parts[5] = ''; // no column when eval
       }
     }
+
     let filename = parts[3];
     let func = parts[1] || exports$1.UNKNOWN_FUNCTION;
     [func, filename] = extractSafariExtensionDetails(func, filename);
+
     return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);
   }
+
   return;
 };
+
 const geckoStackLineParser = [GECKO_PRIORITY, gecko];
+
 const defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser];
+
 const defaultStackParser = exports$1.createStackParser(...defaultStackLineParsers);
 
 /**
@@ -3921,7 +4440,13 @@ const defaultStackParser = exports$1.createStackParser(...defaultStackLineParser
 const extractSafariExtensionDetails = (func, filename) => {
   const isSafariExtension = func.indexOf('safari-extension') !== -1;
   const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;
-  return isSafariExtension || isSafariWebExtension ? [func.indexOf('@') !== -1 ? func.split('@')[0] : exports$1.UNKNOWN_FUNCTION, isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`] : [func, filename];
+
+  return isSafariExtension || isSafariWebExtension
+    ? [
+        func.indexOf('@') !== -1 ? (func.split('@')[0] ) : exports$1.UNKNOWN_FUNCTION,
+        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,
+      ]
+    : [func, filename];
 };
 
 /**
@@ -3929,12 +4454,14 @@ const extractSafariExtensionDetails = (func, filename) => {
  *
  * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
  */
-const DEBUG_BUILD = typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__;
+const DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);
 
 /** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */
 const MAX_ALLOWED_STRING_LENGTH = 1024;
+
 const INTEGRATION_NAME$3 = 'Breadcrumbs';
-const _breadcrumbsIntegration = (options = {}) => {
+
+const _breadcrumbsIntegration = ((options = {}) => {
   const _options = {
     console: true,
     dom: true,
@@ -3942,8 +4469,9 @@ const _breadcrumbsIntegration = (options = {}) => {
     history: true,
     sentry: true,
     xhr: true,
-    ...options
+    ...options,
   };
+
   return {
     name: INTEGRATION_NAME$3,
     setup(client) {
@@ -3966,9 +4494,10 @@ const _breadcrumbsIntegration = (options = {}) => {
       if (_options.sentry) {
         client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));
       }
-    }
+    },
   };
-};
+}) ;
+
 const breadcrumbsIntegration = defineIntegration(_breadcrumbsIntegration);
 
 /**
@@ -3979,14 +4508,18 @@ function _getSentryBreadcrumbHandler(client) {
     if (exports$1.getClient() !== client) {
       return;
     }
-    addBreadcrumb({
-      category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,
-      event_id: event.event_id,
-      level: event.level,
-      message: exports$1.getEventDescription(event)
-    }, {
-      event
-    });
+
+    addBreadcrumb(
+      {
+        category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,
+        event_id: event.event_id,
+        level: event.level,
+        message: exports$1.getEventDescription(event),
+      },
+      {
+        event,
+      },
+    );
   };
 }
 
@@ -3994,51 +4527,61 @@ function _getSentryBreadcrumbHandler(client) {
  * A HOC that creates a function that creates breadcrumbs from DOM API calls.
  * This is a HOC so that we get access to dom options in the closure.
  */
-function _getDomBreadcrumbHandler(client, dom) {
+function _getDomBreadcrumbHandler(
+  client,
+  dom,
+) {
   return function _innerDomBreadcrumb(handlerData) {
     if (exports$1.getClient() !== client) {
       return;
     }
+
     let target;
     let componentName;
     let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;
-    let maxStringLength = typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;
+
+    let maxStringLength =
+      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;
     if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {
-      DEBUG_BUILD && exports$1.logger.warn(`\`dom.maxStringLength\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`);
+      DEBUG_BUILD &&
+        exports$1.logger.warn(
+          `\`dom.maxStringLength\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,
+        );
       maxStringLength = MAX_ALLOWED_STRING_LENGTH;
     }
+
     if (typeof keyAttrs === 'string') {
       keyAttrs = [keyAttrs];
     }
 
     // Accessing event.target can throw (see getsentry/raven-js#838, #768)
     try {
-      const event = handlerData.event;
+      const event = handlerData.event ;
       const element = _isEvent(event) ? event.target : event;
-      target = exports$1.htmlTreeAsString(element, {
-        keyAttrs,
-        maxStringLength
-      });
+
+      target = exports$1.htmlTreeAsString(element, { keyAttrs, maxStringLength });
       componentName = exports$1.getComponentName(element);
     } catch (e) {
       target = '<unknown>';
     }
+
     if (target.length === 0) {
       return;
     }
+
     const breadcrumb = {
       category: `ui.${handlerData.name}`,
-      message: target
+      message: target,
     };
+
     if (componentName) {
-      breadcrumb.data = {
-        'ui.component_name': componentName
-      };
+      breadcrumb.data = { 'ui.component_name': componentName };
     }
+
     addBreadcrumb(breadcrumb, {
       event: handlerData.event,
       name: handlerData.name,
-      global: handlerData.global
+      global: handlerData.global,
     });
   };
 }
@@ -4051,15 +4594,17 @@ function _getConsoleBreadcrumbHandler(client) {
     if (exports$1.getClient() !== client) {
       return;
     }
+
     const breadcrumb = {
       category: 'console',
       data: {
         arguments: handlerData.args,
-        logger: 'console'
+        logger: 'console',
       },
       level: severityLevelFromString(handlerData.level),
-      message: exports$1.safeJoin(handlerData.args, ' ')
+      message: exports$1.safeJoin(handlerData.args, ' '),
     };
+
     if (handlerData.level === 'assert') {
       if (handlerData.args[0] === false) {
         breadcrumb.message = `Assertion failed: ${exports$1.safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;
@@ -4069,9 +4614,10 @@ function _getConsoleBreadcrumbHandler(client) {
         return;
       }
     }
+
     addBreadcrumb(breadcrumb, {
       input: handlerData.args,
-      level: handlerData.level
+      level: handlerData.level,
     });
   };
 }
@@ -4084,40 +4630,40 @@ function _getXhrBreadcrumbHandler(client) {
     if (exports$1.getClient() !== client) {
       return;
     }
-    const {
-      startTimestamp,
-      endTimestamp
-    } = handlerData;
+
+    const { startTimestamp, endTimestamp } = handlerData;
+
     const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];
 
     // We only capture complete, non-sentry requests
     if (!startTimestamp || !endTimestamp || !sentryXhrData) {
       return;
     }
-    const {
-      method,
-      url,
-      status_code,
-      body
-    } = sentryXhrData;
+
+    const { method, url, status_code, body } = sentryXhrData;
+
     const data = {
       method,
       url,
-      status_code
+      status_code,
     };
+
     const hint = {
       xhr: handlerData.xhr,
       input: body,
       startTimestamp,
-      endTimestamp
+      endTimestamp,
     };
+
     const breadcrumb = {
       category: 'xhr',
       data,
       type: 'http',
-      level: getBreadcrumbLogLevelFromHttpStatusCode(status_code)
+      level: getBreadcrumbLogLevelFromHttpStatusCode(status_code),
     };
-    client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint);
+
+    client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint );
+
     addBreadcrumb(breadcrumb, hint);
   };
 }
@@ -4130,54 +4676,61 @@ function _getFetchBreadcrumbHandler(client) {
     if (exports$1.getClient() !== client) {
       return;
     }
-    const {
-      startTimestamp,
-      endTimestamp
-    } = handlerData;
+
+    const { startTimestamp, endTimestamp } = handlerData;
 
     // We only capture complete fetch requests
     if (!endTimestamp) {
       return;
     }
+
     if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {
       // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)
       return;
     }
+
     if (handlerData.error) {
       const data = handlerData.fetchData;
       const hint = {
         data: handlerData.error,
         input: handlerData.args,
         startTimestamp,
-        endTimestamp
+        endTimestamp,
       };
+
       const breadcrumb = {
         category: 'fetch',
         data,
         level: 'error',
-        type: 'http'
-      };
-      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint);
+        type: 'http',
+      } ;
+
+      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint );
+
       addBreadcrumb(breadcrumb, hint);
     } else {
-      const response = handlerData.response;
+      const response = handlerData.response ;
       const data = {
         ...handlerData.fetchData,
-        status_code: response?.status
+        status_code: response?.status,
       };
+
       const hint = {
         input: handlerData.args,
         response,
         startTimestamp,
-        endTimestamp
+        endTimestamp,
       };
+
       const breadcrumb = {
         category: 'fetch',
         data,
         type: 'http',
-        level: getBreadcrumbLogLevelFromHttpStatusCode(data.status_code)
+        level: getBreadcrumbLogLevelFromHttpStatusCode(data.status_code),
       };
-      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint);
+
+      client.emit('beforeOutgoingRequestBreadcrumb', breadcrumb, hint );
+
       addBreadcrumb(breadcrumb, hint);
     }
   };
@@ -4191,6 +4744,7 @@ function _getHistoryBreadcrumbHandler(client) {
     if (exports$1.getClient() !== client) {
       return;
     }
+
     let from = handlerData.from;
     let to = handlerData.to;
     const parsedLoc = parseUrl(WINDOW$1.location.href);
@@ -4210,30 +4764,67 @@ function _getHistoryBreadcrumbHandler(client) {
     if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {
       from = parsedFrom.relative;
     }
+
     addBreadcrumb({
       category: 'navigation',
       data: {
         from,
-        to
-      }
+        to,
+      },
     });
   };
 }
+
 function _isEvent(event) {
-  return !!event && !!event.target;
-}
+  return !!event && !!(event ).target;
+}
+
+const DEFAULT_EVENT_TARGET = [
+  'EventTarget',
+  'Window',
+  'Node',
+  'ApplicationCache',
+  'AudioTrackList',
+  'BroadcastChannel',
+  'ChannelMergerNode',
+  'CryptoOperation',
+  'EventSource',
+  'FileReader',
+  'HTMLUnknownElement',
+  'IDBDatabase',
+  'IDBRequest',
+  'IDBTransaction',
+  'KeyOperation',
+  'MediaController',
+  'MessagePort',
+  'ModalWindow',
+  'Notification',
+  'SVGElementInstance',
+  'Screen',
+  'SharedWorker',
+  'TextTrack',
+  'TextTrackCue',
+  'TextTrackList',
+  'WebSocket',
+  'WebSocketWorker',
+  'Worker',
+  'XMLHttpRequest',
+  'XMLHttpRequestEventTarget',
+  'XMLHttpRequestUpload',
+];
 
-const DEFAULT_EVENT_TARGET = ['EventTarget', 'Window', 'Node', 'ApplicationCache', 'AudioTrackList', 'BroadcastChannel', 'ChannelMergerNode', 'CryptoOperation', 'EventSource', 'FileReader', 'HTMLUnknownElement', 'IDBDatabase', 'IDBRequest', 'IDBTransaction', 'KeyOperation', 'MediaController', 'MessagePort', 'ModalWindow', 'Notification', 'SVGElementInstance', 'Screen', 'SharedWorker', 'TextTrack', 'TextTrackCue', 'TextTrackList', 'WebSocket', 'WebSocketWorker', 'Worker', 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'XMLHttpRequestUpload'];
 const INTEGRATION_NAME$2 = 'BrowserApiErrors';
-const _browserApiErrorsIntegration = (options = {}) => {
+
+const _browserApiErrorsIntegration = ((options = {}) => {
   const _options = {
     XMLHttpRequest: true,
     eventTarget: true,
     requestAnimationFrame: true,
     setInterval: true,
     setTimeout: true,
-    ...options
+    ...options,
   };
+
   return {
     name: INTEGRATION_NAME$2,
     // TODO: This currently only works for the first client this is setup
@@ -4242,62 +4833,70 @@ const _browserApiErrorsIntegration = (options = {}) => {
       if (_options.setTimeout) {
         exports$1.fill(WINDOW$1, 'setTimeout', _wrapTimeFunction);
       }
+
       if (_options.setInterval) {
         exports$1.fill(WINDOW$1, 'setInterval', _wrapTimeFunction);
       }
+
       if (_options.requestAnimationFrame) {
         exports$1.fill(WINDOW$1, 'requestAnimationFrame', _wrapRAF);
       }
+
       if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW$1) {
         exports$1.fill(XMLHttpRequest.prototype, 'send', _wrapXHR);
       }
+
       const eventTargetOption = _options.eventTarget;
       if (eventTargetOption) {
         const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;
         eventTarget.forEach(_wrapEventTarget);
       }
-    }
+    },
   };
-};
+}) ;
 
 /**
  * Wrap timer functions and event targets to catch errors and provide better meta data.
  */
 const browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);
+
 function _wrapTimeFunction(original) {
-  return function (...args) {
+  return function ( ...args) {
     const originalCallback = args[0];
     args[0] = wrap(originalCallback, {
       mechanism: {
-        data: {
-          function: exports$1.getFunctionName(original)
-        },
+        data: { function: exports$1.getFunctionName(original) },
         handled: false,
-        type: 'instrument'
-      }
+        type: 'instrument',
+      },
     });
     return original.apply(this, args);
   };
 }
+
 function _wrapRAF(original) {
-  return function (callback) {
-    return original.apply(this, [wrap(callback, {
-      mechanism: {
-        data: {
-          function: 'requestAnimationFrame',
-          handler: exports$1.getFunctionName(original)
+  return function ( callback) {
+    return original.apply(this, [
+      wrap(callback, {
+        mechanism: {
+          data: {
+            function: 'requestAnimationFrame',
+            handler: exports$1.getFunctionName(original),
+          },
+          handled: false,
+          type: 'instrument',
         },
-        handled: false,
-        type: 'instrument'
-      }
-    })]);
+      }),
+    ]);
   };
 }
+
 function _wrapXHR(originalSend) {
-  return function (...args) {
+  return function ( ...args) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const xhr = this;
     const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];
+
     xmlHttpRequestProps.forEach(prop => {
       if (prop in xhr && typeof xhr[prop] === 'function') {
         exports$1.fill(xhr, prop, function (original) {
@@ -4305,11 +4904,11 @@ function _wrapXHR(originalSend) {
             mechanism: {
               data: {
                 function: prop,
-                handler: exports$1.getFunctionName(original)
+                handler: exports$1.getFunctionName(original),
               },
               handled: false,
-              type: 'instrument'
-            }
+              type: 'instrument',
+            },
           };
 
           // If Instrument integration has been called before BrowserApiErrors, get the name of original function
@@ -4323,19 +4922,24 @@ function _wrapXHR(originalSend) {
         });
       }
     });
+
     return originalSend.apply(this, args);
   };
 }
+
 function _wrapEventTarget(target) {
-  const globalObject = WINDOW$1;
+  const globalObject = WINDOW$1 ;
   const proto = globalObject[target]?.prototype;
 
   // eslint-disable-next-line no-prototype-builtins
   if (!proto?.hasOwnProperty?.('addEventListener')) {
     return;
   }
-  exports$1.fill(proto, 'addEventListener', function (original) {
-    return function (eventName, fn, options) {
+
+  exports$1.fill(proto, 'addEventListener', function (original)
+
+ {
+    return function ( eventName, fn, options) {
       try {
         if (isEventListenerObject(fn)) {
           // ESlint disable explanation:
@@ -4349,31 +4953,39 @@ function _wrapEventTarget(target) {
               data: {
                 function: 'handleEvent',
                 handler: exports$1.getFunctionName(fn),
-                target
+                target,
               },
               handled: false,
-              type: 'instrument'
-            }
+              type: 'instrument',
+            },
           });
         }
       } catch {
         // can sometimes get 'Permission denied to access property "handle Event'
       }
-      return original.apply(this, [eventName, wrap(fn, {
-        mechanism: {
-          data: {
-            function: 'addEventListener',
-            handler: exports$1.getFunctionName(fn),
-            target
+
+      return original.apply(this, [
+        eventName,
+        wrap(fn, {
+          mechanism: {
+            data: {
+              function: 'addEventListener',
+              handler: exports$1.getFunctionName(fn),
+              target,
+            },
+            handled: false,
+            type: 'instrument',
           },
-          handled: false,
-          type: 'instrument'
-        }
-      }), options]);
+        }),
+        options,
+      ]);
     };
   });
-  exports$1.fill(proto, 'removeEventListener', function (originalRemoveEventListener) {
-    return function (eventName, fn, options) {
+
+  exports$1.fill(proto, 'removeEventListener', function (originalRemoveEventListener)
+
+ {
+    return function ( eventName, fn, options) {
       /**
        * There are 2 possible scenarios here:
        *
@@ -4392,7 +5004,7 @@ function _wrapEventTarget(target) {
        * to get rid of the initial handler and it'd stick there forever.
        */
       try {
-        const originalEventHandler = fn.__sentry_wrapped__;
+        const originalEventHandler = (fn ).__sentry_wrapped__;
         if (originalEventHandler) {
           originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
         }
@@ -4403,8 +5015,9 @@ function _wrapEventTarget(target) {
     };
   });
 }
+
 function isEventListenerObject(obj) {
-  return typeof obj.handleEvent === 'function';
+  return typeof (obj ).handleEvent === 'function';
 }
 
 /**
@@ -4418,7 +5031,8 @@ const browserSessionIntegration = defineIntegration(() => {
     name: 'BrowserSession',
     setupOnce() {
       if (typeof WINDOW$1.document === 'undefined') {
-        DEBUG_BUILD && exports$1.logger.warn('Using the `browserSessionIntegration` in non-browser environments is not supported.');
+        DEBUG_BUILD &&
+          exports$1.logger.warn('Using the `browserSessionIntegration` in non-browser environments is not supported.');
         return;
       }
 
@@ -4426,35 +5040,30 @@ const browserSessionIntegration = defineIntegration(() => {
       // concept that can be used as a metric.
       // Automatically captured sessions are akin to page views, and thus we
       // discard their duration.
-      exports$1.startSession({
-        ignoreDuration: true
-      });
+      exports$1.startSession({ ignoreDuration: true });
       exports$1.captureSession();
 
       // We want to create a session for every navigation as well
-      addHistoryInstrumentationHandler(({
-        from,
-        to
-      }) => {
+      addHistoryInstrumentationHandler(({ from, to }) => {
         // Don't create an additional session for the initial route or if the location did not change
         if (from !== undefined && from !== to) {
-          exports$1.startSession({
-            ignoreDuration: true
-          });
+          exports$1.startSession({ ignoreDuration: true });
           exports$1.captureSession();
         }
       });
-    }
+    },
   };
 });
 
 const INTEGRATION_NAME$1 = 'GlobalHandlers';
-const _globalHandlersIntegration = (options = {}) => {
+
+const _globalHandlersIntegration = ((options = {}) => {
   const _options = {
     onerror: true,
     onunhandledrejection: true,
-    ...options
+    ...options,
   };
+
   return {
     name: INTEGRATION_NAME$1,
     setupOnce() {
@@ -4469,58 +5078,67 @@ const _globalHandlersIntegration = (options = {}) => {
         _installGlobalOnUnhandledRejectionHandler(client);
         globalHandlerLog('onunhandledrejection');
       }
-    }
+    },
   };
-};
+}) ;
+
 const globalHandlersIntegration = defineIntegration(_globalHandlersIntegration);
+
 function _installGlobalOnErrorHandler(client) {
   addGlobalErrorInstrumentationHandler(data => {
-    const {
-      stackParser,
-      attachStacktrace
-    } = getOptions();
+    const { stackParser, attachStacktrace } = getOptions();
+
     if (exports$1.getClient() !== client || shouldIgnoreOnError()) {
       return;
     }
-    const {
-      msg,
+
+    const { msg, url, line, column, error } = data;
+
+    const event = _enhanceEventWithInitialFrame(
+      eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),
       url,
       line,
       column,
-      error
-    } = data;
-    const event = _enhanceEventWithInitialFrame(eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false), url, line, column);
+    );
+
     event.level = 'error';
+
     exports$1.captureEvent(event, {
       originalException: error,
       mechanism: {
         handled: false,
-        type: 'onerror'
-      }
+        type: 'onerror',
+      },
     });
   });
 }
+
 function _installGlobalOnUnhandledRejectionHandler(client) {
   addGlobalUnhandledRejectionInstrumentationHandler(e => {
-    const {
-      stackParser,
-      attachStacktrace
-    } = getOptions();
+    const { stackParser, attachStacktrace } = getOptions();
+
     if (exports$1.getClient() !== client || shouldIgnoreOnError()) {
       return;
     }
-    const error = _getUnhandledRejectionError(e);
-    const event = exports$1.isPrimitive(error) ? _eventFromRejectionWithPrimitive(error) : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);
+
+    const error = _getUnhandledRejectionError(e );
+
+    const event = exports$1.isPrimitive(error)
+      ? _eventFromRejectionWithPrimitive(error)
+      : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);
+
     event.level = 'error';
+
     exports$1.captureEvent(event, {
       originalException: error,
       mechanism: {
         handled: false,
-        type: 'onunhandledrejection'
-      }
+        type: 'onunhandledrejection',
+      },
     });
   });
 }
+
 function _getUnhandledRejectionError(error) {
   if (exports$1.isPrimitive(error)) {
     return error;
@@ -4528,10 +5146,11 @@ function _getUnhandledRejectionError(error) {
 
   // dig the object of the rejection out of known event types
   try {
+
     // PromiseRejectionEvents store the object of the rejection under 'reason'
     // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
-    if ('reason' in error) {
-      return error.reason;
+    if ('reason' in (error )) {
+      return (error ).reason;
     }
 
     // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents
@@ -4539,8 +5158,8 @@ function _getUnhandledRejectionError(error) {
     // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec
     // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and
     // https://github.com/getsentry/sentry-javascript/issues/2380
-    if ('detail' in error && 'reason' in error.detail) {
-      return error.detail.reason;
+    if ('detail' in (error ) && 'reason' in (error ).detail) {
+      return (error ).detail.reason;
     }
   } catch {} // eslint-disable-line no-empty
 
@@ -4556,25 +5175,34 @@ function _getUnhandledRejectionError(error) {
 function _eventFromRejectionWithPrimitive(reason) {
   return {
     exception: {
-      values: [{
-        type: 'UnhandledRejection',
-        // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)
-        value: `Non-Error promise rejection captured with value: ${String(reason)}`
-      }]
-    }
+      values: [
+        {
+          type: 'UnhandledRejection',
+          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)
+          value: `Non-Error promise rejection captured with value: ${String(reason)}`,
+        },
+      ],
+    },
   };
 }
-function _enhanceEventWithInitialFrame(event, url, line, column) {
+
+function _enhanceEventWithInitialFrame(
+  event,
+  url,
+  line,
+  column,
+) {
   // event.exception
-  const e = event.exception = event.exception || {};
+  const e = (event.exception = event.exception || {});
   // event.exception.values
-  const ev = e.values = e.values || [];
+  const ev = (e.values = e.values || []);
   // event.exception.values[0]
-  const ev0 = ev[0] = ev[0] || {};
+  const ev0 = (ev[0] = ev[0] || {});
   // event.exception.values[0].stacktrace
-  const ev0s = ev0.stacktrace = ev0.stacktrace || {};
+  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});
   // event.exception.values[0].stacktrace.frames
-  const ev0sf = ev0s.frames = ev0s.frames || [];
+  const ev0sf = (ev0s.frames = ev0s.frames || []);
+
   const colno = column;
   const lineno = line;
   const filename = exports$1.isString(url) && url.length > 0 ? url : exports$1.getLocationHref();
@@ -4586,19 +5214,22 @@ function _enhanceEventWithInitialFrame(event, url, line, column) {
       filename,
       function: exports$1.UNKNOWN_FUNCTION,
       in_app: true,
-      lineno
+      lineno,
     });
   }
+
   return event;
 }
+
 function globalHandlerLog(type) {
   DEBUG_BUILD && exports$1.logger.log(`Global Handler attached: ${type}`);
 }
+
 function getOptions() {
   const client = exports$1.getClient();
   const options = client?.getOptions() || {
     stackParser: () => [],
-    attachStacktrace: false
+    attachStacktrace: false,
   };
   return options;
 }
@@ -4615,36 +5246,48 @@ const httpContextIntegration = defineIntegration(() => {
       if (!WINDOW$1.navigator && !WINDOW$1.location && !WINDOW$1.document) {
         return;
       }
+
       const reqData = getHttpRequestData();
       const headers = {
         ...reqData.headers,
-        ...event.request?.headers
+        ...event.request?.headers,
       };
+
       event.request = {
         ...reqData,
         ...event.request,
-        headers
+        headers,
       };
-    }
+    },
   };
 });
 
 const DEFAULT_KEY = 'cause';
 const DEFAULT_LIMIT = 5;
+
 const INTEGRATION_NAME = 'LinkedErrors';
-const _linkedErrorsIntegration = (options = {}) => {
+
+const _linkedErrorsIntegration = ((options = {}) => {
   const limit = options.limit || DEFAULT_LIMIT;
   const key = options.key || DEFAULT_KEY;
+
   return {
     name: INTEGRATION_NAME,
     preprocessEvent(event, hint, client) {
       const options = client.getOptions();
+
       applyAggregateErrorsToEvent(
-      // This differs from the LinkedErrors integration in core by using a different exceptionFromError function
-      exceptionFromError, options.stackParser, key, limit, event, hint);
-    }
+        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function
+        exceptionFromError,
+        options.stackParser,
+        key,
+        limit,
+        event,
+        hint,
+      );
+    },
   };
-};
+}) ;
 
 /**
  * Aggregrate linked errors in an event.
@@ -4658,23 +5301,34 @@ function getDefaultIntegrations(_options) {
    * `getDefaultIntegrations` but with an adjusted set of integrations.
    */
   return [
-  // TODO(v10): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
-  // eslint-disable-next-line deprecation/deprecation
-  inboundFiltersIntegration(), functionToStringIntegration(), browserApiErrorsIntegration(), breadcrumbsIntegration(), globalHandlersIntegration(), linkedErrorsIntegration(), dedupeIntegration(), httpContextIntegration(), browserSessionIntegration()];
+    // TODO(v10): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
+    // eslint-disable-next-line deprecation/deprecation
+    inboundFiltersIntegration(),
+    functionToStringIntegration(),
+    browserApiErrorsIntegration(),
+    breadcrumbsIntegration(),
+    globalHandlersIntegration(),
+    linkedErrorsIntegration(),
+    dedupeIntegration(),
+    httpContextIntegration(),
+    browserSessionIntegration(),
+  ];
 }
 
 /** Exported only for tests. */
 function applyDefaultOptions(optionsArg = {}) {
   const defaultOptions = {
     defaultIntegrations: getDefaultIntegrations(),
-    release: typeof __SENTRY_RELEASE__ === 'string' // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value
-    ? __SENTRY_RELEASE__ : WINDOW$1.SENTRY_RELEASE?.id,
-    // This supports the variable that sentry-webpack-plugin injects
-    sendClientReports: true
+    release:
+      typeof __SENTRY_RELEASE__ === 'string' // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value
+        ? __SENTRY_RELEASE__
+        : WINDOW$1.SENTRY_RELEASE?.id, // This supports the variable that sentry-webpack-plugin injects
+    sendClientReports: true,
   };
+
   return {
     ...defaultOptions,
-    ...dropTopLevelUndefinedKeys(optionsArg)
+    ...dropTopLevelUndefinedKeys(optionsArg),
   };
 }
 
@@ -4684,12 +5338,14 @@ function applyDefaultOptions(optionsArg = {}) {
  */
 function dropTopLevelUndefinedKeys(obj) {
   const mutatetedObj = {};
+
   for (const k of Object.getOwnPropertyNames(obj)) {
-    const key = k;
+    const key = k ;
     if (obj[key] !== undefined) {
       mutatetedObj[key] = obj[key];
     }
   }
+
   return mutatetedObj;
 }
 
@@ -4743,76 +5399,89 @@ function init(browserOptions = {}) {
   if (!browserOptions.skipBrowserExtensionCheck && _checkForBrowserExtension()) {
     return;
   }
+
   const options = applyDefaultOptions(browserOptions);
   const clientOptions = {
     ...options,
     stackParser: exports$1.stackParserFromStackParserOptions(options.stackParser || defaultStackParser),
     integrations: getIntegrationsToSetup(options),
-    transport: options.transport || makeFetchTransport
+    transport: options.transport || makeFetchTransport,
   };
+
   return initAndBind(BrowserClient, clientOptions);
 }
+
 function _isEmbeddedBrowserExtension() {
   if (typeof WINDOW$1.window === 'undefined') {
     // No need to show the error if we're not in a browser window environment (e.g. service workers)
     return false;
   }
-  const _window = WINDOW$1;
+
+  const _window = WINDOW$1 ;
 
   // Running the SDK in NW.js, which appears like a browser extension but isn't, is also fine
   // see: https://github.com/getsentry/sentry-javascript/issues/12668
   if (_window.nw) {
     return false;
   }
+
   const extensionObject = _window['chrome'] || _window['browser'];
+
   if (!extensionObject?.runtime?.id) {
     return false;
   }
+
   const href = exports$1.getLocationHref();
   const extensionProtocols = ['chrome-extension', 'moz-extension', 'ms-browser-extension', 'safari-web-extension'];
 
   // Running the SDK in a dedicated extension page and calling Sentry.init is fine; no risk of data leakage
-  const isDedicatedExtensionPage = WINDOW$1 === WINDOW$1.top && extensionProtocols.some(protocol => href.startsWith(`${protocol}://`));
+  const isDedicatedExtensionPage =
+    WINDOW$1 === WINDOW$1.top && extensionProtocols.some(protocol => href.startsWith(`${protocol}://`));
+
   return !isDedicatedExtensionPage;
 }
+
 function _checkForBrowserExtension() {
   if (_isEmbeddedBrowserExtension()) {
     if (DEBUG_BUILD) {
       exports$1.consoleSandbox(() => {
         // eslint-disable-next-line no-console
-        console.error('[Sentry] You cannot use Sentry.init() in a browser extension, see: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/');
+        console.error(
+          '[Sentry] You cannot use Sentry.init() in a browser extension, see: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',
+        );
       });
     }
+
     return true;
   }
 }
 
 async function appGlobalScript () {
-  return await new Promise(resolve => {
-    init({
-      dsn: "https://d4dd33313afbf480bb76f965a5dcc733@sentry.ylzhaopin.com/9",
-      integrations: [],
-      beforeSend(event) {
-        if (event.exception && event.exception.values) {
-          const errorValue = event.exception.values[0];
-          if (errorValue.stacktrace && errorValue.stacktrace.frames) {
-            const isFromSdk = errorValue.stacktrace.frames.some(frame => frame.filename && frame.filename.includes('pcm-'));
-            if (!isFromSdk) {
-              return null;
-            }
-          }
-        }
-        return event;
-      },
-      tracesSampleRate: 0.1
+    return await new Promise((resolve) => {
+        init({
+            dsn: "https://d4dd33313afbf480bb76f965a5dcc733@sentry.ylzhaopin.com/9",
+            integrations: [],
+            beforeSend(event) {
+                if (event.exception && event.exception.values) {
+                    const errorValue = event.exception.values[0];
+                    if (errorValue.stacktrace && errorValue.stacktrace.frames) {
+                        const isFromSdk = errorValue.stacktrace.frames.some(frame => frame.filename && frame.filename.includes('pcm-'));
+                        if (!isFromSdk) {
+                            return null;
+                        }
+                    }
+                }
+                return event;
+            },
+            tracesSampleRate: 0.1,
+        });
+        resolve({});
     });
-    resolve({});
-  });
 }
 
 const globalScripts = appGlobalScript;
 
 exports.globalScripts = globalScripts;
-//# sourceMappingURL=app-globals-BS7h0Qoe.js.map
+//# sourceMappingURL=app-globals-BIO4q6tX.js.map
 
-//# sourceMappingURL=app-globals-BS7h0Qoe.js.map
+//# sourceMappingURL=app-globals-BIO4q6tX.js.map