@honeybadger-io/js 4.1.2 → 4.1.3

package/dist/browser/honeybadger.js

@@ -209,22 +209,49 @@
 	        step((generator = generator.apply(thisArg, _arguments || [])).next());
 	    });
 	};
+	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+	    function verb(n) { return function (v) { return step([n, v]); }; }
+	    function step(op) {
+	        if (f) throw new TypeError("Generator is already executing.");
+	        while (_) try {
+	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+	            if (y = 0, t) op = [op[0] & 2, t.value];
+	            switch (op[0]) {
+	                case 0: case 1: t = op; break;
+	                case 4: _.label++; return { value: op[1], done: false };
+	                case 5: _.label++; y = op[1]; op = [0]; continue;
+	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+	                default:
+	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+	                    if (t[2]) _.ops.pop();
+	                    _.trys.pop(); continue;
+	            }
+	            op = body.call(thisArg, _);
+	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+	    }
+	};
 	Object.defineProperty(util$1, "__esModule", { value: true });
 	util$1.isBrowserConfig = util$1.clone = util$1.formatCGIData = util$1.filterUrl = util$1.filter = util$1.generateStackTrace = util$1.endpoint = util$1.instrument = util$1.isErrorObject = util$1.makeNotice = util$1.logger = util$1.sanitize = util$1.shallowClone = util$1.runAfterNotifyHandlers = util$1.runBeforeNotifyHandlers = util$1.getSourceForBacktrace = util$1.getCauses = util$1.makeBacktrace = util$1.objectIsExtensible = util$1.objectIsEmpty = util$1.mergeNotice = util$1.merge = void 0;
