diff --git a/packages/browser/src/integrations/dedupe.ts b/packages/browser/src/integrations/dedupe.ts
index 641823bbde3c..07fe3eccfb6a 100644
--- a/packages/browser/src/integrations/dedupe.ts
+++ b/packages/browser/src/integrations/dedupe.ts
@@ -27,7 +27,7 @@ export class Dedupe implements Integration {
       if (self) {
         // Juuust in case something goes wrong
         try {
-          if (_shouldDropEvent(currentEvent, self._previousEvent)) {
+          if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
             logger.warn(`Event dropped due to being a duplicate of previously captured event.`);
             return null;
           }
@@ -40,164 +40,164 @@ export class Dedupe implements Integration {
       return currentEvent;
     });
   }
-}
-
-/** JSDoc */
-function _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
-  if (!previousEvent) {
-    return false;
-  }
-
-  if (_isSameMessageEvent(currentEvent, previousEvent)) {
-    return true;
-  }
 
-  if (_isSameExceptionEvent(currentEvent, previousEvent)) {
-    return true;
-  }
+  /** JSDoc */
+  private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
+    if (!previousEvent) {
+      return false;
+    }
 
-  return false;
-}
+    if (this._isSameMessageEvent(currentEvent, previousEvent)) {
+      return true;
+    }
 
-/** JSDoc */
-function _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
-  const currentMessage = currentEvent.message;
-  const previousMessage = previousEvent.message;
+    if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
+      return true;
+    }
 
-  // If neither event has a message property, they were both exceptions, so bail out
-  if (!currentMessage && !previousMessage) {
     return false;
   }
 
-  // If only one event has a stacktrace, but not the other one, they are not the same
-  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
-    return false;
-  }
+  /** JSDoc */
+  private _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const currentMessage = currentEvent.message;
+    const previousMessage = previousEvent.message;
 
-  if (currentMessage !== previousMessage) {
-    return false;
-  }
+    // If neither event has a message property, they were both exceptions, so bail out
+    if (!currentMessage && !previousMessage) {
+      return false;
+    }
 
-  if (!_isSameFingerprint(currentEvent, previousEvent)) {
-    return false;
-  }
+    // If only one event has a stacktrace, but not the other one, they are not the same
+    if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
+      return false;
+    }
 
-  if (!_isSameStacktrace(currentEvent, previousEvent)) {
-    return false;
-  }
+    if (currentMessage !== previousMessage) {
+      return false;
+    }
 
-  return true;
-}
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
 
-/** JSDoc */
-function _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
-  const previousException = _getExceptionFromEvent(previousEvent);
-  const currentException = _getExceptionFromEvent(currentEvent);
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
 
-  if (!previousException || !currentException) {
-    return false;
+    return true;
   }
 
-  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
-    return false;
-  }
+  /** JSDoc */
+  private _getFramesFromEvent(event: Event): StackFrame[] | undefined {
+    const exception = event.exception;
 
-  if (!_isSameFingerprint(currentEvent, previousEvent)) {
-    return false;
+    if (exception) {
+      try {
+        // @ts-ignore Object could be undefined
+        return exception.values[0].stacktrace.frames;
+      } catch (_oO) {
+        return undefined;
+      }
+    } else if (event.stacktrace) {
+      return event.stacktrace.frames;
+    }
+    return undefined;
   }
 
-  if (!_isSameStacktrace(currentEvent, previousEvent)) {
-    return false;
-  }
+  /** JSDoc */
+  private _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFrames = this._getFramesFromEvent(currentEvent);
+    let previousFrames = this._getFramesFromEvent(previousEvent);
 
-  return true;
-}
+    // If neither event has a stacktrace, they are assumed to be the same
+    if (!currentFrames && !previousFrames) {
+      return true;
+    }
 
