@sentry/browser 7.0.0-beta.0 → 7.0.0-rc.0

package/cjs/integrations/linkederrors.js

@@ -1,62 +1,93 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@sentry/core");
-const utils_1 = require("@sentry/utils");
-const eventbuilder_1 = require("../eventbuilder");
-const DEFAULT_KEY = 'cause';
-const DEFAULT_LIMIT = 5;
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@sentry/core');
+var utils = require('@sentry/utils');
+var eventbuilder = require('../eventbuilder.js');
+
+var DEFAULT_KEY = 'cause';
+var DEFAULT_LIMIT = 5;
+
 /** Adds SDK info to an event. */
-class LinkedErrors {
-    /**
-     * @inheritDoc
-     */
-    constructor(options = {}) {
-        /**
-         * @inheritDoc
-         */
-        this.name = LinkedErrors.id;
-        this._key = options.key || DEFAULT_KEY;
-        this._limit = options.limit || DEFAULT_LIMIT;
+class LinkedErrors  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'LinkedErrors';}
+
+  /**
+   * @inheritDoc
+   */
+    __init() {this.name = LinkedErrors.id;}
+
+  /**
+   * @inheritDoc
+   */
+  
+
+  /**
+   * @inheritDoc
+   */
+  
+
+  /**
+   * @inheritDoc
+   */
+   constructor(options = {}) {;LinkedErrors.prototype.__init.call(this);
+    this._key = options.key || DEFAULT_KEY;
+    this._limit = options.limit || DEFAULT_LIMIT;
+  }
+
+  /**
+   * @inheritDoc
+   */
+   setupOnce() {
+    var client = core.getCurrentHub().getClient();
+    if (!client) {
+      return;
     }
-    /**
-     * @inheritDoc
-     */
-    setupOnce() {
-        const client = core_1.getCurrentHub().getClient();
-        if (!client) {
-            return;
-        }
-        core_1.addGlobalEventProcessor((event, hint) => {
-            const self = core_1.getCurrentHub().getIntegration(LinkedErrors);
-            return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;
-        });
-    }
-}
-exports.LinkedErrors = LinkedErrors;
-/**
- * @inheritDoc
- */
-LinkedErrors.id = 'LinkedErrors';
+    core.addGlobalEventProcessor((event, hint) => {
+      var self = core.getCurrentHub().getIntegration(LinkedErrors);
+      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;
+    });
+  }
+} LinkedErrors.__initStatic();
+
 /**
  * @inheritDoc
  */