-	const stackTraceParser = __importStar(require$$0);
+	var stackTraceParser = __importStar(require$$0);
 	function merge$1(obj1, obj2) {
-	    const result = {};
-	    for (const k in obj1) {
+	    var result = {};
+	    for (var k in obj1) {
 	        result[k] = obj1[k];
 	    }
-	    for (const k in obj2) {
+	    for (var k in obj2) {
 	        result[k] = obj2[k];
 	    }
 	    return result;
 	}
 	util$1.merge = merge$1;
 	function mergeNotice(notice1, notice2) {
-	    const result = merge$1(notice1, notice2);
+	    var result = merge$1(notice1, notice2);
 	    if (notice1.context && notice2.context) {
 	        result.context = merge$1(notice1.context, notice2.context);
 	    }
@@ -232,7 +259,7 @@
 	}
 	util$1.mergeNotice = mergeNotice;
 	function objectIsEmpty(obj) {
-	    for (const k in obj) {
+	    for (var k in obj) {
 	        if (Object.prototype.hasOwnProperty.call(obj, k)) {
 	            return false;
 	        }
@@ -247,11 +274,12 @@
 	    return Object.isExtensible(obj);
 	}
 	util$1.objectIsExtensible = objectIsExtensible$1;
-	function makeBacktrace(stack, shift = 0) {
+	function makeBacktrace(stack, shift) {
+	    if (shift === void 0) { shift = 0; }
 	    try {
-	        const backtrace = stackTraceParser
+	        var backtrace = stackTraceParser
 	            .parse(stack)
-	            .map(line => {
+	            .map(function (line) {
 	            return {
 	                file: line.file,
 	                method: line.methodName,
@@ -270,8 +298,8 @@
 	util$1.makeBacktrace = makeBacktrace;
 	function getCauses(notice) {
 	    if (notice.cause) {
-	        const causes = [];
-	        let cause = notice;
+	        var causes = [];
+	        var cause = notice;
 	        while (causes.length < 3 && (cause = cause.cause)) {
 	            causes.push({
 	                class: cause.name,
@@ -285,26 +313,36 @@
 	}
 	util$1.getCauses = getCauses;
 	function getSourceForBacktrace(backtrace, getSourceFileHandler) {
-	    return __awaiter(this, void 0, void 0, function* () {
-	        const result = [];
-	        if (!getSourceFileHandler || !backtrace || !backtrace.length) {
-	            return result;
-	        }
-	        let index = 0;
-	        while (backtrace.length) {
-	            const trace = backtrace.splice(0)[index];
-	            const fileContent = yield getSourceFileHandler(trace.file);
-	            result[index] = getSourceCodeSnippet(fileContent, trace.number);
-	            index++;
-	        }
-	        return result;
+	    return __awaiter(this, void 0, void 0, function () {
+	        var result, index, trace, fileContent;
+	        return __generator(this, function (_a) {
+	            switch (_a.label) {
+	                case 0:
+	                    result = [];
+	                    if (!getSourceFileHandler || !backtrace || !backtrace.length) {
+	                        return [2 /*return*/, result];
+	                    }
+	                    index = 0;
+	                    _a.label = 1;
+	                case 1:
+	                    if (!backtrace.length) return [3 /*break*/, 3];
+	                    trace = backtrace.splice(0)[index];
+	                    return [4 /*yield*/, getSourceFileHandler(trace.file)];
+	                case 2:
+	                    fileContent = _a.sent();
+	                    result[index] = getSourceCodeSnippet(fileContent, trace.number);
+	                    index++;
+	                    return [3 /*break*/, 1];
+	                case 3: return [2 /*return*/, result];
+	            }
+	        });
 	    });
 	}
 	util$1.getSourceForBacktrace = getSourceForBacktrace;
 	function runBeforeNotifyHandlers(notice, handlers) {
-	    let result = true;
-	    for (let i = 0, len = handlers.length; i < len; i++) {
-	        const handler = handlers[i];
+	    var result = true;
+	    for (var i = 0, len = handlers.length; i < len; i++) {
+	        var handler = handlers[i];
 	        if (handler(notice) === false) {
 	            result = false;
 	        }
@@ -316,7 +354,7 @@
 	    if (notice && notice.afterNotify) {
 	        notice.afterNotify(error, notice);
 	    }
-	    for (let i = 0, len = handlers.length; i < len; i++) {
+	    for (var i = 0, len = handlers.length; i < len; i++) {
 	        handlers[i](error, notice);
 	    }
 	    return true;
@@ -327,21 +365,22 @@
 	    if (typeof (obj) !== 'object' || obj === null) {
 	        return {};
 	    }
-	    const result = {};
-	    for (const k in obj) {
+	    var result = {};
+	    for (var k in obj) {
 	        result[k] = obj[k];
 	    }
 	    return result;
 	}
 	util$1.shallowClone = shallowClone;
-	function sanitize$2(obj, maxDepth = 8) {
-	    const seenObjects = [];
+	function sanitize$2(obj, maxDepth) {
+	    if (maxDepth === void 0) { maxDepth = 8; }
+	    var seenObjects = [];
 	    function seen(obj) {
 	        if (!obj || typeof (obj) !== 'object') {
 	            return false;
 	        }
-	        for (let i = 0; i < seenObjects.length; i++) {
-	            const value = seenObjects[i];
+	        for (var i = 0; i < seenObjects.length; i++) {
+	            var value = seenObjects[i];
 	            if (value === obj) {
 	                return true;
 	            }
@@ -350,7 +389,7 @@
 	        return false;
 	    }
 	    function canSerialize(obj) {
-	        const typeOfObj = typeof obj;
+	        var typeOfObj = typeof obj;
 	        // Functions are TMI
 	        if (/function/.test(typeOfObj)) {
 	            // Let special toJSON method pass as it's used by JSON.stringify (#722)
@@ -369,7 +408,8 @@
 	        }
 	        return true;
 	    }
-	    function serialize(obj, depth = 0) {
+	    function serialize(obj, depth) {
+	        if (depth === void 0) { depth = 0; }
 	        if (depth >= maxDepth) {
 	            return '[DEPTH]';
 	        }
@@ -383,13 +423,13 @@
 	        }
 	        // Serialize inside arrays
 	        if (Array.isArray(obj)) {
-	            return obj.map(o => safeSerialize(o, depth + 1));
+	            return obj.map(function (o) { return safeSerialize(o, depth + 1); });
 	        }
 	        // Serialize inside objects
 	        if (typeof (obj) === 'object') {
-	            const ret = {};
-	            for (const k in obj) {
-	                const v = obj[k];
+	            var ret = {};
+	            for (var k in obj) {
+	                var v = obj[k];
 	                if (Object.prototype.hasOwnProperty.call(obj, k) && (k != null) && (v != null)) {
 	                    ret[k] = safeSerialize(v, depth + 1);
 	                }
@@ -399,20 +439,26 @@
 	        // Return everything else untouched
 	        return obj;
 	    }
-	    function safeSerialize(obj, depth = 0) {
+	    function safeSerialize(obj, depth) {
+	        if (depth === void 0) { depth = 0; }
 	        try {
 	            return serialize(obj, depth);
 	        }
 	        catch (e) {
-	            return `[ERROR] ${e}`;
+	            return "[ERROR] ".concat(e);
 	        }
 	    }
 	    return safeSerialize(obj);
 	}
 	util$1.sanitize = sanitize$2;
 	function logger(client) {
-	    const log = (method) => {
-	        return function (...args) {
+	    var log = function (method) {
+	        return function () {
+	            var _a;
+	            var args = [];
+	            for (var _i = 0; _i < arguments.length; _i++) {
+	                args[_i] = arguments[_i];
+	            }
 	            if (method === 'debug') {
 	                if (!client.config.debug) {
 	                    return;
@@ -422,7 +468,7 @@
 	                method = 'log';
 	            }
 	            args.unshift('[Honeybadger]');
-	            client.config.logger[method](...args);
+	            (_a = client.config.logger)[method].apply(_a, args);
 	        };
 	    };
 	    return {
@@ -439,19 +485,19 @@
 	 * properties as Error, but supports additional Honeybadger properties.)
 	 */
 	function makeNotice$1(thing) {
-	    let notice;
+	    var notice;
 	    if (!thing) {
 	        notice = {};
 	    }
 	    else if (isErrorObject(thing)) {
-	        const e = thing;
+	        var e = thing;
 	        notice = merge$1(thing, { name: e.name, message: e.message, stack: e.stack, cause: e.cause });
 	    }
 	    else if (typeof thing === 'object') {
 	        notice = shallowClone(thing);
 	    }
 	    else {
-	        const m = String(thing);
+	        var m = String(thing);
 	        notice = { message: m };
 	    }
 	    return notice;
@@ -473,7 +519,7 @@
 	    if (!object || !name || !replacement || !(name in object)) {
 	        return;
 	    }
-	    let original = object[name];
+	    var original = object[name];
 	    while (original && original.__hb_original) {
 	        original = original.__hb_original;
 	    }
@@ -489,9 +535,9 @@
 	}
 	util$1.instrument = instrument$5;
 	function endpoint(base, path) {
-	    const endpoint = base.trim().replace(/\/$/, '');
+	    var endpoint = base.trim().replace(/\/$/, '');
 	    path = path.trim().replace(/(^\/|\/$)/g, '');
-	    return `${endpoint}/${path}`;
+	    return "".concat(endpoint, "/").concat(path);
 	}
 	util$1.endpoint = endpoint;
 	function generateStackTrace() {
@@ -503,9 +549,9 @@
 	            return e.stack;
 	        }
 	    }
-	    const maxStackSize = 10;
-	    const stack = [];
-	    let curr = arguments.callee;
+	    var maxStackSize = 10;
+	    var stack = [];
+	    var curr = arguments.callee;
 	    while (curr && stack.length < maxStackSize) {
 	        if (/function(?:\s+([\w$]+))+\s*\(/.test(curr.toString())) {
 	            stack.push(RegExp.$1 || '<anonymous>');
@@ -530,9 +576,9 @@
 	    if (!is('Array', filters)) {
 	        filters = [];
 	    }
-	    const seen = [];
+	    var seen = [];
 	    function filter(obj) {
-	        let k, newObj;
+	        var k, newObj;
 	        if (is('Object', obj) || is('Array', obj)) {
 	            if (seen.indexOf(obj) !== -1) {
 	                return '[CIRCULAR DATA STRUCTURE]';
@@ -565,7 +611,7 @@
 	}
 	util$1.filter = filter$1;
 	function filterMatch(key, filters) {
-	    for (let i = 0; i < filters.length; i++) {
+	    for (var i = 0; i < filters.length; i++) {
 	        if (key.toLowerCase().indexOf(filters[i].toLowerCase()) !== -1) {
 	            return true;
 	        }
@@ -573,7 +619,7 @@
 	    return false;
 	}
 	function is(type, obj) {
-	    const klass = Object.prototype.toString.call(obj).slice(8, -1);
+	    var klass = Object.prototype.toString.call(obj).slice(8, -1);
 	    return obj !== undefined && obj !== null && klass === type;
 	}
 	function filterUrl(url, filters) {
@@ -583,24 +629,25 @@
 	    if (typeof url !== 'string') {
 	        return url;
 	    }
-	    const query = url.split(/\?/, 2)[1];
+	    var query = url.split(/\?/, 2)[1];
 	    if (!query) {
 	        return url;
 	    }
-	    let result = url;
-	    query.split(/[&]\s?/).forEach((pair) => {
-	        const [key, value] = pair.split('=', 2);
+	    var result = url;
+	    query.split(/[&]\s?/).forEach(function (pair) {
+	        var _a = pair.split('=', 2), key = _a[0], value = _a[1];
 	        if (filterMatch(key, filters)) {
-	            result = result.replace(`${key}=${value}`, `${key}=[FILTERED]`);
+	            result = result.replace("".concat(key, "=").concat(value), "".concat(key, "=[FILTERED]"));
 	        }
 	    });
 	    return result;
 	}
 	util$1.filterUrl = filterUrl;
-	function formatCGIData(vars, prefix = '') {
-	    const formattedVars = {};
+	function formatCGIData(vars, prefix) {
+	    if (prefix === void 0) { prefix = ''; }
+	    var formattedVars = {};
 	    Object.keys(vars).forEach(function (key) {
-	        const formattedKey = prefix + key.replace(/\W/g, '_').toUpperCase();
+	        var formattedKey = prefix + key.replace(/\W/g, '_').toUpperCase();
 	        formattedVars[formattedKey] = vars[key];
 	    });
 	    return formattedVars;
@@ -610,18 +657,19 @@
 	    return JSON.parse(JSON.stringify(obj));
 	}
 	util$1.clone = clone;
-	function getSourceCodeSnippet(fileData, lineNumber, sourceRadius = 2) {
+	function getSourceCodeSnippet(fileData, lineNumber, sourceRadius) {
+	    if (sourceRadius === void 0) { sourceRadius = 2; }
 	    if (!fileData) {
 	        return null;
 	    }
-	    const lines = fileData.split('\n');
+	    var lines = fileData.split('\n');
 	    // add one empty line because array index starts from 0, but error line number is counted from 1
 	    lines.unshift('');
-	    const start = lineNumber - sourceRadius;
-	    const end = lineNumber + sourceRadius;
-	    const result = {};
-	    for (let i = start; i <= end; i++) {
-	        const line = lines[i];
+	    var start = lineNumber - sourceRadius;
+	    var end = lineNumber + sourceRadius;
+	    var result = {};
+	    for (var i = start; i <= end; i++) {
+	        var line = lines[i];
 	        if (typeof line === 'string') {
 	            result[i] = line;
 	        }
@@ -637,80 +685,99 @@
 
 	Object.defineProperty(store, "__esModule", { value: true });
 	store.GlobalStore = void 0;
-	class GlobalStore {
-	    constructor(store) {
+	var GlobalStore = /** @class */ (function () {
+	    function GlobalStore(store) {
 	        this.store = store;
 	    }
-	    getStore() {
+	    GlobalStore.prototype.getStore = function () {
 	        return this.store;
-	    }
-	    run(store, callback, ...args) {
+	    };
+	    GlobalStore.prototype.run = function (store, callback) {
+	        var args = [];
+	        for (var _i = 2; _i < arguments.length; _i++) {
+	            args[_i - 2] = arguments[_i];
+	        }
 	        this.store = store;
-	        return callback(...args);
-	    }
-	}
+	        return callback.apply(void 0, args);
+	    };
+	    return GlobalStore;
+	}());
 	store.GlobalStore = GlobalStore;
 
+	var __assign$1 = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+	    __assign$1 = Object.assign || function(t) {
+	        for (var s, i = 1, n = arguments.length; i < n; i++) {
+	            s = arguments[i];
+	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+	                t[p] = s[p];
+	        }
+	        return t;
+	    };
+	    return __assign$1.apply(this, arguments);
+	};
 	Object.defineProperty(client, "__esModule", { value: true });
 	client.Client = void 0;
-	const util_1$2 = util$1;
-	const store_1 = store;
-	const notifier = {
+	var util_1$2 = util$1;
+	var store_1 = store;
+	var notifier = {
 	    name: 'honeybadger-js',
 	    url: 'https://github.com/honeybadger-io/honeybadger-js',
-	    version: '4.1.2'
+	    version: '4.1.3'
 	};
 	// Split at commas and spaces
-	const TAG_SEPARATOR = /,|\s+/;
+	var TAG_SEPARATOR = /,|\s+/;
 	// Checks for non-blank characters
-	const NOT_BLANK = /\S/;
-	class Client {
-	    constructor(opts = {}, transport) {
+	var NOT_BLANK = /\S/;
+	var Client = /** @class */ (function () {
+	    function Client(opts, transport) {
+	        if (opts === void 0) { opts = {}; }
 	        this.__pluginsExecuted = false;
 	        this.__store = null;
 	        this.__beforeNotifyHandlers = [];
 	        this.__afterNotifyHandlers = [];
-	        this.config = Object.assign({ apiKey: null, endpoint: 'https://api.honeybadger.io', environment: null, hostname: null, projectRoot: null, component: null, action: null, revision: null, reportData: null, breadcrumbsEnabled: true, maxBreadcrumbs: 40, maxObjectDepth: 8, logger: console, developmentEnvironments: ['dev', 'development', 'test'], debug: false, tags: null, enableUncaught: true, enableUnhandledRejection: true, afterUncaught: () => true, filters: ['creditcard', 'password'], __plugins: [] }, opts);
+	        this.config = __assign$1({ apiKey: null, endpoint: 'https://api.honeybadger.io', environment: null, hostname: null, projectRoot: null, component: null, action: null, revision: null, reportData: null, breadcrumbsEnabled: true, maxBreadcrumbs: 40, maxObjectDepth: 8, logger: console, developmentEnvironments: ['dev', 'development', 'test'], debug: false, tags: null, enableUncaught: true, enableUnhandledRejection: true, afterUncaught: function () { return true; }, filters: ['creditcard', 'password'], __plugins: [] }, opts);
 	        // First, we go with the global (shared) store.
 	        // Webserver middleware can then switch to the AsyncStore for async context tracking.
 	        this.__store = new store_1.GlobalStore({ context: {}, breadcrumbs: [] });
 	        this.__transport = transport;
 	        this.logger = (0, util_1$2.logger)(this);
 	    }
-	    getVersion() {
+	    Client.prototype.getVersion = function () {
 	        return notifier.version;
-	    }
-	    configure(opts = {}) {
-	        for (const k in opts) {
+	    };
+	    Client.prototype.configure = function (opts) {
+	        var _this = this;
+	        if (opts === void 0) { opts = {}; }
+	        for (var k in opts) {
 	            this.config[k] = opts[k];
 	        }
 	        if (!this.__pluginsExecuted) {
 	            this.__pluginsExecuted = true;
-	            this.config.__plugins.forEach((plugin) => plugin.load(this));
+	            this.config.__plugins.forEach(function (plugin) { return plugin.load(_this); });
 	        }
 	        return this;
-	    }
-	    __setStore(store) {
+	    };
+	    Client.prototype.__setStore = function (store) {
 	        this.__store = store;
-	    }
-	    beforeNotify(handler) {
+	    };
+	    Client.prototype.beforeNotify = function (handler) {
 	        this.__beforeNotifyHandlers.push(handler);
 	        return this;
-	    }
-	    afterNotify(handler) {
+	    };
+	    Client.prototype.afterNotify = function (handler) {
 	        this.__afterNotifyHandlers.push(handler);
 	        return this;
-	    }
-	    setContext(context) {
+	    };
+	    Client.prototype.setContext = function (context) {
 	        if (typeof context === 'object') {
-	            const store = this.__store.getStore();
+	            var store = this.__store.getStore();
 	            store.context = (0, util_1$2.merge)(store.context, context);
 	        }
 	        return this;
-	    }
-	    resetContext(context) {
+	    };
+	    Client.prototype.resetContext = function (context) {
 	        this.logger.warn('Deprecation warning: `Honeybadger.resetContext()` has been deprecated; please use `Honeybadger.clear()` instead.');
-	        const store = this.__store.getStore();
+	        var store = this.__store.getStore();
 	        if (typeof context === 'object' && context !== null) {
 	            store.context = context;
 	        }
@@ -718,16 +785,19 @@
 	            store.context = {};
 	        }
 	        return this;
-	    }
-	    clear() {
-	        const store = this.__store.getStore();
+	    };
+	    Client.prototype.clear = function () {
+	        var store = this.__store.getStore();
 	        store.context = {};
 	        store.breadcrumbs = [];
 	        return this;
-	    }
-	    notify(noticeable, name = undefined, extra = undefined) {
-	        let preConditionError = null;
-	        const notice = this.makeNotice(noticeable, name, extra);
+	    };
+	    Client.prototype.notify = function (noticeable, name, extra) {
+	        var _this = this;
+	        if (name === void 0) { name = undefined; }
+	        if (extra === void 0) { extra = undefined; }
+	        var preConditionError = null;
+	        var notice = this.makeNotice(noticeable, name, extra);
 	        if (!notice) {
 	            this.logger.debug('failed to build error report');
 	            preConditionError = new Error('failed to build error report');
@@ -746,8 +816,8 @@
 	        }
 	        // we need to have the source file data before the beforeNotifyHandlers,
 	        // in case they modify them
-	        const sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(trace => (0, util_1$2.shallowClone)(trace)) : null;
-	        const beforeNotifyResult = (0, util_1$2.runBeforeNotifyHandlers)(notice, this.__beforeNotifyHandlers);
+	        var sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(function (trace) { return (0, util_1$2.shallowClone)(trace); }) : null;
+	        var beforeNotifyResult = (0, util_1$2.runBeforeNotifyHandlers)(notice, this.__beforeNotifyHandlers);
 	        if (!preConditionError && !beforeNotifyResult) {
 	            this.logger.debug('skipping error report: beforeNotify handlers returned false', notice);
 	            preConditionError = new Error('beforeNotify handlers returned false');
@@ -764,58 +834,61 @@
 	                stack: notice.stack
 	            }
 	        });
-	        const breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
+	        var breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
 	        notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs.slice() : [];
 	        (0, util_1$2.getSourceForBacktrace)(sourceCodeData, this.__getSourceFileHandler)
-	            .then(sourcePerTrace => {
-	            sourcePerTrace.forEach((source, index) => {
+	            .then(function (sourcePerTrace) {
+	            sourcePerTrace.forEach(function (source, index) {
 	                notice.backtrace[index].source = source;
 	            });
-	            const payload = this.__buildPayload(notice);
-	            this.__transport
+	            var payload = _this.__buildPayload(notice);
+	            _this.__transport
 	                .send({
 	                headers: {
-	                    'X-API-Key': this.config.apiKey,
+	                    'X-API-Key': _this.config.apiKey,
 	                    'Content-Type': 'application/json',
 	                    'Accept': 'text/json, application/json'
 	                },
 	                method: 'POST',
-	                endpoint: (0, util_1$2.endpoint)(this.config.endpoint, '/v1/notices/js'),
-	                maxObjectDepth: this.config.maxObjectDepth,
-	                logger: this.logger,
-	                async: (0, util_1$2.isBrowserConfig)(this.config) ? this.config.async : undefined,
+	                endpoint: (0, util_1$2.endpoint)(_this.config.endpoint, '/v1/notices/js'),
+	                maxObjectDepth: _this.config.maxObjectDepth,
+	                logger: _this.logger,
+	                async: (0, util_1$2.isBrowserConfig)(_this.config) ? _this.config.async : undefined,
 	            }, payload)
-	                .then(res => {
+	                .then(function (res) {
 	                if (res.statusCode !== 201) {
-	                    (0, util_1$2.runAfterNotifyHandlers)(notice, this.__afterNotifyHandlers, new Error(`Bad HTTP response: ${res.statusCode}`));
-	                    this.logger.warn(`Error report failed: unknown response from server. code=${res.statusCode}`);
+	                    (0, util_1$2.runAfterNotifyHandlers)(notice, _this.__afterNotifyHandlers, new Error("Bad HTTP response: ".concat(res.statusCode)));
+	                    _this.logger.warn("Error report failed: unknown response from server. code=".concat(res.statusCode));
 	                    return;
 	                }
-	                const uuid = JSON.parse(res.body).id;
+	                var uuid = JSON.parse(res.body).id;
 	                (0, util_1$2.runAfterNotifyHandlers)((0, util_1$2.merge)(notice, {
 	                    id: uuid
-	                }), this.__afterNotifyHandlers);
-	                this.logger.info(`Error report sent ⚡ https://app.honeybadger.io/notice/${uuid}`);
+	                }), _this.__afterNotifyHandlers);
+	                _this.logger.info("Error report sent \u26A1 https://app.honeybadger.io/notice/".concat(uuid));
 	            })
-	                .catch(err => {
-	                this.logger.error('Error report failed: an unknown error occurred.', `message=${err.message}`);
-	                (0, util_1$2.runAfterNotifyHandlers)(notice, this.__afterNotifyHandlers, err);
+	                .catch(function (err) {
+	                _this.logger.error('Error report failed: an unknown error occurred.', "message=".concat(err.message));
+	                (0, util_1$2.runAfterNotifyHandlers)(notice, _this.__afterNotifyHandlers, err);
 	            });
 	        });
 	        return true;
-	    }
+	    };
 	    /**
 	     * An async version of {@link notify} that resolves only after the notice has been reported to Honeybadger.
 	     * Implemented using the {@link afterNotify} hook.
 	     * Rejects if for any reason the report failed to be reported.
 	     * Useful in serverless environments (AWS Lambda).
 	     */
-	    notifyAsync(noticeable, name = undefined, extra = undefined) {
-	        return new Promise((resolve, reject) => {
-	            const applyAfterNotify = (partialNotice) => {
-	                const originalAfterNotify = partialNotice.afterNotify;
-	                partialNotice.afterNotify = (err) => {
-	                    originalAfterNotify === null || originalAfterNotify === void 0 ? void 0 : originalAfterNotify.call(this, err);
+	    Client.prototype.notifyAsync = function (noticeable, name, extra) {
+	        var _this = this;
+	        if (name === void 0) { name = undefined; }
+	        if (extra === void 0) { extra = undefined; }
+	        return new Promise(function (resolve, reject) {
+	            var applyAfterNotify = function (partialNotice) {
+	                var originalAfterNotify = partialNotice.afterNotify;
+	                partialNotice.afterNotify = function (err) {
+	                    originalAfterNotify === null || originalAfterNotify === void 0 ? void 0 : originalAfterNotify.call(_this, err);
 	                    if (err) {
 	                        return reject(err);
 	                    }
@@ -823,7 +896,7 @@
 	                };
 	            };
 	            // We have to respect any afterNotify hooks that come from the arguments
-	            let objectToOverride;
+	            var objectToOverride;
 	            if (noticeable.afterNotify) {
 	                objectToOverride = noticeable;
 	            }
@@ -843,13 +916,15 @@
 	                objectToOverride = name = {};
 	            }
 	            applyAfterNotify(objectToOverride);
-	            this.notify(noticeable, name, extra);
+	            _this.notify(noticeable, name, extra);
 	        });
-	    }
-	    makeNotice(noticeable, name = undefined, extra = undefined) {
-	        let notice = (0, util_1$2.makeNotice)(noticeable);
+	    };
+	    Client.prototype.makeNotice = function (noticeable, name, extra) {
+	        if (name === void 0) { name = undefined; }
+	        if (extra === void 0) { extra = undefined; }
+	        var notice = (0, util_1$2.makeNotice)(noticeable);
 	        if (name && !(typeof name === 'object')) {
-	            const n = String(name);
+	            var n = String(name);
 	            name = { name: n };
 	        }
 	        if (name) {
@@ -861,13 +936,13 @@
 	        if ((0, util_1$2.objectIsEmpty)(notice)) {
 	            return null;
 	        }
-	        const context = this.__getStoreContentsOrDefault().context;
-	        const noticeTags = this.__constructTags(notice.tags);
-	        const contextTags = this.__constructTags(context['tags']);
-	        const configTags = this.__constructTags(this.config.tags);
+	        var context = this.__getStoreContentsOrDefault().context;
+	        var noticeTags = this.__constructTags(notice.tags);
+	        var contextTags = this.__constructTags(context['tags']);
+	        var configTags = this.__constructTags(this.config.tags);
 	        // Turning into a Set will remove duplicates
-	        const tags = noticeTags.concat(contextTags).concat(configTags);
-	        const uniqueTags = tags.filter((item, index) => tags.indexOf(item) === index);
+	        var tags = noticeTags.concat(contextTags).concat(configTags);
+	        var uniqueTags = tags.filter(function (item, index) { return tags.indexOf(item) === index; });
 	        notice = (0, util_1$2.merge)(notice, {
 	            name: notice.name || 'Error',
 	            context: (0, util_1$2.merge)(context, notice.context),
@@ -878,46 +953,46 @@
 	            revision: notice.revision || this.config.revision,
 	            tags: uniqueTags,
 	        });
-	        let backtraceShift = 0;
+	        var backtraceShift = 0;
 	        if (typeof notice.stack !== 'string' || !notice.stack.trim()) {
 	            notice.stack = (0, util_1$2.generateStackTrace)();
 	            backtraceShift = 2;
 	        }
 	        notice.backtrace = (0, util_1$2.makeBacktrace)(notice.stack, backtraceShift);
 	        return notice;
-	    }
-	    addBreadcrumb(message, opts) {
+	    };
+	    Client.prototype.addBreadcrumb = function (message, opts) {
 	        if (!this.config.breadcrumbsEnabled) {
 	            return;
 	        }
 	        opts = opts || {};
-	        const metadata = (0, util_1$2.shallowClone)(opts.metadata);
-	        const category = opts.category || 'custom';
-	        const timestamp = new Date().toISOString();
-	        const store = this.__store.getStore();
-	        let breadcrumbs = store.breadcrumbs;
+	        var metadata = (0, util_1$2.shallowClone)(opts.metadata);
+	        var category = opts.category || 'custom';
+	        var timestamp = new Date().toISOString();
+	        var store = this.__store.getStore();
+	        var breadcrumbs = store.breadcrumbs;
 	        breadcrumbs.push({
 	            category: category,
 	            message: message,
 	            metadata: metadata,
 	            timestamp: timestamp
 	        });
-	        const limit = this.config.maxBreadcrumbs;
+	        var limit = this.config.maxBreadcrumbs;
 	        if (breadcrumbs.length > limit) {
 	            breadcrumbs = breadcrumbs.slice(breadcrumbs.length - limit);
 	        }
 	        store.breadcrumbs = breadcrumbs;
 	        return this;
-	    }
-	    __developmentMode() {
+	    };
+	    Client.prototype.__developmentMode = function () {
 	        if (this.config.reportData === true) {
 	            return false;
 	        }
 	        return (this.config.environment && this.config.developmentEnvironments.includes(this.config.environment));
-	    }
-	    __buildPayload(notice) {
-	        const headers = (0, util_1$2.filter)(notice.headers, this.config.filters) || {};
-	        const cgiData = (0, util_1$2.filter)(Object.assign(Object.assign({}, notice.cgiData), (0, util_1$2.formatCGIData)(headers, 'HTTP_')), this.config.filters);
+	    };
+	    Client.prototype.__buildPayload = function (notice) {
+	        var headers = (0, util_1$2.filter)(notice.headers, this.config.filters) || {};
+	        var cgiData = (0, util_1$2.filter)(__assign$1(__assign$1({}, notice.cgiData), (0, util_1$2.formatCGIData)(headers, 'HTTP_')), this.config.filters);
 	        return {
 	            notifier: notifier,
 	            breadcrumbs: {
@@ -950,24 +1025,25 @@
 	            },
 	            details: notice.details || {}
 	        };
-	    }
-	    __constructTags(tags) {
+	    };
+	    Client.prototype.__constructTags = function (tags) {
 	        if (!tags) {
 	            return [];
 	        }
-	        return tags.toString().split(TAG_SEPARATOR).filter((tag) => NOT_BLANK.test(tag));
-	    }
+	        return tags.toString().split(TAG_SEPARATOR).filter(function (tag) { return NOT_BLANK.test(tag); });
+	    };
 	    /**
 	     * For ALS, the store may be uninitialized (if .run()` has not been called).
 	     * This provides an easy way to read the existing store object or fall back to a default.
 	     * Returns *a copy* of the s tore contents.
 	     */
-	    __getStoreContentsOrDefault() {
-	        const existingStoreContents = this.__store.getStore();
-	        const storeContents = existingStoreContents || {};
-	        return Object.assign({ context: {}, breadcrumbs: [] }, storeContents);
-	    }
-	}
+	    Client.prototype.__getStoreContentsOrDefault = function () {
+	        var existingStoreContents = this.__store.getStore();
+	        var storeContents = existingStoreContents || {};
+	        return __assign$1({ context: {}, breadcrumbs: [] }, storeContents);
+	    };
+	    return Client;
+	}());
 	client.Client = Client;
 
 	var types = {};
@@ -1020,46 +1096,46 @@
 	    if (!element || !element.tagName) {
 	        return '';
 	    }
-	    let name = element.tagName.toLowerCase();
+	    var name = element.tagName.toLowerCase();
 	    // Ignore the root <html> element in selectors and events.
 	    if (name === 'html') {
 	        return '';
 	    }
 	    if (element.id) {
-	        name += `#${element.id}`;
+	        name += "#".concat(element.id);
 	    }
-	    const stringClassNames = element.getAttribute('class');
+	    var stringClassNames = element.getAttribute('class');
 	    if (stringClassNames) {
-	        stringClassNames.split(/\s+/).forEach(className => {
-	            name += `.${className}`;
+	        stringClassNames.split(/\s+/).forEach(function (className) {
+	            name += ".".concat(className);
 	        });
 	    }
-	    ['alt', 'name', 'title', 'type'].forEach(attrName => {
-	        const attr = element.getAttribute(attrName);
+	    ['alt', 'name', 'title', 'type'].forEach(function (attrName) {
+	        var attr = element.getAttribute(attrName);
 	        if (attr) {
-	            name += `[${attrName}="${attr}"]`;
+	            name += "[".concat(attrName, "=\"").concat(attr, "\"]");
 	        }
 	    });
-	    const siblings = getSiblings(element);
+	    var siblings = getSiblings(element);
 	    if (siblings.length > 1) {
-	        name += `:nth-child(${Array.prototype.indexOf.call(siblings, element) + 1})`;
+	        name += ":nth-child(".concat(Array.prototype.indexOf.call(siblings, element) + 1, ")");
 	    }
 	    return name;
 	}
 	util.stringNameOfElement = stringNameOfElement;
 	function stringSelectorOfElement(element) {
-	    const name = stringNameOfElement(element);
+	    var name = stringNameOfElement(element);
 	    if (element.parentNode && element.parentNode.tagName) {
-	        const parentName = stringSelectorOfElement(element.parentNode);
+	        var parentName = stringSelectorOfElement(element.parentNode);
 	        if (parentName.length > 0) {
-	            return `${parentName} > ${name}`;
+	            return "".concat(parentName, " > ").concat(name);
 	        }
 	    }
 	    return name;
 	}
 	util.stringSelectorOfElement = stringSelectorOfElement;
 	function stringTextOfElement(element) {
-	    let text = element.textContent || element.innerText || '';
+	    var text = element.textContent || element.innerText || '';
 	    if (!text && (element.type === 'submit' || element.type === 'button')) {
 	        text = element.value;
 	    }
@@ -1076,10 +1152,10 @@
 	    // If fetch isn't native, it may be wrapped by someone else. Try to get
 	    // a pristine function from an iframe.
 	    try {
-	        const sandbox = document.createElement('iframe');
+	        var sandbox = document.createElement('iframe');
 	        sandbox.style.display = 'none';
 	        document.head.appendChild(sandbox);
-	        const result = sandbox.contentWindow.fetch && isNative(sandbox.contentWindow.fetch);
+	        var result = sandbox.contentWindow.fetch && isNative(sandbox.contentWindow.fetch);
 	        document.head.removeChild(sandbox);
 	        return result;
 	    }
@@ -1096,7 +1172,7 @@
 	}
 	function parseURL(url) {
 	    // Regexp: https://tools.ietf.org/html/rfc3986#appendix-B
-	    const match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/) || {};
+	    var match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/) || {};
 	    return {
 	        protocol: match[2],
 	        host: match[4],
@@ -1105,8 +1181,8 @@
 	}
 	util.parseURL = parseURL;
 	function localURLPathname(url) {
-	    const parsed = parseURL(url);
-	    const parsedDocURL = parseURL(document.URL);
+	    var parsed = parseURL(url);
+	    var parsedDocURL = parseURL(document.URL);
 	    // URL must be relative
 	    if (!parsed.host || !parsed.protocol) {
 	        return parsed.pathname;
@@ -1116,13 +1192,13 @@
 	        return parsed.pathname;
 	    }
 	    // x-domain
-	    return `${parsed.protocol}://${parsed.host}${parsed.pathname}`;
+	    return "".concat(parsed.protocol, "://").concat(parsed.host).concat(parsed.pathname);
 	}
 	util.localURLPathname = localURLPathname;
 	function decodeCookie(string) {
-	    const result = {};
-	    string.split(/[;,]\s?/).forEach((pair) => {
-	        const [key, value] = pair.split('=', 2);
+	    var result = {};
+	    string.split(/[;,]\s?/).forEach(function (pair) {
+	        var _a = pair.split('=', 2), key = _a[0], value = _a[1];
 	        result[key] = value;
 	    });
 	    return result;
@@ -1132,8 +1208,8 @@
 	    if (typeof object !== 'object') {
 	        return undefined;
 	    }
-	    const cookies = [];
-	    for (const k in object) {
+	    var cookies = [];
+	    for (var k in object) {
 	        cookies.push(k + '=' + object[k]);
 	    }
 	    return cookies.join(';');
@@ -1142,14 +1218,14 @@
 	// Helpers
 	function getSiblings(element) {
 	    try {
-	        const nodes = element.parentNode.childNodes;
-	        const siblings = [];
-	        Array.prototype.forEach.call(nodes, node => {
+	        var nodes = element.parentNode.childNodes;
+	        var siblings_1 = [];
+	        Array.prototype.forEach.call(nodes, function (node) {
 	            if (node.tagName && node.tagName === element.tagName) {
-	                siblings.push(node);
+	                siblings_1.push(node);
 	            }
 	        });
-	        return siblings;
+	        return siblings_1;
 	    }
 	    catch (e) {
 	        return [];
@@ -1165,7 +1241,7 @@
 	// handlers: try/catch, or `window.onerror`. When available, `window.onerror`
 	// will provide more information in modern browsers.
 	util.preferCatch = (function () {
-	    let preferCatch = true;
+	    var preferCatch = true;
 	    // IE < 10
 	    if (!window.atob) {
 	        preferCatch = false;
@@ -1189,24 +1265,25 @@
 	Object.defineProperty(onerror, "__esModule", { value: true });
 	onerror.onError = onerror.ignoreNextOnError = void 0;
 	/* eslint-disable prefer-rest-params */
-	const core_1$6 = src;
-	const { instrument: instrument$4, makeNotice } = core_1$6.Util;
-	let ignoreOnError = 0;
-	let currentTimeout;
+	var core_1$6 = src;
+	var instrument$4 = core_1$6.Util.instrument, makeNotice = core_1$6.Util.makeNotice;
+	var ignoreOnError = 0;
+	var currentTimeout;
 	function ignoreNextOnError() {
 	    ignoreOnError += 1;
 	    clearTimeout(currentTimeout);
-	    currentTimeout = setTimeout(() => {
+	    currentTimeout = setTimeout(function () {
 	        ignoreOnError = 0;
 	    });
 	}
 	onerror.ignoreNextOnError = ignoreNextOnError;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	function onError(_window = window) {
+	function onError(_window) {
+	    if (_window === void 0) { _window = window; }
 	    return {
-	        load: (client) => {
+	        load: function (client) {
 	            instrument$4(_window, 'onerror', function (original) {
-	                const onerror = function (msg, url, line, col, err) {
+	                var onerror = function (msg, url, line, col, err) {
 	                    client.logger.debug('window.onerror callback invoked', arguments);
 	                    if (ignoreOnError > 0) {
 	                        client.logger.debug('Ignoring window.onerror (error likely reported earlier)', arguments);
@@ -1221,7 +1298,7 @@
 	                        }
 	                        return;
 	                    }
-	                    const notice = makeNotice(err);
+	                    var notice = makeNotice(err);
 	                    if (!notice.name) {
 	                        notice.name = 'window.onerror';
 	                    }
@@ -1232,7 +1309,7 @@
 	                        // Simulate v8 stack
 	                        notice.stack = [notice.message, '\n    at ? (', url || 'unknown', ':', line || 0, ':', col || 0, ')'].join('');
 	                    }
-	                    client.addBreadcrumb((notice.name === 'window.onerror' || !notice.name) ? 'window.onerror' : `window.onerror: ${notice.name}`, {
+	                    client.addBreadcrumb((notice.name === 'window.onerror' || !notice.name) ? 'window.onerror' : "window.onerror: ".concat(notice.name), {
 	                        category: 'error',
 	                        metadata: {
 	                            name: notice.name,
@@ -1261,12 +1338,13 @@
 
 	Object.defineProperty(onunhandledrejection, "__esModule", { value: true });
 	/* eslint-disable prefer-rest-params */
-	const core_1$5 = src;
-	const { instrument: instrument$3 } = core_1$5.Util;
+	var core_1$5 = src;
+	var instrument$3 = core_1$5.Util.instrument;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	function default_1$3(_window = window) {
+	function default_1$3(_window) {
+	    if (_window === void 0) { _window = window; }
 	    return {
-	        load: (client) => {
+	        load: function (client) {
 	            if (!client.config.enableUnhandledRejection) {
 	                return;
 	            }
@@ -1278,31 +1356,31 @@
 	                    if (!client.config.enableUnhandledRejection) {
 	                        return;
 	                    }
-	                    const { reason } = promiseRejectionEvent;
+	                    var reason = promiseRejectionEvent.reason;
 	                    if (reason instanceof Error) {
 	                        // simulate v8 stack
 	                        // const fileName = reason.fileName || 'unknown'
 	                        // const lineNumber = reason.lineNumber || 0
-	                        const fileName = 'unknown';
-	                        const lineNumber = 0;
-	                        const stackFallback = `${reason.message}\n    at ? (${fileName}:${lineNumber})`;
-	                        const stack = reason.stack || stackFallback;
-	                        const err = {
+	                        var fileName = 'unknown';
+	                        var lineNumber = 0;
+	                        var stackFallback = "".concat(reason.message, "\n    at ? (").concat(fileName, ":").concat(lineNumber, ")");
+	                        var stack = reason.stack || stackFallback;
+	                        var err = {
 	                            name: reason.name,
-	                            message: `UnhandledPromiseRejectionWarning: ${reason}`,
-	                            stack
+	                            message: "UnhandledPromiseRejectionWarning: ".concat(reason),
+	                            stack: stack
 	                        };
-	                        client.addBreadcrumb(`window.onunhandledrejection: ${err.name}`, {
+	                        client.addBreadcrumb("window.onunhandledrejection: ".concat(err.name), {
 	                            category: 'error',
 	                            metadata: err
 	                        });
 	                        client.notify(err);
 	                        return;
 	                    }
-	                    const message = typeof reason === 'string' ? reason : ((_a = JSON.stringify(reason)) !== null && _a !== void 0 ? _a : 'Unspecified reason');
+	                    var message = typeof reason === 'string' ? reason : ((_a = JSON.stringify(reason)) !== null && _a !== void 0 ? _a : 'Unspecified reason');
 	                    client.notify({
 	                        name: 'window.onunhandledrejection',
-	                        message: `UnhandledPromiseRejectionWarning: ${message}`
+	                        message: "UnhandledPromiseRejectionWarning: ".concat(message)
 	                    });
 	                }
 	                return function (promiseRejectionEvent) {
@@ -1321,12 +1399,13 @@
 
 	Object.defineProperty(breadcrumbs, "__esModule", { value: true });
 	/* eslint-disable prefer-rest-params */
-	const core_1$4 = src;
-	const util_1$1 = util;
-	const { sanitize: sanitize$1, instrument: instrument$2 } = core_1$4.Util;
-	function default_1$2(_window = window) {
+	var core_1$4 = src;
+	var util_1$1 = util;
+	var sanitize$1 = core_1$4.Util.sanitize, instrument$2 = core_1$4.Util.instrument;
+	function default_1$2(_window) {
+	    if (_window === void 0) { _window = window; }
 	    return {
-	        load: (client) => {
+	        load: function (client) {
 	            function breadcrumbsEnabled(type) {
 	                if (client.config.breadcrumbsEnabled === true) {
 	                    return true;
@@ -1345,7 +1424,7 @@
 	                    if (!Array.isArray(obj)) {
 	                        return '';
 	                    }
-	                    return obj.map(value => {
+	                    return obj.map(function (value) {
 	                        try {
 	                            return String(value);
 	                        }
@@ -1354,12 +1433,12 @@
 	                        }
 	                    }).join(' ');
 	                }
-	                ['debug', 'info', 'warn', 'error', 'log'].forEach(level => {
+	                ['debug', 'info', 'warn', 'error', 'log'].forEach(function (level) {
 	                    instrument$2(_window.console, level, function (original) {
 	                        return function () {
-	                            const args = Array.prototype.slice.call(arguments);
-	                            const message = inspectArray(args);
-	                            const opts = {
+	                            var args = Array.prototype.slice.call(arguments);
+	                            var message = inspectArray(args);
+	                            var opts = {
 	                                category: 'log',
 	                                metadata: {
 	                                    level: level,
@@ -1379,8 +1458,8 @@
 	                if (!breadcrumbsEnabled('dom')) {
 	                    return;
 	                }
-	                _window.addEventListener('click', (event) => {
-	                    let message, selector, text;
+	                _window.addEventListener('click', function (event) {
+	                    var message, selector, text;
 	                    try {
 	                        message = (0, util_1$1.stringNameOfElement)(event.target);
 	                        selector = (0, util_1$1.stringSelectorOfElement)(event.target);
@@ -1398,9 +1477,9 @@
 	                    client.addBreadcrumb(message, {
 	                        category: 'ui.click',
 	                        metadata: {
-	                            selector,
-	                            text,
-	                            event
+	                            selector: selector,
+	                            text: text,
+	                            event: event
 	                        }
 	                    });
 	                }, true);
@@ -1414,15 +1493,15 @@
 	                instrument$2(XMLHttpRequest.prototype, 'open', function (original) {
 	                    return function () {
 	                        // eslint-disable-next-line @typescript-eslint/no-this-alias
-	                        const xhr = this;
-	                        const url = arguments[1];
-	                        const method = typeof arguments[0] === 'string' ? arguments[0].toUpperCase() : arguments[0];
-	                        const message = `${method} ${(0, util_1$1.localURLPathname)(url)}`;
+	                        var xhr = this;
+	                        var url = arguments[1];
+	                        var method = typeof arguments[0] === 'string' ? arguments[0].toUpperCase() : arguments[0];
+	                        var message = "".concat(method, " ").concat((0, util_1$1.localURLPathname)(url));
 	                        this.__hb_xhr = {
 	                            type: 'xhr',
-	                            method,
-	                            url,
-	                            message
+	                            method: method,
+	                            url: url,
+	                            message: message
 	                        };
 	                        if (typeof original === 'function') {
 	                            original.apply(xhr, arguments);
@@ -1433,10 +1512,10 @@
 	                instrument$2(XMLHttpRequest.prototype, 'send', function (original) {
 	                    return function () {
 	                        // eslint-disable-next-line @typescript-eslint/no-this-alias
-	                        const xhr = this;
+	                        var xhr = this;
 	                        function onreadystatechangeHandler() {
 	                            if (xhr.readyState === 4) {
-	                                let message;
+	                                var message = void 0;
 	                                if (xhr.__hb_xhr) {
 	                                    xhr.__hb_xhr.status_code = xhr.status;
 	                                    message = xhr.__hb_xhr.message;
@@ -1481,9 +1560,9 @@
 	                instrument$2(_window, 'fetch', function (original) {
 	                    return function () {
 	                        // eslint-disable-next-line prefer-rest-params
-	                        const input = arguments[0];
-	                        let method = 'GET';
-	                        let url;
+	                        var input = arguments[0];
+	                        var method = 'GET';
+	                        var url;
 	                        if (typeof input === 'string') {
 	                            url = input;
 	                        }
@@ -1502,11 +1581,11 @@
 	                        if (typeof method === 'string') {
 	                            method = method.toUpperCase();
 	                        }
-	                        const message = `${method} ${(0, util_1$1.localURLPathname)(url)}`;
-	                        const metadata = {
+	                        var message = "".concat(method, " ").concat((0, util_1$1.localURLPathname)(url));
+	                        var metadata = {
 	                            type: 'fetch',
-	                            method,
-	                            url
+	                            method: method,
+	                            url: url
 	                        };
 	                        return original
 	                            .apply(this, arguments)
@@ -1514,14 +1593,14 @@
 	                            metadata['status_code'] = response.status;
 	                            client.addBreadcrumb(message, {
 	                                category: 'request',
-	                                metadata
+	                                metadata: metadata
 	                            });
 	                            return response;
 	                        })
 	                            .catch(function (error) {
 	                            client.addBreadcrumb('fetch error', {
 	                                category: 'error',
-	                                metadata
+	                                metadata: metadata
 	                            });
 	                            throw error;
 	                        });
@@ -1534,14 +1613,14 @@
 	                    return;
 	                }
 	                // The last known href of the current page
-	                let lastHref = _window.location.href;
+	                var lastHref = _window.location.href;
 	                function recordUrlChange(from, to) {
 	                    lastHref = to;
 	                    client.addBreadcrumb('Page changed', {
 	                        category: 'navigation',
 	                        metadata: {
-	                            from,
-	                            to
+	                            from: from,
+	                            to: to
 	                        }
 	                    });
 	                }
@@ -1558,7 +1637,7 @@
 	                // https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState
 	                function historyWrapper(original) {
 	                    return function () {
-	                        const url = arguments.length > 2 ? arguments[2] : undefined;
+	                        var url = arguments.length > 2 ? arguments[2] : undefined;
 	                        if (url) {
 	                            recordUrlChange(lastHref, String(url));
 	                        }
@@ -1577,11 +1656,12 @@
 
 	Object.defineProperty(timers, "__esModule", { value: true });
 	/* eslint-disable prefer-rest-params */
-	const core_1$3 = src;
-	const { instrument: instrument$1 } = core_1$3.Util;
-	function default_1$1(_window = window) {
+	var core_1$3 = src;
+	var instrument$1 = core_1$3.Util.instrument;
+	function default_1$1(_window) {
+	    if (_window === void 0) { _window = window; }
 	    return {
-	        load: (client) => {
+	        load: function (client) {
 	            // Wrap timers
 	            (function () {
 	                function instrumentTimer(wrapOpts) {
@@ -1589,10 +1669,10 @@
 	                        // See https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout
 	                        return function (func, delay) {
 	                            if (typeof func === 'function') {
-	                                const args = Array.prototype.slice.call(arguments, 2);
+	                                var args_1 = Array.prototype.slice.call(arguments, 2);
 	                                func = client.__wrap(func, wrapOpts);
 	                                return original(function () {
-	                                    func(...args);
+	                                    func.apply(void 0, args_1);
 	                                }, delay);
 	                            }
 	                            else {
@@ -1612,20 +1692,21 @@
 	var event_listeners = {};
 
 	Object.defineProperty(event_listeners, "__esModule", { value: true });
-	const core_1$2 = src;
-	const { instrument } = core_1$2.Util;
-	function default_1(_window = window) {
+	var core_1$2 = src;
+	var instrument = core_1$2.Util.instrument;
+	function default_1(_window) {
+	    if (_window === void 0) { _window = window; }
 	    return {
-	        load: (client) => {
+	        load: function (client) {
 	            // Wrap event listeners
 	            // Event targets borrowed from bugsnag-js:
 	            // See https://github.com/bugsnag/bugsnag-js/blob/d55af916a4d3c7757f979d887f9533fe1a04cc93/src/bugsnag.js#L542
-	            const targets = ['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'];
+	            var targets = ['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'];
 	            targets.forEach(function (prop) {
-	                const prototype = _window[prop] && _window[prop].prototype;
+	                var prototype = _window[prop] && _window[prop].prototype;
 	                if (prototype && Object.prototype.hasOwnProperty.call(prototype, 'addEventListener')) {
 	                    instrument(prototype, 'addEventListener', function (original) {
-	                        const wrapOpts = { component: `${prop}.prototype.addEventListener` };
+	                        var wrapOpts = { component: "".concat(prop, ".prototype.addEventListener") };
 	                        // See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
 	                        return function (type, listener, useCapture, wantsUntrusted) {
 	                            try {
@@ -1657,83 +1738,116 @@
 
 	Object.defineProperty(transport, "__esModule", { value: true });
 	transport.BrowserTransport = void 0;
-	const core_1$1 = src;
-	const { sanitize } = core_1$1.Util;
-	class BrowserTransport {
-	    send(options, payload) {
-	        return new Promise((resolve, reject) => {
+	var core_1$1 = src;
+	var sanitize = core_1$1.Util.sanitize;
+	var BrowserTransport = /** @class */ (function () {
+	    function BrowserTransport() {
+	    }
+	    BrowserTransport.prototype.send = function (options, payload) {
+	        return new Promise(function (resolve, reject) {
 	            try {
-	                const x = new XMLHttpRequest();
-	                x.open(options.method, options.endpoint, options.async);
+	                var x_1 = new XMLHttpRequest();
+	                x_1.open(options.method, options.endpoint, options.async);
 	                if (Object.keys(options.headers || []).length) {
-	                    for (const i in options.headers) {
+	                    for (var i in options.headers) {
 	                        if (typeof options.headers[i] !== 'undefined') {
-	                            x.setRequestHeader(i, String(options.headers[i]));
+	                            x_1.setRequestHeader(i, String(options.headers[i]));
 	                        }
 	                    }
 	                }
-	                x.send(payload ? JSON.stringify(sanitize(payload, options.maxObjectDepth)) : undefined);
-	                x.onload = () => resolve({ statusCode: x.status, body: x.response });
+	                x_1.send(payload ? JSON.stringify(sanitize(payload, options.maxObjectDepth)) : undefined);
+	                x_1.onload = function () { return resolve({ statusCode: x_1.status, body: x_1.response }); };
 	            }
 	            catch (err) {
 	                reject(err);
 	            }
 	        });
-	    }
-	}
+	    };
+	    return BrowserTransport;
+	}());
 	transport.BrowserTransport = BrowserTransport;
 
+	var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+	    var extendStatics = function (d, b) {
+	        extendStatics = Object.setPrototypeOf ||
+	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+	        return extendStatics(d, b);
+	    };
+	    return function (d, b) {
+	        if (typeof b !== "function" && b !== null)
+	            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+	        extendStatics(d, b);
+	        function __() { this.constructor = d; }
+	        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+	    };
+	})();
+	var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
+	    __assign = Object.assign || function(t) {
+	        for (var s, i = 1, n = arguments.length; i < n; i++) {
+	            s = arguments[i];
+	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+	                t[p] = s[p];
+	        }
+	        return t;
+	    };
+	    return __assign.apply(this, arguments);
+	};
 	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
 	    return (mod && mod.__esModule) ? mod : { "default": mod };
 	};
 	Object.defineProperty(browser, "__esModule", { value: true });
-	const core_1 = src;
-	const util_1 = util;
-	const onerror_1 = onerror;
-	const onunhandledrejection_1 = __importDefault(onunhandledrejection);
-	const breadcrumbs_1 = __importDefault(breadcrumbs);
-	const timers_1 = __importDefault(timers);
-	const event_listeners_1 = __importDefault(event_listeners);
-	const transport_1 = transport;
-	const { merge, filter, objectIsExtensible } = core_1.Util;
-	class Honeybadger extends core_1.Client {
-	    constructor(opts = {}) {
-	        super(Object.assign({ async: true, maxErrors: null, projectRoot: window.location.protocol + '//' + window.location.host }, opts), new transport_1.BrowserTransport());
+	var core_1 = src;
+	var util_1 = util;
+	var onerror_1 = onerror;
+	var onunhandledrejection_1 = __importDefault(onunhandledrejection);
+	var breadcrumbs_1 = __importDefault(breadcrumbs);
+	var timers_1 = __importDefault(timers);
+	var event_listeners_1 = __importDefault(event_listeners);
+	var transport_1 = transport;
+	var merge = core_1.Util.merge, filter = core_1.Util.filter, objectIsExtensible = core_1.Util.objectIsExtensible;
+	var Honeybadger = /** @class */ (function (_super) {
+	    __extends(Honeybadger, _super);
+	    function Honeybadger(opts) {
+	        if (opts === void 0) { opts = {}; }
+	        var _this = _super.call(this, __assign({ async: true, maxErrors: null, projectRoot: window.location.protocol + '//' + window.location.host }, opts), new transport_1.BrowserTransport()) || this;
 	        /** @internal */
-	        this.__errorsSent = 0;
+	        _this.__errorsSent = 0;
 	        /** @internal */
-	        this.__lastWrapErr = undefined;
+	        _this.__lastWrapErr = undefined;
 	        /** @internal */
-	        this.__beforeNotifyHandlers = [
-	            (notice) => {
-	                if (this.__exceedsMaxErrors()) {
-	                    this.logger.debug('Dropping notice: max errors exceeded', notice);
+	        _this.__beforeNotifyHandlers = [
+	            function (notice) {
+	                if (_this.__exceedsMaxErrors()) {
+	                    _this.logger.debug('Dropping notice: max errors exceeded', notice);
 	                    return false;
 	                }
 	                if (notice && !notice.url) {
 	                    notice.url = document.URL;
 	                }
-	                this.__incrementErrorsCount();
+	                _this.__incrementErrorsCount();
 	                return true;
 	            }
 	        ];
+	        return _this;
 	    }
-	    configure(opts = {}) {
-	        return super.configure(opts);
-	    }
-	    resetMaxErrors() {
+	    Honeybadger.prototype.configure = function (opts) {
+	        if (opts === void 0) { opts = {}; }
+	        return _super.prototype.configure.call(this, opts);
+	    };
+	    Honeybadger.prototype.resetMaxErrors = function () {
 	        return (this.__errorsSent = 0);
-	    }
-	    factory(opts) {
+	    };
+	    Honeybadger.prototype.factory = function (opts) {
 	        // eslint-disable-next-line @typescript-eslint/no-explicit-any
 	        return new Honeybadger(opts);
-	    }
-	    checkIn(_id) {
+	    };
+	    Honeybadger.prototype.checkIn = function (_id) {
 	        throw new Error('Honeybadger.checkIn() is not supported on the browser');
-	    }
+	    };
 	    /** @internal */
-	    __buildPayload(notice) {
-	        const cgiData = {
+	    Honeybadger.prototype.__buildPayload = function (notice) {
+	        var cgiData = {
 	            HTTP_USER_AGENT: undefined,
 	            HTTP_REFERER: undefined,
 	            HTTP_COOKIE: undefined
@@ -1742,7 +1856,7 @@
 	        if (document.referrer.match(/\S/)) {
 	            cgiData.HTTP_REFERER = document.referrer;
 	        }
-	        let cookiesObject;
+	        var cookiesObject;
 	        if (typeof notice.cookies === 'string') {
 	            cookiesObject = (0, util_1.decodeCookie)(notice.cookies);
 	        }
@@ -1752,17 +1866,18 @@
 	        if (cookiesObject) {
 	            cgiData.HTTP_COOKIE = (0, util_1.encodeCookie)(filter(cookiesObject, this.config.filters));
 	        }
-	        const payload = super.__buildPayload(notice);
+	        var payload = _super.prototype.__buildPayload.call(this, notice);
 	        payload.request.cgi_data = merge(cgiData, payload.request.cgi_data);
 	        return payload;
-	    }
+	    };
 	    /**
 	     * wrap always returns the same function so that callbacks can be removed via
 	     * removeEventListener.
 	     * @internal
 	     */
-	    __wrap(f, opts = {}) {
-	        const func = f;
+	    Honeybadger.prototype.__wrap = function (f, opts) {
+	        if (opts === void 0) { opts = {}; }
+	        var func = f;
 	        if (!opts) {
 	            opts = {};
 	        }
@@ -1775,7 +1890,7 @@
 	            }
 	            if (!func.___hb) {
 	                // eslint-disable-next-line @typescript-eslint/no-this-alias
-	                const client = this;
+	                var client_1 = this;
 	                func.___hb = function () {
 	                    if (util_1.preferCatch) {
 	                        try {
@@ -1783,12 +1898,12 @@
 	                            return func.apply(this, arguments);
 	                        }
 	                        catch (err) {
-	                            if (client.__lastWrapErr === err) {
+	                            if (client_1.__lastWrapErr === err) {
 	                                throw (err);
 	                            }
-	                            client.__lastWrapErr = err;
+	                            client_1.__lastWrapErr = err;
 	                            (0, onerror_1.ignoreNextOnError)();
-	                            client.addBreadcrumb(opts.component ? `${opts.component}: ${err.name}` : err.name, {
+	                            client_1.addBreadcrumb(opts.component ? "".concat(opts.component, ": ").concat(err.name) : err.name, {
 	                                category: 'error',
 	                                metadata: {
 	                                    message: err.message,
@@ -1796,8 +1911,8 @@
 	                                    stack: err.stack
 	                                }
 	                            });
-	                            if (client.config.enableUncaught) {
-	                                client.notify(err);
+	                            if (client_1.config.enableUncaught) {
+	                                client_1.notify(err);
 	                            }
 	                            throw (err);
 	                        }
@@ -1814,16 +1929,17 @@
 	        catch (_e) {
 	            return func;
 	        }
-	    }
+	    };
 	    /** @internal */
-	    __incrementErrorsCount() {
+	    Honeybadger.prototype.__incrementErrorsCount = function () {
 	        return this.__errorsSent++;
-	    }
+	    };
 	    /** @internal */
-	    __exceedsMaxErrors() {
+	    Honeybadger.prototype.__exceedsMaxErrors = function () {
 	        return this.config.maxErrors && this.__errorsSent >= this.config.maxErrors;
-	    }
-	}
+	    };
+	    return Honeybadger;
+	}(core_1.Client));
 	var _default = browser.default = new Honeybadger({
 	    __plugins: [
 	        (0, onerror_1.onError)(),