-/** JSDoc */
-function _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
-  let currentFrames = _getFramesFromEvent(currentEvent);
-  let previousFrames = _getFramesFromEvent(previousEvent);
+    // If only one event has a stacktrace, but not the other one, they are not the same
+    if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+      return false;
+    }
+
+    currentFrames = currentFrames as StackFrame[];
+    previousFrames = previousFrames as StackFrame[];
+
+    // If number of frames differ, they are not the same
+    if (previousFrames.length !== currentFrames.length) {
+      return false;
+    }
+
+    // Otherwise, compare the two
+    for (let i = 0; i < previousFrames.length; i++) {
+      const frameA = previousFrames[i];
+      const frameB = currentFrames[i];
+
+      if (
+        frameA.filename !== frameB.filename ||
+        frameA.lineno !== frameB.lineno ||
+        frameA.colno !== frameB.colno ||
+        frameA.function !== frameB.function
+      ) {
+        return false;
+      }
+    }
 
-  // If neither event has a stacktrace, they are assumed to be the same
-  if (!currentFrames && !previousFrames) {
     return true;
   }
 
-  // If only one event has a stacktrace, but not the other one, they are not the same
-  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
-    return false;
+  /** JSDoc */
+  private _getExceptionFromEvent(event: Event): Exception | undefined {
+    return event.exception && event.exception.values && event.exception.values[0];
   }
 
-  currentFrames = currentFrames as StackFrame[];
-  previousFrames = previousFrames as StackFrame[];
+  /** JSDoc */
+  private _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const previousException = this._getExceptionFromEvent(previousEvent);
+    const currentException = this._getExceptionFromEvent(currentEvent);
 
-  // If number of frames differ, they are not the same
-  if (previousFrames.length !== currentFrames.length) {
-    return false;
-  }
+    if (!previousException || !currentException) {
+      return false;
+    }
 
-  // Otherwise, compare the two
-  for (let i = 0; i < previousFrames.length; i++) {
-    const frameA = previousFrames[i];
-    const frameB = currentFrames[i];
-
-    if (
-      frameA.filename !== frameB.filename ||
-      frameA.lineno !== frameB.lineno ||
-      frameA.colno !== frameB.colno ||
-      frameA.function !== frameB.function
-    ) {
+    if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
       return false;
     }
-  }
 
-  return true;
-}
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
 
-/** JSDoc */
-function _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
-  let currentFingerprint = currentEvent.fingerprint;
-  let previousFingerprint = previousEvent.fingerprint;
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
 
-  // If neither event has a fingerprint, they are assumed to be the same
-  if (!currentFingerprint && !previousFingerprint) {
     return true;
   }
 
-  // If only one event has a fingerprint, but not the other one, they are not the same
-  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
-    return false;
-  }
-
-  currentFingerprint = currentFingerprint as string[];
-  previousFingerprint = previousFingerprint as string[];
+  /** JSDoc */
+  private _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFingerprint = currentEvent.fingerprint;
+    let previousFingerprint = previousEvent.fingerprint;
 
-  // Otherwise, compare the two
-  try {
-    return !!(currentFingerprint.join('') === previousFingerprint.join(''));
-  } catch (_oO) {
-    return false;
-  }
-}
+    // If neither event has a fingerprint, they are assumed to be the same
+    if (!currentFingerprint && !previousFingerprint) {
+      return true;
+    }
 
-/** JSDoc */
-function _getExceptionFromEvent(event: Event): Exception | undefined {
-  return event.exception && event.exception.values && event.exception.values[0];
-}
+    // If only one event has a fingerprint, but not the other one, they are not the same
+    if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
+      return false;
+    }
 
-/** JSDoc */
-function _getFramesFromEvent(event: Event): StackFrame[] | undefined {
-  const exception = event.exception;
+    currentFingerprint = currentFingerprint as string[];
+    previousFingerprint = previousFingerprint as string[];
 
-  if (exception) {
+    // Otherwise, compare the two
     try {
-      // @ts-ignore Object could be undefined
-      return exception.values[0].stacktrace.frames;
+      return !!(currentFingerprint.join('') === previousFingerprint.join(''));
     } catch (_oO) {
-      return undefined;
+      return false;
     }
-  } else if (event.stacktrace) {
-    return event.stacktrace.frames;
   }
-  return undefined;
 }