-function _handler(parser, key, limit, event, hint) {
-    if (!event.exception || !event.exception.values || !hint || !utils_1.isInstanceOf(hint.originalException, Error)) {
-        return event;
-    }
-    const linkedErrors = _walkErrorTree(parser, limit, hint.originalException, key);
-    event.exception.values = [...linkedErrors, ...event.exception.values];
+function _handler(
+  parser,
+  key,
+  limit,
+  event,
+  hint,
+) {
+  if (!event.exception || !event.exception.values || !hint || !utils.isInstanceOf(hint.originalException, Error)) {
     return event;
+  }
+  var linkedErrors = _walkErrorTree(parser, limit, hint.originalException , key);
+  event.exception.values = [...linkedErrors, ...event.exception.values];
+  return event;
 }
-exports._handler = _handler;
+
 /**
  * JSDOC
  */
-function _walkErrorTree(parser, limit, error, key, stack = []) {
-    if (!utils_1.isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {
-        return stack;
-    }
-    const exception = eventbuilder_1.exceptionFromError(parser, error[key]);
-    return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);
+function _walkErrorTree(
+  parser,
+  limit,
+  error,
+  key,
+  stack = [],
+) {
+  if (!utils.isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {
+    return stack;
+  }
+  var exception = eventbuilder.exceptionFromError(parser, error[key]);
+  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);
 }
+
+exports.LinkedErrors = LinkedErrors;
+exports._handler = _handler;
 exports._walkErrorTree = _walkErrorTree;
-//# sourceMappingURL=linkederrors.js.map
+//# sourceMappingURL=linkederrors.js.map

package/cjs/integrations/linkederrors.js.map

@@ -1 +1 @@
-{"version":3,"file":"linkederrors.js","sourceRoot":"","sources":["../../../../src/integrations/linkederrors.ts"],"names":[],"mappings":";AAAA,uCAAsE;AAEtE,yCAA6C;AAG7C,kDAAqD;AAErD,MAAM,WAAW,GAAG,OAAO,CAAC;AAC5B,MAAM,aAAa,GAAG,CAAC,CAAC;AAOxB,iCAAiC;AACjC,MAAa,YAAY;IAqBvB;;OAEG;IACH,YAAmB,UAAwC,EAAE;QAlB7D;;WAEG;QACa,SAAI,GAAW,YAAY,CAAC,EAAE,CAAC;QAgB7C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,IAAI,WAAW,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAAC;IAC/C,CAAC;IAED;;OAEG;IACI,SAAS;QACd,MAAM,MAAM,GAAG,oBAAa,EAAE,CAAC,SAAS,EAAiB,CAAC;QAC1D,IAAI,CAAC,MAAM,EAAE;YACX,OAAO;SACR;QACD,8BAAuB,CAAC,CAAC,KAAY,EAAE,IAAgB,EAAE,EAAE;YACzD,MAAM,IAAI,GAAG,oBAAa,EAAE,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;YAC1D,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACvG,CAAC,CAAC,CAAC;IACL,CAAC;;AAzCH,oCA0CC;AAzCC;;GAEG;AACW,eAAE,GAAW,cAAc,CAAC;AAwC5C;;GAEG;AACH,SAAgB,QAAQ,CACtB,MAAmB,EACnB,GAAW,EACX,KAAa,EACb,KAAY,EACZ,IAAgB;IAEhB,IAAI,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,oBAAY,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,EAAE;QACxG,OAAO,KAAK,CAAC;KACd;IACD,MAAM,YAAY,GAAG,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,iBAAkC,EAAE,GAAG,CAAC,CAAC;IACjG,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,GAAG,YAAY,EAAE,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACtE,OAAO,KAAK,CAAC;AACf,CAAC;AAbD,4BAaC;AAED;;GAEG;AACH,SAAgB,cAAc,CAC5B,MAAmB,EACnB,KAAa,EACb,KAAoB,EACpB,GAAW,EACX,QAAqB,EAAE;IAEvB,IAAI,CAAC,oBAAY,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,EAAE;QACjE,OAAO,KAAK,CAAC;KACd;IACD,MAAM,SAAS,GAAG,iCAAkB,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IACzD,OAAO,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;AAC/E,CAAC;AAZD,wCAYC","sourcesContent":["import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, ExtendedError, Integration, StackParser } from '@sentry/types';\nimport { isInstanceOf } from '@sentry/utils';\n\nimport { BrowserClient } from '../client';\nimport { exceptionFromError } from '../eventbuilder';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\ninterface LinkedErrorsOptions {\n  key: string;\n  limit: number;\n}\n\n/** Adds SDK info to an event. */\nexport class LinkedErrors implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'LinkedErrors';\n\n  /**\n   * @inheritDoc\n   */\n  public readonly name: string = LinkedErrors.id;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _key: LinkedErrorsOptions['key'];\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _limit: LinkedErrorsOptions['limit'];\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: Partial<LinkedErrorsOptions> = {}) {\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    const client = getCurrentHub().getClient<BrowserClient>();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n}\n\n/**\n * @inheritDoc\n */\nexport function _handler(\n  parser: StackParser,\n  key: string,\n  limit: number,\n  event: Event,\n  hint?: EventHint,\n): Event | null {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  const linkedErrors = _walkErrorTree(parser, limit, hint.originalException as ExtendedError, key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nexport function _walkErrorTree(\n  parser: StackParser,\n  limit: number,\n  error: ExtendedError,\n  key: string,\n  stack: Exception[] = [],\n): Exception[] {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  const exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n"]}
+{"version":3,"file":"linkederrors.js","sources":["../../../../src/integrations/linkederrors.ts"],"sourcesContent":["import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { Event, EventHint, Exception, ExtendedError, Integration, StackParser } from '@sentry/types';\nimport { isInstanceOf } from '@sentry/utils';\n\nimport { BrowserClient } from '../client';\nimport { exceptionFromError } from '../eventbuilder';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\ninterface LinkedErrorsOptions {\n  key: string;\n  limit: number;\n}\n\n/** Adds SDK info to an event. */\nexport class LinkedErrors implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'LinkedErrors';\n\n  /**\n   * @inheritDoc\n   */\n  public readonly name: string = LinkedErrors.id;\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _key: LinkedErrorsOptions['key'];\n\n  /**\n   * @inheritDoc\n   */\n  private readonly _limit: LinkedErrorsOptions['limit'];\n\n  /**\n   * @inheritDoc\n   */\n  public constructor(options: Partial<LinkedErrorsOptions> = {}) {\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setupOnce(): void {\n    const client = getCurrentHub().getClient<BrowserClient>();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event: Event, hint?: EventHint) => {\n      const self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n}\n\n/**\n * @inheritDoc\n */\nexport function _handler(\n  parser: StackParser,\n  key: string,\n  limit: number,\n  event: Event,\n  hint?: EventHint,\n): Event | null {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  const linkedErrors = _walkErrorTree(parser, limit, hint.originalException as ExtendedError, key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nexport function _walkErrorTree(\n  parser: StackParser,\n  limit: number,\n  error: ExtendedError,\n  key: string,\n  stack: Exception[] = [],\n): Exception[] {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  const exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n"],"names":[],"mappings":";;;;;;AAOA;AACA;;AAOA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;"}

package/cjs/integrations/trycatch.js

@@ -1,227 +1,271 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@sentry/utils");
-const helpers_1 = require("../helpers");
-const DEFAULT_EVENT_TARGET = [
-    'EventTarget',
-    'Window',
-    'Node',
-    'ApplicationCache',
-    'AudioTrackList',
-    'ChannelMergerNode',
-    'CryptoOperation',
-    'EventSource',
-    'FileReader',
-    'HTMLUnknownElement',
-    'IDBDatabase',
-    'IDBRequest',
-    'IDBTransaction',
-    'KeyOperation',
-    'MediaController',
-    'MessagePort',
-    'ModalWindow',
-    'Notification',
-    'SVGElementInstance',
-    'Screen',
-    'TextTrack',
-    'TextTrackCue',
-    'TextTrackList',
-    'WebSocket',
-    'WebSocketWorker',
-    'Worker',
-    'XMLHttpRequest',
-    'XMLHttpRequestEventTarget',
-    'XMLHttpRequestUpload',
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@sentry/utils');
+var helpers = require('../helpers.js');
+
+var DEFAULT_EVENT_TARGET = [
+  'EventTarget',
+  'Window',
+  'Node',
+  'ApplicationCache',
+  'AudioTrackList',
+  'ChannelMergerNode',
+  'CryptoOperation',
+  'EventSource',
+  'FileReader',
+  'HTMLUnknownElement',
+  'IDBDatabase',
+  'IDBRequest',
+  'IDBTransaction',
+  'KeyOperation',
+  'MediaController',
+  'MessagePort',
+  'ModalWindow',
+  'Notification',
+  'SVGElementInstance',
+  'Screen',
+  'TextTrack',
+  'TextTrackCue',
+  'TextTrackList',
+  'WebSocket',
+  'WebSocketWorker',
+  'Worker',
+  'XMLHttpRequest',
+  'XMLHttpRequestEventTarget',
+  'XMLHttpRequestUpload',
 ];
+
 /** Wrap timer functions and event targets to catch errors and provide better meta data */
-class TryCatch {
-    /**
-     * @inheritDoc
-     */
-    constructor(options) {
-        /**
-         * @inheritDoc
-         */
-        this.name = TryCatch.id;
-        this._options = Object.assign({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);
+class TryCatch  {
+  /**
+   * @inheritDoc
+   */
+   static __initStatic() {this.id = 'TryCatch';}
+
+  /**
+   * @inheritDoc
+   */
+   __init() {this.name = TryCatch.id;}
+
+  /** JSDoc */
+  
+
+  /**
+   * @inheritDoc
+   */
+   constructor(options) {;TryCatch.prototype.__init.call(this);
+    this._options = {
+      XMLHttpRequest: true,
+      eventTarget: true,
+      requestAnimationFrame: true,
+      setInterval: true,
+      setTimeout: true,
+      ...options,
+    };
+  }
+
+  /**
+   * Wrap timer functions and event targets to catch errors
+   * and provide better metadata.
+   */
+   setupOnce() {
+    var global = utils.getGlobalObject();
+
+    if (this._options.setTimeout) {
+      utils.fill(global, 'setTimeout', _wrapTimeFunction);
     }
-    /**
-     * Wrap timer functions and event targets to catch errors
-     * and provide better metadata.
-     */
-    setupOnce() {
-        const global = utils_1.getGlobalObject();
-        if (this._options.setTimeout) {
-            utils_1.fill(global, 'setTimeout', _wrapTimeFunction);
-        }
-        if (this._options.setInterval) {
-            utils_1.fill(global, 'setInterval', _wrapTimeFunction);
-        }
-        if (this._options.requestAnimationFrame) {
-            utils_1.fill(global, 'requestAnimationFrame', _wrapRAF);
-        }
-        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {
-            utils_1.fill(XMLHttpRequest.prototype, 'send', _wrapXHR);
-        }
-        const eventTargetOption = this._options.eventTarget;
-        if (eventTargetOption) {
-            const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;
-            eventTarget.forEach(_wrapEventTarget);
-        }
+
+    if (this._options.setInterval) {
+      utils.fill(global, 'setInterval', _wrapTimeFunction);
     }
-}
-exports.TryCatch = TryCatch;
-/**
- * @inheritDoc
- */
-TryCatch.id = 'TryCatch';
+
+    if (this._options.requestAnimationFrame) {
+      utils.fill(global, 'requestAnimationFrame', _wrapRAF);
+    }
+
+    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {
+      utils.fill(XMLHttpRequest.prototype, 'send', _wrapXHR);
+    }
+
+    var eventTargetOption = this._options.eventTarget;
+    if (eventTargetOption) {
+      var eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;
+      eventTarget.forEach(_wrapEventTarget);
+    }
+  }
+} TryCatch.__initStatic();
+
 /** JSDoc */
 function _wrapTimeFunction(original) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return function (...args) {
-        const originalCallback = args[0];
-        args[0] = helpers_1.wrap(originalCallback, {
-            mechanism: {
-                data: { function: utils_1.getFunctionName(original) },
-                handled: true,
-                type: 'instrument',
-            },
-        });
-        return original.apply(this, args);
-    };
+    return function ( ...args) {
+    var originalCallback = args[0];
+    args[0] = helpers.wrap(originalCallback, {
+      mechanism: {
+        data: { function: utils.getFunctionName(original) },
+        handled: true,
+        type: 'instrument',
+      },
+    });
+    return original.apply(this, args);
+  };
 }
+
 /** JSDoc */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _wrapRAF(original) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return function (callback) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return function ( callback) {
         return original.apply(this, [
-            helpers_1.wrap(callback, {
-                mechanism: {
-                    data: {
-                        function: 'requestAnimationFrame',
-                        handler: utils_1.getFunctionName(original),
-                    },
-                    handled: true,
-                    type: 'instrument',
-                },
-            }),
-        ]);
-    };
+      helpers.wrap(callback, {
+        mechanism: {
+          data: {
+            function: 'requestAnimationFrame',
+            handler: utils.getFunctionName(original),
+          },
+          handled: true,
+          type: 'instrument',
+        },
+      }),
+    ]);
+  };
 }
+
 /** JSDoc */
 function _wrapXHR(originalSend) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    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') {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                utils_1.fill(xhr, prop, function (original) {
-                    const wrapOptions = {
-                        mechanism: {
-                            data: {
-                                function: prop,
-                                handler: utils_1.getFunctionName(original),
-                            },
-                            handled: true,
-                            type: 'instrument',
-                        },
-                    };
-                    // If Instrument integration has been called before TryCatch, get the name of original function
-                    const originalFunction = utils_1.getOriginalFunction(original);
-                    if (originalFunction) {
-                        wrapOptions.mechanism.data.handler = utils_1.getFunctionName(originalFunction);
-                    }
-                    // Otherwise wrap directly
-                    return helpers_1.wrap(original, wrapOptions);
-                });
-            }
+    return function ( ...args) {
+        var xhr = this;
+    var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];
+
+    xmlHttpRequestProps.forEach(prop => {
+      if (prop in xhr && typeof xhr[prop] === 'function') {
+                utils.fill(xhr, prop, function (original) {
+          var wrapOptions = {
+            mechanism: {
+              data: {
+                function: prop,
+                handler: utils.getFunctionName(original),
+              },
+              handled: true,
+              type: 'instrument',
+            },
+          };
+
+          // If Instrument integration has been called before TryCatch, get the name of original function
+          var originalFunction = utils.getOriginalFunction(original);
+          if (originalFunction) {
+            wrapOptions.mechanism.data.handler = utils.getFunctionName(originalFunction);
+          }
+
+          // Otherwise wrap directly
+          return helpers.wrap(original, wrapOptions);
         });
-        return originalSend.apply(this, args);
-    };
+      }
+    });
+
+    return originalSend.apply(this, args);
+  };
 }
