@honeybadger-io/js 4.1.2 → 4.1.3

package/dist/server/honeybadger.js

@@ -223,22 +223,49 @@ var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (this
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __generator$1 = (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(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;
 function mergeNotice(notice1, notice2) {
-    const result = merge(notice1, notice2);
+    var result = merge(notice1, notice2);
     if (notice1.context && notice2.context) {
         result.context = merge(notice1.context, notice2.context);
     }
@@ -246,7 +273,7 @@ function mergeNotice(notice1, notice2) {
 }
 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;
         }
@@ -261,11 +288,12 @@ function objectIsExtensible(obj) {
     return Object.isExtensible(obj);
 }
 util$1.objectIsExtensible = objectIsExtensible;
-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,
@@ -284,8 +312,8 @@ function makeBacktrace(stack, shift = 0) {
 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,
@@ -299,26 +327,36 @@ function getCauses(notice) {
 }
 util$1.getCauses = getCauses;
 function getSourceForBacktrace(backtrace, getSourceFileHandler) {
-    return __awaiter$1(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$1(this, void 0, void 0, function () {
+        var result, index, trace, fileContent;
+        return __generator$1(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;
         }
@@ -330,7 +368,7 @@ function runAfterNotifyHandlers(notice, handlers, error) {
     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;
@@ -341,21 +379,22 @@ function shallowClone(obj) {
     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$1(obj, maxDepth = 8) {
-    const seenObjects = [];
+function sanitize$1(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;
             }
@@ -364,7 +403,7 @@ function sanitize$1(obj, maxDepth = 8) {
         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)
@@ -383,7 +422,8 @@ function sanitize$1(obj, maxDepth = 8) {
         }
         return true;
     }
-    function serialize(obj, depth = 0) {
+    function serialize(obj, depth) {
+        if (depth === void 0) { depth = 0; }
         if (depth >= maxDepth) {
             return '[DEPTH]';
         }
@@ -397,13 +437,13 @@ function sanitize$1(obj, maxDepth = 8) {
         }
         // 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);
                 }
@@ -413,20 +453,26 @@ function sanitize$1(obj, maxDepth = 8) {
         // 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$1;
 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;
@@ -436,7 +482,7 @@ function logger(client) {
                 method = 'log';
             }
             args.unshift('[Honeybadger]');
-            client.config.logger[method](...args);
+            (_a = client.config.logger)[method].apply(_a, args);
         };
     };
     return {
@@ -453,19 +499,19 @@ util$1.logger = logger;
  * properties as Error, but supports additional Honeybadger properties.)
  */
 function makeNotice(thing) {
-    let notice;
+    var notice;
     if (!thing) {
         notice = {};
     }
     else if (isErrorObject(thing)) {
-        const e = thing;
+        var e = thing;
         notice = merge(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;
@@ -487,7 +533,7 @@ function instrument(object, name, replacement) {
     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;
     }
@@ -503,9 +549,9 @@ function instrument(object, name, replacement) {
 }
 util$1.instrument = instrument;
 function endpoint$1(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$1;
 function generateStackTrace() {
@@ -517,9 +563,9 @@ function generateStackTrace() {
             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>');
@@ -544,9 +590,9 @@ function filter(obj, filters) {
     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]';
@@ -579,7 +625,7 @@ function filter(obj, filters) {
 }
 util$1.filter = filter;
 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;
         }
@@ -587,7 +633,7 @@ function filterMatch(key, filters) {
     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) {
@@ -597,24 +643,25 @@ function filterUrl(url, filters) {
     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;
@@ -624,18 +671,19 @@ function clone(obj) {
     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;
         }
@@ -651,80 +699,99 @@ var store = {};
 
 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$4 = util$1;
-const store_1 = store;
-const notifier = {
+var util_1$4 = 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$4.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$4.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;
         }
@@ -732,16 +799,19 @@ class Client {
             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');
@@ -760,8 +830,8 @@ class Client {
         }
         // 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$4.shallowClone)(trace)) : null;
-        const beforeNotifyResult = (0, util_1$4.runBeforeNotifyHandlers)(notice, this.__beforeNotifyHandlers);
+        var sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(function (trace) { return (0, util_1$4.shallowClone)(trace); }) : null;
+        var beforeNotifyResult = (0, util_1$4.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');
@@ -778,58 +848,61 @@ class Client {
                 stack: notice.stack
             }
         });
-        const breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
+        var breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
         notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs.slice() : [];
         (0, util_1$4.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$4.endpoint)(this.config.endpoint, '/v1/notices/js'),
-                maxObjectDepth: this.config.maxObjectDepth,
-                logger: this.logger,
-                async: (0, util_1$4.isBrowserConfig)(this.config) ? this.config.async : undefined,
+                endpoint: (0, util_1$4.endpoint)(_this.config.endpoint, '/v1/notices/js'),
+                maxObjectDepth: _this.config.maxObjectDepth,
+                logger: _this.logger,
+                async: (0, util_1$4.isBrowserConfig)(_this.config) ? _this.config.async : undefined,
             }, payload)
-                .then(res => {
+                .then(function (res) {
                 if (res.statusCode !== 201) {
-                    (0, util_1$4.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$4.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$4.runAfterNotifyHandlers)((0, util_1$4.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$4.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$4.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);
                     }
@@ -837,7 +910,7 @@ class Client {
                 };
             };
             // We have to respect any afterNotify hooks that come from the arguments
-            let objectToOverride;
+            var objectToOverride;
             if (noticeable.afterNotify) {
                 objectToOverride = noticeable;
             }
@@ -857,13 +930,15 @@ class Client {
                 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$4.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$4.makeNotice)(noticeable);
         if (name && !(typeof name === 'object')) {
-            const n = String(name);
+            var n = String(name);
             name = { name: n };
         }
         if (name) {
@@ -875,13 +950,13 @@ class Client {
         if ((0, util_1$4.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$4.merge)(notice, {
             name: notice.name || 'Error',
             context: (0, util_1$4.merge)(context, notice.context),
@@ -892,46 +967,46 @@ class Client {
             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$4.generateStackTrace)();
             backtraceShift = 2;
         }
         notice.backtrace = (0, util_1$4.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$4.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$4.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$4.filter)(notice.headers, this.config.filters) || {};
-        const cgiData = (0, util_1$4.filter)(Object.assign(Object.assign({}, notice.cgiData), (0, util_1$4.formatCGIData)(headers, 'HTTP_')), this.config.filters);
+    };
+    Client.prototype.__buildPayload = function (notice) {
+        var headers = (0, util_1$4.filter)(notice.headers, this.config.filters) || {};
+        var cgiData = (0, util_1$4.filter)(__assign$1(__assign$1({}, notice.cgiData), (0, util_1$4.formatCGIData)(headers, 'HTTP_')), this.config.filters);
         return {
             notifier: notifier,
             breadcrumbs: {
@@ -964,24 +1039,25 @@ class Client {
             },
             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 = {};
@@ -1032,15 +1108,42 @@ var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisAr
         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 };
+    }
+};
 var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(util, "__esModule", { value: true });
 util.getSourceFile = util.getStats = util.fatallyLogAndExit = void 0;
-const os_1$1 = __importDefault$3(require$$0__default["default"]);
-const fs_1 = __importDefault$3(require$$1__default["default"]);
-const util_1$3 = require$$2__default["default"];
-const readFile = (0, util_1$3.promisify)(fs_1.default.readFile);
+var os_1$1 = __importDefault$3(require$$0__default["default"]);
+var fs_1 = __importDefault$3(require$$1__default["default"]);
+var util_1$3 = require$$2__default["default"];
+var readFile = (0, util_1$3.promisify)(fs_1.default.readFile);
 function fatallyLogAndExit(err) {
     console.error('[Honeybadger] Exiting process due to uncaught exception');
     console.error(err.stack || err);
@@ -1048,46 +1151,58 @@ function fatallyLogAndExit(err) {
 }
 util.fatallyLogAndExit = fatallyLogAndExit;
 function getStats() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const load = os_1$1.default.loadavg();
-        const stats = {
-            load: {
-                one: load[0],
-                five: load[1],
-                fifteen: load[2]
-            },
-            mem: {}
-        };
-        const fallback = () => {
-            stats.mem = {
-                free: os_1$1.default.freemem(),
-                total: os_1$1.default.totalmem()
-            };
-        };
-        if (!fs_1.default.existsSync('/proc/meminfo')) {
-            fallback();
-            return stats;
-        }
-        try {
-            const memData = yield readFile('/proc/meminfo', 'utf8');
-            // The first four lines, in order, are Total, Free, Buffers, Cached.
-            // @TODO: Figure out if there's a way to only read these lines
-            const data = memData.split('\n').slice(0, 4);
-            const results = data.map(function (i) {
-                return parseInt(/\s+(\d+)\skB/i.exec(i)[1], 10) / 1024.0;
-            });
-            stats.mem = {
-                total: results[0],
-                free: results[1],
-                buffers: results[2],
-                cached: results[3],
-                free_total: results[1] + results[2] + results[3]
-            };
-        }
-        catch (error) {
-            fallback();
-        }
-        return stats;
+    return __awaiter(this, void 0, void 0, function () {
+        var load, stats, fallback, memData, data, results;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    load = os_1$1.default.loadavg();
+                    stats = {
+                        load: {
+                            one: load[0],
+                            five: load[1],
+                            fifteen: load[2]
+                        },
+                        mem: {}
+                    };
+                    fallback = function () {
+                        stats.mem = {
+                            free: os_1$1.default.freemem(),
+                            total: os_1$1.default.totalmem()
+                        };
+                    };
+                    if (!fs_1.default.existsSync('/proc/meminfo')) {
+                        fallback();
+                        return [2 /*return*/, stats];
+                    }
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, readFile('/proc/meminfo', 'utf8')
+                        // The first four lines, in order, are Total, Free, Buffers, Cached.
+                        // @TODO: Figure out if there's a way to only read these lines
+                    ];
+                case 2:
+                    memData = _a.sent();
+                    data = memData.split('\n').slice(0, 4);
+                    results = data.map(function (i) {
+                        return parseInt(/\s+(\d+)\skB/i.exec(i)[1], 10) / 1024.0;
+                    });
+                    stats.mem = {
+                        total: results[0],
+                        free: results[1],
+                        buffers: results[2],
+                        cached: results[3],
+                        free_total: results[1] + results[2] + results[3]
+                    };
+                    return [3 /*break*/, 4];
+                case 3:
+                    _a.sent();
+                    fallback();
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/, stats];
+            }
+        });
     });
 }
 util.getStats = getStats;
@@ -1097,13 +1212,19 @@ util.getStats = getStats;
  * @param path to source code
  */
 function getSourceFile(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return yield readFile(path, 'utf-8');
-        }
-        catch (_e) {
-            return null;
-        }
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, readFile(path, 'utf-8')];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, null];
+                case 3: return [2 /*return*/];
+            }
+        });
     });
 }
 util.getSourceFile = getSourceFile;
@@ -1116,11 +1237,11 @@ var async_store = {};
 
 Object.defineProperty(async_store, "__esModule", { value: true });
 async_store.AsyncStore = void 0;
-const core_1$2 = src;
-let Store;
+var core_1$2 = src;
+var Store;
 try {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { AsyncLocalStorage } = require('async_hooks');
+    var AsyncLocalStorage = require('async_hooks').AsyncLocalStorage;
     Store = new AsyncLocalStorage();
 }
 catch (e) {
@@ -1130,7 +1251,7 @@ async_store.AsyncStore = Store;
 
 Object.defineProperty(aws_lambda, "__esModule", { value: true });
 aws_lambda.removeAwsDefaultUncaughtExceptionListener = aws_lambda.lambdaHandler = void 0;
-const async_store_1$1 = async_store;
+var async_store_1$1 = async_store;
 function isHandlerSync(handler) {
     return handler.length > 2;
 }
@@ -1145,14 +1266,14 @@ function reportToHoneybadger(hb, err, callback) {
 function asyncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context) {
         hb.__setStore(async_store_1$1.AsyncStore);
-        return new Promise((resolve, reject) => {
-            async_store_1$1.AsyncStore.run({ context: {}, breadcrumbs: [] }, () => {
-                const timeoutHandler = setupTimeoutWarning(hb, context);
+        return new Promise(function (resolve, reject) {
+            async_store_1$1.AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+                var timeoutHandler = setupTimeoutWarning(hb, context);
                 try {
                     handler(event, context)
                         .then(resolve)
-                        .catch(err => reportToHoneybadger(hb, err, reject))
-                        .finally(() => clearTimeout(timeoutHandler));
+                        .catch(function (err) { return reportToHoneybadger(hb, err, reject); })
+                        .finally(function () { return clearTimeout(timeoutHandler); });
                 }
                 catch (err) {
                     clearTimeout(timeoutHandler);
@@ -1165,10 +1286,10 @@ function asyncHandler(handler, hb) {
 function syncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context, cb) {
         hb.__setStore(async_store_1$1.AsyncStore);
-        async_store_1$1.AsyncStore.run({ context: {}, breadcrumbs: [] }, () => {
-            const timeoutHandler = setupTimeoutWarning(hb, context);
+        async_store_1$1.AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+            var timeoutHandler = setupTimeoutWarning(hb, context);
             try {
-                handler(event, context, (error, result) => {
+                handler(event, context, function (error, result) {
                     clearTimeout(timeoutHandler);
                     if (error) {
                         return reportToHoneybadger(hb, error, cb);
@@ -1190,21 +1311,21 @@ function setupTimeoutWarning(hb, context) {
     if (!shouldReportTimeoutWarning(hb, context)) {
         return;
     }
-    const delay = context.getRemainingTimeInMillis() - (hb.config.timeoutWarningThresholdMs);
-    return setTimeout(() => {
-        hb.notify(`${context.functionName}[${context.functionVersion}] may have timed out`);
+    var delay = context.getRemainingTimeInMillis() - (hb.config.timeoutWarningThresholdMs);
+    return setTimeout(function () {
+        hb.notify("".concat(context.functionName, "[").concat(context.functionVersion, "] may have timed out"));
     }, delay > 0 ? delay : 0);
 }
 function lambdaHandler(handler) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const hb = this;
+    var hb = this;
     if (isHandlerSync(handler)) {
         return syncHandler(handler, hb);
     }
     return asyncHandler(handler, hb);
 }
 aws_lambda.lambdaHandler = lambdaHandler;
-let listenerRemoved = false;
+var listenerRemoved = false;
 /**
  * Removes AWS Lambda default listener that
  * exits the process before letting us report to honeybadger.
@@ -1214,7 +1335,7 @@ function removeAwsDefaultUncaughtExceptionListener() {
         return;
     }
     listenerRemoved = true;
-    const listeners = process.listeners('uncaughtException');
+    var listeners = process.listeners('uncaughtException');
     if (listeners.length === 0) {
         return;
     }
@@ -1224,11 +1345,11 @@ function removeAwsDefaultUncaughtExceptionListener() {
 aws_lambda.removeAwsDefaultUncaughtExceptionListener = removeAwsDefaultUncaughtExceptionListener;
 
 Object.defineProperty(uncaught_exception, "__esModule", { value: true });
-const util_1$2 = util;
-const aws_lambda_1$1 = aws_lambda;
-let count = 0;
+var util_1$2 = util;
+var aws_lambda_1$1 = aws_lambda;
+var count = 0;
 function removeAwsLambdaListener() {
-    const isLambda = !!process.env.LAMBDA_TASK_ROOT;
+    var isLambda = !!process.env.LAMBDA_TASK_ROOT;
     if (!isLambda) {
         return;
     }
@@ -1236,7 +1357,7 @@ function removeAwsLambdaListener() {
 }
 function default_1$1() {
     return {
-        load: (client) => {
+        load: function (client) {
             if (!client.config.enableUncaught) {
                 return;
             }
@@ -1248,7 +1369,7 @@ function default_1$1() {
                 }
                 if (client.config.enableUncaught) {
                     client.notify(uncaughtError, {
-                        afterNotify: (_err, _notice) => {
+                        afterNotify: function (_err, _notice) {
                             count += 1;
                             client.config.afterUncaught(uncaughtError);
                         }
@@ -1269,7 +1390,7 @@ var unhandled_rejection = {};
 Object.defineProperty(unhandled_rejection, "__esModule", { value: true });
 function default_1() {
     return {
-        load: (client) => {
+        load: function (client) {
             if (!client.config.enableUnhandledRejection) {
                 return;
             }
@@ -1291,12 +1412,12 @@ var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || fu
 };
 Object.defineProperty(middleware, "__esModule", { value: true });
 middleware.errorHandler = middleware.requestHandler = void 0;
-const url_1$1 = __importDefault$2(require$$0__default$1["default"]);
+var url_1$1 = __importDefault$2(require$$0__default$1["default"]);
 function fullUrl(req) {
-    const connection = req.connection;
-    const address = connection && connection.address();
+    var connection = req.connection;
+    var address = connection && connection.address();
     // @ts-ignore The old @types/node incorrectly defines `address` as string|Address
-    const port = address ? address.port : undefined;
+    var port = address ? address.port : undefined;
     // @ts-ignore
     return url_1$1.default.format({
         protocol: req.protocol,
@@ -1334,96 +1455,129 @@ var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || fu
 };
 Object.defineProperty(transport, "__esModule", { value: true });
 transport.ServerTransport = void 0;
-const core_1$1 = src;
-const url_1 = require$$0__default$1["default"];
-const http_1 = __importDefault$1(require$$2__default$1["default"]);
-const https_1 = __importDefault$1(require$$3__default["default"]);
-const util_1$1 = util;
-const { sanitize } = core_1$1.Util;
-class ServerTransport {
-    send(options, payload) {
-        const { protocol, hostname, pathname } = new url_1.URL(options.endpoint);
-        const transport = (protocol === 'http:' ? http_1.default : https_1.default);
-        return new Promise((resolve, reject) => {
-            let promise;
+var core_1$1 = src;
+var url_1 = require$$0__default$1["default"];
+var http_1 = __importDefault$1(require$$2__default$1["default"]);
+var https_1 = __importDefault$1(require$$3__default["default"]);
+var util_1$1 = util;
+var sanitize = core_1$1.Util.sanitize;
+var ServerTransport = /** @class */ (function () {
+    function ServerTransport() {
+    }
+    ServerTransport.prototype.send = function (options, payload) {
+        var _this = this;
+        var _a = new url_1.URL(options.endpoint), protocol = _a.protocol, hostname = _a.hostname, pathname = _a.pathname;
+        var transport = (protocol === 'http:' ? http_1.default : https_1.default);
+        return new Promise(function (resolve, reject) {
+            var promise;
             // this should not be here. it should be done before reaching the transport layer
             // it could be inside a beforeNotifyHandler, but is not possible at the moment because those handlers are synchronous
-            if (this.isNoticePayload(payload)) {
-                promise = this.appendMetadata(payload);
+            if (_this.isNoticePayload(payload)) {
+                promise = _this.appendMetadata(payload);
             }
             else {
                 promise = Promise.resolve();
             }
-            promise.then(() => {
+            promise.then(function () {
                 //
                 // We use a httpOptions object to limit issues with libraries that may patch Node.js
                 // See https://github.com/honeybadger-io/honeybadger-js/issues/825#issuecomment-1193113433
-                const httpOptions = {
+                var httpOptions = {
                     method: options.method,
                     headers: options.headers,
                     path: pathname,
-                    protocol,
-                    hostname,
+                    protocol: protocol,
+                    hostname: hostname,
                 };
-                let data = undefined;
+                var data = undefined;
                 if (payload) {
                     data = Buffer.from(JSON.stringify(sanitize(payload, options.maxObjectDepth)), 'utf8');
                     httpOptions.headers['Content-Length'] = data.length;
                 }
-                const req = transport.request(httpOptions, (res) => {
-                    options.logger.debug(`statusCode: ${res.statusCode}`);
-                    let body = '';
-                    res.on('data', (chunk) => {
+                var req = transport.request(httpOptions, function (res) {
+                    options.logger.debug("statusCode: ".concat(res.statusCode));
+                    var body = '';
+                    res.on('data', function (chunk) {
                         body += chunk;
                     });
-                    res.on('end', () => resolve({ statusCode: res.statusCode, body }));
+                    res.on('end', function () { return resolve({ statusCode: res.statusCode, body: body }); });
                 });
-                req.on('error', (err) => reject(err));
+                req.on('error', function (err) { return reject(err); });
                 if (data) {
                     req.write(data);
                 }
                 req.end();
             });
         });
-    }
-    isNoticePayload(payload) {
+    };
+    ServerTransport.prototype.isNoticePayload = function (payload) {
         return payload && payload.error !== undefined;
-    }
-    appendMetadata(payload) {
+    };
+    ServerTransport.prototype.appendMetadata = function (payload) {
         payload.server.pid = process.pid;
         return (0, util_1$1.getStats)()
-            .then(stats => {
+            .then(function (stats) {
             payload.server.stats = stats;
         });
-    }
-}
+    };
+    return ServerTransport;
+}());
 transport.ServerTransport = ServerTransport;
 
+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(server, "__esModule", { value: true });
-const os_1 = __importDefault(require$$0__default["default"]);
-const domain_1 = __importDefault(require$$1__default$1["default"]);
-const core_1 = src;
-const util_1 = util;
-const uncaught_exception_1 = __importDefault(uncaught_exception);
-const unhandled_rejection_1 = __importDefault(unhandled_rejection);
-const middleware_1 = middleware;
-const aws_lambda_1 = aws_lambda;
-const async_store_1 = async_store;
-const transport_1 = transport;
-const { endpoint } = core_1.Util;
-const kHoneybadgerStore = Symbol.for('kHoneybadgerStore');
-class Honeybadger extends core_1.Client {
-    constructor(opts = {}) {
+var os_1 = __importDefault(require$$0__default["default"]);
+var domain_1 = __importDefault(require$$1__default$1["default"]);
+var core_1 = src;
+var util_1 = util;
+var uncaught_exception_1 = __importDefault(uncaught_exception);
+var unhandled_rejection_1 = __importDefault(unhandled_rejection);
+var middleware_1 = middleware;
+var aws_lambda_1 = aws_lambda;
+var async_store_1 = async_store;
+var transport_1 = transport;
+var endpoint = core_1.Util.endpoint;
+var kHoneybadgerStore = Symbol.for('kHoneybadgerStore');
+var Honeybadger = /** @class */ (function (_super) {
+    __extends(Honeybadger, _super);
+    function Honeybadger(opts) {
+        if (opts === void 0) { opts = {}; }
+        var _this = this;
         var _a;
-        super(Object.assign({ afterUncaught: util_1.fatallyLogAndExit, projectRoot: process.cwd(), hostname: os_1.default.hostname() }, opts), new transport_1.ServerTransport());
+        _this = _super.call(this, __assign({ afterUncaught: util_1.fatallyLogAndExit, projectRoot: process.cwd(), hostname: os_1.default.hostname() }, opts), new transport_1.ServerTransport()) || this;
         /** @internal */
-        this.__beforeNotifyHandlers = [
-            (notice) => {
+        _this.__beforeNotifyHandlers = [
+            function (notice) {
                 if (notice && notice.backtrace) {
-                    notice.backtrace.forEach((line) => {
+                    notice.backtrace.forEach(function (line) {
                         if (line.file) {
                             line.file = line.file.replace(/.*\/node_modules\/(.+)/, '[NODE_MODULES]/$1');
                             line.file = line.file.replace(notice.projectRoot, '[PROJECT_ROOT]');
@@ -1434,36 +1588,39 @@ class Honeybadger extends core_1.Client {
             }
         ];
         // serverless defaults
-        const config = this.config;
+        var config = _this.config;
         config.reportTimeoutWarning = (_a = config.reportTimeoutWarning) !== null && _a !== void 0 ? _a : true;
         config.timeoutWarningThresholdMs = config.timeoutWarningThresholdMs || 50;
-        this.__getSourceFileHandler = util_1.getSourceFile.bind(this);
-        this.errorHandler = middleware_1.errorHandler.bind(this);
-        this.requestHandler = middleware_1.requestHandler.bind(this);
-        this.lambdaHandler = aws_lambda_1.lambdaHandler.bind(this);
+        _this.__getSourceFileHandler = util_1.getSourceFile.bind(_this);
+        _this.errorHandler = middleware_1.errorHandler.bind(_this);
+        _this.requestHandler = middleware_1.requestHandler.bind(_this);
+        _this.lambdaHandler = aws_lambda_1.lambdaHandler.bind(_this);
+        return _this;
     }
-    factory(opts) {
+    Honeybadger.prototype.factory = function (opts) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new Honeybadger(opts);
-    }
-    configure(opts = {}) {
-        return super.configure(opts);
-    }
-    checkIn(id) {
+    };
+    Honeybadger.prototype.configure = function (opts) {
+        if (opts === void 0) { opts = {}; }
+        return _super.prototype.configure.call(this, opts);
+    };
+    Honeybadger.prototype.checkIn = function (id) {
+        var _this = this;
         return this.__transport
             .send({
             method: 'GET',
-            endpoint: endpoint(this.config.endpoint, `v1/check_in/${id}`),
+            endpoint: endpoint(this.config.endpoint, "v1/check_in/".concat(id)),
             logger: this.logger,
         })
-            .then(() => {
-            this.logger.info('CheckIn sent');
+            .then(function () {
+            _this.logger.info('CheckIn sent');
             return Promise.resolve();
         })
-            .catch(err => {
-            this.logger.error('CheckIn failed: an unknown error occurred.', `message=${err.message}`);
+            .catch(function (err) {
+            _this.logger.error('CheckIn failed: an unknown error occurred.', "message=".concat(err.message));
         });
-    }
+    };
     // This method is intended for web frameworks.
     // It allows us to track context for individual requests without leaking to other requests
     // by doing two things:
@@ -1471,8 +1628,9 @@ class Honeybadger extends core_1.Client {
     // 2. Attaching the store contents to the request object,
     //   so, even if the store is destroyed, we can still recover the context for a given request
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    withRequest(request, handler, onError) {
-        const storeObject = (request[kHoneybadgerStore] || this.__getStoreContentsOrDefault());
+    Honeybadger.prototype.withRequest = function (request, handler, onError) {
+        var _this = this;
+        var storeObject = (request[kHoneybadgerStore] || this.__getStoreContentsOrDefault());
         this.__setStore(async_store_1.AsyncStore);
         if (!request[kHoneybadgerStore]) {
             request[kHoneybadgerStore] = storeObject;
@@ -1484,14 +1642,15 @@ class Honeybadger extends core_1.Client {
             // But the `onError` handler might be request-specific.
             // Note that this doesn't still handle all cases. `domain` has its own problems:
             // See https://github.com/honeybadger-io/honeybadger-js/pull/711
-            const dom = domain_1.default.create();
-            const onErrorWithContext = (err) => this.__store.run(storeObject, () => onError(err));
+            var dom = domain_1.default.create();
+            var onErrorWithContext = function (err) { return _this.__store.run(storeObject, function () { return onError(err); }); };
             dom.on('error', onErrorWithContext);
             handler = dom.bind(handler);
         }
         return this.__store.run(storeObject, handler);
-    }
-}
+    };
+    return Honeybadger;
+}(core_1.Client));
 var _default = server.default = new Honeybadger({
     __plugins: [
         (0, uncaught_exception_1.default)(),