diff --git a/packages/integrations/src/dedupe.ts b/packages/integrations/src/dedupe.ts
index 641823bbde3c..07fe3eccfb6a 100644
--- a/packages/integrations/src/dedupe.ts
+++ b/packages/integrations/src/dedupe.ts
@@ -27,7 +27,7 @@ export class Dedupe implements Integration {
       if (self) {
         // Juuust in case something goes wrong
         try {
-          if (_shouldDropEvent(currentEvent, self._previousEvent)) {
+          if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
             logger.warn(`Event dropped due to being a duplicate of previously captured event.`);
             return null;
           }
@@ -40,164 +40,164 @@ export class Dedupe implements Integration {
       return currentEvent;
     });
   }
-}
-
-/** JSDoc */
-function _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
-  if (!previousEvent) {
-    return false;
-  }
-
-  if (_isSameMessageEvent(currentEvent, previousEvent)) {
-    return true;
-  }
 
-  if (_isSameExceptionEvent(currentEvent, previousEvent)) {
-    return true;
-  }
+  /** JSDoc */
+  private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
+    if (!previousEvent) {
+      return false;
+    }
 
-  return false;
-}
+    if (this._isSameMessageEvent(currentEvent, previousEvent)) {
+      return true;
+    }
 
-/** JSDoc */
-function _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
-  const currentMessage = currentEvent.message;
-  const previousMessage = previousEvent.message;
+    if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
+      return true;
+    }
 
-  // If neither event has a message property, they were both exceptions, so bail out
-  if (!currentMessage && !previousMessage) {
     return false;
   }
 
-  // If only one event has a stacktrace, but not the other one, they are not the same
-  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
-    return false;
-  }
+  /** JSDoc */
+  private _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const currentMessage = currentEvent.message;
+    const previousMessage = previousEvent.message;
 
-  if (currentMessage !== previousMessage) {
-    return false;
-  }
+    // If neither event has a message property, they were both exceptions, so bail out
+    if (!currentMessage && !previousMessage) {
+      return false;
+    }
 
-  if (!_isSameFingerprint(currentEvent, previousEvent)) {
-    return false;
-  }
+    // If only one event has a stacktrace, but not the other one, they are not the same
+    if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
+      return false;
+    }
 
-  if (!_isSameStacktrace(currentEvent, previousEvent)) {
-    return false;
-  }
+    if (currentMessage !== previousMessage) {
+      return false;
+    }
 
-  return true;
-}
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
 
-/** JSDoc */
-function _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
-  const previousException = _getExceptionFromEvent(previousEvent);
-  const currentException = _getExceptionFromEvent(currentEvent);
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
 
-  if (!previousException || !currentException) {
-    return false;
+    return true;
   }
 
-  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
-    return false;
-  }
+  /** JSDoc */
+  private _getFramesFromEvent(event: Event): StackFrame[] | undefined {
+    const exception = event.exception;
 
-  if (!_isSameFingerprint(currentEvent, previousEvent)) {
-    return false;
+    if (exception) {
+      try {
+        // @ts-ignore Object could be undefined
+        return exception.values[0].stacktrace.frames;
+      } catch (_oO) {
+        return undefined;
+      }
+    } else if (event.stacktrace) {
+      return event.stacktrace.frames;
+    }
+    return undefined;
   }
 
-  if (!_isSameStacktrace(currentEvent, previousEvent)) {
-    return false;
-  }
+  /** JSDoc */
+  private _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFrames = this._getFramesFromEvent(currentEvent);
+    let previousFrames = this._getFramesFromEvent(previousEvent);
 
-  return true;
-}
+    // If neither event has a stacktrace, they are assumed to be the same
+    if (!currentFrames && !previousFrames) {
+      return true;
+    }
 
