@honeybadger-io/js 4.0.5 → 4.1.2

package/dist/server/honeybadger.js

@@ -1,102 +1,54 @@
 'use strict';
 
-var os = require('os');
-var domain = require('domain');
-var fs = require('fs');
-var util = require('util');
-var url = require('url');
-var http = require('http');
-var https = require('https');
+var require$$0$1 = require('os');
+var require$$1$1 = require('domain');
+var require$$1 = require('fs');
+var require$$2 = require('util');
+var require$$0$2 = require('url');
+var require$$2$1 = require('http');
+var require$$3 = require('https');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-var domain__default = /*#__PURE__*/_interopDefaultLegacy(domain);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
-var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
-var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-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);
-};
-
-function __extends(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 = function() {
-    __assign = Object.assign || function __assign(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);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(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 require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
+var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
+var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
+var require$$2__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$2$1);
+var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getAugmentedNamespace(n) {
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function () {
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
 }
 
+var server = {};
+
+var src = {};
+
+var client = {};
+
+var util$1 = {};
+
 var UNKNOWN_FUNCTION = '<unknown>';
 /**
  * This parses the different stack traces and puts them into one format
@@ -232,36 +184,88 @@ function parseNode(line) {
   };
 }
 
-function merge(obj1, obj2) {
+var stackTraceParser_esm = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	parse: parse
+});
+
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(stackTraceParser_esm);
+
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
     var result = {};
-    for (var k in obj1) {
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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);
+function merge(obj1, obj2) {
+    const result = {};
+    for (const k in obj1) {
         result[k] = obj1[k];
     }
-    for (var k in obj2) {
+    for (const k in obj2) {
         result[k] = obj2[k];
     }
     return result;
 }
+util$1.merge = merge;
 function mergeNotice(notice1, notice2) {
-    var result = merge(notice1, notice2);
+    const result = merge(notice1, notice2);
     if (notice1.context && notice2.context) {
         result.context = merge(notice1.context, notice2.context);
     }
     return result;
 }
+util$1.mergeNotice = mergeNotice;
 function objectIsEmpty(obj) {
-    for (var k in obj) {
+    for (const k in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, k)) {
             return false;
         }
     }
     return true;
 }
-function makeBacktrace(stack, shift) {
-    if (shift === void 0) { shift = 0; }
+util$1.objectIsEmpty = objectIsEmpty;
+function objectIsExtensible(obj) {
+    if (typeof Object.isExtensible !== 'function') {
+        return true;
+    }
+    return Object.isExtensible(obj);
+}
+util$1.objectIsExtensible = objectIsExtensible;
+function makeBacktrace(stack, shift = 0) {
     try {
-        var backtrace = parse(stack)
-            .map(function (line) {
+        const backtrace = stackTraceParser
+            .parse(stack)
+            .map(line => {
             return {
                 file: line.file,
                 method: line.methodName,
@@ -277,71 +281,81 @@ function makeBacktrace(stack, shift) {
         return [];
     }
 }
+util$1.makeBacktrace = makeBacktrace;
+function getCauses(notice) {
+    if (notice.cause) {
+        const causes = [];
+        let cause = notice;
+        while (causes.length < 3 && (cause = cause.cause)) {
+            causes.push({
+                class: cause.name,
+                message: cause.message,
+                backtrace: typeof cause.stack == 'string' ? makeBacktrace(cause.stack) : null
+            });
+        }
+        return causes;
+    }
+    return [];
+}
+util$1.getCauses = getCauses;
 function getSourceForBacktrace(backtrace, getSourceFileHandler) {
-    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];
-            }
-        });
+    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;
     });
 }
+util$1.getSourceForBacktrace = getSourceForBacktrace;
 function runBeforeNotifyHandlers(notice, handlers) {
-    var result = true;
-    for (var i = 0, len = handlers.length; i < len; i++) {
-        var handler = handlers[i];
+    let result = true;
+    for (let i = 0, len = handlers.length; i < len; i++) {
+        const handler = handlers[i];
         if (handler(notice) === false) {
             result = false;
         }
     }
     return result;
 }
+util$1.runBeforeNotifyHandlers = runBeforeNotifyHandlers;
 function runAfterNotifyHandlers(notice, handlers, error) {
     if (notice && notice.afterNotify) {
         notice.afterNotify(error, notice);
     }
-    for (var i = 0, len = handlers.length; i < len; i++) {
+    for (let i = 0, len = handlers.length; i < len; i++) {
         handlers[i](error, notice);
     }
     return true;
 }
+util$1.runAfterNotifyHandlers = runAfterNotifyHandlers;
 // Returns a new object with properties from other object.
 function shallowClone(obj) {
     if (typeof (obj) !== 'object' || obj === null) {
         return {};
     }
-    var result = {};
-    for (var k in obj) {
+    const result = {};
+    for (const k in obj) {
         result[k] = obj[k];
     }
     return result;
 }
-function sanitize(obj, maxDepth) {
-    if (maxDepth === void 0) { maxDepth = 8; }
-    var seenObjects = [];
+util$1.shallowClone = shallowClone;
+function sanitize$1(obj, maxDepth = 8) {
+    const seenObjects = [];
     function seen(obj) {
         if (!obj || typeof (obj) !== 'object') {
             return false;
         }
-        for (var i = 0; i < seenObjects.length; i++) {
-            var value = seenObjects[i];
+        for (let i = 0; i < seenObjects.length; i++) {
+            const value = seenObjects[i];
             if (value === obj) {
                 return true;
             }
@@ -350,7 +364,7 @@ function sanitize(obj, maxDepth) {
         return false;
     }
     function canSerialize(obj) {
-        var typeOfObj = typeof obj;
+        const typeOfObj = typeof obj;
         // Functions are TMI
         if (/function/.test(typeOfObj)) {
             // Let special toJSON method pass as it's used by JSON.stringify (#722)
@@ -369,8 +383,7 @@ function sanitize(obj, maxDepth) {
         }
         return true;
     }
-    function serialize(obj, depth) {
-        if (depth === void 0) { depth = 0; }
+    function serialize(obj, depth = 0) {
         if (depth >= maxDepth) {
             return '[DEPTH]';
         }
@@ -384,13 +397,13 @@ function sanitize(obj, maxDepth) {
         }
         // Serialize inside arrays
         if (Array.isArray(obj)) {
-            return obj.map(function (o) { return safeSerialize(o, depth + 1); });
+            return obj.map(o => safeSerialize(o, depth + 1));
         }
         // Serialize inside objects
         if (typeof (obj) === 'object') {
-            var ret = {};
-            for (var k in obj) {
-                var v = obj[k];
+            const ret = {};
+            for (const k in obj) {
+                const v = obj[k];
                 if (Object.prototype.hasOwnProperty.call(obj, k) && (k != null) && (v != null)) {
                     ret[k] = safeSerialize(v, depth + 1);
                 }
@@ -400,25 +413,20 @@ function sanitize(obj, maxDepth) {
         // Return everything else untouched
         return obj;
     }
-    function safeSerialize(obj, depth) {
-        if (depth === void 0) { depth = 0; }
+    function safeSerialize(obj, depth = 0) {
         try {
             return serialize(obj, depth);
         }
         catch (e) {
-            return "[ERROR] ".concat(e);
+            return `[ERROR] ${e}`;
         }
     }
     return safeSerialize(obj);
 }
+util$1.sanitize = sanitize$1;
 function logger(client) {
-    var log = function (method) {
-        return function () {
-            var _a;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
+    const log = (method) => {
+        return function (...args) {
             if (method === 'debug') {
                 if (!client.config.debug) {
                     return;
@@ -428,7 +436,7 @@ function logger(client) {
                 method = 'log';
             }
             args.unshift('[Honeybadger]');
-            (_a = client.config.logger)[method].apply(_a, args);
+            client.config.logger[method](...args);
         };
     };
     return {
@@ -439,33 +447,67 @@ function logger(client) {
         error: log('error')
     };
 }
+util$1.logger = logger;
 /**
  * Converts any object into a notice object (which at minimum has the same
  * properties as Error, but supports additional Honeybadger properties.)
  */
 function makeNotice(thing) {
-    var notice;
+    let notice;
     if (!thing) {
         notice = {};
     }
-    else if (thing instanceof Error || Object.prototype.toString.call(thing) === '[object Error]') {
-        var e = thing;
-        notice = merge(thing, { name: e.name, message: e.message, stack: e.stack });
+    else if (isErrorObject(thing)) {
+        const 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 {
-        var m = String(thing);
+        const m = String(thing);
         notice = { message: m };
     }
     return notice;
 }
-function endpoint(base, path) {
-    var endpoint = base.trim().replace(/\/$/, '');
+util$1.makeNotice = makeNotice;
+function isErrorObject(thing) {
+    return thing instanceof Error
+        || Object.prototype.toString.call(thing) === '[object Error]'; // Important for cross-realm objects
+}
+util$1.isErrorObject = isErrorObject;
+/**
+ * Instrument an existing function inside an object (usually global).
+ * @param {!Object} object
+ * @param {!String} name
+ * @param {!Function} replacement
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function instrument(object, name, replacement) {
+    if (!object || !name || !replacement || !(name in object)) {
+        return;
+    }
+    let original = object[name];
+    while (original && original.__hb_original) {
+        original = original.__hb_original;
+    }
+    try {
+        object[name] = replacement(original);
+        object[name].__hb_original = original;
+    }
+    catch (_e) {
+        // Ignores errors like this one:
+        //   Error: TypeError: Cannot set property onunhandledrejection of [object Object] which has only a getter
+        //   User-Agent: Mozilla/5.0 (Linux; Android 10; SAMSUNG SM-G960F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/12.1 Chrome/79.0.3945.136 Mobile Safari/537.36
+    }
+}
+util$1.instrument = instrument;
+function endpoint$1(base, path) {
+    const endpoint = base.trim().replace(/\/$/, '');
     path = path.trim().replace(/(^\/|\/$)/g, '');
-    return "".concat(endpoint, "/").concat(path);
+    return `${endpoint}/${path}`;
 }
+util$1.endpoint = endpoint$1;
 function generateStackTrace() {
     try {
         throw new Error('');
@@ -475,9 +517,9 @@ function generateStackTrace() {
             return e.stack;
         }
     }
-    var maxStackSize = 10;
-    var stack = [];
-    var curr = arguments.callee;
+    const maxStackSize = 10;
+    const stack = [];
+    let curr = arguments.callee;
     while (curr && stack.length < maxStackSize) {
         if (/function(?:\s+([\w$]+))+\s*\(/.test(curr.toString())) {
             stack.push(RegExp.$1 || '<anonymous>');
@@ -494,6 +536,7 @@ function generateStackTrace() {
     }
     return stack.join('\n');
 }
+util$1.generateStackTrace = generateStackTrace;
 function filter(obj, filters) {
     if (!is('Object', obj)) {
         return;
@@ -501,9 +544,9 @@ function filter(obj, filters) {
     if (!is('Array', filters)) {
         filters = [];
     }
-    var seen = [];
+    const seen = [];
     function filter(obj) {
-        var k, newObj;
+        let k, newObj;
         if (is('Object', obj) || is('Array', obj)) {
             if (seen.indexOf(obj) !== -1) {
                 return '[CIRCULAR DATA STRUCTURE]';
@@ -534,8 +577,9 @@ function filter(obj, filters) {
     }
     return filter(obj);
 }
+util$1.filter = filter;
 function filterMatch(key, filters) {
-    for (var i = 0; i < filters.length; i++) {
+    for (let i = 0; i < filters.length; i++) {
         if (key.toLowerCase().indexOf(filters[i].toLowerCase()) !== -1) {
             return true;
         }
@@ -543,7 +587,7 @@ function filterMatch(key, filters) {
     return false;
 }
 function is(type, obj) {
-    var klass = Object.prototype.toString.call(obj).slice(8, -1);
+    const klass = Object.prototype.toString.call(obj).slice(8, -1);
     return obj !== undefined && obj !== null && klass === type;
 }
 function filterUrl(url, filters) {
@@ -553,41 +597,45 @@ function filterUrl(url, filters) {
     if (typeof url !== 'string') {
         return url;
     }
-    var query = url.split(/\?/, 2)[1];
+    const query = url.split(/\?/, 2)[1];
     if (!query) {
         return url;
     }
-    var result = url;
-    query.split(/[&]\s?/).forEach(function (pair) {
-        var _a = pair.split('=', 2), key = _a[0], value = _a[1];
+    let result = url;
+    query.split(/[&]\s?/).forEach((pair) => {
+        const [key, value] = pair.split('=', 2);
         if (filterMatch(key, filters)) {
-            result = result.replace("".concat(key, "=").concat(value), "".concat(key, "=[FILTERED]"));
+            result = result.replace(`${key}=${value}`, `${key}=[FILTERED]`);
         }
     });
     return result;
 }
-function formatCGIData(vars, prefix) {
-    if (prefix === void 0) { prefix = ''; }
-    var formattedVars = {};
+util$1.filterUrl = filterUrl;
+function formatCGIData(vars, prefix = '') {
+    const formattedVars = {};
     Object.keys(vars).forEach(function (key) {
-        var formattedKey = prefix + key.replace(/\W/g, '_').toUpperCase();
+        const formattedKey = prefix + key.replace(/\W/g, '_').toUpperCase();
         formattedVars[formattedKey] = vars[key];
     });
     return formattedVars;
 }
-function getSourceCodeSnippet(fileData, lineNumber, sourceRadius) {
-    if (sourceRadius === void 0) { sourceRadius = 2; }
+util$1.formatCGIData = formatCGIData;
+function clone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+util$1.clone = clone;
+function getSourceCodeSnippet(fileData, lineNumber, sourceRadius = 2) {
     if (!fileData) {
         return null;
     }
-    var lines = fileData.split('\n');
+    const lines = fileData.split('\n');
     // add one empty line because array index starts from 0, but error line number is counted from 1
     lines.unshift('');
-    var start = lineNumber - sourceRadius;
-    var end = lineNumber + sourceRadius;
-    var result = {};
-    for (var i = start; i <= end; i++) {
-        var line = lines[i];
+    const start = lineNumber - sourceRadius;
+    const end = lineNumber + sourceRadius;
+    const result = {};
+    for (let i = start; i <= end; i++) {
+        const line = lines[i];
         if (typeof line === 'string') {
             result[i] = line;
         }
@@ -597,85 +645,86 @@ function getSourceCodeSnippet(fileData, lineNumber, sourceRadius) {
 function isBrowserConfig(config) {
     return config.async !== undefined;
 }
+util$1.isBrowserConfig = isBrowserConfig;
+
+var store = {};
 
-var GlobalStore = /** @class */ (function () {
-    function GlobalStore(store) {
+Object.defineProperty(store, "__esModule", { value: true });
+store.GlobalStore = void 0;
+class GlobalStore {
+    constructor(store) {
         this.store = store;
     }
-    GlobalStore.prototype.getStore = function () {
+    getStore() {
         return this.store;
-    };
-    GlobalStore.prototype.run = function (store, callback) {
-        var args = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
-        }
+    }
+    run(store, callback, ...args) {
         this.store = store;
-        return callback.apply(void 0, args);
-    };
-    return GlobalStore;
-}());
+        return callback(...args);
+    }
+}
+store.GlobalStore = GlobalStore;
 
-var notifier = {
+Object.defineProperty(client, "__esModule", { value: true });
+client.Client = void 0;
+const util_1$4 = util$1;
+const store_1 = store;
+const notifier = {
     name: 'honeybadger-js',
     url: 'https://github.com/honeybadger-io/honeybadger-js',
-    version: '4.0.5'
+    version: '4.1.2'
 };
 // Split at commas and spaces
-var TAG_SEPARATOR = /,|\s+/;
+const TAG_SEPARATOR = /,|\s+/;
 // Checks for non-blank characters
-var NOT_BLANK = /\S/;
-var Client = /** @class */ (function () {
-    function Client(opts, transport) {
-        if (opts === void 0) { opts = {}; }
+const NOT_BLANK = /\S/;
+class Client {
+    constructor(opts = {}, transport) {
         this.__pluginsExecuted = false;
         this.__store = null;
         this.__beforeNotifyHandlers = [];
         this.__afterNotifyHandlers = [];
-        this.config = __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: function () { return true; }, filters: ['creditcard', 'password'], __plugins: [] }, opts);
+        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);
         // First, we go with the global (shared) store.
         // Webserver middleware can then switch to the AsyncStore for async context tracking.
-        this.__store = new GlobalStore({ context: {}, breadcrumbs: [] });
+        this.__store = new store_1.GlobalStore({ context: {}, breadcrumbs: [] });
         this.__transport = transport;
-        this.logger = logger(this);
+        this.logger = (0, util_1$4.logger)(this);
     }
-    Client.prototype.getVersion = function () {
+    getVersion() {
         return notifier.version;
-    };
-    Client.prototype.configure = function (opts) {
-        var _this = this;
-        if (opts === void 0) { opts = {}; }
-        for (var k in opts) {
+    }
+    configure(opts = {}) {
+        for (const k in opts) {
             this.config[k] = opts[k];
         }
         if (!this.__pluginsExecuted) {
             this.__pluginsExecuted = true;
-            this.config.__plugins.forEach(function (plugin) { return plugin.load(_this); });
+            this.config.__plugins.forEach((plugin) => plugin.load(this));
         }
         return this;
-    };
-    /** @internal */
-    Client.prototype.__setStore = function (store) {
+    }
+    __setStore(store) {
         this.__store = store;
-    };
-    Client.prototype.beforeNotify = function (handler) {
+    }
+    beforeNotify(handler) {
         this.__beforeNotifyHandlers.push(handler);
         return this;
-    };
-    Client.prototype.afterNotify = function (handler) {
+    }
+    afterNotify(handler) {
         this.__afterNotifyHandlers.push(handler);
         return this;
-    };
-    Client.prototype.setContext = function (context) {
+    }
+    setContext(context) {
         if (typeof context === 'object') {
-            var store = this.__store.getStore();
-            store.context = merge(store.context, context);
+            const store = this.__store.getStore();
+            store.context = (0, util_1$4.merge)(store.context, context);
         }
         return this;
-    };
-    Client.prototype.resetContext = function (context) {
+    }
+    resetContext(context) {
         this.logger.warn('Deprecation warning: `Honeybadger.resetContext()` has been deprecated; please use `Honeybadger.clear()` instead.');
-        var store = this.__store.getStore();
+        const store = this.__store.getStore();
         if (typeof context === 'object' && context !== null) {
             store.context = context;
         }
@@ -683,19 +732,16 @@ var Client = /** @class */ (function () {
             store.context = {};
         }
         return this;
-    };
-    Client.prototype.clear = function () {
-        var store = this.__store.getStore();
+    }
+    clear() {
+        const store = this.__store.getStore();
         store.context = {};
         store.breadcrumbs = [];
         return this;
-    };
-    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);
+    }
+    notify(noticeable, name = undefined, extra = undefined) {
+        let preConditionError = null;
+        const notice = this.makeNotice(noticeable, name, extra);
         if (!notice) {
             this.logger.debug('failed to build error report');
             preConditionError = new Error('failed to build error report');
@@ -714,14 +760,14 @@ var Client = /** @class */ (function () {
         }
         // we need to have the source file data before the beforeNotifyHandlers,
         // in case they modify them
-        var sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(function (trace) { return shallowClone(trace); }) : null;
-        var beforeNotifyResult = runBeforeNotifyHandlers(notice, this.__beforeNotifyHandlers);
+        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);
         if (!preConditionError && !beforeNotifyResult) {
             this.logger.debug('skipping error report: beforeNotify handlers returned false', notice);
             preConditionError = new Error('beforeNotify handlers returned false');
         }
         if (preConditionError) {
-            runAfterNotifyHandlers(notice, this.__afterNotifyHandlers, preConditionError);
+            (0, util_1$4.runAfterNotifyHandlers)(notice, this.__afterNotifyHandlers, preConditionError);
             return false;
         }
         this.addBreadcrumb('Honeybadger Notice', {
@@ -732,61 +778,58 @@ var Client = /** @class */ (function () {
                 stack: notice.stack
             }
         });
-        var breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
+        const breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
         notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs.slice() : [];
-        getSourceForBacktrace(sourceCodeData, this.__getSourceFileHandler)
-            .then(function (sourcePerTrace) {
-            sourcePerTrace.forEach(function (source, index) {
+        (0, util_1$4.getSourceForBacktrace)(sourceCodeData, this.__getSourceFileHandler)
+            .then(sourcePerTrace => {
+            sourcePerTrace.forEach((source, index) => {
                 notice.backtrace[index].source = source;
             });
-            var payload = _this.__buildPayload(notice);
-            _this.__transport
+            const 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: endpoint(_this.config.endpoint, '/v1/notices/js'),
-                maxObjectDepth: _this.config.maxObjectDepth,
-                logger: _this.logger,
-                async: 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(function (res) {
+                .then(res => {
                 if (res.statusCode !== 201) {
-                    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));
+                    (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}`);
                     return;
                 }
-                var uuid = JSON.parse(res.body).id;
-                runAfterNotifyHandlers(merge(notice, {
+                const 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 \u26A1 https://app.honeybadger.io/notice/".concat(uuid));
+                }), this.__afterNotifyHandlers);
+                this.logger.info(`Error report sent ⚡ https://app.honeybadger.io/notice/${uuid}`);
             })
-                .catch(function (err) {
-                _this.logger.error('Error report failed: an unknown error occurred.', "message=".concat(err.message));
-                runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, err);
+                .catch(err => {
+                this.logger.error('Error report failed: an unknown error occurred.', `message=${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).
      */
-    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);
+    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);
                     if (err) {
                         return reject(err);
                     }
@@ -794,7 +837,7 @@ var Client = /** @class */ (function () {
                 };
             };
             // We have to respect any afterNotify hooks that come from the arguments
-            var objectToOverride;
+            let objectToOverride;
             if (noticeable.afterNotify) {
                 objectToOverride = noticeable;
             }
@@ -814,83 +857,81 @@ var Client = /** @class */ (function () {
                 objectToOverride = name = {};
             }
             applyAfterNotify(objectToOverride);
-            _this.notify(noticeable, name, extra);
+            this.notify(noticeable, name, extra);
         });
-    };
-    Client.prototype.makeNotice = function (noticeable, name, extra) {
-        if (name === void 0) { name = undefined; }
-        if (extra === void 0) { extra = undefined; }
-        var notice = makeNotice(noticeable);
+    }
+    makeNotice(noticeable, name = undefined, extra = undefined) {
+        let notice = (0, util_1$4.makeNotice)(noticeable);
         if (name && !(typeof name === 'object')) {
-            var n = String(name);
+            const n = String(name);
             name = { name: n };
         }
         if (name) {
-            notice = mergeNotice(notice, name);
+            notice = (0, util_1$4.mergeNotice)(notice, name);
         }
         if (typeof extra === 'object' && extra !== null) {
-            notice = mergeNotice(notice, extra);
+            notice = (0, util_1$4.mergeNotice)(notice, extra);
         }
-        if (objectIsEmpty(notice)) {
+        if ((0, util_1$4.objectIsEmpty)(notice)) {
             return null;
         }
-        var context = this.__getStoreContentsOrDefault().context;
-        var noticeTags = this.__constructTags(notice.tags);
-        var contextTags = this.__constructTags(context['tags']);
-        var configTags = this.__constructTags(this.config.tags);
+        const context = this.__getStoreContentsOrDefault().context;
+        const noticeTags = this.__constructTags(notice.tags);
+        const contextTags = this.__constructTags(context['tags']);
+        const configTags = this.__constructTags(this.config.tags);
         // Turning into a Set will remove duplicates
-        var tags = noticeTags.concat(contextTags).concat(configTags);
-        var uniqueTags = tags.filter(function (item, index) { return tags.indexOf(item) === index; });
-        notice = merge(notice, {
+        const tags = noticeTags.concat(contextTags).concat(configTags);
+        const uniqueTags = tags.filter((item, index) => tags.indexOf(item) === index);
+        notice = (0, util_1$4.merge)(notice, {
             name: notice.name || 'Error',
-            context: merge(context, notice.context),
+            context: (0, util_1$4.merge)(context, notice.context),
             projectRoot: notice.projectRoot || this.config.projectRoot,
             environment: notice.environment || this.config.environment,
             component: notice.component || this.config.component,
             action: notice.action || this.config.action,
             revision: notice.revision || this.config.revision,
-            tags: uniqueTags
+            tags: uniqueTags,
         });
-        var backtraceShift = 0;
+        let backtraceShift = 0;
         if (typeof notice.stack !== 'string' || !notice.stack.trim()) {
-            notice.stack = generateStackTrace();
+            notice.stack = (0, util_1$4.generateStackTrace)();
             backtraceShift = 2;
         }
-        notice.backtrace = makeBacktrace(notice.stack, backtraceShift);
+        notice.backtrace = (0, util_1$4.makeBacktrace)(notice.stack, backtraceShift);
         return notice;
-    };
-    Client.prototype.addBreadcrumb = function (message, opts) {
+    }
+    addBreadcrumb(message, opts) {
         if (!this.config.breadcrumbsEnabled) {
             return;
         }
         opts = opts || {};
-        var metadata = shallowClone(opts.metadata);
-        var category = opts.category || 'custom';
-        var timestamp = new Date().toISOString();
-        var store = this.__store.getStore();
-        var breadcrumbs = store.breadcrumbs;
+        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;
         breadcrumbs.push({
             category: category,
             message: message,
             metadata: metadata,
             timestamp: timestamp
         });
-        var limit = this.config.maxBreadcrumbs;
+        const limit = this.config.maxBreadcrumbs;
         if (breadcrumbs.length > limit) {
             breadcrumbs = breadcrumbs.slice(breadcrumbs.length - limit);
         }
         store.breadcrumbs = breadcrumbs;
         return this;
-    };
-    Client.prototype.__developmentMode = function () {
+    }
+    __developmentMode() {
         if (this.config.reportData === true) {
             return false;
         }
         return (this.config.environment && this.config.developmentEnvironments.includes(this.config.environment));
-    };
-    Client.prototype.__buildPayload = function (notice) {
-        var headers = filter(notice.headers, this.config.filters) || {};
-        var cgiData = filter(__assign(__assign({}, notice.cgiData), formatCGIData(headers, 'HTTP_')), this.config.filters);
+    }
+    __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);
         return {
             notifier: notifier,
             breadcrumbs: {
@@ -902,16 +943,17 @@ var Client = /** @class */ (function () {
                 message: notice.message,
                 backtrace: notice.backtrace,
                 fingerprint: notice.fingerprint,
-                tags: notice.tags
+                tags: notice.tags,
+                causes: (0, util_1$4.getCauses)(notice),
             },
             request: {
-                url: filterUrl(notice.url, this.config.filters),
+                url: (0, util_1$4.filterUrl)(notice.url, this.config.filters),
                 component: notice.component,
                 action: notice.action,
                 context: notice.context,
                 cgi_data: cgiData,
-                params: filter(notice.params, this.config.filters) || {},
-                session: filter(notice.session, this.config.filters) || {}
+                params: (0, util_1$4.filter)(notice.params, this.config.filters) || {},
+                session: (0, util_1$4.filter)(notice.session, this.config.filters) || {}
             },
             server: {
                 project_root: notice.projectRoot,
@@ -922,121 +964,173 @@ var Client = /** @class */ (function () {
             },
             details: notice.details || {}
         };
-    };
-    Client.prototype.__constructTags = function (tags) {
+    }
+    __constructTags(tags) {
         if (!tags) {
             return [];
         }
-        return tags.toString().split(TAG_SEPARATOR).filter(function (tag) { return NOT_BLANK.test(tag); });
-    };
+        return tags.toString().split(TAG_SEPARATOR).filter((tag) => 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 store contents.
-     * @internal
+     * Returns *a copy* of the s tore contents.
      */
-    Client.prototype.__getStoreContentsOrDefault = function () {
-        var existingStoreContents = this.__store.getStore();
-        var storeContents = existingStoreContents || {};
-        return __assign({ context: {}, breadcrumbs: [] }, storeContents);
-    };
-    return Client;
-}());
+    __getStoreContentsOrDefault() {
+        const existingStoreContents = this.__store.getStore();
+        const storeContents = existingStoreContents || {};
+        return Object.assign({ context: {}, breadcrumbs: [] }, storeContents);
+    }
+}
+client.Client = Client;
+
+var types = {};
+
+Object.defineProperty(types, "__esModule", { value: true });
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
+	    Object.defineProperty(o, "default", { enumerable: true, value: v });
+	}) : function(o, v) {
+	    o["default"] = v;
+	});
+	var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
+	    if (mod && mod.__esModule) return mod;
+	    var result = {};
+	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+	    __setModuleDefault(result, mod);
+	    return result;
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Util = exports.Types = exports.Store = exports.Client = void 0;
+	var client_1 = client;
+	Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+	exports.Store = __importStar(store);
+	exports.Types = __importStar(types);
+	exports.Util = __importStar(util$1);
+} (src));
 
-var readFile = util.promisify(fs__default["default"].readFile);
+var util = {};
+
+var __awaiter = (commonjsGlobal && commonjsGlobal.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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);
 function fatallyLogAndExit(err) {
     console.error('[Honeybadger] Exiting process due to uncaught exception');
     console.error(err.stack || err);
     process.exit(1);
 }
+util.fatallyLogAndExit = fatallyLogAndExit;
 function getStats() {
-    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__default["default"].loadavg();
-                    stats = {
-                        load: {
-                            one: load[0],
-                            five: load[1],
-                            fifteen: load[2]
-                        },
-                        mem: {}
-                    };
-                    fallback = function () {
-                        stats.mem = {
-                            free: os__default["default"].freemem(),
-                            total: os__default["default"].totalmem()
-                        };
-                    };
-                    if (!fs__default["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];
-            }
-        });
+    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;
     });
 }
+util.getStats = getStats;
 /**
  * Get source file if possible, used to build `notice.backtrace.source`
  *
  * @param path to source code
  */
 function getSourceFile(path) {
-    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*/];
-            }
-        });
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield readFile(path, 'utf-8');
+        }
+        catch (_e) {
+            return null;
+        }
     });
 }
+util.getSourceFile = getSourceFile;
+
+var uncaught_exception = {};
+
+var aws_lambda = {};
 
-var Store;
+var async_store = {};
+
+Object.defineProperty(async_store, "__esModule", { value: true });
+async_store.AsyncStore = void 0;
+const core_1$2 = src;
+let Store;
 try {
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    var AsyncLocalStorage = require('async_hooks').AsyncLocalStorage;
+    const { AsyncLocalStorage } = require('async_hooks');
     Store = new AsyncLocalStorage();
 }
 catch (e) {
-    Store = new GlobalStore({ context: {}, breadcrumbs: [] });
+    Store = new core_1$2.Store.GlobalStore({ context: {}, breadcrumbs: [] });
 }
-var AsyncStore = Store;
+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;
 function isHandlerSync(handler) {
     return handler.length > 2;
 }
@@ -1050,15 +1144,15 @@ function reportToHoneybadger(hb, err, callback) {
 }
 function asyncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context) {
-        hb.__setStore(AsyncStore);
-        return new Promise(function (resolve, reject) {
-            AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
-                var timeoutHandler = setupTimeoutWarning(hb, 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);
                 try {
                     handler(event, context)
                         .then(resolve)
-                        .catch(function (err) { return reportToHoneybadger(hb, err, reject); })
-                        .finally(function () { return clearTimeout(timeoutHandler); });
+                        .catch(err => reportToHoneybadger(hb, err, reject))
+                        .finally(() => clearTimeout(timeoutHandler));
                 }
                 catch (err) {
                     clearTimeout(timeoutHandler);
@@ -1070,11 +1164,11 @@ function asyncHandler(handler, hb) {
 }
 function syncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context, cb) {
-        hb.__setStore(AsyncStore);
-        AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
-            var timeoutHandler = setupTimeoutWarning(hb, context);
+        hb.__setStore(async_store_1$1.AsyncStore);
+        async_store_1$1.AsyncStore.run({ context: {}, breadcrumbs: [] }, () => {
+            const timeoutHandler = setupTimeoutWarning(hb, context);
             try {
-                handler(event, context, function (error, result) {
+                handler(event, context, (error, result) => {
                     clearTimeout(timeoutHandler);
                     if (error) {
                         return reportToHoneybadger(hb, error, cb);
@@ -1096,20 +1190,21 @@ function setupTimeoutWarning(hb, context) {
     if (!shouldReportTimeoutWarning(hb, context)) {
         return;
     }
-    var delay = context.getRemainingTimeInMillis() - (hb.config.timeoutWarningThresholdMs);
-    return setTimeout(function () {
-        hb.notify("".concat(context.functionName, "[").concat(context.functionVersion, "] may have timed out"));
+    const delay = context.getRemainingTimeInMillis() - (hb.config.timeoutWarningThresholdMs);
+    return setTimeout(() => {
+        hb.notify(`${context.functionName}[${context.functionVersion}] may have timed out`);
     }, delay > 0 ? delay : 0);
 }
 function lambdaHandler(handler) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
-    var hb = this;
+    const hb = this;
     if (isHandlerSync(handler)) {
         return syncHandler(handler, hb);
     }
     return asyncHandler(handler, hb);
 }
-var listenerRemoved = false;
+aws_lambda.lambdaHandler = lambdaHandler;
+let listenerRemoved = false;
 /**
  * Removes AWS Lambda default listener that
  * exits the process before letting us report to honeybadger.
@@ -1119,25 +1214,29 @@ function removeAwsDefaultUncaughtExceptionListener() {
         return;
     }
     listenerRemoved = true;
-    var listeners = process.listeners('uncaughtException');
+    const listeners = process.listeners('uncaughtException');
     if (listeners.length === 0) {
         return;
     }
     // We assume it's the first listener
     process.removeListener('uncaughtException', listeners[0]);
 }
+aws_lambda.removeAwsDefaultUncaughtExceptionListener = removeAwsDefaultUncaughtExceptionListener;
 
-var count = 0;
+Object.defineProperty(uncaught_exception, "__esModule", { value: true });
+const util_1$2 = util;
+const aws_lambda_1$1 = aws_lambda;
+let count = 0;
 function removeAwsLambdaListener() {
-    var isLambda = !!process.env.LAMBDA_TASK_ROOT;
+    const isLambda = !!process.env.LAMBDA_TASK_ROOT;
     if (!isLambda) {
         return;
     }
-    removeAwsDefaultUncaughtExceptionListener();
+    (0, aws_lambda_1$1.removeAwsDefaultUncaughtExceptionListener)();
 }
-function uncaughtException () {
+function default_1$1() {
     return {
-        load: function (client) {
+        load: (client) => {
             if (!client.config.enableUncaught) {
                 return;
             }
@@ -1145,11 +1244,11 @@ function uncaughtException () {
             process.on('uncaughtException', function honeybadgerUncaughtExceptionListener(uncaughtError) {
                 // Prevent recursive errors
                 if (count > 1) {
-                    fatallyLogAndExit(uncaughtError);
+                    (0, util_1$2.fatallyLogAndExit)(uncaughtError);
                 }
                 if (client.config.enableUncaught) {
                     client.notify(uncaughtError, {
-                        afterNotify: function (_err, _notice) {
+                        afterNotify: (_err, _notice) => {
                             count += 1;
                             client.config.afterUncaught(uncaughtError);
                         }
@@ -1163,10 +1262,14 @@ function uncaughtException () {
         }
     };
 }
+uncaught_exception.default = default_1$1;
+
+var unhandled_rejection = {};
 
-function unhandledRejection () {
+Object.defineProperty(unhandled_rejection, "__esModule", { value: true });
+function default_1() {
     return {
-        load: function (client) {
+        load: (client) => {
             if (!client.config.enableUnhandledRejection) {
                 return;
             }
@@ -1179,14 +1282,23 @@ function unhandledRejection () {
         }
     };
 }
+unhandled_rejection.default = default_1;
 
+var middleware = {};
+
+var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(middleware, "__esModule", { value: true });
+middleware.errorHandler = middleware.requestHandler = void 0;
+const url_1$1 = __importDefault$2(require$$0__default$1["default"]);
 function fullUrl(req) {
-    var connection = req.connection;
-    var address = connection && connection.address();
+    const connection = req.connection;
+    const address = connection && connection.address();
     // @ts-ignore The old @types/node incorrectly defines `address` as string|Address
-    var port = address ? address.port : undefined;
+    const port = address ? address.port : undefined;
     // @ts-ignore
-    return url__default["default"].format({
+    return url_1$1.default.format({
         protocol: req.protocol,
         hostname: req.hostname,
         port: port,
@@ -1197,6 +1309,7 @@ function fullUrl(req) {
 function requestHandler(req, res, next) {
     this.withRequest(req, next, next);
 }
+middleware.requestHandler = requestHandler;
 function errorHandler(err, req, _res, next) {
     this.notify(err, {
         url: fullUrl(req),
@@ -1212,82 +1325,105 @@ function errorHandler(err, req, _res, next) {
         return next(err);
     }
 }
+middleware.errorHandler = errorHandler;
 
-var ServerTransport = /** @class */ (function () {
-    function ServerTransport() {
-    }
-    ServerTransport.prototype.send = function (options, payload) {
-        var _this = this;
-        var _a = new url.URL(options.endpoint), protocol = _a.protocol, hostname = _a.hostname, pathname = _a.pathname;
-        var transport = (protocol === 'http:' ? http__default["default"] : https__default["default"]);
-        return new Promise(function (resolve, reject) {
-            var promise;
+var transport = {};
+
+var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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;
             // 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(function () {
+            promise.then(() => {
                 //
                 // 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
-                var httpOptions = {
+                const httpOptions = {
                     method: options.method,
                     headers: options.headers,
                     path: pathname,
-                    protocol: protocol,
-                    hostname: hostname,
+                    protocol,
+                    hostname,
                 };
-                var data = undefined;
+                let data = undefined;
                 if (payload) {
                     data = Buffer.from(JSON.stringify(sanitize(payload, options.maxObjectDepth)), 'utf8');
                     httpOptions.headers['Content-Length'] = data.length;
                 }
-                var req = transport.request(httpOptions, function (res) {
-                    options.logger.debug("statusCode: ".concat(res.statusCode));
-                    var body = '';
-                    res.on('data', function (chunk) {
+                const req = transport.request(httpOptions, (res) => {
+                    options.logger.debug(`statusCode: ${res.statusCode}`);
+                    let body = '';
+                    res.on('data', (chunk) => {
                         body += chunk;
                     });
-                    res.on('end', function () { return resolve({ statusCode: res.statusCode, body: body }); });
+                    res.on('end', () => resolve({ statusCode: res.statusCode, body }));
                 });
-                req.on('error', function (err) { return reject(err); });
+                req.on('error', (err) => reject(err));
                 if (data) {
                     req.write(data);
                 }
                 req.end();
             });
         });
-    };
-    ServerTransport.prototype.isNoticePayload = function (payload) {
+    }
+    isNoticePayload(payload) {
         return payload && payload.error !== undefined;
-    };
-    ServerTransport.prototype.appendMetadata = function (payload) {
+    }
+    appendMetadata(payload) {
         payload.server.pid = process.pid;
-        return getStats()
-            .then(function (stats) {
+        return (0, util_1$1.getStats)()
+            .then(stats => {
             payload.server.stats = stats;
         });
-    };
-    return ServerTransport;
-}());
-
-var kHoneybadgerStore = Symbol.for('kHoneybadgerStore');
-var Honeybadger = /** @class */ (function (_super) {
-    __extends(Honeybadger, _super);
-    function Honeybadger(opts) {
-        if (opts === void 0) { opts = {}; }
-        var _this = this;
+    }
+}
+transport.ServerTransport = ServerTransport;
+
+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 _a;
-        _this = _super.call(this, __assign({ afterUncaught: fatallyLogAndExit, projectRoot: process.cwd(), hostname: os__default["default"].hostname() }, opts), new ServerTransport()) || this;
+        super(Object.assign({ afterUncaught: util_1.fatallyLogAndExit, projectRoot: process.cwd(), hostname: os_1.default.hostname() }, opts), new transport_1.ServerTransport());
         /** @internal */
-        _this.__beforeNotifyHandlers = [
-            function (notice) {
+        this.__beforeNotifyHandlers = [
+            (notice) => {
                 if (notice && notice.backtrace) {
-                    notice.backtrace.forEach(function (line) {
+                    notice.backtrace.forEach((line) => {
                         if (line.file) {
                             line.file = line.file.replace(/.*\/node_modules\/(.+)/, '[NODE_MODULES]/$1');
                             line.file = line.file.replace(notice.projectRoot, '[PROJECT_ROOT]');
@@ -1298,39 +1434,36 @@ var Honeybadger = /** @class */ (function (_super) {
             }
         ];
         // serverless defaults
-        var config = _this.config;
+        const config = this.config;
         config.reportTimeoutWarning = (_a = config.reportTimeoutWarning) !== null && _a !== void 0 ? _a : true;
         config.timeoutWarningThresholdMs = config.timeoutWarningThresholdMs || 50;
-        _this.__getSourceFileHandler = getSourceFile.bind(_this);
-        _this.errorHandler = errorHandler.bind(_this);
-        _this.requestHandler = requestHandler.bind(_this);
-        _this.lambdaHandler = lambdaHandler.bind(_this);
-        return _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);
     }
-    Honeybadger.prototype.factory = function (opts) {
+    factory(opts) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new Honeybadger(opts);
-    };
-    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;
+    }
+    configure(opts = {}) {
+        return super.configure(opts);
+    }
+    checkIn(id) {
         return this.__transport
             .send({
             method: 'GET',
-            endpoint: endpoint(this.config.endpoint, "v1/check_in/".concat(id)),
+            endpoint: endpoint(this.config.endpoint, `v1/check_in/${id}`),
             logger: this.logger,
         })
-            .then(function () {
-            _this.logger.info('CheckIn sent');
+            .then(() => {
+            this.logger.info('CheckIn sent');
             return Promise.resolve();
         })
-            .catch(function (err) {
-            _this.logger.error('CheckIn failed: an unknown error occurred.', "message=".concat(err.message));
+            .catch(err => {
+            this.logger.error('CheckIn failed: an unknown error occurred.', `message=${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:
@@ -1338,10 +1471,9 @@ var Honeybadger = /** @class */ (function (_super) {
     // 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
-    Honeybadger.prototype.withRequest = function (request, handler, onError) {
-        var _this = this;
-        var storeObject = (request[kHoneybadgerStore] || this.__getStoreContentsOrDefault());
-        this.__setStore(AsyncStore);
+    withRequest(request, handler, onError) {
+        const storeObject = (request[kHoneybadgerStore] || this.__getStoreContentsOrDefault());
+        this.__setStore(async_store_1.AsyncStore);
         if (!request[kHoneybadgerStore]) {
             request[kHoneybadgerStore] = storeObject;
         }
@@ -1352,20 +1484,19 @@ var Honeybadger = /** @class */ (function (_super) {
             // 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
-            var dom = domain__default["default"].create();
-            var onErrorWithContext = function (err) { return _this.__store.run(storeObject, function () { return onError(err); }); };
+            const dom = domain_1.default.create();
+            const onErrorWithContext = (err) => this.__store.run(storeObject, () => onError(err));
             dom.on('error', onErrorWithContext);
             handler = dom.bind(handler);
         }
         return this.__store.run(storeObject, handler);
-    };
-    return Honeybadger;
-}(Client));
-var server = new Honeybadger({
+    }
+}
+var _default = server.default = new Honeybadger({
     __plugins: [
-        uncaughtException(),
-        unhandledRejection()
+        (0, uncaught_exception_1.default)(),
+        (0, unhandled_rejection_1.default)()
     ],
 });
 
-module.exports = server;
+module.exports = _default;