+
 /** JSDoc */
 function _wrapEventTarget(target) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const global = utils_1.getGlobalObject();
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    const proto = global[target] && global[target].prototype;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
+    var global = utils.getGlobalObject() ;
+    var proto = global[target] && global[target].prototype;
+
     if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
-        return;
-    }
-    utils_1.fill(proto, 'addEventListener', function (original) {
-        return function (eventName, fn, options) {
-            try {
-                if (typeof fn.handleEvent === 'function') {
-                    fn.handleEvent = helpers_1.wrap(fn.handleEvent.bind(fn), {
-                        mechanism: {
-                            data: {
-                                function: 'handleEvent',
-                                handler: utils_1.getFunctionName(fn),
-                                target,
-                            },
-                            handled: true,
-                            type: 'instrument',
-                        },
-                    });
-                }
-            }
-            catch (err) {
-                // can sometimes get 'Permission denied to access property "handle Event'
-            }
-            return original.apply(this, [
-                eventName,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                helpers_1.wrap(fn, {
-                    mechanism: {
-                        data: {
-                            function: 'addEventListener',
-                            handler: utils_1.getFunctionName(fn),
-                            target,
-                        },
-                        handled: true,
-                        type: 'instrument',
-                    },
-                }),
-                options,
-            ]);
-        };
-    });
-    utils_1.fill(proto, 'removeEventListener', function (originalRemoveEventListener) {
-        return function (eventName, fn, options) {
-            /**
-             * There are 2 possible scenarios here:
-             *
-             * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified
-             * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function
-             * as a pass-through, and call original `removeEventListener` with it.
-             *
-             * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using
-             * our wrapped version of `addEventListener`, which internally calls `wrap` helper.
-             * This helper "wraps" whole callback inside a try/catch statement, and attached appropriate metadata to it,
-             * in order for us to make a distinction between wrapped/non-wrapped functions possible.
-             * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.
-             *
-             * When someone adds a handler prior to initialization, and then do it again, but after,
-             * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible
-             * to get rid of the initial handler and it'd stick there forever.
-             */
-            const wrappedEventHandler = fn;
-            try {
-                const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;
-                if (originalEventHandler) {
-                    originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
-                }
-            }
-            catch (e) {
-                // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments
-            }
-            return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);
-        };
-    });
+    return;
+  }
+
+  utils.fill(proto, 'addEventListener', function (original)
+
+ {
+    return function (
+            
+      eventName,
+      fn,
+      options,
+    ) {
+      try {
+        if (typeof fn.handleEvent === 'function') {
+          // ESlint disable explanation:
+          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would
+          //  introduce a bug here, because bind returns a new function that doesn't have our
+          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.
+          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.
+                    fn.handleEvent = helpers.wrap(fn.handleEvent, {
+            mechanism: {
+              data: {
+                function: 'handleEvent',
+                handler: utils.getFunctionName(fn),
+                target,
+              },
+              handled: true,
+              type: 'instrument',
+            },
+          });
+        }
+      } catch (err) {
+        // can sometimes get 'Permission denied to access property "handle Event'
+      }
+
+      return original.apply(this, [
+        eventName,
+                helpers.wrap(fn , {
+          mechanism: {
+            data: {
+              function: 'addEventListener',
+              handler: utils.getFunctionName(fn),
+              target,
+            },
+            handled: true,
+            type: 'instrument',
+          },
+        }),
+        options,
+      ]);
+    };
+  });
+
+  utils.fill(
+    proto,
+    'removeEventListener',
+    function (
+      originalRemoveEventListener,
+          ) {
+      return function (
+                
+        eventName,
+        fn,
+        options,
+      ) {
+        /**
+         * There are 2 possible scenarios here:
+         *
+         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified
+         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function
+         * as a pass-through, and call original `removeEventListener` with it.
+         *
+         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using
+         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.
+         * This helper "wraps" whole callback inside a try/catch statement, and attached appropriate metadata to it,
+         * in order for us to make a distinction between wrapped/non-wrapped functions possible.
+         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.
+         *
+         * When someone adds a handler prior to initialization, and then do it again, but after,
+         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible
+         * to get rid of the initial handler and it'd stick there forever.
+         */
+        var wrappedEventHandler = fn ;
+        try {
+          var originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;
+          if (originalEventHandler) {
+            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
+          }
+        } catch (e) {
+          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments
+        }
+        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);
+      };
+    },
+  );
 }
-//# sourceMappingURL=trycatch.js.map
+
+exports.TryCatch = TryCatch;
+//# sourceMappingURL=trycatch.js.map