-/** JSDoc */
-function _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
-  let currentFrames = _getFramesFromEvent(currentEvent);
-  let previousFrames = _getFramesFromEvent(previousEvent);
+    // If only one event has a stacktrace, but not the other one, they are not the same
+    if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+      return false;
+    }
+
+    currentFrames = currentFrames as StackFrame[];
+    previousFrames = previousFrames as StackFrame[];
+
+    // If number of frames differ, they are not the same
+    if (previousFrames.length !== currentFrames.length) {
+      return false;
+    }
+
+    // Otherwise, compare the two
+    for (let i = 0; i < previousFrames.length; i++) {
+      const frameA = previousFrames[i];
+      const frameB = currentFrames[i];
+
+      if (
+        frameA.filename !== frameB.filename ||
+        frameA.lineno !== frameB.lineno ||
+        frameA.colno !== frameB.colno ||
+        frameA.function !== frameB.function
+      ) {
+        return false;
+      }
+    }
 
-  // If neither event has a stacktrace, they are assumed to be the same
-  if (!currentFrames && !previousFrames) {
     return true;
   }
 
-  // If only one event has a stacktrace, but not the other one, they are not the same
-  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
-    return false;
+  /** JSDoc */
+  private _getExceptionFromEvent(event: Event): Exception | undefined {
+    return event.exception && event.exception.values && event.exception.values[0];
   }
 
-  currentFrames = currentFrames as StackFrame[];
-  previousFrames = previousFrames as StackFrame[];
+  /** JSDoc */
+  private _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
+    const previousException = this._getExceptionFromEvent(previousEvent);
+    const currentException = this._getExceptionFromEvent(currentEvent);
 
-  // If number of frames differ, they are not the same
-  if (previousFrames.length !== currentFrames.length) {
-    return false;
-  }
+    if (!previousException || !currentException) {
+      return false;
+    }
 
-  // Otherwise, compare the two
-  for (let i = 0; i < previousFrames.length; i++) {
-    const frameA = previousFrames[i];
-    const frameB = currentFrames[i];
-
-    if (
-      frameA.filename !== frameB.filename ||
-      frameA.lineno !== frameB.lineno ||
-      frameA.colno !== frameB.colno ||
-      frameA.function !== frameB.function
-    ) {
+    if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
       return false;
     }
-  }
 
-  return true;
-}
+    if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
 
-/** JSDoc */
-function _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
-  let currentFingerprint = currentEvent.fingerprint;
-  let previousFingerprint = previousEvent.fingerprint;
+    if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
 
-  // If neither event has a fingerprint, they are assumed to be the same
-  if (!currentFingerprint && !previousFingerprint) {
     return true;
   }
 
-  // If only one event has a fingerprint, but not the other one, they are not the same
-  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
-    return false;
-  }
-
-  currentFingerprint = currentFingerprint as string[];
-  previousFingerprint = previousFingerprint as string[];
+  /** JSDoc */
+  private _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
+    let currentFingerprint = currentEvent.fingerprint;
+    let previousFingerprint = previousEvent.fingerprint;
 
-  // Otherwise, compare the two
-  try {
-    return !!(currentFingerprint.join('') === previousFingerprint.join(''));
-  } catch (_oO) {
-    return false;
-  }
-}
+    // If neither event has a fingerprint, they are assumed to be the same
+    if (!currentFingerprint && !previousFingerprint) {
+      return true;
+    }
 
-/** JSDoc */
-function _getExceptionFromEvent(event: Event): Exception | undefined {
-  return event.exception && event.exception.values && event.exception.values[0];
-}
+    // If only one event has a fingerprint, but not the other one, they are not the same
+    if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
+      return false;
+    }
 
-/** JSDoc */
-function _getFramesFromEvent(event: Event): StackFrame[] | undefined {
-  const exception = event.exception;
+    currentFingerprint = currentFingerprint as string[];
+    previousFingerprint = previousFingerprint as string[];
 
-  if (exception) {
+    // Otherwise, compare the two
     try {
-      // @ts-ignore Object could be undefined
-      return exception.values[0].stacktrace.frames;
+      return !!(currentFingerprint.join('') === previousFingerprint.join(''));
     } catch (_oO) {
-      return undefined;
+      return false;
     }
-  } else if (event.stacktrace) {
-    return event.stacktrace.frames;
   }
-  return undefined;
 }