@honeybadger-io/js 6.15.2 → 6.16.0

package/dist/server/fastify.js

@@ -0,0 +1,2149 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var require$$0$2 = require('crypto');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
+
+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 fastify = {};
+
+var src = {};
+
+var console_events = {};
+
+var util = {};
+
+var UNKNOWN_FUNCTION = '<unknown>';
+/**
+ * This parses the different stack traces and puts them into one format
+ * This borrows heavily from TraceKit (https://github.com/csnover/TraceKit)
+ */
+
+function parse(stackString) {
+  var lines = stackString.split('\n');
+  return lines.reduce(function (stack, line) {
+    var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseNode(line) || parseJSC(line);
+
+    if (parseResult) {
+      stack.push(parseResult);
+    }
+
+    return stack;
+  }, []);
+}
+var chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|rsc|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+var chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+
+function parseChrome(line) {
+  var parts = chromeRe.exec(line);
+
+  if (!parts) {
+    return null;
+  }
+
+  var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line
+
+  var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
+
+  var submatch = chromeEvalRe.exec(parts[2]);
+
+  if (isEval && submatch != null) {
+    // throw out eval line/column and use top-most line/column number
+    parts[2] = submatch[1]; // url
+
+    parts[3] = submatch[2]; // line
+
+    parts[4] = submatch[3]; // column
+  }
+
+  return {
+    file: !isNative ? parts[2] : null,
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: isNative ? [parts[2]] : [],
+    lineNumber: parts[3] ? +parts[3] : null,
+    column: parts[4] ? +parts[4] : null
+  };
+}
+
+var winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|rsc|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+function parseWinjs(line) {
+  var parts = winjsRe.exec(line);
+
+  if (!parts) {
+    return null;
+  }
+
+  return {
+    file: parts[2],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: [],
+    lineNumber: +parts[3],
+    column: parts[4] ? +parts[4] : null
+  };
+}
+
+var geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|rsc|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
+var geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+
+function parseGecko(line) {
+  var parts = geckoRe.exec(line);
+
+  if (!parts) {
+    return null;
+  }
+
+  var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
+  var submatch = geckoEvalRe.exec(parts[3]);
+
+  if (isEval && submatch != null) {
+    // throw out eval line/column and use top-most line number
+    parts[3] = submatch[1];
+    parts[4] = submatch[2];
+    parts[5] = null; // no column when eval
+  }
+
+  return {
+    file: parts[3],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: parts[2] ? parts[2].split(',') : [],
+    lineNumber: parts[4] ? +parts[4] : null,
+    column: parts[5] ? +parts[5] : null
+  };
+}
+
+var javaScriptCoreRe = /^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;
+
+function parseJSC(line) {
+  var parts = javaScriptCoreRe.exec(line);
+
+  if (!parts) {
+    return null;
+  }
+
+  return {
+    file: parts[3],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: [],
+    lineNumber: +parts[4],
+    column: parts[5] ? +parts[5] : null
+  };
+}
+
+var nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+function parseNode(line) {
+  var parts = nodeRe.exec(line);
+
+  if (!parts) {
+    return null;
+  }
+
+  return {
+    file: parts[2],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: [],
+    lineNumber: +parts[3],
+    column: parts[4] ? +parts[4] : null
+  };
+}
+
+var stackTraceParser_esm = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	parse: parse
+});
+
+var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(stackTraceParser_esm);
+
+(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;
+	};
+	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 __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 (g && (g = 0, op[0] && (_ = 0)), _) 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(exports, "__esModule", { value: true });
+	exports.logDeprecatedMethod = exports.globalThisOrWindow = exports.isBrowserConfig = exports.clone = exports.formatCGIData = exports.filterUrl = exports.filter = exports.generateStackTrace = exports.endpoint = exports.instrumentConsole = exports.instrument = exports.isErrorObject = exports.makeNotice = exports.logger = exports.sanitize = exports.shallowClone = exports.runAfterNotifyHandlers = exports.shouldSampleEvent = exports.resolveInsights = exports.runBeforeEventHandlers = exports.runBeforeNotifyHandlers = exports.getSourceForBacktrace = exports.getCauses = exports.calculateBacktraceShift = exports.DEFAULT_BACKTRACE_SHIFT = exports.makeBacktrace = exports.objectIsExtensible = exports.objectIsEmpty = exports.mergeNotice = exports.merge = void 0;
+	/* eslint-disable prefer-rest-params */
+	var stackTraceParser = __importStar(require$$0$1);
+	function merge(obj1, obj2) {
+	    var result = {};
+	    for (var k in obj1) {
+	        result[k] = obj1[k];
+	    }
+	    for (var k in obj2) {
+	        result[k] = obj2[k];
+	    }
+	    return result;
+	}
+	exports.merge = merge;
+	function mergeNotice(notice1, notice2) {
+	    var result = merge(notice1, notice2);
+	    if (notice1.context && notice2.context) {
+	        result.context = merge(notice1.context, notice2.context);
+	    }
+	    return result;
+	}
+	exports.mergeNotice = mergeNotice;
+	function objectIsEmpty(obj) {
+	    for (var k in obj) {
+	        if (Object.prototype.hasOwnProperty.call(obj, k)) {
+	            return false;
+	        }
+	    }
+	    return true;
+	}
+	exports.objectIsEmpty = objectIsEmpty;
+	function objectIsExtensible(obj) {
+	    if (typeof Object.isExtensible !== 'function') {
+	        return true;
+	    }
+	    return Object.isExtensible(obj);
+	}
+	exports.objectIsExtensible = objectIsExtensible;
+	function makeBacktrace(stack, filterHbSourceCode, logger) {
+	    if (filterHbSourceCode === void 0) { filterHbSourceCode = false; }
+	    if (logger === void 0) { logger = console; }
+	    if (!stack) {
+	        return [];
+	    }
+	    try {
+	        var backtrace = stackTraceParser
+	            .parse(stack)
+	            .map(function (line) {
+	            return {
+	                file: line.file,
+	                method: line.methodName,
+	                number: line.lineNumber,
+	                column: line.column
+	            };
+	        });
+	        if (filterHbSourceCode) {
+	            backtrace.splice(0, calculateBacktraceShift(backtrace));
+	        }
+	        return backtrace;
+	    }
+	    catch (err) {
+	        logger.debug(err);
+	        return [];
+	    }
+	}
+	exports.makeBacktrace = makeBacktrace;
+	function isFrameFromHbSourceCode(frame) {
+	    var hasHbFile = false;
+	    var hasHbMethod = false;
+	    if (frame.file) {
+	        hasHbFile = frame.file.toLowerCase().indexOf('@honeybadger-io') > -1;
+	    }
+	    if (frame.method) {
+	        hasHbMethod = frame.method.toLowerCase().indexOf('@honeybadger-io') > -1;
+	    }
+	    return hasHbFile || hasHbMethod;
+	}
+	exports.DEFAULT_BACKTRACE_SHIFT = 3;
+	/**
+	 * If {@link generateStackTrace} is used, we want to exclude frames that come from
+	 * Honeybadger's source code.
+	 *
+	 * Logic:
+	 * - For each frame, increment the shift if source code is from Honeybadger
+	 * - If a frame from an <anonymous> file is encountered increment the shift ONLY if between Honeybadger source code
+	 *   (i.e. previous and next frames are from Honeybadger)
+	 * - Exit when frame encountered is not from Honeybadger source code
+	 *
+	 * Note: this will not always work, especially in browser versions where code
+	 *       is minified, uglified and bundled.
+	 *       For those cases we default to 3:
+	 *       - generateStackTrace
+	 *       - makeNotice
+	 *       - notify
+	 */
+	function calculateBacktraceShift(backtrace) {
+	    var shift = 0;
+	    for (var i = 0; i < backtrace.length; i++) {
+	        var frame = backtrace[i];
+	        if (isFrameFromHbSourceCode(frame)) {
+	            shift++;
+	            continue;
+	        }
+	        if (!frame.file || frame.file === '<anonymous>') {
+	            var nextFrame = backtrace[i + 1];
+	            if (nextFrame && isFrameFromHbSourceCode(nextFrame)) {
+	                shift++;
+	                continue;
+	            }
+	        }
+	        break;
+	    }
+	    return shift || exports.DEFAULT_BACKTRACE_SHIFT;
+	}
+	exports.calculateBacktraceShift = calculateBacktraceShift;
+	function getCauses(notice, logger) {
+	    if (notice.cause) {
+	        var causes = [];
+	        var cause = notice;
+	        // @ts-ignore this throws an error if tsconfig.json has strict: true
+	        while (causes.length < 3 && (cause = cause.cause)) {
+	            causes.push({
+	                class: cause.name,
+	                message: cause.message,
+	                backtrace: typeof cause.stack == 'string' ? makeBacktrace(cause.stack, false, logger) : null
+	            });
+	        }
+	        return causes;
+	    }
+	    return [];
+	}
+	exports.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, trace.column, 2);
+	                    index++;
+	                    return [3 /*break*/, 1];
+	                case 3: return [2 /*return*/, result];
+	            }
+	        });
+	    });
+	}
+	exports.getSourceForBacktrace = getSourceForBacktrace;
+	function runBeforeNotifyHandlers(notice, handlers) {
+	    var results = [];
+	    var result = true;
+	    for (var i = 0, len = handlers.length; i < len; i++) {
+	        var handler = handlers[i];
+	        var handlerResult = handler(notice);
+	        if (handlerResult === false) {
+	            result = false;
+	        }
+	        results.push(handlerResult);
+	    }
+	    return {
+	        results: results,
+	        result: result
+	    };
+	}
+	exports.runBeforeNotifyHandlers = runBeforeNotifyHandlers;
+	function runBeforeEventHandlers(payload, handlers, logger) {
+	    return __awaiter(this, void 0, void 0, function () {
+	        var i, len, result, err_1;
+	        return __generator(this, function (_a) {
+	            switch (_a.label) {
+	                case 0:
+	                    i = 0, len = handlers.length;
+	                    _a.label = 1;
+	                case 1:
+	                    if (!(i < len)) return [3 /*break*/, 7];
+	                    result = void 0;
+	                    _a.label = 2;
+	                case 2:
+	                    _a.trys.push([2, 4, , 5]);
+	                    return [4 /*yield*/, handlers[i](payload)];
+	                case 3:
+	                    result = _a.sent();
+	                    return [3 /*break*/, 5];
+	                case 4:
+	                    err_1 = _a.sent();
+	                    // A buggy handler should not suppress unrelated events. Log and treat as no-op.
+	                    logger === null || logger === void 0 ? void 0 : logger.error('beforeEvent handler threw; continuing', err_1);
+	                    return [3 /*break*/, 6];
+	                case 5:
+	                    if (result === false) {
+	                        return [2 /*return*/, false];
+	                    }
+	                    _a.label = 6;
+	                case 6:
+	                    i++;
+	                    return [3 /*break*/, 1];
+	                case 7: return [2 /*return*/, true];
+	            }
+	        });
+	    });
+	}
+	exports.runBeforeEventHandlers = runBeforeEventHandlers;
+	function resolveInsights(config) {
+	    var _a, _b;
+	    var insights = config.insights;
+	    if (!insights || insights.enabled !== true) {
+	        return { console: false, http: false };
+	    }
+	    return {
+	        console: (_a = insights.console) !== null && _a !== void 0 ? _a : false,
+	        http: (_b = insights.http) !== null && _b !== void 0 ? _b : false,
+	    };
+	}
+	exports.resolveInsights = resolveInsights;
+	function fnv1a(str) {
+	    var h = 0x811c9dc5;
+	    for (var i = 0, len = str.length; i < len; i++) {
+	        h ^= str.charCodeAt(i);
+	        h = Math.imul(h, 0x01000193);
+	    }
+	    return h >>> 0;
+	}
+	function clampSampleRate(rate) {
+	    if (rate < 0)
+	        return 0;
+	    if (rate > 100)
+	        return 100;
+	    return rate;
+	}
+	function shouldSampleEvent(event, configRate) {
+	    var meta = event._hb;
+	    var override = meta && Number.isFinite(meta.sampleRate) ? meta.sampleRate : undefined;
+	    var rawRate = override !== undefined ? override : configRate;
+	    // Guard against non-finite rates (e.g. NaN from Number(invalidConfig)); an
+	    // unusable rate must not silently drop every event, so fall back to send-all.
+	    var rate = clampSampleRate(Number.isFinite(rawRate) ? rawRate : 100);
+	    if (rate <= 0)
+	        return false;
+	    if (rate >= 100)
+	        return true;
+	    var requestId = event.request_id;
+	    if (typeof requestId === 'string' && requestId.length > 0) {
+	        return fnv1a(requestId) % 100 < rate;
+	    }
+	    return Math.random() * 100 < rate;
+	}
+	exports.shouldSampleEvent = shouldSampleEvent;
+	function runAfterNotifyHandlers(notice, handlers, error) {
+	    if (notice && notice.afterNotify) {
+	        notice.afterNotify(error, notice);
+	    }
+	    for (var i = 0, len = handlers.length; i < len; i++) {
+	        handlers[i](error, notice);
+	    }
+	    return true;
+	}
+	exports.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) {
+	        result[k] = obj[k];
+	    }
+	    return result;
+	}
+	exports.shallowClone = shallowClone;
+	function sanitize(obj, maxDepth) {
+	    if (maxDepth === void 0) { maxDepth = 8; }
+	    var seenObjects = [];
+	    function seen(obj) {
+	        if (!obj || typeof (obj) !== 'object') {
+	            return false;
+	        }
+	        for (var i = 0; i < seenObjects.length; i++) {
+	            var value = seenObjects[i];
+	            if (value === obj) {
+	                return true;
+	            }
+	        }
+	        seenObjects.push(obj);
+	        return false;
+	    }
+	    function canSerialize(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)
+	            return obj.name === 'toJSON';
+	        }
+	        // Symbols can't convert to strings.
+	        if (/symbol/.test(typeOfObj)) {
+	            return false;
+	        }
+	        if (obj === null) {
+	            return false;
+	        }
+	        // No prototype, likely created with `Object.create(null)`.
+	        if (typeof obj === 'object' && typeof obj.hasOwnProperty === 'undefined') {
+	            return false;
+	        }
+	        return true;
+	    }
+	    function serialize(obj, depth) {
+	        if (depth === void 0) { depth = 0; }
+	        if (depth >= maxDepth) {
+	            return '[DEPTH]';
+	        }
+	        // Inspect invalid types
+	        if (!canSerialize(obj)) {
+	            return Object.prototype.toString.call(obj);
+	        }
+	        // Halt circular references
+	        if (seen(obj)) {
+	            return '[RECURSION]';
+	        }
+	        // Serialize inside arrays
+	        if (Array.isArray(obj)) {
+	            return obj.map(function (o) { return safeSerialize(o, depth + 1); });
+	        }
+	        // Serialize inside objects
+	        if (typeof (obj) === 'object') {
+	            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);
+	                }
+	            }
+	            return ret;
+	        }
+	        // Return everything else untouched
+	        return obj;
+	    }
+	    function safeSerialize(obj, depth) {
+	        if (depth === void 0) { depth = 0; }
+	        try {
+	            return serialize(obj, depth);
+	        }
+	        catch (e) {
+	            return "[ERROR] ".concat(e);
+	        }
+	    }
+	    return safeSerialize(obj);
+	}
+	exports.sanitize = sanitize;
+	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];
+	            }
+	            if (method === 'debug') {
+	                if (!client.config.debug) {
+	                    return;
+	                }
+	                // Log at default level so that you don't need to also enable verbose
+	                // logging in Chrome.
+	                method = 'log';
+	            }
+	            args.unshift('[Honeybadger]');
+	            (_a = client.config.logger)[method].apply(_a, args);
+	        };
+	    };
+	    return {
+	        log: log('log'),
+	        info: log('info'),
+	        debug: log('debug'),
+	        warn: log('warn'),
+	        error: log('error')
+	    };
+	}
+	exports.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;
+	    if (!thing) {
+	        notice = {};
+	    }
+	    else if (isErrorObject(thing)) {
+	        var e = thing;
+	        notice = merge(thing, { name: e.name, message: e.message, stack: e.stack, cause: e.cause, originalError: e });
+	    }
+	    else if (typeof thing === 'object') {
+	        notice = shallowClone(thing);
+	    }
+	    else {
+	        var m = String(thing);
+	        notice = { message: m };
+	    }
+	    return notice;
+	}
+	exports.makeNotice = makeNotice;
+	function isErrorObject(thing) {
+	    return thing instanceof Error
+	        || Object.prototype.toString.call(thing) === '[object Error]'; // Important for cross-realm objects
+	}
+	exports.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;
+	    }
+	    try {
+	        var original = object[name];
+	        while (original && original.__hb_original) {
+	            original = original.__hb_original;
+	        }
+	        object[name] = replacement(original);
+	        object[name].__hb_original = original;
+	    }
+	    catch (_e) {
+	        // Ignores errors where "original" is a restricted object (see #1001)
+	        // Uncaught Error: Permission denied to access property "__hb_original"
+	        // Also ignores:
+	        //   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
+	    }
+	}
+	exports.instrument = instrument;
+	var _consoleAlreadyInstrumented = false;
+	var listeners = [];
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	function instrumentConsole(_window, handler) {
+	    if (!_window || !_window.console || !handler) {
+	        return;
+	    }
+	    listeners.push(handler);
+	    if (_consoleAlreadyInstrumented) {
+	        return;
+	    }
+	    _consoleAlreadyInstrumented = true;
+	    ['debug', 'info', 'warn', 'error', 'log'].forEach(function (level) {
+	        instrument(_window.console, level, function hbLogger(original) {
+	            return function () {
+	                var args = Array.prototype.slice.call(arguments);
+	                listeners.forEach(function (listener) {
+	                    try {
+	                        listener(level, args);
+	                    }
+	                    catch (_e) {
+	                        // ignore
+	                        // should never reach here because instrument method already wraps with try/catch block
+	                    }
+	                });
+	                if (typeof original === 'function') {
+	                    Function.prototype.apply.call(original, _window.console, arguments);
+	                }
+	            };
+	        });
+	    });
+	}
+	exports.instrumentConsole = instrumentConsole;
+	function endpoint(base, path) {
+	    var endpoint = base.trim().replace(/\/$/, '');
+	    path = path.trim().replace(/(^\/|\/$)/g, '');
+	    return "".concat(endpoint, "/").concat(path);
+	}
+	exports.endpoint = endpoint;
+	function generateStackTrace() {
+	    try {
+	        throw new Error('');
+	    }
+	    catch (e) {
+	        if (e.stack) {
+	            return e.stack;
+	        }
+	    }
+	    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>');
+	        }
+	        else {
+	            stack.push('<anonymous>');
+	        }
+	        try {
+	            curr = curr.caller;
+	        }
+	        catch (e) {
+	            break;
+	        }
+	    }
+	    return stack.join('\n');
+	}
+	exports.generateStackTrace = generateStackTrace;
+	function filter(obj, filters) {
+	    if (!is('Object', obj)) {
+	        return;
+	    }
+	    if (!is('Array', filters)) {
+	        filters = [];
+	    }
+	    var seen = [];
+	    function filter(obj) {
+	        var k, newObj;
+	        if (is('Object', obj) || is('Array', obj)) {
+	            if (seen.indexOf(obj) !== -1) {
+	                return '[CIRCULAR DATA STRUCTURE]';
+	            }
+	            seen.push(obj);
+	        }
+	        if (is('Object', obj)) {
+	            newObj = {};
+	            for (k in obj) {
+	                if (filterMatch(k, filters)) {
+	                    newObj[k] = '[FILTERED]';
+	                }
+	                else {
+	                    newObj[k] = filter(obj[k]);
+	                }
+	            }
+	            return newObj;
+	        }
+	        if (is('Array', obj)) {
+	            return obj.map(function (v) {
+	                return filter(v);
+	            });
+	        }
+	        if (is('Function', obj)) {
+	            return '[FUNC]';
+	        }
+	        return obj;
+	    }
+	    return filter(obj);
+	}
+	exports.filter = filter;
+	function filterMatch(key, filters) {
+	    for (var i = 0; i < filters.length; i++) {
+	        if (key.toLowerCase().indexOf(filters[i].toLowerCase()) !== -1) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+	function is(type, obj) {
+	    var klass = Object.prototype.toString.call(obj).slice(8, -1);
+	    return obj !== undefined && obj !== null && klass === type;
+	}
+	function filterUrl(url, filters) {
+	    if (!filters) {
+	        return url;
+	    }
+	    if (typeof url !== 'string') {
+	        return url;
+	    }
+	    var 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];
+	        if (filterMatch(key, filters)) {
+	            result = result.replace("".concat(key, "=").concat(value), "".concat(key, "=[FILTERED]"));
+	        }
+	    });
+	    return result;
+	}
+	exports.filterUrl = filterUrl;
+	function formatCGIData(vars, prefix) {
+	    if (prefix === void 0) { prefix = ''; }
+	    var formattedVars = {};
+	    Object.keys(vars).forEach(function (key) {
+	        var formattedKey = prefix + key.replace(/\W/g, '_').toUpperCase();
+	        formattedVars[formattedKey] = vars[key];
+	    });
+	    return formattedVars;
+	}
+	exports.formatCGIData = formatCGIData;
+	function clone(obj) {
+	    return JSON.parse(JSON.stringify(obj));
+	}
+	exports.clone = clone;
+	var THRESHOLD_COLUMN_NUMBER = 10000;
+	var THRESHOLD_LINE_LENGTH = 10000;
+	var THRESHOLD_FILE_SIZE = 200000; // 200KB threshold
+	function getThresholdExceededSnippet(lineNumber) {
+	    var _a;
+	    return _a = {}, _a[lineNumber] = 'SOURCE_SIZE_TOO_LARGE', _a;
+	}
+	function getSourceCodeSnippet(fileData, lineNumber, columnNumber, sourceRadius) {
+	    if (sourceRadius === void 0) { sourceRadius = 2; }
+	    if (!fileData) {
+	        return null;
+	    }
+	    // If column number is provided and very high, it's likely a bundled/minified file
+	    if (columnNumber && columnNumber > THRESHOLD_COLUMN_NUMBER) {
+	        return getThresholdExceededSnippet(lineNumber);
+	    }
+	    // If file is very large, it's likely bundled
+	    if (fileData.length > THRESHOLD_FILE_SIZE) {
+	        return getThresholdExceededSnippet(lineNumber);
+	    }
+	    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('');
+	    // Check if the target line is extremely long
+	    var targetLine = lines[lineNumber];
+	    if (targetLine && targetLine.length > THRESHOLD_LINE_LENGTH) {
+	        return getThresholdExceededSnippet(lineNumber);
+	    }
+	    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;
+	        }
+	    }
+	    return result;
+	}
+	function isBrowserConfig(config) {
+	    return config.async !== undefined;
+	}
+	exports.isBrowserConfig = isBrowserConfig;
+	/** globalThis has fairly good support. But just in case, lets check its defined.
+	 * @see {https://caniuse.com/?search=globalThis}
+	 */
+	function globalThisOrWindow() {
+	    if (typeof globalThis !== 'undefined') {
+	        return globalThis;
+	    }
+	    if (typeof self !== 'undefined') {
+	        return self;
+	    }
+	    return window;
+	}
+	exports.globalThisOrWindow = globalThisOrWindow;
+	var _deprecatedMethodCalls = {};
+	/**
+	 * Logs a deprecation warning, every X calls to the method.
+	 */
+	function logDeprecatedMethod(logger, oldMethod, newMethod, callCountThreshold) {
+	    if (callCountThreshold === void 0) { callCountThreshold = 100; }
+	    var key = "".concat(oldMethod, "-").concat(newMethod);
+	    if (typeof _deprecatedMethodCalls[key] === 'undefined') {
+	        _deprecatedMethodCalls[key] = 0;
+	    }
+	    if (_deprecatedMethodCalls[key] % callCountThreshold !== 0) {
+	        _deprecatedMethodCalls[key]++;
+	        return;
+	    }
+	    var msg = "Deprecation warning: ".concat(oldMethod, " has been deprecated; please use ").concat(newMethod, " instead.");
+	    logger.warn(msg);
+	    _deprecatedMethodCalls[key]++;
+	}
+	exports.logDeprecatedMethod = logDeprecatedMethod;
+	
+} (util));
+
+Object.defineProperty(console_events, "__esModule", { value: true });
+var util_1$3 = util;
+function default_1(_window) {
+    if (_window === void 0) { _window = (0, util_1$3.globalThisOrWindow)(); }
+    return {
+        shouldReloadOnConfigure: false,
+        load: function (client) {
+            function sendEventsToInsights() {
+                return (0, util_1$3.resolveInsights)(client.config).console;
+            }
+            if (!sendEventsToInsights()) {
+                return;
+            }
+            (0, util_1$3.instrumentConsole)(_window, function (level, args) {
+                if (!sendEventsToInsights()) {
+                    return;
+                }
+                if (args.length === 0) {
+                    return;
+                }
+                var data = {
+                    severity: level,
+                };
+                if (typeof args[0] === 'string') {
+                    data.message = args[0];
+                    data.args = args.slice(1);
+                }
+                else {
+                    data.args = args;
+                }
+                client.event('log', data);
+            });
+        }
+    };
+}
+console_events.default = default_1;
+
+var client = {};
+
+var store = {};
+
+Object.defineProperty(store, "__esModule", { value: true });
+store.GlobalStore = void 0;
+var util_1$2 = util;
+var GlobalStore = /** @class */ (function () {
+    function GlobalStore(contents, breadcrumbsLimit) {
+        this.contents = contents;
+        this.breadcrumbsLimit = breadcrumbsLimit;
+    }
+    GlobalStore.create = function (contents, breadcrumbsLimit) {
+        return new GlobalStore(contents, breadcrumbsLimit);
+    };
+    GlobalStore.prototype.available = function () {
+        return true;
+    };
+    GlobalStore.prototype.getContents = function (key) {
+        var value = key ? this.contents[key] : this.contents;
+        return JSON.parse(JSON.stringify(value));
+    };
+    GlobalStore.prototype.setContext = function (context) {
+        this.contents.context = (0, util_1$2.merge)(this.contents.context, context || {});
+    };
+    GlobalStore.prototype.setEventContext = function (eventContext) {
+        this.contents.eventContext = (0, util_1$2.merge)(this.contents.eventContext, eventContext || {});
+    };
+    GlobalStore.prototype.clearEventContext = function () {
+        this.contents.eventContext = {};
+    };
+    GlobalStore.prototype.addBreadcrumb = function (breadcrumb) {
+        if (this.contents.breadcrumbs.length == this.breadcrumbsLimit) {
+            this.contents.breadcrumbs.shift();
+        }
+        this.contents.breadcrumbs.push(breadcrumb);
+    };
+    GlobalStore.prototype.clear = function () {
+        this.contents.context = {};
+        this.contents.eventContext = {};
+        this.contents.breadcrumbs = [];
+    };
+    GlobalStore.prototype.run = function (callback) {
+        return callback();
+    };
+    return GlobalStore;
+}());
+store.GlobalStore = GlobalStore;
+
+var throttled_events_worker = {};
+
+class NdJson {
+    static parse(data) {
+        const lines = data.trim().split('\n');
+        return lines.map(line => JSON.parse(line));
+    }
+    static stringify(data) {
+        return data.map(item => JSON.stringify(item)).join('\n');
+    }
+}
+
+var module$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	NdJson: NdJson
+});
+
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(module$1);
+
+var defaults = {};
+
+Object.defineProperty(defaults, "__esModule", { value: true });
+defaults.BREADCRUMBS_SELECTOR_ATTRIBUTES = defaults.CONFIG = void 0;
+defaults.CONFIG = {
+    apiKey: null,
+    endpoint: 'https://api.honeybadger.io',
+    appEndpoint: 'https://app.honeybadger.io',
+    environment: null,
+    hostname: null,
+    projectRoot: null,
+    component: null,
+    action: null,
+    revision: null,
+    reportData: null,
+    breadcrumbsEnabled: true,
+    // deprecated: `eventsEnabled: true` auto-enables insights.enabled + insights.console
+    eventsEnabled: false,
+    insights: {
+        enabled: false,
+        console: false,
+        http: false,
+    },
+    events: {
+        dispatchIntervalSeconds: 10,
+        bulkThreshold: 500,
+        sampleRatePercentage: 100,
+    },
+    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: [],
+};
+// Browser-only, so it lives outside CONFIG (which is shared with Node).
+defaults.BREADCRUMBS_SELECTOR_ATTRIBUTES = ['data-hb-name'];
+
+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);
+};
+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());
+    });
+};
+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 (g && (g = 0, op[0] && (_ = 0)), _) 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(throttled_events_worker, "__esModule", { value: true });
+throttled_events_worker.ThrottledEventsWorker = void 0;
+var json_nd_1 = require$$0;
+var util_1$1 = util;
+var defaults_1$1 = defaults;
+var ThrottledEventsWorker = /** @class */ (function () {
+    function ThrottledEventsWorker(config, transport) {
+        this.config = config;
+        this.transport = transport;
+        this.queue = [];
+        this.cooldownTimer = null;
+        // Timestamp (ms) until which the post-send cooldown window is active. A timer
+        // is only armed while there are queued events waiting for this window; when the
+        // queue drains empty we keep the timestamp but drop the timer, so an idle worker
+        // never holds a pending timer (which would otherwise keep a Node process alive
+        // for the full interval.
+        this.cooldownUntil = 0;
+        this.inFlight = null;
+        this.config = __assign$1(__assign$1({}, defaults_1$1.CONFIG), config);
+        this.logger = this.originalLogger();
+    }
+    ThrottledEventsWorker.prototype.configure = function (opts) {
+        for (var k in opts) {
+            this.config[k] = opts[k];
+        }
+    };
+    ThrottledEventsWorker.prototype.log = function (payload) {
+        this.queue.push(payload);
+        if (this.inFlight) {
+            return;
+        }
+        // Crossing the bulk threshold preempts any pending cooldown and dispatches now.
+        if (this.queue.length >= this.bulkThreshold()) {
+            this.clearCooldownTimer();
+            this.processQueue();
+            return;
+        }
+        // A timer is already counting down the cooldown window; the queued event
+        // will be picked up when it fires.
+        if (this.cooldownTimer) {
+            return;
+        }
+        // We're inside a cooldown window but no timer is armed (the queue had drained
+        // empty after the previous send). Arm one for the remaining time so this event
+        // still respects the interval.
+        var remaining = this.cooldownRemainingMs();
+        if (remaining > 0) {
+            this.scheduleCooldownTimer(remaining);
+            return;
+        }
+        this.processQueue();
+    };
+    ThrottledEventsWorker.prototype.flushAsync = function () {
+        var _this = this;
+        var _a;
+        this.logger.debug('[Honeybadger] Flushing events');
+        this.clearCooldownTimer();
+        var previous = (_a = this.inFlight) !== null && _a !== void 0 ? _a : Promise.resolve();
+        var flush = previous.then(function () { return _this.drainAll(); });
+        // Mark the flush as in-flight so a concurrent log() doesn't start an
+        // overlapping processQueue() drain while we're draining here.
+        this.inFlight = flush;
+        var clear = function () {
+            if (_this.inFlight === flush) {
+                _this.inFlight = null;
+            }
+        };
+        flush.then(clear, clear);
+        return flush;
+    };
+    ThrottledEventsWorker.prototype.drainAll = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.queue.length > 0)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.send()];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 0];
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ThrottledEventsWorker.prototype.processQueue = function () {
+        var _this = this;
+        if (this.queue.length === 0 || this.inFlight) {
+            return;
+        }
+        var inFlight = this.send()
+            .catch(function (error) {
+            _this.logger.error('[Honeybadger] Error making HTTP request:', error);
+        })
+            .then(function () {
+            // Only reset if we're still the current operation; a flushAsync() may
+            // have taken ownership of inFlight while this send was resolving.
+            if (_this.inFlight === inFlight) {
+                _this.inFlight = null;
+                _this.scheduleNextDispatch();
+            }
+        });
+        this.inFlight = inFlight;
+    };
+    ThrottledEventsWorker.prototype.scheduleNextDispatch = function () {
+        var intervalMs = this.dispatchIntervalMs();
+        // Capture the cooldown deadline at dispatch time so a later config change to
+        // the interval doesn't retroactively shorten a window already in progress.
+        this.cooldownUntil = Date.now() + intervalMs;
+        if (this.queue.length >= this.bulkThreshold()) {
+            this.processQueue();
+            return;
+        }
+        // Only arm a timer when there's queued work waiting for it. If the queue is
+        // empty, `cooldownUntil` alone enforces the window: the next log() will arm a
+        // timer for whatever time remains, and an idle worker holds no timer at all.
+        if (this.queue.length > 0) {
+            this.scheduleCooldownTimer(intervalMs);
+        }
+    };
+    ThrottledEventsWorker.prototype.cooldownRemainingMs = function () {
+        if (!this.cooldownUntil) {
+            return 0;
+        }
+        return Math.max(0, this.cooldownUntil - Date.now());
+    };
+    ThrottledEventsWorker.prototype.scheduleCooldownTimer = function (ms) {
+        var _this = this;
+        this.cooldownTimer = setTimeout(function () {
+            _this.cooldownTimer = null;
+            _this.processQueue();
+        }, ms);
+        // In Node, don't let a pending cooldown timer keep the process alive for the
+        // whole batching interval. `unref` lets the event loop go idle so the process
+        // can exit (or a shutdown / `beforeExit` handler can run) promptly instead of
+        // blocking for `dispatchIntervalSeconds`. Queued events aren't lost: a
+        // `flushAsync()` on the way out still drains them before exit. (`unref` is
+        // Node-only; the browser's numeric setTimeout handle has no such method.)
+        if (typeof this.cooldownTimer === 'object' && this.cooldownTimer !== null && typeof this.cooldownTimer.unref === 'function') {
+            this.cooldownTimer.unref();
+        }
+    };
+    ThrottledEventsWorker.prototype.clearCooldownTimer = function () {
+        if (this.cooldownTimer) {
+            clearTimeout(this.cooldownTimer);
+            this.cooldownTimer = null;
+        }
+    };
+    ThrottledEventsWorker.prototype.send = function () {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var eventsData, data;
+            return __generator$1(this, function (_a) {
+                if (this.queue.length === 0) {
+                    return [2 /*return*/];
+                }
+                eventsData = this.queue.splice(0, this.bulkThreshold());
+                data = json_nd_1.NdJson.stringify(eventsData);
+                return [2 /*return*/, this.makeHttpRequest(data)];
+            });
+        });
+    };
+    ThrottledEventsWorker.prototype.bulkThreshold = function () {
+        var _a;
+        var v = (_a = this.config.events) === null || _a === void 0 ? void 0 : _a.bulkThreshold;
+        return typeof v === 'number' && v > 0 ? v : defaults_1$1.CONFIG.events.bulkThreshold;
+    };
+    ThrottledEventsWorker.prototype.dispatchIntervalMs = function () {
+        var _a;
+        var v = (_a = this.config.events) === null || _a === void 0 ? void 0 : _a.dispatchIntervalSeconds;
+        var seconds = typeof v === 'number' && v >= 0 ? v : defaults_1$1.CONFIG.events.dispatchIntervalSeconds;
+        return seconds * 1000;
+    };
+    ThrottledEventsWorker.prototype.makeHttpRequest = function (data) {
+        return __awaiter$1(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator$1(this, function (_a) {
+                return [2 /*return*/, this.transport
+                        .send({
+                        headers: {
+                            'X-API-Key': this.config.apiKey,
+                            'Content-Type': 'application/json',
+                        },
+                        method: 'POST',
+                        endpoint: (0, util_1$1.endpoint)(this.config.endpoint, '/v1/events'),
+                        maxObjectDepth: this.config.maxObjectDepth,
+                        logger: this.logger,
+                    }, data)
+                        .then(function (resp) {
+                        if ([200, 201].includes(resp.statusCode)) {
+                            _this.logger.debug('[Honeybadger] Events sent successfully');
+                        }
+                        else {
+                            _this.logger.debug("[Honeybadger] Events failed[".concat(resp.statusCode, "]: ").concat(resp.body));
+                        }
+                    })
+                        .catch(function (err) {
+                        _this.logger.error("[Honeybadger] Error sending events: ".concat(err.message));
+                    })];
+            });
+        });
+    };
+    /**
+     * todo: improve this
+     *
+     * The events plugin overrides the console methods to enable automatic instrumentation
+     * of console logs to the Honeybadger API.
+     * So if we want to log something in here we need to use the original methods.
+     */
+    ThrottledEventsWorker.prototype.originalLogger = function () {
+        var _this = this;
+        var _a, _b, _c, _d;
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            log: (_a = console.log.__hb_original) !== null && _a !== void 0 ? _a : console.log,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            info: (_b = console.info.__hb_original) !== null && _b !== void 0 ? _b : console.info,
+            debug: function () {
+                var _a;
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                if (!_this.config.debug) {
+                    return;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                var func = (_a = console.debug.__hb_original) !== null && _a !== void 0 ? _a : console.debug;
+                return func.apply(void 0, args);
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            warn: (_c = console.warn.__hb_original) !== null && _c !== void 0 ? _c : console.warn,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error: (_d = console.error.__hb_original) !== null && _d !== void 0 ? _d : console.error,
+        };
+    };
+    return ThrottledEventsWorker;
+}());
+throttled_events_worker.ThrottledEventsWorker = ThrottledEventsWorker;
+
+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 __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 __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 (g && (g = 0, op[0] && (_ = 0)), _) 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(client, "__esModule", { value: true });
+client.Client = void 0;
+var util_1 = util;
+var store_1 = store;
+var throttled_events_worker_1 = throttled_events_worker;
+var defaults_1 = defaults;
+// Split at commas and spaces
+var 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 = {}; }
+        this.__pluginsLoaded = false;
+        this.__store = null;
+        this.__beforeNotifyHandlers = [];
+        this.__beforeEventHandlers = [];
+        this.__afterNotifyHandlers = [];
+        this.__pendingEvents = new Set();
+        this.__notifier = {
+            name: '@honeybadger-io/core',
+            url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
+            version: '6.16.0'
+        };
+        this.config = __assign(__assign({}, defaults_1.CONFIG), opts);
+        this.__initStore();
+        this.__transport = transport;
+        this.__eventsWorker = new throttled_events_worker_1.ThrottledEventsWorker(this.config, this.__transport);
+        this.logger = (0, util_1.logger)(this);
+        this.__applyEventsEnabledShim(opts);
+    }
+    Client.prototype.getVersion = function () {
+        return this.__notifier.version;
+    };
+    Client.prototype.getNotifier = function () {
+        return this.__notifier;
+    };
+    /**
+     * CAREFUL: When adding a new notifier or updating the name of an existing notifier,
+     * the Honeybadger rails project may need its mappings updated.
+     * See https://github.com/honeybadger-io/honeybadger/blob/master/app/presenters/breadcrumbs_presenter.rb
+     *     https://github.com/honeybadger-io/honeybadger/blob/master/app/models/parser/java_script.rb
+     *     https://github.com/honeybadger-io/honeybadger/blob/master/app/models/language.rb
+     **/
+    Client.prototype.setNotifier = function (notifier) {
+        this.__notifier = notifier;
+    };
+    Client.prototype.configure = function (opts) {
+        if (opts === void 0) { opts = {}; }
+        for (var k in opts) {
+            this.config[k] = opts[k];
+        }
+        this.__applyEventsEnabledShim(opts);
+        this.__eventsWorker.configure(this.config);
+        this.loadPlugins();
+        return this;
+    };
+    /**
+     * Backwards compatibility: `eventsEnabled: true` used to opt into console events.
+     * The deprecated flag auto-enables `insights.enabled` and `insights.console`;
+     * explicit user-provided insights values win over the shim.
+     */
+    Client.prototype.__applyEventsEnabledShim = function (opts) {
+        var _a;
+        if (opts.eventsEnabled !== true) {
+            return;
+        }
+        this.logger.warn('Deprecation warning: `eventsEnabled` has been deprecated; please use `insights.enabled` and `insights.console` instead.');
+        this.config.insights = __assign(__assign(__assign({}, ((_a = this.config.insights) !== null && _a !== void 0 ? _a : {})), { enabled: true, console: true }), opts.insights);
+    };
+    Client.prototype.loadPlugins = function () {
+        var _this = this;
+        var pluginsToLoad = this.__pluginsLoaded
+            ? this.config.__plugins.filter(function (plugin) { return plugin.shouldReloadOnConfigure; })
+            : this.config.__plugins;
+        pluginsToLoad.forEach(function (plugin) { return plugin.load(_this); });
+        this.__pluginsLoaded = true;
+    };
+    Client.prototype.__initStore = function () {
+        this.__store = new store_1.GlobalStore({ context: {}, eventContext: {}, breadcrumbs: [] }, this.config.maxBreadcrumbs);
+    };
+    Client.prototype.beforeNotify = function (handler) {
+        this.__beforeNotifyHandlers.push(handler);
+        return this;
+    };
+    Client.prototype.beforeEvent = function (handler) {
+        this.__beforeEventHandlers.push(handler);
+        return this;
+    };
+    Client.prototype.afterNotify = function (handler) {
+        this.__afterNotifyHandlers.push(handler);
+        return this;
+    };
+    Client.prototype.setContext = function (context) {
+        if (typeof context === 'object' && context != null) {
+            this.__store.setContext(context);
+        }
+        return this;
+    };
+    Client.prototype.setEventContext = function (eventContext) {
+        if (typeof eventContext === 'object' && eventContext != null) {
+            this.__store.setEventContext(eventContext);
+        }
+        return this;
+    };
+    Client.prototype.clearEventContext = function () {
+        this.__store.clearEventContext();
+        return this;
+    };
+    Client.prototype.resetContext = function (context) {
+        this.logger.warn('Deprecation warning: `Honeybadger.resetContext()` has been deprecated; please use `Honeybadger.clear()` instead.');
+        this.__store.clear();
+        if (typeof context === 'object' && context !== null) {
+            this.__store.setContext(context);
+        }
+        return this;
+    };
+    Client.prototype.clear = function () {
+        this.__store.clear();
+        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 notice = this.makeNotice(noticeable, name, extra);
+        // 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 (0, util_1.shallowClone)(trace); }) : null;
+        var preConditionsResult = this.__runPreconditions(notice);
+        if (preConditionsResult instanceof Error) {
+            (0, util_1.runAfterNotifyHandlers)(notice, this.__afterNotifyHandlers, preConditionsResult);
+            return false;
+        }
+        if (preConditionsResult instanceof Promise) {
+            preConditionsResult.then(function (result) {
+                if (result instanceof Error) {
+                    (0, util_1.runAfterNotifyHandlers)(notice, _this.__afterNotifyHandlers, result);
+                    return false;
+                }
+                return _this.__send(notice, sourceCodeData);
+            });
+            return true;
+        }
+        this.__send(notice, sourceCodeData).catch(function (_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);
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve();
+                };
+            };
+            // We have to respect any afterNotify hooks that come from the arguments
+            var objectToOverride;
+            if (noticeable.afterNotify) {
+                objectToOverride = noticeable;
+            }
+            else if (name && name.afterNotify) {
+                objectToOverride = name;
+            }
+            else if (extra && extra.afterNotify) {
+                objectToOverride = extra;
+            }
+            else if (name && typeof name === 'object') {
+                objectToOverride = name;
+            }
+            else if (extra) {
+                objectToOverride = extra;
+            }
+            else {
+                objectToOverride = name = {};
+            }
+            applyAfterNotify(objectToOverride);
+            _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 = (0, util_1.makeNotice)(noticeable);
+        if (name && !(typeof name === 'object')) {
+            var n = String(name);
+            name = { name: n };
+        }
+        if (name) {
+            notice = (0, util_1.mergeNotice)(notice, name);
+        }
+        if (typeof extra === 'object' && extra !== null) {
+            notice = (0, util_1.mergeNotice)(notice, extra);
+        }
+        if ((0, util_1.objectIsEmpty)(notice)) {
+            return null;
+        }
+        var context = this.__store.getContents('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
+        var tags = noticeTags.concat(contextTags).concat(configTags);
+        var uniqueTags = tags.filter(function (item, index) { return tags.indexOf(item) === index; });
+        notice = (0, util_1.merge)(notice, {
+            name: notice.name || 'Error',
+            context: (0, util_1.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,
+        });
+        // If we're passed a custom backtrace array, use it
+        // Otherwise we make one.
+        if (!Array.isArray(notice.backtrace) || !notice.backtrace.length) {
+            if (typeof notice.stack !== 'string' || !notice.stack.trim()) {
+                notice.stack = (0, util_1.generateStackTrace)();
+                notice.backtrace = (0, util_1.makeBacktrace)(notice.stack, true, this.logger);
+            }
+            else {
+                notice.backtrace = (0, util_1.makeBacktrace)(notice.stack, false, this.logger);
+            }
+        }
+        return notice;
+    };
+    Client.prototype.addBreadcrumb = function (message, opts) {
+        if (!this.config.breadcrumbsEnabled) {
+            return;
+        }
+        opts = opts || {};
+        var metadata = (0, util_1.shallowClone)(opts.metadata);
+        var category = opts.category || 'custom';
+        var timestamp = new Date().toISOString();
+        this.__store.addBreadcrumb({
+            category: category,
+            message: message,
+            metadata: metadata,
+            timestamp: timestamp
+        });
+        return this;
+    };
+    /**
+     * @deprecated Use {@link event} instead.
+     */
+    Client.prototype.logEvent = function (data) {
+        (0, util_1.logDeprecatedMethod)(this.logger, 'Honeybadger.logEvent', 'Honeybadger.event');
+        this.event('log', data);
+    };
+    Client.prototype.event = function (type, data) {
+        var _this = this;
+        var _a;
+        if (typeof type === 'object') {
+            data = type;
+            type = (_a = type['event_type']) !== null && _a !== void 0 ? _a : undefined;
+        }
+        var eventContext = this.__store.getContents('eventContext') || {};
+        var payload = __assign(__assign({ event_type: type, ts: new Date().toISOString() }, eventContext), data);
+        // Track in-flight handler chains so flushAsync() can await them before
+        // delegating to the events logger; otherwise a caller that awaits flushAsync()
+        // immediately after event() may flush before the payload enters the queue.
+        var inFlight = (0, util_1.runBeforeEventHandlers)(payload, this.__beforeEventHandlers, this.logger)
+            .then(function (shouldSend) {
+            var _a, _b;
+            if (!shouldSend) {
+                _this.logger.debug('skipping event: beforeEvent handler returned false');
+                return;
+            }
+            var sampleRate = (_b = (_a = _this.config.events) === null || _a === void 0 ? void 0 : _a.sampleRatePercentage) !== null && _b !== void 0 ? _b : 100;
+            if (!(0, util_1.shouldSampleEvent)(payload, sampleRate)) {
+                _this.logger.debug('skipping event: dropped by sampleRatePercentage');
+                return;
+            }
+            delete payload._hb;
+            _this.__eventsWorker.log(payload);
+        })
+            .catch(function (err) {
+            // should not happen, because each handler is wrapped with a try/catch
+            _this.logger.error('beforeEvent handler chain failed; dropping event', err);
+        })
+            .finally(function () {
+            _this.__pendingEvents.delete(inFlight);
+        });
+        this.__pendingEvents.add(inFlight);
+    };
+    /**
+     * This method currently flushes the event (Insights) queue.
+     * In the future, it should also flush the error queue (assuming an error throttler is implemented).
+     */
+    Client.prototype.flushAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.__pendingEvents.size > 0)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.allSettled(Array.from(this.__pendingEvents))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, this.__eventsWorker.flushAsync()];
+                }
+            });
+        });
+    };
+    Client.prototype.__getBreadcrumbs = function () {
+        return this.__store.getContents('breadcrumbs').slice();
+    };
+    Client.prototype.__getContext = function () {
+        return this.__store.getContents('context');
+    };
+    Client.prototype.__developmentMode = function () {
+        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 = (0, util_1.filter)(notice.headers, this.config.filters) || {};
+        var cgiData = (0, util_1.filter)(__assign(__assign({}, notice.cgiData), (0, util_1.formatCGIData)(headers, 'HTTP_')), this.config.filters);
+        return {
+            notifier: this.__notifier,
+            breadcrumbs: {
+                enabled: !!this.config.breadcrumbsEnabled,
+                trail: notice.__breadcrumbs || []
+            },
+            error: {
+                class: notice.name,
+                message: notice.message,
+                backtrace: notice.backtrace,
+                fingerprint: notice.fingerprint,
+                tags: notice.tags,
+                causes: (0, util_1.getCauses)(notice, this.logger),
+            },
+            request: {
+                url: (0, util_1.filterUrl)(notice.url, this.config.filters),
+                component: notice.component,
+                action: notice.action,
+                context: notice.context,
+                cgi_data: cgiData,
+                params: (0, util_1.filter)(notice.params, this.config.filters) || {},
+                session: (0, util_1.filter)(notice.session, this.config.filters) || {}
+            },
+            server: {
+                project_root: notice.projectRoot,
+                environment_name: notice.environment,
+                revision: notice.revision,
+                hostname: this.config.hostname,
+                time: new Date().toUTCString()
+            },
+            details: notice.details || {}
+        };
+    };
+    Client.prototype.__constructTags = function (tags) {
+        if (!tags) {
+            return [];
+        }
+        return tags.toString().split(TAG_SEPARATOR).filter(function (tag) { return NOT_BLANK.test(tag); });
+    };
+    Client.prototype.__runPreconditions = function (notice) {
+        var _this = this;
+        var preConditionError = null;
+        if (!notice) {
+            this.logger.debug('failed to build error report');
+            preConditionError = new Error('failed to build error report');
+        }
+        if (this.config.reportData === false) {
+            this.logger.debug('skipping error report: honeybadger.js is disabled', notice);
+            preConditionError = new Error('honeybadger.js is disabled');
+        }
+        if (this.__developmentMode()) {
+            this.logger.log('honeybadger.js is in development mode; the following error report will be sent in production.', notice);
+            preConditionError = new Error('honeybadger.js is in development mode');
+        }
+        if (!this.config.apiKey) {
+            this.logger.warn('could not send error report: no API key has been configured', notice);
+            preConditionError = new Error('missing API key');
+        }
+        var beforeNotifyResult = (0, util_1.runBeforeNotifyHandlers)(notice, this.__beforeNotifyHandlers);
+        if (!preConditionError && !beforeNotifyResult.result) {
+            this.logger.debug('skipping error report: one or more beforeNotify handlers returned false', notice);
+            preConditionError = new Error('beforeNotify handlers returned false');
+        }
+        if (beforeNotifyResult.results.length && beforeNotifyResult.results.some(function (result) { return result instanceof Promise; })) {
+            return Promise.allSettled(beforeNotifyResult.results)
+                .then(function (results) {
+                if (!preConditionError && (results.some(function (result) { return result.status === 'rejected' || result.value === false; }))) {
+                    _this.logger.debug('skipping error report: one or more beforeNotify handlers returned false', notice);
+                    preConditionError = new Error('beforeNotify handlers (async) returned false');
+                }
+                if (preConditionError) {
+                    return preConditionError;
+                }
+            });
+        }
+        return preConditionError;
+    };
+    Client.prototype.__send = function (notice, originalBacktrace) {
+        var _this = this;
+        if (this.config.breadcrumbsEnabled) {
+            this.addBreadcrumb('Honeybadger Notice', {
+                category: 'notice',
+                metadata: {
+                    message: notice.message,
+                    name: notice.name,
+                    stack: notice.stack
+                }
+            });
+            notice.__breadcrumbs = this.__store.getContents('breadcrumbs');
+        }
+        else {
+            notice.__breadcrumbs = [];
+        }
+        return (0, util_1.getSourceForBacktrace)(originalBacktrace, this.__getSourceFileHandler)
+            .then(function (sourcePerTrace) { return __awaiter(_this, void 0, void 0, function () {
+            var payload;
+            return __generator(this, function (_a) {
+                sourcePerTrace.forEach(function (source, index) {
+                    notice.backtrace[index].source = source;
+                });
+                payload = this.__buildPayload(notice);
+                return [2 /*return*/, this.__transport
+                        .send({
+                        headers: {
+                            'X-API-Key': this.config.apiKey,
+                            'Content-Type': 'application/json',
+                            'Accept': 'text/json, application/json'
+                        },
+                        method: 'POST',
+                        endpoint: (0, util_1.endpoint)(this.config.endpoint, '/v1/notices/js'),
+                        maxObjectDepth: this.config.maxObjectDepth,
+                        logger: this.logger,
+                    }, payload)];
+            });
+        }); })
+            .then(function (res) {
+            if (res.statusCode !== 201) {
+                (0, util_1.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 false;
+            }
+            var uuid = JSON.parse(res.body).id;
+            (0, util_1.runAfterNotifyHandlers)((0, util_1.merge)(notice, {
+                id: uuid
+            }), _this.__afterNotifyHandlers);
+            var noticeUrl = (0, util_1.endpoint)(_this.config.appEndpoint, "notice/".concat(uuid));
+            _this.logger.info("Error report sent \u26A1 ".concat(noticeUrl));
+            return true;
+        })
+            .catch(function (err) {
+            _this.logger.error('Error report failed: an unknown error occurred.', "message=".concat(err.message));
+            (0, util_1.runAfterNotifyHandlers)(notice, _this.__afterNotifyHandlers, err);
+            return false;
+        });
+    };
+    return Client;
+}());
+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 __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	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;
+	};
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Plugins = exports.Defaults = exports.Util = exports.Types = exports.Client = void 0;
+	var console_events_1 = __importDefault(console_events);
+	var client_1 = client;
+	Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+	__exportStar(store, exports);
+	exports.Types = __importStar(types);
+	exports.Util = __importStar(util);
+	exports.Defaults = __importStar(defaults);
+	exports.Plugins = {
+	    consoleEvents: console_events_1.default,
+	    /**
+	     * @deprecated Use `consoleEvents` instead. Kept as an alias for backwards
+	     * compatibility and will be removed in a future major version.
+	     */
+	    events: console_events_1.default,
+	};
+	
+} (src));
+
+var http_event = {};
+
+/**
+ * Shared helpers for HTTP-event instrumentation.
+ *
+ * Used by inbound (Express, Fastify, Lambda, Next.js) and — in a later PR —
+ * outbound (`http`, `https`, `fetch`) integrations.
+ */
+Object.defineProperty(http_event, "__esModule", { value: true });
+http_event.buildRequestEventPayload = http_event.durationMs = http_event.startTimer = http_event.seedRequestEventContext = http_event.getOrCreateCorrelationId = http_event.getOrCreateRequestId = void 0;
+var crypto_1 = require$$0__default["default"];
+/**
+ * Reads a header value from a Node-style headers bag in a case-insensitive
+ * manner. When the value is an array (e.g. `Set-Cookie`), returns the first
+ * element. Returns `undefined` when the header is missing or empty.
+ */
+function readHeader(headers, name) {
+    if (!headers)
+        return undefined;
+    var lower = name.toLowerCase();
+    var value = headers[lower];
+    if (value === undefined) {
+        for (var _i = 0, _a = Object.keys(headers); _i < _a.length; _i++) {
+            var key = _a[_i];
+            if (key.toLowerCase() === lower) {
+                value = headers[key];
+                break;
+            }
+        }
+    }
+    if (Array.isArray(value))
+        value = value[0];
+    if (typeof value !== 'string')
+        return undefined;
+    var trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+/**
+ * Generates a UUID-like identifier. Prefers Node's `crypto.randomUUID()` when
+ * available (Node 14.17+); falls back to a Math.random-based v4-shaped string
+ * for older Node versions.
+ */
+function generateId() {
+    if (typeof crypto_1.randomUUID === 'function') {
+        try {
+            return (0, crypto_1.randomUUID)();
+        }
+        catch (_e) {
+            // fall through to manual generation
+        }
+    }
+    // v4-shaped, not crypto-quality. Acceptable since this is a correlation id,
+    // not a security token.
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (ch) {
+        var r = (Math.random() * 16) | 0;
+        var v = ch === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Returns a unique-per-request id. Reads `x-request-id`, then `request-id`
+ * headers; falls back to a generated id when neither is present.
+ */
+function getOrCreateRequestId(headers) {
+    var _a, _b;
+    return ((_b = (_a = readHeader(headers, 'x-request-id')) !== null && _a !== void 0 ? _a : readHeader(headers, 'request-id')) !== null && _b !== void 0 ? _b : generateId());
+}
+http_event.getOrCreateRequestId = getOrCreateRequestId;
+/**
+ * Returns a correlation id that may span multiple requests in a logical trace.
+ * Reads `x-correlation-id`, then `x-amzn-trace-id`; falls back to the supplied
+ * `requestId` so callers always have both fields populated.
+ */
+function getOrCreateCorrelationId(headers, requestId) {
+    var _a, _b;
+    return ((_b = (_a = readHeader(headers, 'x-correlation-id')) !== null && _a !== void 0 ? _a : readHeader(headers, 'x-amzn-trace-id')) !== null && _b !== void 0 ? _b : requestId);
+}
+http_event.getOrCreateCorrelationId = getOrCreateCorrelationId;
+/**
+ * Convenience helper for framework integrations: read request/correlation ids
+ * from the request headers and return both. When no headers contain either
+ * value, both ids are generated and `requestId === correlationId`.
+ */
+function seedRequestEventContext(headers) {
+    var requestId = getOrCreateRequestId(headers);
+    var correlationId = getOrCreateCorrelationId(headers, requestId);
+    return { request_id: requestId, correlation_id: correlationId };
+}
+http_event.seedRequestEventContext = seedRequestEventContext;
+/**
+ * Starts a high-resolution timer.
+ */
+function startTimer() {
+    return process.hrtime.bigint();
+}
+http_event.startTimer = startTimer;
+var NS_PER_MS = BigInt(1000000);
+/**
+ * Returns the integer number of milliseconds elapsed since `start`.
+ */
+function durationMs(start) {
+    var diff = process.hrtime.bigint() - start;
+    return Number(diff / NS_PER_MS);
+}
+http_event.durationMs = durationMs;
+/**
+ * Builds the per-request event payload. `request_id` and `correlation_id` are
+ * NOT added here — they live on `eventContext` and are merged onto every event
+ * by the client.
+ */
+function buildRequestEventPayload(input) {
+    var payload = {};
+    if (input.method !== undefined)
+        payload.method = input.method;
+    if (input.path !== undefined)
+        payload.path = input.path;
+    if (input.route !== undefined)
+        payload.route = input.route;
+    if (input.status !== undefined)
+        payload.status = input.status;
+    if (input.duration !== undefined)
+        payload.duration = input.duration;
+    if (input.extra) {
+        for (var _i = 0, _a = Object.keys(input.extra); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (!Object.prototype.hasOwnProperty.call(payload, k)) {
+                payload[k] = input.extra[k];
+            }
+        }
+    }
+    return payload;
+}
+http_event.buildRequestEventPayload = buildRequestEventPayload;
+
+Object.defineProperty(fastify, "__esModule", { value: true });
+exports.fastifyPlugin = fastify.fastifyPlugin = void 0;
+var core_1 = src;
+var http_event_1 = http_event;
+var kHbStart = Symbol('honeybadger.start');
+// `fastify-plugin` is an optional peer dependency: only Fastify users need it,
+// so it is resolved lazily when the factory is called (same pattern as the
+// `async_hooks` require in ./async_store.ts).
+function requireFastifyPlugin() {
+    var _a;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        var fp = require('fastify-plugin');
+        return (_a = fp.default) !== null && _a !== void 0 ? _a : fp;
+    }
+    catch (e) {
+        var message = typeof (e === null || e === void 0 ? void 0 : e.message) === 'string' ? e.message : '';
+        var isMissing = (e === null || e === void 0 ? void 0 : e.code) === 'MODULE_NOT_FOUND' || (message.includes('Cannot find module') && message.includes('fastify-plugin'));
+        if (!isMissing) {
+            throw e;
+        }
+        throw new Error('@honeybadger-io/js: fastifyPlugin requires the `fastify-plugin` package. ' +
+            'Install it in your application: npm install fastify-plugin');
+    }
+}
+/**
+ * Returns a Fastify plugin bound to the given Honeybadger client.
+ *
+ * Exposed as a factory (rather than a method on the singleton) so the
+ * framework-specific code stays off the client API:
+ *
+ *     const { fastifyPlugin } = require('@honeybadger-io/js/dist/server/fastify')
+ *     fastify.register(fastifyPlugin(Honeybadger))
+ *
+ * Requires the `fastify-plugin` package (declared as an optional peer
+ * dependency of this package) — the factory throws with install instructions
+ * when it cannot be resolved. The returned plugin is wrapped with
+ * `fastify-plugin`, so its hooks apply to the calling context rather than
+ * being encapsulated.
+ *
+ * The plugin runs every request inside `client.withRequest(req, ...)`, seeding
+ * `request_id` / `correlation_id` on the event context. When
+ * `insights.enabled` and `insights.http` are both true it also emits a
+ * `request.handled` event per request with method, path, route, status and
+ * duration.
+ *
+ * Supports Fastify 4+.
+ */
+function fastifyPlugin(client) {
+    var fp = requireFastifyPlugin();
+    var plugin = function (fastify, _opts, done) {
+        fastify.addHook('onRequest', function (req, _reply, hookDone) {
+            client.withRequest(req, function () {
+                client.setEventContext((0, http_event_1.seedRequestEventContext)(req.headers));
+                if (core_1.Util.resolveInsights(client.config).http) {
+                    req[kHbStart] = (0, http_event_1.startTimer)();
+                }
+                hookDone();
+            });
+        });
+        fastify.addHook('onResponse', function (req, reply, hookDone) {
+            // `withRequest` keys store contents off the request object, so this
+            // re-entry shares the contents populated in `onRequest` — the event
+            // payload below picks up `request_id` / `correlation_id` (and any
+            // context the user set during the route handler).
+            client.withRequest(req, function () {
+                var _a, _b;
+                if (core_1.Util.resolveInsights(client.config).http && req[kHbStart] != null) {
+                    client.event('request.handled', (0, http_event_1.buildRequestEventPayload)({
+                        method: req.method,
+                        path: typeof req.url === 'string' ? req.url.split('?')[0] : req.url,
+                        route: (_b = (_a = req.routeOptions) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : req.routerPath,
+                        status: reply.statusCode,
+                        duration: (0, http_event_1.durationMs)(req[kHbStart]),
+                    }));
+                }
+                hookDone();
+            });
+        });
+        done();
+    };
+    return fp(plugin, { name: '@honeybadger-io/js' });
+}
+exports.fastifyPlugin = fastify.fastifyPlugin = fastifyPlugin;
+
+exports["default"] = fastify;
+//# sourceMappingURL=fastify.js.map