@hardfin/cli 0.1.0-dev.26 → 0.1.0-dev.27

package/dist/sentry-D5lKx0nm.js

@@ -0,0 +1,4384 @@
+#!/usr/bin/env node
+import { n as toScrubbed } from "./scrub-VtQmxap1.js";
+import { dirname } from "node:path";
+import { request } from "node:http";
+import { fileURLToPath } from "node:url";
+import { request as request$1 } from "node:https";
+//#region node_modules/@sentry/core/build/esm/debug-build.js
+const DEBUG_BUILD = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/worldwide.js
+const GLOBAL_OBJ = globalThis;
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/version.js
+const SDK_VERSION = "11.1.0";
+//#endregion
+//#region node_modules/@sentry/core/build/esm/carrier.js
+function getMainCarrier() {
+	getSentryCarrier(GLOBAL_OBJ);
+	return GLOBAL_OBJ;
+}
+function getSentryCarrier(carrier) {
+	const __SENTRY__ = carrier.__SENTRY__ = carrier.__SENTRY__ || {};
+	__SENTRY__.version = __SENTRY__.version || "11.1.0";
+	return __SENTRY__[SDK_VERSION] = __SENTRY__["11.1.0"] || {};
+}
+function getGlobalSingleton(name, creator, obj = GLOBAL_OBJ) {
+	const __SENTRY__ = obj.__SENTRY__ = obj.__SENTRY__ || {};
+	const carrier = __SENTRY__[SDK_VERSION] = __SENTRY__["11.1.0"] || {};
+	return carrier[name] || (carrier[name] = creator());
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/debug-logger.js
+const PREFIX = "Sentry Logger ";
+const originalConsoleMethods = {};
+function consoleSandbox(callback) {
+	if (!("console" in GLOBAL_OBJ)) return callback();
+	const console = GLOBAL_OBJ.console;
+	const wrappedFuncs = {};
+	const wrappedLevels = Object.keys(originalConsoleMethods);
+	wrappedLevels.forEach((level) => {
+		const originalConsoleMethod = originalConsoleMethods[level];
+		wrappedFuncs[level] = console[level];
+		console[level] = originalConsoleMethod;
+	});
+	try {
+		return callback();
+	} finally {
+		wrappedLevels.forEach((level) => {
+			console[level] = wrappedFuncs[level];
+		});
+	}
+}
+function enable() {
+	_getLoggerSettings().enabled = true;
+}
+function disable() {
+	_getLoggerSettings().enabled = false;
+}
+function isEnabled() {
+	return _getLoggerSettings().enabled;
+}
+function log(...args) {
+	_maybeLog("log", ...args);
+}
+function warn(...args) {
+	_maybeLog("warn", ...args);
+}
+function error(...args) {
+	_maybeLog("error", ...args);
+}
+function _maybeLog(level, ...args) {
+	if (!DEBUG_BUILD) return;
+	if (isEnabled()) consoleSandbox(() => {
+		GLOBAL_OBJ.console[level](`${PREFIX}[${level}]:`, ...args);
+	});
+}
+function _getLoggerSettings() {
+	if (!DEBUG_BUILD) return { enabled: false };
+	return getGlobalSingleton("loggerSettings", () => ({ enabled: false }));
+}
+const debug = {
+	/** Enable logging. */
+	enable,
+	/** Disable logging. */
+	disable,
+	/** Check if logging is enabled. */
+	isEnabled,
+	/** Log a message. */
+	log,
+	/** Log a warning. */
+	warn,
+	/** Log an error. */
+	error
+};
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/stacktrace.js
+const STACKTRACE_FRAME_LIMIT = 50;
+const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+const STRIP_FRAME_REGEXP = /captureMessage|captureException/;
+function createStackParser(...parsers) {
+	const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map((p) => p[1]);
+	return (stack, skipFirstLines = 0, framesToPop = 0) => {
+		const frames = [];
+		const lines = stack.split("\n");
+		for (let i = skipFirstLines; i < lines.length; i++) {
+			let line = lines[i];
+			if (line.length > 1024) line = line.slice(0, 1024);
+			const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
+			if (cleanedLine.includes("Error: ")) continue;
+			for (const parser of sortedParsers) {
+				const frame = parser(cleanedLine);
+				if (frame) {
+					frames.push(frame);
+					break;
+				}
+			}
+			if (frames.length >= STACKTRACE_FRAME_LIMIT + framesToPop) break;
+		}
+		return stripSentryFramesAndReverse(frames.slice(framesToPop));
+	};
+}
+function stripSentryFramesAndReverse(stack) {
+	if (!stack.length) return [];
+	const localStack = Array.from(stack);
+	if (/sentryWrapped/.test(getLastStackFrame(localStack).function || "")) localStack.pop();
+	localStack.reverse();
+	if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || "")) {
+		localStack.pop();
+		if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || "")) localStack.pop();
+	}
+	return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame) => ({
+		...frame,
+		filename: frame.filename || getLastStackFrame(localStack).filename,
+		function: frame.function || "?"
+	}));
+}
+function getLastStackFrame(arr) {
+	return arr[arr.length - 1] || {};
+}
+const defaultFunctionName = "<anonymous>";
+function getFunctionName(fn) {
+	try {
+		if (!fn || typeof fn !== "function") return defaultFunctionName;
+		return fn.name || defaultFunctionName;
+	} catch {
+		return defaultFunctionName;
+	}
+}
+function normalizeStackTracePath(path) {
+	let filename = path?.startsWith("file://") ? path.slice(7) : path;
+	if (filename?.match(/\/[A-Z]:/)) filename = filename.slice(1);
+	return filename;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/is.js
+const objectToString = Object.prototype.toString;
+function isError(wat) {
+	switch (objectToString.call(wat)) {
+		case "[object Error]":
+		case "[object Exception]":
+		case "[object DOMException]":
+		case "[object WebAssembly.Exception]": return true;
+		default: return isInstanceOf(wat, Error);
+	}
+}
+function isBuiltin(wat, className) {
+	return objectToString.call(wat) === `[object ${className}]`;
+}
+function isErrorEvent$1(wat) {
+	return isBuiltin(wat, "ErrorEvent");
+}
+function isString(wat) {
+	return isBuiltin(wat, "String");
+}
+function isParameterizedString(wat) {
+	return typeof wat === "object" && wat !== null && "__sentry_template_string__" in wat && "__sentry_template_values__" in wat;
+}
+function isPrimitive(wat) {
+	return wat === null || isParameterizedString(wat) || typeof wat !== "object" && typeof wat !== "function";
+}
+function isPlainObject(wat) {
+	return isBuiltin(wat, "Object");
+}
+function isObjectLike(wat) {
+	return typeof wat === "object" && wat !== null;
+}
+function isEvent(wat) {
+	return typeof Event !== "undefined" && isInstanceOf(wat, Event);
+}
+function isRegExp(wat) {
+	return isBuiltin(wat, "RegExp");
+}
+function isThenable(wat) {
+	return Boolean(wat?.then && typeof wat.then === "function");
+}
+function isInstanceOf(wat, base) {
+	try {
+		return wat instanceof base;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/object.js
+function addNonEnumerableProperty(obj, name, value) {
+	try {
+		Object.defineProperty(obj, name, {
+			value,
+			writable: true,
+			configurable: true
+		});
+	} catch {
+		DEBUG_BUILD && debug.log(`Failed to add non-enumerable property "${String(name)}" to object`, obj);
+	}
+}
+function convertToPlainObject(value) {
+	if (isError(value)) return {
+		message: value.message,
+		name: value.name,
+		stack: value.stack,
+		...getOwnProperties(value)
+	};
+	if (isEvent(value)) {
+		const { type, target, currentTarget, detail } = value;
+		return {
+			type,
+			target,
+			currentTarget,
+			...detail ? { detail } : {},
+			...getOwnProperties(value)
+		};
+	}
+	return value;
+}
+function getOwnProperties(obj) {
+	if (isObjectLike(obj)) return Object.fromEntries(Object.entries(obj));
+	return {};
+}
+function extractExceptionKeysForMessage(exception) {
+	const keys = Object.keys(convertToPlainObject(exception));
+	keys.sort();
+	return !keys[0] ? "[object has no keys]" : keys.join(", ");
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/randomSafeContext.js
+let RESOLVED_RUNNER;
+function withRandomSafeContext(cb) {
+	if (RESOLVED_RUNNER !== void 0) return RESOLVED_RUNNER ? RESOLVED_RUNNER(cb) : cb();
+	const sym = /* @__PURE__ */ Symbol.for("__SENTRY_SAFE_RANDOM_ID_WRAPPER__");
+	const globalWithSymbol = GLOBAL_OBJ;
+	if (sym in globalWithSymbol && typeof globalWithSymbol[sym] === "function") {
+		RESOLVED_RUNNER = globalWithSymbol[sym];
+		return RESOLVED_RUNNER(cb);
+	}
+	RESOLVED_RUNNER = null;
+	return cb();
+}
+function safeMathRandom() {
+	return withRandomSafeContext(() => Math.random());
+}
+function safeDateNow() {
+	return withRandomSafeContext(() => Date.now());
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/normalizationHints.js
+const SENTRY_SKIP_NORMALIZATION = /* @__PURE__ */ Symbol.for("sentry.skipNormalization");
+const SENTRY_OVERRIDE_NORMALIZATION_DEPTH = /* @__PURE__ */ Symbol.for("sentry.overrideNormalizationDepth");
+function hasSkipNormalizationHint(value) {
+	return Boolean(value[SENTRY_SKIP_NORMALIZATION]);
+}
+function getNormalizationDepthOverrideHint(value) {
+	const v = value[SENTRY_OVERRIDE_NORMALIZATION_DEPTH];
+	return typeof v === "number" ? v : void 0;
+}
+function normalize(input, depth = 100, maxProperties = Infinity) {
+	try {
+		return visit("", input, depth, maxProperties);
+	} catch (err) {
+		return { ERROR: `**non-serializable** (${err})` };
+	}
+}
+function normalizeToSize(object, depth = 3, maxSize = 102400) {
+	const normalized = normalize(object, depth);
+	if (jsonSize(normalized) > maxSize) return normalizeToSize(object, depth - 1, maxSize);
+	return normalized;
+}
+function visit(key, value, depth = Infinity, maxProperties = Infinity, memo = memoBuilder()) {
+	const [memoize, unmemoize] = memo;
+	if (value == null || ["boolean", "string"].includes(typeof value) || typeof value === "number" && Number.isFinite(value)) return value;
+	const stringified = stringifyValue(key, value);
+	if (!stringified.startsWith("[object ")) return stringified;
+	if (hasSkipNormalizationHint(value)) return value;
+	const overrideDepth = getNormalizationDepthOverrideHint(value);
+	const remainingDepth = overrideDepth !== void 0 ? overrideDepth : depth;
+	if (remainingDepth === 0) return stringified.replace("object ", "");
+	if (memoize(value)) return "[Circular ~]";
+	const valueWithToJSON = value;
+	if (valueWithToJSON && typeof valueWithToJSON.toJSON === "function") try {
+		return visit("", valueWithToJSON.toJSON(), remainingDepth - 1, maxProperties, memo);
+	} catch {}
+	const normalized = Array.isArray(value) ? [] : {};
+	let numAdded = 0;
+	const visitable = convertToPlainObject(value);
+	for (const visitKey in visitable) {
+		if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) continue;
+		if (numAdded >= maxProperties) {
+			normalized[visitKey] = "[MaxProperties ~]";
+			break;
+		}
+		const visitValue = visitable[visitKey];
+		normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);
+		numAdded++;
+	}
+	unmemoize(value);
+	return normalized;
+}
+function stringifyValue(key, value) {
+	try {
+		if (typeof global !== "undefined" && value === global) return "[Global]";
+		if (typeof value === "number" && !Number.isFinite(value)) return `[${value}]`;
+		if (typeof value === "function") return `[Function: ${getFunctionName(value)}]`;
+		if (typeof value === "symbol") return `[${String(value)}]`;
+		if (typeof value === "bigint") return `[BigInt: ${String(value)}]`;
+		return `[object ${getConstructorName(value)}]`;
+	} catch (err) {
+		return `**non-serializable** (${err})`;
+	}
+}
+function getConstructorName(value) {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype?.constructor ? prototype.constructor.name : "null prototype";
+}
+function utf8Length(value) {
+	return ~-encodeURI(value).split(/%..|./).length;
+}
+function jsonSize(value) {
+	return utf8Length(JSON.stringify(value));
+}
+function memoBuilder() {
+	const inner = /* @__PURE__ */ new WeakSet();
+	function memoize(obj) {
+		if (inner.has(obj)) return true;
+		inner.add(obj);
+		return false;
+	}
+	function unmemoize(obj) {
+		inner.delete(obj);
+	}
+	return [memoize, unmemoize];
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/string.js
+function truncate(str, max = 0) {
+	if (typeof str !== "string" || max === 0) return str;
+	return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+function isMatchingPattern(value, pattern, requireExactStringMatch = false) {
+	if (!isString(value)) return false;
+	if (isRegExp(pattern)) return pattern.test(value);
+	if (isString(pattern)) return requireExactStringMatch ? value === pattern : value.includes(pattern);
+	if (typeof pattern === "function") return pattern(value);
+	return false;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/misc.js
+function getCrypto() {
+	const gbl = GLOBAL_OBJ;
+	return gbl.crypto || gbl.msCrypto;
+}
+let emptyUuid;
+function getRandomByte() {
+	return safeMathRandom() * 16;
+}
+function uuid4(crypto = getCrypto()) {
+	try {
+		if (crypto?.randomUUID) return withRandomSafeContext(() => crypto.randomUUID()).replace(/-/g, "");
+	} catch {}
+	if (!emptyUuid) emptyUuid = "10000000100040008000100000000000";
+	return emptyUuid.replace(/[018]/g, (c) => (c ^ (getRandomByte() & 15) >> c / 4).toString(16));
+}
+function getFirstException(event) {
+	return event.exception?.values?.[0];
+}
+function addExceptionTypeValue(event, value, type) {
+	const exception = event.exception = event.exception || {};
+	const values = exception.values = exception.values || [];
+	const firstException = values[0] = values[0] || {};
+	if (!firstException.value) firstException.value = value || "";
+	if (!firstException.type) firstException.type = type || "Error";
+}
+function addExceptionMechanism(event, newMechanism) {
+	const firstException = getFirstException(event);
+	if (!firstException) return;
+	applyExceptionMechanism(firstException, newMechanism);
+}
+function addExceptionMechanismToCapturedException(event, newMechanism) {
+	const exceptions = event.exception?.values;
+	const capturedException = exceptions?.find((exception) => exception.mechanism?.exception_id === 0) ?? exceptions?.[0];
+	if (!capturedException) return;
+	applyExceptionMechanism(capturedException, newMechanism);
+}
+function applyExceptionMechanism(exception, newMechanism) {
+	const defaultMechanism = {
+		type: "generic",
+		handled: true
+	};
+	const currentMechanism = exception.mechanism;
+	exception.mechanism = {
+		...defaultMechanism,
+		...currentMechanism,
+		...newMechanism
+	};
+	if (newMechanism && "data" in newMechanism) exception.mechanism.data = {
+		...currentMechanism?.data,
+		...newMechanism.data
+	};
+}
+function checkOrSetAlreadyCaught(exception) {
+	if (isAlreadyCaptured(exception)) return true;
+	try {
+		addNonEnumerableProperty(exception, "__sentry_captured__", true);
+	} catch {}
+	return false;
+}
+function isAlreadyCaptured(exception) {
+	try {
+		return exception.__sentry_captured__;
+	} catch {}
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/time.js
+const ONE_SECOND_IN_MS = 1e3;
+function dateTimestampInSeconds() {
+	return safeDateNow() / ONE_SECOND_IN_MS;
+}
+function createUnixTimestampInSecondsFunc() {
+	const { performance } = GLOBAL_OBJ;
+	if (!performance?.now || !performance.timeOrigin) return dateTimestampInSeconds;
+	const timeOrigin = performance.timeOrigin;
+	return () => {
+		return (timeOrigin + withRandomSafeContext(() => performance.now())) / ONE_SECOND_IN_MS;
+	};
+}
+let _cachedTimestampInSeconds;
+function timestampInSeconds() {
+	return (_cachedTimestampInSeconds ?? (_cachedTimestampInSeconds = createUnixTimestampInSecondsFunc()))();
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/session.js
+function updateSession(session, context = {}) {
+	if (context.user) {
+		if (!session.ipAddress && context.user.ip_address) session.ipAddress = context.user.ip_address;
+		if (!session.did && !context.did) session.did = context.user.id || context.user.email || context.user.username;
+	}
+	session.timestamp = context.timestamp || timestampInSeconds();
+	if (context.abnormal_mechanism) session.abnormal_mechanism = context.abnormal_mechanism;
+	if (context.ignoreDuration) session.ignoreDuration = context.ignoreDuration;
+	if (context.sid) session.sid = context.sid.length === 32 ? context.sid : uuid4();
+	if (context.init !== void 0) session.init = context.init;
+	if (!session.did && context.did) session.did = `${context.did}`;
+	if (typeof context.started === "number") session.started = context.started;
+	if (session.ignoreDuration) session.duration = void 0;
+	else if (typeof context.duration === "number") session.duration = context.duration;
+	else {
+		const duration = session.timestamp - session.started;
+		session.duration = duration >= 0 ? duration : 0;
+	}
+	if (context.release) session.release = context.release;
+	if (context.environment) session.environment = context.environment;
+	if (!session.ipAddress && context.ipAddress) session.ipAddress = context.ipAddress;
+	if (!session.userAgent && context.userAgent) session.userAgent = context.userAgent;
+	if (typeof context.errors === "number") session.errors = context.errors;
+	if (context.status) session.status = context.status;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/merge.js
+function merge(initialObj, mergeObj, levels = 2) {
+	if (!mergeObj || typeof mergeObj !== "object" || levels <= 0) return mergeObj;
+	if (initialObj && Object.keys(mergeObj).length === 0) return initialObj;
+	const output = { ...initialObj };
+	for (const key in mergeObj) if (Object.prototype.hasOwnProperty.call(mergeObj, key)) output[key] = merge(output[key], mergeObj[key], levels - 1);
+	return output;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/propagationContext.js
+function generateTraceId() {
+	return uuid4();
+}
+function generateSpanId() {
+	return uuid4().substring(16);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/scope.js
+const DEFAULT_MAX_BREADCRUMBS = 100;
+var Scope = class Scope {
+	constructor() {
+		this._notifyingListeners = false;
+		this._scopeListeners = [];
+		this._eventProcessors = [];
+		this._breadcrumbs = [];
+		this._attachments = [];
+		this._user = {};
+		this._tags = {};
+		this._attributes = {};
+		this._extra = {};
+		this._contexts = {};
+		this._sdkProcessingMetadata = {};
+		addNonEnumerableProperty(this, "refs", {});
+		this._propagationContext = {
+			traceId: generateTraceId(),
+			sampleRand: safeMathRandom()
+		};
+	}
+	/**
+	* Clone all data from this scope into a new scope.
+	*/
+	clone() {
+		const newScope = new Scope();
+		newScope._breadcrumbs = [...this._breadcrumbs];
+		newScope._tags = { ...this._tags };
+		newScope._attributes = { ...this._attributes };
+		newScope._extra = { ...this._extra };
+		newScope._contexts = { ...this._contexts };
+		if (this._contexts.flags) newScope._contexts.flags = { values: [...this._contexts.flags.values] };
+		newScope._user = this._user;
+		newScope._level = this._level;
+		newScope._session = this._session;
+		newScope._transactionName = this._transactionName;
+		newScope._fingerprint = this._fingerprint;
+		newScope._eventProcessors = [...this._eventProcessors];
+		newScope._attachments = [...this._attachments];
+		newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };
+		newScope._propagationContext = { ...this._propagationContext };
+		newScope._client = this._client;
+		newScope._lastEventId = this._lastEventId;
+		newScope._conversationId = this._conversationId;
+		newScope.refs = { ...this.refs };
+		return newScope;
+	}
+	/**
+	* Update the client assigned to this scope.
+	* Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client,
+	* as well as manually created scopes.
+	*/
+	setClient(client) {
+		this._client = client;
+	}
+	/**
+	* Set the ID of the last captured error event.
+	* This is generally only captured on the isolation scope.
+	*/
+	setLastEventId(lastEventId) {
+		this._lastEventId = lastEventId;
+	}
+	/**
+	* Get the client assigned to this scope.
+	*/
+	getClient() {
+		return this._client;
+	}
+	/**
+	* Get the ID of the last captured error event.
+	* This is generally only available on the isolation scope.
+	*/
+	lastEventId() {
+		return this._lastEventId;
+	}
+	/**
+	* @inheritDoc
+	*/
+	addScopeListener(callback) {
+		this._scopeListeners.push(callback);
+	}
+	/**
+	* Add an event processor that will be called before an event is sent.
+	*/
+	addEventProcessor(callback) {
+		this._eventProcessors.push(callback);
+		return this;
+	}
+	/**
+	* Set the user for this scope.
+	* Set to `null` to unset the user.
+	*/
+	setUser(user) {
+		this._user = user || {
+			email: void 0,
+			id: void 0,
+			ip_address: void 0,
+			username: void 0
+		};
+		if (this._session) updateSession(this._session, { user });
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Get the user from this scope.
+	*/
+	getUser() {
+		return this._user;
+	}
+	/**
+	* Set the conversation ID for this scope.
+	* Set to `null` to unset the conversation ID.
+	*/
+	setConversationId(conversationId) {
+		this._conversationId = conversationId || void 0;
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Set an object that will be merged into existing tags on the scope,
+	* and will be sent as tags data with the event.
+	*/
+	setTags(tags) {
+		this._tags = {
+			...this._tags,
+			...tags
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Set a single tag that will be sent as tags data with the event.
+	*/
+	setTag(key, value) {
+		return this.setTags({ [key]: value });
+	}
+	/**
+	* Sets attributes onto the scope.
+	*
+	* These attributes are applied to logs, metrics and streamed spans.
+	*
+	* Supported attribute value types are `string`, `number`, `boolean`, `string[]`, `number[]` and `boolean[]`.
+	*
+	* @param newAttributes - The attributes to set on the scope, as key-value pairs.
+	*
+	* @example
+	* ```typescript
+	* scope.setAttributes({
+	*   is_admin: true,
+	*   payment_selection: 'credit_card',
+	*   render_duration: 150,
+	* });
+	* ```
+	*/
+	setAttributes(newAttributes) {
+		this._attributes = {
+			...this._attributes,
+			...newAttributes
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Sets an attribute onto the scope.
+	*
+	* These attributes are applied to logs, metrics and streamed spans.
+	*
+	* Supported attribute value types are `string`, `number`, `boolean`, `string[]`, `number[]` and `boolean[]`.
+	*
+	* @param key - The attribute key.
+	* @param value - The attribute value.
+	*
+	* @example
+	* ```typescript
+	* scope.setAttribute('is_admin', true);
+	* scope.setAttribute('render_duration', 150);
+	* ```
+	*/
+	setAttribute(key, value) {
+		return this.setAttributes({ [key]: value });
+	}
+	/**
+	* Removes the attribute with the given key from the scope.
+	*
+	* @param key - The attribute key.
+	*
+	* @example
+	* ```typescript
+	* scope.removeAttribute('is_admin');
+	* ```
+	*/
+	removeAttribute(key) {
+		if (key in this._attributes) {
+			delete this._attributes[key];
+			this._notifyScopeListeners();
+		}
+		return this;
+	}
+	/**
+	* Set an object that will be merged into existing extra on the scope,
+	* and will be sent as extra data with the event.
+	*/
+	setExtras(extras) {
+		this._extra = {
+			...this._extra,
+			...extras
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Set a single key:value extra entry that will be sent as extra data with the event.
+	*/
+	setExtra(key, extra) {
+		this._extra = {
+			...this._extra,
+			[key]: extra
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Sets the fingerprint on the scope to send with the events.
+	* @param {string[]} fingerprint Fingerprint to group events in Sentry.
+	*/
+	setFingerprint(fingerprint) {
+		this._fingerprint = fingerprint;
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Sets the level on the scope for future events.
+	*/
+	setLevel(level) {
+		this._level = level;
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Sets the transaction name on the scope so that the name of e.g. taken server route or
+	* the page location is attached to future events.
+	*
+	* IMPORTANT: Calling this function does NOT change the name of the currently active
+	* root span. If you want to change the name of the active root span, use
+	* `Sentry.updateSpanName(rootSpan, 'new name')` instead.
+	*
+	* By default, the SDK updates the scope's transaction name automatically on sensible
+	* occasions, such as a page navigation or when handling a new request on the server.
+	*/
+	setTransactionName(name) {
+		this._transactionName = name;
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Sets context data with the given name.
+	* Data passed as context will be normalized. You can also pass `null` to unset the context.
+	* Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key.
+	*/
+	setContext(key, context) {
+		if (context === null) delete this._contexts[key];
+		else this._contexts[key] = context;
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Set the session for the scope.
+	*/
+	setSession(session) {
+		if (!session) delete this._session;
+		else this._session = session;
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Get the session from the scope.
+	*/
+	getSession() {
+		return this._session;
+	}
+	/**
+	* Updates the scope with provided data. Can work in three variations:
+	* - plain object containing updatable attributes
+	* - Scope instance that'll extract the attributes from
+	* - callback function that'll receive the current scope as an argument and allow for modifications
+	*/
+	update(captureContext) {
+		if (!captureContext) return this;
+		const scopeToMerge = typeof captureContext === "function" ? captureContext(this) : captureContext;
+		const { tags, attributes, extra, user, contexts, level, fingerprint = [], propagationContext, conversationId } = (scopeToMerge instanceof Scope ? scopeToMerge.getScopeData() : isPlainObject(scopeToMerge) ? captureContext : void 0) || {};
+		this._tags = {
+			...this._tags,
+			...tags
+		};
+		this._attributes = {
+			...this._attributes,
+			...attributes
+		};
+		this._extra = {
+			...this._extra,
+			...extra
+		};
+		this._contexts = {
+			...this._contexts,
+			...contexts
+		};
+		if (user && Object.keys(user).length) this._user = user;
+		if (level) this._level = level;
+		if (fingerprint.length) this._fingerprint = fingerprint;
+		if (propagationContext) this._propagationContext = propagationContext;
+		if (conversationId) this._conversationId = conversationId;
+		return this;
+	}
+	/**
+	* Adds a breadcrumb to the scope.
+	* By default, the last 100 breadcrumbs are kept.
+	*/
+	addBreadcrumb(breadcrumb, maxBreadcrumbs) {
+		const maxCrumbs = typeof maxBreadcrumbs === "number" ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
+		if (maxCrumbs <= 0) return this;
+		const mergedBreadcrumb = {
+			timestamp: dateTimestampInSeconds(),
+			...breadcrumb,
+			message: breadcrumb.message ? truncate(breadcrumb.message, 2048) : breadcrumb.message
+		};
+		this._breadcrumbs.push(mergedBreadcrumb);
+		if (this._breadcrumbs.length > maxCrumbs) this._breadcrumbs = this._breadcrumbs.slice(-maxCrumbs);
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Get the last breadcrumb of the scope.
+	*/
+	getLastBreadcrumb() {
+		return this._breadcrumbs[this._breadcrumbs.length - 1];
+	}
+	/**
+	* Clear all breadcrumbs from the scope.
+	*/
+	clearBreadcrumbs() {
+		this._breadcrumbs = [];
+		this._notifyScopeListeners();
+		return this;
+	}
+	/**
+	* Add an attachment to the scope.
+	*/
+	addAttachment(attachment) {
+		this._attachments.push(attachment);
+		return this;
+	}
+	/**
+	* Clear all attachments from the scope.
+	*/
+	clearAttachments() {
+		this._attachments = [];
+		return this;
+	}
+	/**
+	* Get the data of this scope, which should be applied to an event during processing.
+	*/
+	getScopeData() {
+		return {
+			breadcrumbs: this._breadcrumbs,
+			attachments: this._attachments,
+			contexts: this._contexts,
+			tags: this._tags,
+			attributes: this._attributes,
+			extra: this._extra,
+			user: this._user,
+			level: this._level,
+			fingerprint: this._fingerprint || [],
+			eventProcessors: this._eventProcessors,
+			propagationContext: this._propagationContext,
+			sdkProcessingMetadata: this._sdkProcessingMetadata,
+			transactionName: this._transactionName,
+			conversationId: this._conversationId
+		};
+	}
+	/**
+	* Add data which will be accessible during event processing but won't get sent to Sentry.
+	*/
+	setSDKProcessingMetadata(newData) {
+		this._sdkProcessingMetadata = merge(this._sdkProcessingMetadata, newData, 2);
+		return this;
+	}
+	/**
+	* Add propagation context to the scope, used for distributed tracing
+	*/
+	setPropagationContext(context) {
+		this._propagationContext = context;
+		return this;
+	}
+	/**
+	* Get propagation context from the scope, used for distributed tracing
+	*/
+	getPropagationContext() {
+		return this._propagationContext;
+	}
+	/**
+	* Capture an exception for this scope.
+	*
+	* @returns {string} The id of the captured Sentry event.
+	*/
+	captureException(exception, hint) {
+		const eventId = hint?.event_id || uuid4();
+		if (!this._client) {
+			DEBUG_BUILD && debug.warn("No client configured on scope - will not capture exception!");
+			return eventId;
+		}
+		const syntheticException = /* @__PURE__ */ new Error("Sentry syntheticException");
+		this._client.captureException(exception, {
+			originalException: exception,
+			syntheticException,
+			...hint,
+			event_id: eventId
+		}, this);
+		return eventId;
+	}
+	/**
+	* Capture a message for this scope.
+	*
+	* @returns {string} The id of the captured message.
+	*/
+	captureMessage(message, level, hint) {
+		const eventId = hint?.event_id || uuid4();
+		if (!this._client) {
+			DEBUG_BUILD && debug.warn("No client configured on scope - will not capture message!");
+			return eventId;
+		}
+		const syntheticException = hint?.syntheticException ?? new Error(message);
+		this._client.captureMessage(message, level, {
+			originalException: message,
+			syntheticException,
+			...hint,
+			event_id: eventId
+		}, this);
+		return eventId;
+	}
+	/**
+	* Capture a Sentry event for this scope.
+	*
+	* @returns {string} The id of the captured event.
+	*/
+	captureEvent(event, hint) {
+		const eventId = event.event_id || hint?.event_id || uuid4();
+		if (!this._client) {
+			DEBUG_BUILD && debug.warn("No client configured on scope - will not capture event!");
+			return eventId;
+		}
+		this._client.captureEvent(event, {
+			...hint,
+			event_id: eventId
+		}, this);
+		return eventId;
+	}
+	/**
+	* This will be called on every set call.
+	*/
+	_notifyScopeListeners() {
+		if (!this._notifyingListeners) {
+			this._notifyingListeners = true;
+			this._scopeListeners.forEach((callback) => {
+				callback(this);
+			});
+			this._notifyingListeners = false;
+		}
+	}
+};
+//#endregion
+//#region node_modules/@sentry/core/build/esm/defaultScopes.js
+function getDefaultCurrentScope() {
+	return getGlobalSingleton("defaultCurrentScope", () => new Scope());
+}
+function getDefaultIsolationScope() {
+	return getGlobalSingleton("defaultIsolationScope", () => new Scope());
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/constants.js
+const SUPPRESS_TRACING_KEY = "__SENTRY_SUPPRESS_TRACING__";
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/chain-and-copy-promiselike.js
+const isActualPromise = (p) => p instanceof Promise && !p[kChainedCopy];
+const kChainedCopy = /* @__PURE__ */ Symbol("chained PromiseLike");
+const chainAndCopyPromiseLike = (original, onSuccess, onError) => {
+	const chained = original.then((value) => {
+		onSuccess(value);
+		return value;
+	}, (err) => {
+		onError(err);
+		throw err;
+	});
+	return isActualPromise(chained) && isActualPromise(original) ? chained : copyProps(original, chained);
+};
+const copyProps = (original, chained) => {
+	if (!chained) return original;
+	let mutated = false;
+	for (const key in original) {
+		if (key in chained) continue;
+		mutated = true;
+		const value = original[key];
+		if (typeof value === "function") Object.defineProperty(chained, key, {
+			value: (...args) => value.apply(original, args),
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		else chained[key] = value;
+	}
+	if (mutated) Object.assign(chained, { [kChainedCopy]: true });
+	return chained;
+};
+//#endregion
+//#region node_modules/@sentry/core/build/esm/asyncContext/stackStrategy.js
+var AsyncContextStack = class {
+	constructor(scope, isolationScope) {
+		let assignedScope;
+		if (!scope) assignedScope = new Scope();
+		else assignedScope = scope;
+		let assignedIsolationScope;
+		if (!isolationScope) assignedIsolationScope = new Scope();
+		else assignedIsolationScope = isolationScope;
+		this._stack = [{ scope: assignedScope }];
+		this._isolationScope = assignedIsolationScope;
+	}
+	/**
+	* Fork a scope for the stack.
+	*/
+	withScope(callback) {
+		const scope = this._pushScope();
+		let maybePromiseResult;
+		try {
+			maybePromiseResult = callback(scope);
+		} catch (e) {
+			this._popScope();
+			throw e;
+		}
+		if (isThenable(maybePromiseResult)) return chainAndCopyPromiseLike(maybePromiseResult, () => this._popScope(), () => this._popScope());
+		this._popScope();
+		return maybePromiseResult;
+	}
+	/**
+	* Get the client of the stack.
+	*/
+	getClient() {
+		return this.getStackTop().client;
+	}
+	/**
+	* Returns the scope of the top stack.
+	*/
+	getScope() {
+		return this.getStackTop().scope;
+	}
+	/**
+	* Get the isolation scope for the stack.
+	*/
+	getIsolationScope() {
+		return this._isolationScope;
+	}
+	/**
+	* Returns the topmost scope layer in the order domain > local > process.
+	*/
+	getStackTop() {
+		return this._stack[this._stack.length - 1];
+	}
+	/**
+	* Push a scope to the stack.
+	*/
+	_pushScope() {
+		const scope = this.getScope().clone();
+		this._stack.push({
+			client: this.getClient(),
+			scope
+		});
+		return scope;
+	}
+	/**
+	* Pop a scope from the stack.
+	*/
+	_popScope() {
+		if (this._stack.length <= 1) return false;
+		return !!this._stack.pop();
+	}
+};
+function getAsyncContextStack() {
+	const sentry = getSentryCarrier(getMainCarrier());
+	return sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope());
+}
+function withScope$1(callback) {
+	return getAsyncContextStack().withScope(callback);
+}
+function withSetScope(scope, callback) {
+	const stack = getAsyncContextStack();
+	return stack.withScope(() => {
+		stack.getStackTop().scope = scope;
+		return callback(scope);
+	});
+}
+function withIsolationScope(callback) {
+	return getAsyncContextStack().withScope(() => {
+		return callback(getAsyncContextStack().getIsolationScope());
+	});
+}
+function getStackAsyncContextStrategy() {
+	return {
+		suppressTracing: suppressTracingInStack,
+		withIsolationScope,
+		withScope: withScope$1,
+		withSetScope,
+		withSetIsolationScope: (_isolationScope, callback) => {
+			return withIsolationScope(callback);
+		},
+		getCurrentScope: () => getAsyncContextStack().getScope(),
+		getIsolationScope: () => getAsyncContextStack().getIsolationScope()
+	};
+}
+function suppressTracingInStack(callback) {
+	return withScope$1((scope) => {
+		scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: true });
+		const res = callback();
+		scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: void 0 });
+		return res;
+	});
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/asyncContext/index.js
+function getAsyncContextStrategy(carrier) {
+	const sentry = getSentryCarrier(carrier);
+	if (sentry.acs) return sentry.acs;
+	return getStackAsyncContextStrategy();
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/attributes.js
+function isAttributeObject(maybeObj) {
+	return typeof maybeObj === "object" && maybeObj != null && !Array.isArray(maybeObj) && Object.keys(maybeObj).includes("value");
+}
+function attributeValueToTypedAttributeValue(rawValue, useFallback) {
+	const { value, unit } = isAttributeObject(rawValue) ? rawValue : {
+		value: rawValue,
+		unit: void 0
+	};
+	const attributeValue = getTypedAttributeValue(value);
+	const checkedUnit = unit && typeof unit === "string" ? { unit } : {};
+	if (attributeValue) return {
+		...attributeValue,
+		...checkedUnit
+	};
+	if (!useFallback || useFallback === "skip-undefined" && value === void 0) return;
+	let stringValue = "";
+	try {
+		stringValue = JSON.stringify(value) ?? "";
+	} catch {}
+	return {
+		value: stringValue,
+		type: "string",
+		...checkedUnit
+	};
+}
+function serializeAttributes(attributes, fallback = false) {
+	const serializedAttributes = {};
+	for (const [key, value] of Object.entries(attributes ?? {})) {
+		const typedValue = attributeValueToTypedAttributeValue(value, fallback);
+		if (typedValue) serializedAttributes[key] = typedValue;
+	}
+	return serializedAttributes;
+}
+function estimateTypedAttributesSizeInBytes(attributes) {
+	if (!attributes) return 0;
+	let weight = 0;
+	for (const [key, attr] of Object.entries(attributes)) {
+		weight += key.length * 2;
+		weight += attr.type.length * 2;
+		weight += (attr.unit?.length ?? 0) * 2;
+		const val = attr.value;
+		if (Array.isArray(val)) weight += estimatePrimitiveSizeInBytes$1(val[0]) * val.length;
+		else if (isPrimitive(val)) weight += estimatePrimitiveSizeInBytes$1(val);
+		else weight += 100;
+	}
+	return weight;
+}
+function estimatePrimitiveSizeInBytes$1(value) {
+	if (typeof value === "string") return value.length * 2;
+	else if (typeof value === "boolean") return 4;
+	else if (typeof value === "number") return 8;
+	return 0;
+}
+function getTypedAttributeValue(value) {
+	if (Array.isArray(value)) return {
+		value,
+		type: "array"
+	};
+	const primitiveType = typeof value === "string" ? "string" : typeof value === "boolean" ? "boolean" : typeof value === "number" && !Number.isNaN(value) ? Number.isInteger(value) ? "integer" : "double" : null;
+	if (primitiveType) return {
+		value,
+		type: primitiveType
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/currentScopes.js
+function getExternalPropagationContext() {
+	return getSentryCarrier(getMainCarrier()).externalPropagationContextProvider?.();
+}
+function getCurrentScope() {
+	return getAsyncContextStrategy(getMainCarrier()).getCurrentScope();
+}
+function getIsolationScope() {
+	return getAsyncContextStrategy(getMainCarrier()).getIsolationScope();
+}
+function getGlobalScope() {
+	return getGlobalSingleton("globalScope", () => new Scope());
+}
+function withScope(...rest) {
+	const acs = getAsyncContextStrategy(getMainCarrier());
+	if (rest.length === 2) {
+		const [scope, callback] = rest;
+		if (!scope) return acs.withScope(callback);
+		return acs.withSetScope(scope, callback);
+	}
+	return acs.withScope(rest[0]);
+}
+function getClient() {
+	return getCurrentScope().getClient();
+}
+function getTraceContextFromScope(scope) {
+	const externalContext = getExternalPropagationContext();
+	if (externalContext) return {
+		trace_id: externalContext.traceId,
+		span_id: externalContext.spanId
+	};
+	const { traceId, parentSpanId, propagationSpanId } = scope.getPropagationContext();
+	const traceContext = {
+		trace_id: traceId,
+		span_id: propagationSpanId || generateSpanId()
+	};
+	if (parentSpanId) traceContext.parent_span_id = parentSpanId;
+	return traceContext;
+}
+//#endregion
+//#region node_modules/@sentry/conventions/dist/attributes.mjs
+const zd = "sentry.sdk.name";
+const Yd = "sentry.sdk.version";
+const Vd = "sentry.segment.id";
+const Fd = "sentry.segment.name";
+const Wd = "sentry.segment.name.source";
+const ag = "sentry.trace_lifecycle";
+const SEMANTIC_ATTRIBUTE_SENTRY_OP = "sentry.op";
+const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = "sentry.origin";
+const SEMANTIC_ATTRIBUTE_SENTRY_RELEASE = "sentry.release";
+const SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT = "sentry.environment";
+const SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS = "sentry.sdk.integrations";
+const SEMANTIC_ATTRIBUTE_USER_ID = "user.id";
+const SEMANTIC_ATTRIBUTE_USER_EMAIL = "user.email";
+const SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS = "user.ip_address";
+const SEMANTIC_ATTRIBUTE_USER_USERNAME = "user.name";
+const SEMANTIC_ATTRIBUTE_PROFILE_ID = "sentry.profile_id";
+const SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME = "sentry.exclusive_time";
+//#endregion
+//#region node_modules/@sentry/core/build/esm/types/spanStatus.js
+const SPAN_STATUS_TYPES = [
+	"ok",
+	"deadline_exceeded",
+	"unauthenticated",
+	"permission_denied",
+	"not_found",
+	"resource_exhausted",
+	"invalid_argument",
+	"unimplemented",
+	"unavailable",
+	"internal_error",
+	"unknown_error",
+	"cancelled",
+	"already_exists",
+	"failed_precondition",
+	"aborted",
+	"out_of_range",
+	"data_loss"
+];
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spanstatus.js
+function isStatusErrorMessageValid(message) {
+	return message !== "ok" && SPAN_STATUS_TYPES.includes(message);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/weakRef.js
+function derefWeakRef(ref) {
+	if (!ref) return;
+	if (typeof ref === "object" && "deref" in ref && typeof ref.deref === "function") try {
+		return ref.deref();
+	} catch {
+		return;
+	}
+	return ref;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/utils.js
+const SCOPE_ON_START_SPAN_FIELD = "_sentryScope";
+const ISOLATION_SCOPE_ON_START_SPAN_FIELD = "_sentryIsolationScope";
+function getCapturedScopesOnSpan(span) {
+	const spanWithScopes = span;
+	return {
+		scope: spanWithScopes[SCOPE_ON_START_SPAN_FIELD],
+		isolationScope: derefWeakRef(spanWithScopes[ISOLATION_SCOPE_ON_START_SPAN_FIELD])
+	};
+}
+function baggageHeaderToDynamicSamplingContext(baggageHeader) {
+	const baggageObject = parseBaggageHeader(baggageHeader);
+	if (!baggageObject) return;
+	const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {
+		if (key.startsWith("sentry-")) {
+			const nonPrefixedKey = key.slice(7);
+			acc[nonPrefixedKey] = value;
+		}
+		return acc;
+	}, {});
+	if (Object.keys(dynamicSamplingContext).length > 0) return dynamicSamplingContext;
+	else return;
+}
+function parseBaggageHeader(baggageHeader) {
+	if (!baggageHeader || !isString(baggageHeader) && !Array.isArray(baggageHeader)) return;
+	if (Array.isArray(baggageHeader)) return baggageHeader.reduce((acc, curr) => {
+		const currBaggageObject = baggageHeaderToObject(curr);
+		Object.entries(currBaggageObject).forEach(([key, value]) => {
+			acc[key] = value;
+		});
+		return acc;
+	}, {});
+	return baggageHeaderToObject(baggageHeader);
+}
+function baggageHeaderToObject(baggageHeader) {
+	return baggageHeader.split(",").map((baggageEntry) => {
+		const eqIdx = baggageEntry.indexOf("=");
+		if (eqIdx === -1) return [];
+		return [baggageEntry.slice(0, eqIdx), baggageEntry.slice(eqIdx + 1)].map((keyOrValue) => {
+			try {
+				return decodeURIComponent(keyOrValue.trim());
+			} catch {
+				return;
+			}
+		});
+	}).reduce((acc, [key, value]) => {
+		if (key && value) acc[key] = value;
+		return acc;
+	}, {});
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/dsn.js
+const ORG_ID_REGEX = /^o(\d+)\./;
+const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)((?:\[[:.%\w]+\]|[\w.-]+))(?::(\d+))?\/(.+)/;
+function isValidProtocol(protocol) {
+	return protocol === "http" || protocol === "https";
+}
+function dsnToString(dsn, withPassword = false) {
+	const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
+	return `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ""}@${host}${port ? `:${port}` : ""}/${path ? `${path}/` : path}${projectId}`;
+}
+function dsnFromString(str) {
+	const match = DSN_REGEX.exec(str);
+	if (!match) {
+		consoleSandbox(() => {
+			console.error(`Invalid Sentry Dsn: ${str}`);
+		});
+		return;
+	}
+	const [protocol, publicKey, pass = "", host = "", port = "", lastPath = ""] = match.slice(1);
+	let path = "";
+	let projectId = lastPath;
+	const split = projectId.split("/");
+	if (split.length > 1) {
+		path = split.slice(0, -1).join("/");
+		projectId = split.pop();
+	}
+	if (projectId) {
+		const projectMatch = projectId.match(/^\d+/);
+		if (projectMatch) projectId = projectMatch[0];
+	}
+	return dsnFromComponents({
+		host,
+		pass,
+		path,
+		projectId,
+		port,
+		protocol,
+		publicKey
+	});
+}
+function dsnFromComponents(components) {
+	return {
+		protocol: components.protocol,
+		publicKey: components.publicKey || "",
+		pass: components.pass || "",
+		host: components.host,
+		port: components.port || "",
+		path: components.path || "",
+		projectId: components.projectId
+	};
+}
+function validateDsn(dsn) {
+	if (!DEBUG_BUILD) return true;
+	const { port, projectId, protocol } = dsn;
+	if ([
+		"protocol",
+		"publicKey",
+		"host",
+		"projectId"
+	].find((component) => {
+		if (!dsn[component]) {
+			debug.error(`Invalid Sentry Dsn: ${component} missing`);
+			return true;
+		}
+		return false;
+	})) return false;
+	if (!projectId.match(/^\d+$/)) {
+		debug.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+		return false;
+	}
+	if (!isValidProtocol(protocol)) {
+		debug.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+		return false;
+	}
+	if (port && isNaN(parseInt(port, 10))) {
+		debug.error(`Invalid Sentry Dsn: Invalid port ${port}`);
+		return false;
+	}
+	return true;
+}
+function extractOrgIdFromDsnHost(host) {
+	return host.match(ORG_ID_REGEX)?.[1];
+}
+function extractOrgIdFromClient(client) {
+	const options = client.getOptions();
+	const { host } = client.getDsn() || {};
+	let org_id;
+	if (options.orgId) org_id = String(options.orgId);
+	else if (host) org_id = extractOrgIdFromDsnHost(host);
+	return org_id;
+}
+function makeDsn(from) {
+	const components = typeof from === "string" ? dsnFromString(from) : dsnFromComponents(from);
+	if (!components || !validateDsn(components)) return;
+	return components;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/parseSampleRate.js
+function parseSampleRate(sampleRate) {
+	if (typeof sampleRate === "boolean") return Number(sampleRate);
+	const rate = typeof sampleRate === "string" ? parseFloat(sampleRate) : sampleRate;
+	if (typeof rate !== "number" || isNaN(rate) || rate < 0 || rate > 1) return;
+	return rate;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/spanOnScope.js
+const SCOPE_SPAN_FIELD = "span";
+function _getSpanForScope(scope) {
+	return derefWeakRef(scope.refs[SCOPE_SPAN_FIELD]);
+}
+function spanToTraceContext(span) {
+	const { spanId, traceId: trace_id, isRemote } = span.spanContext();
+	const parent_span_id = isRemote ? spanId : spanToStaticSpanJSON(span).parent_span_id;
+	const scope = getCapturedScopesOnSpan(span).scope;
+	return {
+		parent_span_id,
+		span_id: isRemote ? scope?.getPropagationContext().propagationSpanId || generateSpanId() : spanId,
+		trace_id
+	};
+}
+function convertSpanLinksForEnvelope(links) {
+	if (links && links.length > 0) return links.map(({ context: { spanId, traceId, traceFlags, ...restContext }, attributes }) => ({
+		span_id: spanId,
+		trace_id: traceId,
+		sampled: traceFlags === 1,
+		attributes,
+		...restContext
+	}));
+	else return;
+}
+function getStreamedSpanLinks(links) {
+	if (links?.length) return links.map(({ context: { spanId, traceId, traceFlags }, attributes }) => ({
+		span_id: spanId,
+		trace_id: traceId,
+		sampled: traceFlags === 1,
+		attributes
+	}));
+	else return;
+}
+function spanTimeInputToSeconds(input) {
+	if (typeof input === "number") return ensureTimestampInSeconds(input);
+	if (Array.isArray(input)) return input[0] + input[1] / 1e9;
+	if (input instanceof Date) return ensureTimestampInSeconds(input.getTime());
+	return timestampInSeconds();
+}
+function ensureTimestampInSeconds(timestamp) {
+	return timestamp > 9999999999 ? timestamp / 1e3 : timestamp;
+}
+function spanToStaticSpanJSON(span) {
+	if (spanIsSentrySpan(span)) return span.getStaticSpanJSON();
+	const { spanId: span_id, traceId: trace_id } = span.spanContext();
+	if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
+		const { attributes, startTime, name, endTime, status, links } = span;
+		return {
+			span_id,
+			trace_id,
+			data: attributes,
+			description: name,
+			parent_span_id: getOtelParentSpanId(span),
+			start_timestamp: spanTimeInputToSeconds(startTime),
+			timestamp: spanTimeInputToSeconds(endTime) || void 0,
+			status: getStatusMessage(status),
+			op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],
+			origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN],
+			links: convertSpanLinksForEnvelope(links)
+		};
+	}
+	return {
+		span_id,
+		trace_id,
+		start_timestamp: 0,
+		status: "ok",
+		data: {}
+	};
+}
+function spanToJSON(span) {
+	if (spanIsSentrySpan(span)) return span.getSpanJSON();
+	const { spanId: span_id, traceId: trace_id } = span.spanContext();
+	if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
+		const { attributes, startTime, name, endTime, status, links } = span;
+		return {
+			name,
+			span_id,
+			trace_id,
+			parent_span_id: getOtelParentSpanId(span),
+			start_timestamp: spanTimeInputToSeconds(startTime),
+			end_timestamp: spanTimeInputToSeconds(endTime) || void 0,
+			is_segment: spanIsSegment(span),
+			status: getSimpleStatus(status),
+			attributes: addStatusMessageAttribute(attributes, status),
+			links: getStreamedSpanLinks(links)
+		};
+	}
+	return {
+		span_id,
+		trace_id,
+		start_timestamp: 0,
+		name: "",
+		status: "ok",
+		is_segment: spanIsSegment(span),
+		attributes: {}
+	};
+}
+function getOtelParentSpanId(span) {
+	return "parentSpanId" in span ? span.parentSpanId : "parentSpanContext" in span ? span.parentSpanContext?.spanId : void 0;
+}
+function streamedSpanJsonToSerializedSpan(spanJson) {
+	return {
+		...spanJson,
+		end_timestamp: spanJson.end_timestamp ?? spanJson.start_timestamp,
+		attributes: serializeAttributes(spanJson.attributes),
+		links: spanJson.links?.map((link) => ({
+			...link,
+			attributes: serializeAttributes(link.attributes)
+		}))
+	};
+}
+function spanIsOpenTelemetrySdkTraceBaseSpan(span) {
+	const castSpan = span;
+	return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;
+}
+function spanIsSentrySpan(span) {
+	return typeof span.getSpanJSON === "function";
+}
+function spanIsSampled(span) {
+	const { traceFlags } = span.spanContext();
+	return traceFlags === 1;
+}
+function getStatusMessage(status) {
+	if (!status || status.code === 0) return "ok";
+	if (status.code === 1) return "ok";
+	return status.message && isStatusErrorMessageValid(status.message) ? status.message : "internal_error";
+}
+function getSimpleStatus(status) {
+	return !status || status.code === 1 || status.code === 0 || status.message === "cancelled" ? "ok" : "error";
+}
+function addStatusMessageAttribute(attributes, status) {
+	const statusMessage = getSimpleStatus(status) === "error" ? status?.message : void 0;
+	return {
+		...statusMessage && { ["sentry.status.message"]: statusMessage },
+		...attributes
+	};
+}
+const ROOT_SPAN_FIELD = "_sentryRootSpan";
+const getRootSpan = INTERNAL_getSegmentSpan;
+function INTERNAL_getSegmentSpan(span) {
+	return span[ROOT_SPAN_FIELD] || span;
+}
+function spanIsSegment(span) {
+	return span === INTERNAL_getSegmentSpan(span);
+}
+function getActiveSpan(scope) {
+	const acs = getAsyncContextStrategy(getMainCarrier());
+	if (acs.getActiveSpan) return acs.getActiveSpan(scope);
+	return _getSpanForScope(scope || getCurrentScope());
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/hasSpansEnabled.js
+function hasSpansEnabled(maybeOptions) {
+	if (typeof __SENTRY_TRACING__ === "boolean" && !__SENTRY_TRACING__) return false;
+	const options = maybeOptions || getClient()?.getOptions();
+	return !!options && (options.tracesSampleRate != null || !!options.tracesSampler);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/should-ignore-span.js
+function logIgnoredSpan(droppedSpan) {
+	debug.log(`Ignoring span ${droppedSpan.op} - ${droppedSpan.description} because it matches \`ignoreSpans\`.`);
+}
+function shouldIgnoreSpan(span, ignoreSpans) {
+	if (!ignoreSpans?.length) return false;
+	for (const pattern of ignoreSpans) {
+		if (isStringOrRegExp(pattern)) {
+			if (span.description && isMatchingPattern(span.description, pattern)) {
+				DEBUG_BUILD && logIgnoredSpan(span);
+				return true;
+			}
+			continue;
+		}
+		const hasAttributes = !!pattern.attributes && Object.keys(pattern.attributes).length > 0;
+		if (!pattern.name && !pattern.op && !hasAttributes) continue;
+		const nameMatches = pattern.name ? span.description && isMatchingPattern(span.description, pattern.name) : true;
+		const opMatches = pattern.op ? span.op && isMatchingPattern(span.op, pattern.op) : true;
+		const attrsMatch = pattern.attributes ? Object.entries(pattern.attributes).every(([key, valuePattern]) => _matchesAttributeValue(span.attributes?.[key], valuePattern)) : true;
+		if (nameMatches && opMatches && attrsMatch) {
+			DEBUG_BUILD && logIgnoredSpan(span);
+			return true;
+		}
+	}
+	return false;
+}
+function _matchesAttributeValue(actual, pat) {
+	if (typeof actual === "string" && (typeof pat === "string" || pat instanceof RegExp)) return isMatchingPattern(actual, pat);
+	if (Array.isArray(actual) && Array.isArray(pat)) return actual.length === pat.length && actual.every((v, i) => v === pat[i]);
+	return actual === pat;
+}
+function reparentChildSpans(spans, dropSpan) {
+	const droppedSpanParentId = dropSpan.parent_span_id;
+	const droppedSpanId = dropSpan.span_id;
+	if (!droppedSpanParentId) return;
+	for (const span of spans) if (span.parent_span_id === droppedSpanId) span.parent_span_id = droppedSpanParentId;
+}
+function isStringOrRegExp(value) {
+	return typeof value === "string" || value instanceof RegExp;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/integration.js
+const installedIntegrations = [];
+function setupIntegrations(client, integrations) {
+	const integrationIndex = {};
+	integrations.forEach((integration) => {
+		if (integration?.beforeSetup) integration.beforeSetup(client);
+	});
+	integrations.forEach((integration) => {
+		if (integration) setupIntegration(client, integration, integrationIndex);
+	});
+	return integrationIndex;
+}
+function afterSetupIntegrations(client, integrations) {
+	for (const integration of integrations) if (integration?.afterAllSetup) integration.afterAllSetup(client);
+}
+function setupIntegration(client, integration, integrationIndex) {
+	if (integrationIndex[integration.name]) {
+		DEBUG_BUILD && debug.log(`Integration skipped because it was already installed: ${integration.name}`);
+		return;
+	}
+	integrationIndex[integration.name] = integration;
+	if (!installedIntegrations.includes(integration.name) && typeof integration.setupOnce === "function") {
+		integration.setupOnce();
+		installedIntegrations.push(integration.name);
+	}
+	if (integration.setup && typeof integration.setup === "function") integration.setup(client);
+	if (typeof integration.preprocessEvent === "function") {
+		const callback = integration.preprocessEvent.bind(integration);
+		client.on("preprocessEvent", (event, hint) => callback(event, hint, client));
+	}
+	if (typeof integration.processEvent === "function") {
+		const callback = integration.processEvent.bind(integration);
+		const processor = Object.assign((event, hint) => callback(event, hint, client), { id: integration.name });
+		client.addEventProcessor(processor);
+	}
+	["processSpan", "processSegmentSpan"].forEach((hook) => {
+		const callback = integration[hook];
+		if (typeof callback === "function") client.on(hook, (span) => callback.call(integration, span, client));
+	});
+	DEBUG_BUILD && debug.log(`Integration installed: ${integration.name}`);
+}
+function defineIntegration(fn) {
+	return fn;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/constants.js
+const DEFAULT_ENVIRONMENT = "production";
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/sentryNonRecordingSpan.js
+const NON_RECORDING_SPAN_FIELD = /* @__PURE__ */ Symbol.for("sentry.nonRecordingSpan");
+function spanIsNonRecordingSpan(span) {
+	return !!span && span[NON_RECORDING_SPAN_FIELD] === true;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/dynamicSamplingContext.js
+const FROZEN_DSC_FIELD = "_frozenDsc";
+function getDynamicSamplingContextFromClient(trace_id, client) {
+	const options = client.getOptions();
+	const { publicKey: public_key } = client.getDsn() || {};
+	const dsc = {
+		environment: options.environment || "production",
+		release: options.release,
+		public_key,
+		trace_id,
+		org_id: extractOrgIdFromClient(client)
+	};
+	client.emit("createDsc", dsc);
+	return dsc;
+}
+function getDynamicSamplingContextFromScope(client, scope) {
+	if (getExternalPropagationContext()) return;
+	const propagationContext = scope.getPropagationContext();
+	return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);
+}
+function getDynamicSamplingContextFromSpan(span) {
+	const client = getClient();
+	if (!client) return {};
+	const rootSpan = getRootSpan(span);
+	const rootSpanJson = spanToStaticSpanJSON(rootSpan);
+	const rootSpanAttributes = rootSpanJson.data;
+	const traceState = rootSpan.spanContext().traceState;
+	const rootSpanSampleRate = traceState?.get("sentry.sample_rate") ?? rootSpanAttributes["sentry.sample_rate"] ?? rootSpanAttributes["sentry.previous_trace_sample_rate"];
+	function applyLocalSampleRateToDsc(dsc2) {
+		if (typeof rootSpanSampleRate === "number" || typeof rootSpanSampleRate === "string") dsc2.sample_rate = `${rootSpanSampleRate}`;
+		return dsc2;
+	}
+	const frozenDsc = rootSpan[FROZEN_DSC_FIELD];
+	if (frozenDsc) return applyLocalSampleRateToDsc(frozenDsc);
+	const isNonRecordingRoot = spanIsNonRecordingSpan(rootSpan);
+	const isIgnoredRoot = isNonRecordingRoot && rootSpan.dropReason === "ignored";
+	if (isNonRecordingRoot && (!hasSpansEnabled(client.getOptions()) || isIgnoredRoot)) {
+		const capturedScope = getCapturedScopesOnSpan(rootSpan).scope;
+		const scopeDsc = capturedScope && getDynamicSamplingContextFromScope(client, capturedScope);
+		if (scopeDsc) {
+			const dsc2 = { ...scopeDsc };
+			if (isIgnoredRoot) dsc2.sampled = "false";
+			return applyLocalSampleRateToDsc(dsc2);
+		}
+	}
+	const traceStateDsc = traceState?.get("sentry.dsc");
+	const dscOnTraceState = traceStateDsc && baggageHeaderToDynamicSamplingContext(traceStateDsc);
+	if (dscOnTraceState) return applyLocalSampleRateToDsc(dscOnTraceState);
+	const dsc = getDynamicSamplingContextFromClient(span.spanContext().traceId, client);
+	const source = rootSpanAttributes[Wd];
+	const name = rootSpanJson.description;
+	if (source !== "url" && name) dsc.transaction = name;
+	if (hasSpansEnabled()) {
+		dsc.sampled = String(spanIsSampled(rootSpan));
+		dsc.sample_rand = traceState?.get("sentry.sample_rand") ?? getCapturedScopesOnSpan(rootSpan).scope?.getPropagationContext().sampleRand.toString();
+	}
+	applyLocalSampleRateToDsc(dsc);
+	client.emit("createDsc", dsc, rootSpan);
+	return dsc;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/scopeData.js
+function applyScopeDataToEvent(event, data) {
+	const { fingerprint, breadcrumbs, sdkProcessingMetadata } = data;
+	applyDataToEvent(event, data);
+	applyFingerprintToEvent(event, fingerprint);
+	applyBreadcrumbsToEvent(event, breadcrumbs);
+	applySdkMetadataToEvent(event, sdkProcessingMetadata);
+}
+function mergeScopeData(data, mergeData) {
+	const { extra, tags, attributes, user, contexts, level, sdkProcessingMetadata, breadcrumbs, fingerprint, eventProcessors, attachments, propagationContext, transactionName } = mergeData;
+	mergeAndOverwriteScopeData(data, "extra", extra);
+	mergeAndOverwriteScopeData(data, "tags", tags);
+	mergeAndOverwriteScopeData(data, "attributes", attributes);
+	mergeAndOverwriteScopeData(data, "user", user);
+	mergeAndOverwriteScopeData(data, "contexts", contexts);
+	data.sdkProcessingMetadata = merge(data.sdkProcessingMetadata, sdkProcessingMetadata, 2);
+	if (level) data.level = level;
+	if (transactionName) data.transactionName = transactionName;
+	if (breadcrumbs.length) data.breadcrumbs = [...data.breadcrumbs, ...breadcrumbs];
+	if (fingerprint.length) data.fingerprint = [...data.fingerprint, ...fingerprint];
+	if (eventProcessors.length) data.eventProcessors = [...data.eventProcessors, ...eventProcessors];
+	if (attachments.length) data.attachments = [...data.attachments, ...attachments];
+	data.propagationContext = {
+		...data.propagationContext,
+		...propagationContext
+	};
+}
+function mergeAndOverwriteScopeData(data, prop, mergeVal) {
+	data[prop] = merge(data[prop], mergeVal, 1);
+}
+function getCombinedScopeData(isolationScope, currentScope) {
+	const scopeData = getGlobalScope().getScopeData();
+	isolationScope && mergeScopeData(scopeData, isolationScope.getScopeData());
+	currentScope && mergeScopeData(scopeData, currentScope.getScopeData());
+	return scopeData;
+}
+function applyDataToEvent(event, data) {
+	const { extra, tags, user, contexts, level, transactionName } = data;
+	if (Object.keys(extra).length) event.extra = {
+		...extra,
+		...event.extra
+	};
+	if (Object.keys(tags).length) event.tags = {
+		...tags,
+		...event.tags
+	};
+	if (Object.keys(user).length) event.user = {
+		...user,
+		...event.user
+	};
+	if (Object.keys(contexts).length) event.contexts = {
+		...contexts,
+		...event.contexts
+	};
+	if (level) event.level = level;
+	if (transactionName && event.type !== "transaction") event.transaction = transactionName;
+}
+function applyBreadcrumbsToEvent(event, breadcrumbs) {
+	const mergedBreadcrumbs = [...event.breadcrumbs || [], ...breadcrumbs];
+	event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : void 0;
+}
+function applySdkMetadataToEvent(event, sdkProcessingMetadata) {
+	event.sdkProcessingMetadata = {
+		...event.sdkProcessingMetadata,
+		...sdkProcessingMetadata
+	};
+}
+function applySpanToEvent(event, span) {
+	event.contexts = {
+		trace: spanToTraceContext(span),
+		...event.contexts
+	};
+	event.sdkProcessingMetadata = {
+		dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),
+		...event.sdkProcessingMetadata
+	};
+	const transactionName = spanToStaticSpanJSON(getRootSpan(span)).description;
+	if (transactionName && !event.transaction && event.type === "transaction") event.transaction = transactionName;
+}
+function applyFingerprintToEvent(event, fingerprint) {
+	event.fingerprint = event.fingerprint ? Array.isArray(event.fingerprint) ? event.fingerprint : [event.fingerprint] : [];
+	if (fingerprint) event.fingerprint = event.fingerprint.concat(fingerprint);
+	if (!event.fingerprint.length) delete event.fingerprint;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/safeCallback.js
+function safeCallback(message, fn, fallback) {
+	let result;
+	try {
+		result = fn();
+	} catch (error) {
+		return recover(message, error, fallback);
+	}
+	if (isThenable(result)) return result.then(void 0, (error) => recover(message, error, fallback));
+	return result;
+}
+function recover(message, error, fallback) {
+	DEBUG_BUILD && debug.error(message, error);
+	return fallback(error);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/beforeSendSpan.js
+function isStaticBeforeSendSpanCallback(callback) {
+	return !!callback && typeof callback === "function" && "_static" in callback && !!callback._static;
+}
+let hasShownSpanDropWarning = false;
+function applyBeforeSendSpanCallback(span, beforeSendSpan) {
+	const modifiedSpan = safeCallback(DEBUG_BUILD ? "The `beforeSendSpan` callback threw an error, sending the span unmodified:" : "", () => beforeSendSpan(span), () => span);
+	if (modifiedSpan) return modifiedSpan;
+	if (!hasShownSpanDropWarning) {
+		consoleSandbox(() => {
+			console.warn("[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly or use `ignoreSpans`.");
+		});
+		hasShownSpanDropWarning = true;
+	}
+	return span;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/spanJsonToStreamedSpan.js
+function spanJsonToSerializedStreamedSpan(span) {
+	return streamedSpanJsonToSerializedSpan({
+		trace_id: span.trace_id,
+		span_id: span.span_id,
+		parent_span_id: span.parent_span_id,
+		name: span.description || "",
+		start_timestamp: span.start_timestamp,
+		end_timestamp: span.timestamp,
+		status: !span.status || span.status === "ok" || span.status === "cancelled" ? "ok" : "error",
+		is_segment: false,
+		attributes: { ...span.data },
+		links: span.links
+	});
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/scopeContextAttributes.js
+function scopeContextsToSpanAttributes(contexts) {
+	const attrs = {};
+	const { response, profile, cloud_resource, culture, state } = contexts;
+	if (response) {
+		if (response.status_code != null) attrs["http.response.status_code"] = response.status_code;
+		if (response.body_size != null) attrs["http.response.body.size"] = response.body_size;
+	}
+	if (profile) {
+		if (profile.profile_id) attrs["sentry.profile_id"] = profile.profile_id;
+		if (profile.profiler_id) attrs["sentry.profiler_id"] = profile.profiler_id;
+	}
+	if (cloud_resource) {
+		for (const [key, value] of Object.entries(cloud_resource)) if (value != null) attrs[key] = value;
+	}
+	if (culture) {
+		if (culture.locale) attrs["culture.locale"] = culture.locale;
+		if (culture.timezone) attrs["culture.timezone"] = culture.timezone;
+	}
+	if (state?.state && typeof state.state.type === "string") attrs["state.type"] = state.state.type;
+	const angular = contexts["angular"];
+	if (angular) {
+		const version = angular["version"];
+		if (typeof version === "string" || typeof version === "number") attrs["angular.version"] = version;
+	}
+	const react = contexts["react"];
+	if (react) {
+		const version = react["version"];
+		if (typeof version === "string" || typeof version === "number") attrs["react.version"] = version;
+	}
+	return attrs;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/captureSpan.js
+function captureSpan(span, client) {
+	const spanJSON = spanToJSON(span);
+	const segmentSpan = INTERNAL_getSegmentSpan(span);
+	const serializedSegmentSpan = spanToJSON(segmentSpan);
+	const { isolationScope: spanIsolationScope, scope: spanScope } = getCapturedScopesOnSpan(span);
+	const finalScopeData = getCombinedScopeData(spanIsolationScope, spanScope);
+	applyCommonSpanAttributes(spanJSON, serializedSegmentSpan, client, finalScopeData);
+	client.emit("preprocessSpan", spanJSON);
+	if (spanJSON.is_segment) {
+		applyScopeToSegmentSpan(spanJSON, finalScopeData);
+		applySdkMetadataToSegmentSpan(spanJSON, client);
+		client.emit("processSegmentSpan", spanJSON);
+	}
+	client.emit("processSpan", spanJSON);
+	const { beforeSendSpan, traceLifecycle } = client.getOptions();
+	return {
+		...streamedSpanJsonToSerializedSpan(traceLifecycle !== "static" && beforeSendSpan && !isStaticBeforeSendSpanCallback(beforeSendSpan) ? applyBeforeSendSpanCallback(spanJSON, beforeSendSpan) : spanJSON),
+		_segmentSpan: segmentSpan
+	};
+}
+function applyScopeToSegmentSpan(segmentSpanJSON, scopeData) {
+	safeSetSpanJSONAttributes(segmentSpanJSON, scopeContextsToSpanAttributes(scopeData.contexts));
+}
+function safeSetSpanJSONAttributes(spanJSON, newAttributes) {
+	const originalAttributes = spanJSON.attributes ?? (spanJSON.attributes = {});
+	Object.entries(newAttributes).forEach(([key, value]) => {
+		if (value != null && !(key in originalAttributes)) originalAttributes[key] = value;
+	});
+}
+function applySdkMetadataToSegmentSpan(segmentSpanJSON, client) {
+	const integrationNames = client.getIntegrationNames();
+	if (!integrationNames.length) return;
+	safeSetSpanJSONAttributes(segmentSpanJSON, { [SEMANTIC_ATTRIBUTE_SENTRY_SDK_INTEGRATIONS]: integrationNames });
+}
+function commonSpanAttributes(serializedSegmentSpan, client, scopeData, includeScopeAttributes = true) {
+	const sdk = client.getSdkMetadata();
+	const { release, environment } = client.getOptions();
+	return {
+		[ag]: "stream",
+		[Fd]: serializedSegmentSpan.name,
+		[Vd]: serializedSegmentSpan.span_id,
+		[zd]: sdk?.sdk?.name,
+		[Yd]: sdk?.sdk?.version,
+		[SEMANTIC_ATTRIBUTE_SENTRY_RELEASE]: release,
+		[SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT]: environment || "production",
+		[SEMANTIC_ATTRIBUTE_USER_ID]: scopeData.user?.id,
+		[SEMANTIC_ATTRIBUTE_USER_EMAIL]: scopeData.user?.email,
+		[SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS]: scopeData.user?.ip_address,
+		[SEMANTIC_ATTRIBUTE_USER_USERNAME]: scopeData.user?.username,
+		...includeScopeAttributes ? scopeData.attributes : void 0
+	};
+}
+function applyCommonSpanAttributes(spanJSON, serializedSegmentSpan, client, scopeData) {
+	safeSetSpanJSONAttributes(spanJSON, commonSpanAttributes(serializedSegmentSpan, client, scopeData));
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/hasSpanStreamingEnabled.js
+function hasSpanStreamingEnabled(client) {
+	return client.getOptions().traceLifecycle === "stream";
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/timer.js
+function safeUnref(timer) {
+	if (typeof timer === "object" && typeof timer.unref === "function") timer.unref();
+	return timer;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/envelope.js
+function createEnvelope(headers, items = []) {
+	return [headers, items];
+}
+function addItemToEnvelope(envelope, newItem) {
+	const [headers, items] = envelope;
+	return [headers, [...items, newItem]];
+}
+function forEachEnvelopeItem(envelope, callback) {
+	const envelopeItems = envelope[1];
+	for (const envelopeItem of envelopeItems) {
+		const envelopeItemType = envelopeItem[0].type;
+		if (callback(envelopeItem, envelopeItemType)) return true;
+	}
+	return false;
+}
+function envelopeContainsItemType(envelope, types) {
+	return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));
+}
+function encodeUTF8(input) {
+	const carrier = getSentryCarrier(GLOBAL_OBJ);
+	return carrier.encodePolyfill ? carrier.encodePolyfill(input) : new TextEncoder().encode(input);
+}
+function serializeEnvelope(envelope) {
+	const [envHeaders, items] = envelope;
+	let parts = JSON.stringify(envHeaders);
+	function append(next) {
+		if (typeof parts === "string") parts = typeof next === "string" ? parts + next : [encodeUTF8(parts), next];
+		else parts.push(typeof next === "string" ? encodeUTF8(next) : next);
+	}
+	for (const item of items) {
+		const [itemHeaders, payload] = item;
+		append(`
+${JSON.stringify(itemHeaders)}
+`);
+		if (typeof payload === "string" || payload instanceof Uint8Array) append(payload);
+		else {
+			let stringifiedPayload;
+			try {
+				stringifiedPayload = JSON.stringify(payload);
+			} catch {
+				stringifiedPayload = JSON.stringify(normalize(payload));
+			}
+			append(stringifiedPayload);
+		}
+	}
+	return typeof parts === "string" ? parts : concatBuffers(parts);
+}
+function concatBuffers(buffers) {
+	const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);
+	const merged = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const buffer of buffers) {
+		merged.set(buffer, offset);
+		offset += buffer.length;
+	}
+	return merged;
+}
+function createAttachmentEnvelopeItem(attachment) {
+	const buffer = typeof attachment.data === "string" ? encodeUTF8(attachment.data) : attachment.data;
+	return [{
+		type: "attachment",
+		length: buffer.length,
+		filename: attachment.filename,
+		content_type: attachment.contentType,
+		attachment_type: attachment.attachmentType
+	}, buffer];
+}
+const DATA_CATEGORY_OVERRIDES = {
+	sessions: "session",
+	event: "error",
+	client_report: "internal",
+	user_report: "default",
+	profile_chunk: "profile",
+	replay_event: "replay",
+	replay_recording: "replay",
+	check_in: "monitor",
+	raw_security: "security",
+	log: "log_item",
+	trace_metric: "metric"
+};
+function _isOverriddenType(type) {
+	return type in DATA_CATEGORY_OVERRIDES;
+}
+function envelopeItemTypeToDataCategory(type) {
+	return _isOverriddenType(type) ? DATA_CATEGORY_OVERRIDES[type] : type;
+}
+function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
+	if (!metadataOrEvent?.sdk) return;
+	const { name, version } = metadataOrEvent.sdk;
+	return {
+		name,
+		version
+	};
+}
+function createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) {
+	const dynamicSamplingContext = event.sdkProcessingMetadata?.dynamicSamplingContext;
+	return {
+		event_id: event.event_id,
+		sent_at: new Date(safeDateNow()).toISOString(),
+		...sdkInfo && { sdk: sdkInfo },
+		...!!tunnel && dsn && { dsn: dsnToString(dsn) },
+		...dynamicSamplingContext && { trace: dynamicSamplingContext }
+	};
+}
+function getDataCategoryByType(type) {
+	return type === "replay_event" ? "replay" : type || "error";
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/env.js
+function isBrowserBundle() {
+	return typeof __SENTRY_BROWSER_BUNDLE__ !== "undefined" && !!__SENTRY_BROWSER_BUNDLE__;
+}
+/*! __SENTRY_SDK_SOURCE__ */
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/node.js
+function isNodeEnv() {
+	return !isBrowserBundle() && Object.prototype.toString.call(typeof process !== "undefined" ? process : 0) === "[object process]";
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/isBrowser.js
+function isBrowser() {
+	return typeof window !== "undefined" && (!isNodeEnv() || isElectronNodeRenderer());
+}
+function isElectronNodeRenderer() {
+	return GLOBAL_OBJ.process?.type === "renderer";
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/envelope.js
+function createStreamedSpanEnvelope(serializedSpans, dsc, client) {
+	const options = client.getOptions();
+	const dsn = client.getDsn();
+	const tunnel = options.tunnel;
+	const sdk = getSdkMetadataForEnvelopeHeader(options._metadata);
+	return createEnvelope({
+		sent_at: new Date(safeDateNow()).toISOString(),
+		...dscHasRequiredProps(dsc) && { trace: dsc },
+		...sdk && { sdk },
+		...!!tunnel && dsn && { dsn: dsnToString(dsn) }
+	}, [createSpanContainerItem(serializedSpans, client)]);
+}
+function createSpanContainerItem(serializedSpans, client) {
+	const inferSetting = client.getDataCollectionOptions().userInfo ? "auto" : "never";
+	return [{
+		type: "span",
+		item_count: serializedSpans.length,
+		content_type: "application/vnd.sentry.items.span.v2+json"
+	}, {
+		version: 2,
+		ingest_settings: isBrowser() ? {
+			infer_ip: inferSetting,
+			infer_user_agent: inferSetting
+		} : void 0,
+		items: serializedSpans
+	}];
+}
+function dscHasRequiredProps(dsc) {
+	return !!dsc.trace_id && !!dsc.public_key;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/estimateSize.js
+function estimateSerializedSpanSizeInBytes(span) {
+	let weight = 156;
+	weight += span.name.length * 2;
+	weight += estimateTypedAttributesSizeInBytes(span.attributes);
+	if (span.links && span.links.length > 0) {
+		const attributes = span.links[0]?.attributes;
+		const linkWeight = 100 + (attributes ? estimateTypedAttributesSizeInBytes(attributes) : 0);
+		weight += linkWeight * span.links.length;
+	}
+	return weight;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/spanBuffer.js
+const MAX_SPANS_PER_ENVELOPE = 1e3;
+const MAX_TRACE_WEIGHT_IN_BYTES = 5e6;
+var SpanBuffer = class {
+	constructor(client, options) {
+		this._traceBuckets = /* @__PURE__ */ new Map();
+		this._client = client;
+		const { maxSpanLimit, flushInterval, maxTraceWeightInBytes } = options ?? {};
+		this._maxSpanLimit = maxSpanLimit && maxSpanLimit > 0 && maxSpanLimit <= MAX_SPANS_PER_ENVELOPE ? maxSpanLimit : MAX_SPANS_PER_ENVELOPE;
+		this._flushInterval = flushInterval && flushInterval > 0 ? flushInterval : 5e3;
+		this._maxTraceWeight = maxTraceWeightInBytes && maxTraceWeightInBytes > 0 ? maxTraceWeightInBytes : MAX_TRACE_WEIGHT_IN_BYTES;
+		this._client.on("flush", () => {
+			this.drain();
+		});
+		this._client.on("close", () => {
+			this._traceBuckets.forEach((bucket) => {
+				clearTimeout(bucket.timeout);
+			});
+			this._traceBuckets.clear();
+		});
+	}
+	/**
+	* Add a span to the buffer.
+	*/
+	add(spanJSON) {
+		const traceId = spanJSON.trace_id;
+		let bucket = this._traceBuckets.get(traceId);
+		if (!bucket) {
+			bucket = {
+				spans: /* @__PURE__ */ new Set(),
+				size: 0,
+				timeout: safeUnref(setTimeout(() => {
+					this.flush(traceId);
+				}, this._flushInterval))
+			};
+			this._traceBuckets.set(traceId, bucket);
+		}
+		bucket.spans.add(spanJSON);
+		bucket.size += estimateSerializedSpanSizeInBytes(spanJSON);
+		if (bucket.spans.size >= this._maxSpanLimit || bucket.size >= this._maxTraceWeight) this.flush(traceId);
+	}
+	/**
+	* Drain and flush all buffered traces.
+	*/
+	drain() {
+		if (!this._traceBuckets.size) return;
+		DEBUG_BUILD && debug.log(`Flushing span tree map with ${this._traceBuckets.size} traces`);
+		this._traceBuckets.forEach((_, traceId) => {
+			this.flush(traceId);
+		});
+	}
+	/**
+	* Flush spans of a specific trace.
+	* In contrast to {@link SpanBuffer.drain}, this method does not flush all traces, but only the one with the given traceId.
+	*/
+	flush(traceId) {
+		const bucket = this._traceBuckets.get(traceId);
+		if (!bucket) return;
+		if (!bucket.spans.size) {
+			this._removeTrace(traceId);
+			return;
+		}
+		const spans = Array.from(bucket.spans);
+		const segmentSpan = spans[0]?._segmentSpan;
+		if (!segmentSpan) {
+			DEBUG_BUILD && debug.warn("No segment span reference found on span JSON, cannot compute DSC");
+			this._removeTrace(traceId);
+			return;
+		}
+		const dsc = getDynamicSamplingContextFromSpan(segmentSpan);
+		const cleanedSpans = spans.map((spanJSON) => {
+			const { _segmentSpan, ...cleanSpanJSON } = spanJSON;
+			return cleanSpanJSON;
+		});
+		const envelope = createStreamedSpanEnvelope(cleanedSpans, dsc, this._client);
+		DEBUG_BUILD && debug.log(`Sending span envelope for trace ${traceId} with ${cleanedSpans.length} spans`);
+		this._client.sendEnvelope(envelope).then(null, (reason) => {
+			DEBUG_BUILD && debug.error("Error while sending streamed span envelope:", reason);
+		});
+		this._removeTrace(traceId);
+	}
+	_removeTrace(traceId) {
+		const bucket = this._traceBuckets.get(traceId);
+		if (bucket) clearTimeout(bucket.timeout);
+		this._traceBuckets.delete(traceId);
+	}
+};
+//#endregion
+//#region node_modules/@sentry/core/build/esm/integrations/spanStreaming.js
+const INTEGRATION_NAME$2 = "SpanStreaming";
+const spanStreamingIntegration = defineIntegration((options = {}) => {
+	const flushOnSegmentEnd = options.flushOnSegmentEnd ?? true;
+	return {
+		name: INTEGRATION_NAME$2,
+		setup(client) {
+			if (!hasSpanStreamingEnabled(client)) {
+				DEBUG_BUILD && debug.log(`[SpanStreaming] \`traceLifecycle\` is "static", skipping setup.`);
+				return;
+			}
+			const buffer = new SpanBuffer(client);
+			client.on("afterSpanEnd", (span) => {
+				if (!spanIsSampled(span)) return;
+				buffer.add(captureSpan(span, client));
+			});
+			client.on("flushTraceSpans", (traceId) => {
+				buffer.flush(traceId);
+			});
+			if (flushOnSegmentEnd) client.on("afterSegmentSpanEnd", (segmentSpan) => {
+				const traceId = segmentSpan.spanContext().traceId;
+				safeUnref(setTimeout(() => {
+					buffer.flush(traceId);
+				}, 500));
+			});
+		}
+	};
+});
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/errorSpanAttribution.js
+const escapedSpanTraceContexts = /* @__PURE__ */ new WeakMap();
+function toWeakMapKey(error) {
+	return isPrimitive(error) ? void 0 : error;
+}
+function applyEscapedErrorSpanToEvent(event, hint, scope) {
+	const key = toWeakMapKey(hint.originalException);
+	const traceContext = key && escapedSpanTraceContexts.get(key);
+	if (!traceContext) return;
+	const eventTraceContext = event.contexts?.trace;
+	if ((eventTraceContext?.trace_id ?? (scope && getTraceContextFromScope(scope).trace_id)) !== traceContext.trace_id) return;
+	event.contexts = {
+		...event.contexts,
+		trace: {
+			...eventTraceContext,
+			...traceContext
+		}
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/envelope.js
+function _enhanceEventWithSdkInfo(event, newSdkInfo) {
+	if (!newSdkInfo) return event;
+	const eventSdkInfo = event.sdk || {};
+	event.sdk = {
+		...eventSdkInfo,
+		name: eventSdkInfo.name || newSdkInfo.name,
+		version: eventSdkInfo.version || newSdkInfo.version,
+		integrations: [...event.sdk?.integrations || [], ...newSdkInfo.integrations || []],
+		packages: [...event.sdk?.packages || [], ...newSdkInfo.packages || []],
+		settings: event.sdk?.settings || newSdkInfo.settings ? {
+			...event.sdk?.settings,
+			...newSdkInfo.settings
+		} : void 0
+	};
+	return event;
+}
+function createSessionEnvelope(session, dsn, metadata, tunnel) {
+	const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
+	return createEnvelope({
+		sent_at: new Date(safeDateNow()).toISOString(),
+		...sdkInfo && { sdk: sdkInfo },
+		...!!tunnel && dsn && { dsn: dsnToString(dsn) }
+	}, ["aggregates" in session ? [{ type: "sessions" }, session] : [{ type: "session" }, session.toJSON()]]);
+}
+function createEventEnvelope(event, dsn, metadata, tunnel) {
+	const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
+	const eventType = event.type && event.type !== "replay_event" ? event.type : "event";
+	_enhanceEventWithSdkInfo(event, metadata?.sdk);
+	const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);
+	delete event.sdkProcessingMetadata;
+	return createEnvelope(envelopeHeaders, [[{ type: eventType }, event]]);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/syncpromise.js
+const STATE_PENDING = 0;
+const STATE_RESOLVED = 1;
+const STATE_REJECTED = 2;
+function resolvedSyncPromise(value) {
+	return new SyncPromise((resolve) => {
+		resolve(value);
+	});
+}
+function rejectedSyncPromise(reason) {
+	return new SyncPromise((_, reject) => {
+		reject(reason);
+	});
+}
+var SyncPromise = class SyncPromise {
+	constructor(executor) {
+		this._state = STATE_PENDING;
+		this._handlers = [];
+		this._runExecutor(executor);
+	}
+	/** @inheritdoc */
+	then(onfulfilled, onrejected) {
+		return new SyncPromise((resolve, reject) => {
+			this._handlers.push([
+				false,
+				(result) => {
+					if (!onfulfilled) resolve(result);
+					else try {
+						resolve(onfulfilled(result));
+					} catch (e) {
+						reject(e);
+					}
+				},
+				(reason) => {
+					if (!onrejected) reject(reason);
+					else try {
+						resolve(onrejected(reason));
+					} catch (e) {
+						reject(e);
+					}
+				}
+			]);
+			this._executeHandlers();
+		});
+	}
+	/** @inheritdoc */
+	catch(onrejected) {
+		return this.then((val) => val, onrejected);
+	}
+	/** @inheritdoc */
+	finally(onfinally) {
+		return new SyncPromise((resolve, reject) => {
+			let val;
+			let isRejected;
+			return this.then((value) => {
+				isRejected = false;
+				val = value;
+				if (onfinally) onfinally();
+			}, (reason) => {
+				isRejected = true;
+				val = reason;
+				if (onfinally) onfinally();
+			}).then(() => {
+				if (isRejected) {
+					reject(val);
+					return;
+				}
+				resolve(val);
+			});
+		});
+	}
+	/** Excute the resolve/reject handlers. */
+	_executeHandlers() {
+		if (this._state === STATE_PENDING) return;
+		const cachedHandlers = this._handlers.slice();
+		this._handlers = [];
+		cachedHandlers.forEach((handler) => {
+			if (handler[0]) return;
+			if (this._state === STATE_RESOLVED) handler[1](this._value);
+			if (this._state === STATE_REJECTED) handler[2](this._value);
+			handler[0] = true;
+		});
+	}
+	/** Run the executor for the SyncPromise. */
+	_runExecutor(executor) {
+		const setResult = (state, value) => {
+			if (this._state !== STATE_PENDING) return;
+			if (isThenable(value)) {
+				value.then(resolve, reject);
+				return;
+			}
+			this._state = state;
+			this._value = value;
+			this._executeHandlers();
+		};
+		const resolve = (value) => {
+			setResult(STATE_RESOLVED, value);
+		};
+		const reject = (reason) => {
+			setResult(STATE_REJECTED, reason);
+		};
+		try {
+			executor(resolve, reject);
+		} catch (e) {
+			reject(e);
+		}
+	}
+};
+//#endregion
+//#region node_modules/@sentry/core/build/esm/eventProcessors.js
+function notifyEventProcessors(processors, event, hint, index = 0, onDrop) {
+	try {
+		const result = _notifyEventProcessors(event, hint, processors, index, onDrop);
+		return isThenable(result) ? result : resolvedSyncPromise(result);
+	} catch (error) {
+		return rejectedSyncPromise(error);
+	}
+}
+function _notifyEventProcessors(event, hint, processors, index, onDrop) {
+	const processor = processors[index];
+	if (!event || !processor) return event;
+	const processorName = `Event processor "${processor.id || "?"}"`;
+	let callbackError = false;
+	const result = safeCallback(DEBUG_BUILD ? `${processorName} threw an error, dropping event:` : "", () => processor({ ...event }, hint), () => {
+		callbackError = true;
+		return null;
+	});
+	DEBUG_BUILD && result === null && debug.log(`${processorName} dropped event`);
+	if (isThenable(result)) return result.then((final) => {
+		if (!final) {
+			onDrop?.(callbackError ? "callback_error" : "event_processor");
+			return null;
+		}
+		return _notifyEventProcessors(final, hint, processors, index + 1, onDrop);
+	});
+	if (!result) {
+		onDrop?.(callbackError ? "callback_error" : "event_processor");
+		return null;
+	}
+	return _notifyEventProcessors(result, hint, processors, index + 1, onDrop);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/debug-ids.js
+let parsedStackResults;
+let lastSentryKeysCount;
+let lastNativeKeysCount;
+let cachedFilenameDebugIds;
+function getFilenameToDebugIdMap(stackParser) {
+	const sentryDebugIdMap = GLOBAL_OBJ._sentryDebugIds;
+	const nativeDebugIdMap = GLOBAL_OBJ._debugIds;
+	if (!sentryDebugIdMap && !nativeDebugIdMap) return {};
+	const sentryDebugIdKeys = sentryDebugIdMap ? Object.keys(sentryDebugIdMap) : [];
+	const nativeDebugIdKeys = nativeDebugIdMap ? Object.keys(nativeDebugIdMap) : [];
+	if (cachedFilenameDebugIds && sentryDebugIdKeys.length === lastSentryKeysCount && nativeDebugIdKeys.length === lastNativeKeysCount) return cachedFilenameDebugIds;
+	lastSentryKeysCount = sentryDebugIdKeys.length;
+	lastNativeKeysCount = nativeDebugIdKeys.length;
+	cachedFilenameDebugIds = {};
+	if (!parsedStackResults) parsedStackResults = {};
+	const processDebugIds = (debugIdKeys, debugIdMap) => {
+		for (const key of debugIdKeys) {
+			const debugId = debugIdMap[key];
+			const result = parsedStackResults?.[key];
+			if (result && cachedFilenameDebugIds && debugId) {
+				cachedFilenameDebugIds[result[0]] = debugId;
+				if (parsedStackResults) parsedStackResults[key] = [result[0], debugId];
+			} else if (debugId) {
+				const parsedStack = stackParser(key);
+				for (let i = parsedStack.length - 1; i >= 0; i--) {
+					const filename = parsedStack[i]?.filename;
+					if (filename && cachedFilenameDebugIds && parsedStackResults) {
+						cachedFilenameDebugIds[filename] = debugId;
+						parsedStackResults[key] = [filename, debugId];
+						break;
+					}
+				}
+			}
+		}
+	};
+	if (sentryDebugIdMap) processDebugIds(sentryDebugIdKeys, sentryDebugIdMap);
+	if (nativeDebugIdMap) processDebugIds(nativeDebugIdKeys, nativeDebugIdMap);
+	return cachedFilenameDebugIds;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/prepareEvent.js
+function prepareEvent(options, event, hint, scope, client, isolationScope) {
+	const { normalizeDepth = 3, normalizeMaxBreadth = 1e3 } = options;
+	const prepared = {
+		...event,
+		event_id: event.event_id || hint.event_id || uuid4(),
+		timestamp: event.timestamp || dateTimestampInSeconds()
+	};
+	const integrations = hint.integrations || options.integrations.map((i) => i.name);
+	applyClientOptions(prepared, options);
+	applyIntegrationsMetadata(prepared, integrations);
+	if (client) client.emit("applyFrameMetadata", event);
+	if (event.type === void 0) applyDebugIds(prepared, options.stackParser);
+	const finalScope = getFinalScope(scope, hint.captureContext);
+	if (hint.mechanism) addExceptionMechanismToCapturedException(prepared, hint.mechanism);
+	const clientEventProcessors = client ? client.getEventProcessors() : [];
+	const data = getCombinedScopeData(isolationScope, finalScope);
+	const attachments = [...hint.attachments || [], ...data.attachments];
+	if (attachments.length) hint.attachments = attachments;
+	applyScopeDataToEvent(prepared, data);
+	const span = getActiveSpan(finalScope);
+	if (span) applySpanToEvent(prepared, span);
+	applyEscapedErrorSpanToEvent(prepared, hint, finalScope);
+	const eventProcessors = [...clientEventProcessors, ...data.eventProcessors];
+	return (hint.data && hint.data.__sentry__ === true ? resolvedSyncPromise(prepared) : notifyEventProcessors(eventProcessors, prepared, hint, 0, (reason) => {
+		if (!client) return;
+		client.recordDroppedEvent(reason, getDataCategoryByType(event.type));
+		if (event.type === "transaction") client.recordDroppedEvent(reason, "span", 1 + (event.spans || []).length);
+	})).then((evt) => {
+		if (!evt) return null;
+		applyDebugMeta(evt);
+		if (typeof normalizeDepth === "number" && normalizeDepth > 0) return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
+		return evt;
+	});
+}
+function applyClientOptions(event, options) {
+	const { environment, release, dist, maxValueLength } = options;
+	event.environment = event.environment || environment || "production";
+	if (!event.release && release) event.release = release;
+	if (!event.dist && dist) event.dist = dist;
+	const request = event.request;
+	if (request?.url && maxValueLength) request.url = truncate(request.url, maxValueLength);
+	if (maxValueLength) event.exception?.values?.forEach((exception) => {
+		if (exception.value) exception.value = truncate(exception.value, maxValueLength);
+	});
+}
+function applyDebugIds(event, stackParser) {
+	const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);
+	event.exception?.values?.forEach((exception) => {
+		exception.stacktrace?.frames?.forEach((frame) => {
+			if (frame.filename) frame.debug_id = filenameDebugIdMap[frame.filename];
+		});
+	});
+}
+function applyDebugMeta(event) {
+	const filenameDebugIdMap = {};
+	event.exception?.values?.forEach((exception) => {
+		exception.stacktrace?.frames?.forEach((frame) => {
+			if (frame.debug_id) {
+				if (frame.abs_path) filenameDebugIdMap[frame.abs_path] = frame.debug_id;
+				else if (frame.filename) filenameDebugIdMap[frame.filename] = frame.debug_id;
+				delete frame.debug_id;
+			}
+		});
+	});
+	if (Object.keys(filenameDebugIdMap).length === 0) return;
+	event.debug_meta = event.debug_meta || {};
+	event.debug_meta.images = event.debug_meta.images || [];
+	const images = event.debug_meta.images;
+	Object.entries(filenameDebugIdMap).forEach(([filename, debug_id]) => {
+		images.push({
+			type: "sourcemap",
+			code_file: filename,
+			debug_id
+		});
+	});
+}
+function applyIntegrationsMetadata(event, integrationNames) {
+	if (integrationNames.length > 0) {
+		event.sdk = event.sdk || {};
+		event.sdk.integrations = [...event.sdk.integrations || [], ...integrationNames];
+	}
+}
+function normalizeEvent(event, depth, maxBreadth) {
+	if (!event) return null;
+	const normalized = {
+		...event,
+		...event.breadcrumbs && { breadcrumbs: event.breadcrumbs.map((b) => ({
+			...b,
+			...b.data && { data: normalize(b.data, depth, maxBreadth) }
+		})) },
+		...event.user && { user: normalize(event.user, depth, maxBreadth) },
+		...event.contexts && { contexts: normalize(event.contexts, depth, maxBreadth) },
+		...event.extra && { extra: normalize(event.extra, depth, maxBreadth) }
+	};
+	if (event.contexts?.trace && normalized.contexts) {
+		normalized.contexts.trace = event.contexts.trace;
+		if (event.contexts.trace.data) normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);
+	}
+	if (event.spans) normalized.spans = event.spans.map((span) => {
+		return {
+			...span,
+			...span.data && { data: normalize(span.data, depth, maxBreadth) }
+		};
+	});
+	if (event.contexts?.flags && normalized.contexts) normalized.contexts.flags = normalize(event.contexts.flags, 3, maxBreadth);
+	return normalized;
+}
+function getFinalScope(scope, captureContext) {
+	if (!captureContext) return scope;
+	const finalScope = scope ? scope.clone() : new Scope();
+	finalScope.update(captureContext);
+	return finalScope;
+}
+function getBaseApiEndpoint(dsn) {
+	const protocol = dsn.protocol ? `${dsn.protocol}:` : "";
+	const port = dsn.port ? `:${dsn.port}` : "";
+	return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ""}/api/`;
+}
+function _getIngestEndpoint(dsn) {
+	return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;
+}
+function _encodedAuth(dsn, sdkInfo) {
+	const params = { sentry_version: "7" };
+	if (dsn.publicKey) params.sentry_key = dsn.publicKey;
+	if (sdkInfo) params.sentry_client = `${sdkInfo.name}/${sdkInfo.version}`;
+	return new URLSearchParams(params).toString();
+}
+function getEnvelopeEndpointWithUrlEncodedAuth(dsn, tunnel, sdkInfo) {
+	return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/trace-info.js
+function _getTraceInfoFromScope(client, scope) {
+	if (!scope) return [void 0, void 0];
+	return withScope(scope, () => {
+		const span = getActiveSpan();
+		const traceContext = span ? spanToTraceContext(span) : getTraceContextFromScope(scope);
+		return [span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromScope(client, scope), traceContext];
+	});
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/logs/envelope.js
+function createLogContainerEnvelopeItem(items, inferUserData) {
+	const inferSetting = inferUserData ? "auto" : "never";
+	return [{
+		type: "log",
+		item_count: items.length,
+		content_type: "application/vnd.sentry.items.log+json"
+	}, {
+		version: 2,
+		...isBrowser() && { ingest_settings: {
+			infer_ip: inferSetting,
+			infer_user_agent: inferSetting
+		} },
+		items
+	}];
+}
+function createLogEnvelope(logs, metadata, tunnel, dsn, inferUserData) {
+	const headers = {};
+	if (metadata?.sdk) headers.sdk = {
+		name: metadata.sdk.name,
+		version: metadata.sdk.version
+	};
+	if (!!tunnel && !!dsn) headers.dsn = dsnToString(dsn);
+	return createEnvelope(headers, [createLogContainerEnvelopeItem(logs, inferUserData)]);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/logs/internal.js
+function _INTERNAL_flushLogsBuffer(client, maybeLogBuffer) {
+	const logBuffer = maybeLogBuffer ?? _INTERNAL_getLogBuffer(client) ?? [];
+	if (logBuffer.length === 0) return;
+	const clientOptions = client.getOptions();
+	const envelope = createLogEnvelope(logBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn(), client.getDataCollectionOptions().userInfo);
+	_getBufferMap$1().set(client, []);
+	client.emit("flushLogs");
+	client.sendEnvelope(envelope);
+}
+function _INTERNAL_getLogBuffer(client) {
+	return _getBufferMap$1().get(client);
+}
+function _getBufferMap$1() {
+	return getGlobalSingleton("clientToLogBufferMap", () => /* @__PURE__ */ new WeakMap());
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/metrics/envelope.js
+function createMetricContainerEnvelopeItem(items, inferUserData) {
+	const inferSetting = inferUserData ? "auto" : "never";
+	return [{
+		type: "trace_metric",
+		item_count: items.length,
+		content_type: "application/vnd.sentry.items.trace-metric+json"
+	}, {
+		version: 2,
+		...isBrowser() && { ingest_settings: {
+			infer_ip: inferSetting,
+			infer_user_agent: inferSetting
+		} },
+		items
+	}];
+}
+function createMetricEnvelope(metrics, metadata, tunnel, dsn, inferUserData) {
+	const headers = {};
+	if (metadata?.sdk) headers.sdk = {
+		name: metadata.sdk.name,
+		version: metadata.sdk.version
+	};
+	if (!!tunnel && !!dsn) headers.dsn = dsnToString(dsn);
+	return createEnvelope(headers, [createMetricContainerEnvelopeItem(metrics, inferUserData)]);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/metrics/internal.js
+function _INTERNAL_flushMetricsBuffer(client, maybeMetricBuffer) {
+	const metricBuffer = maybeMetricBuffer ?? _INTERNAL_getMetricBuffer(client) ?? [];
+	if (metricBuffer.length === 0) return;
+	const clientOptions = client.getOptions();
+	const envelope = createMetricEnvelope(metricBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn(), client.getDataCollectionOptions().userInfo);
+	_getBufferMap().set(client, []);
+	client.emit("flushMetrics");
+	client.sendEnvelope(envelope);
+}
+function _INTERNAL_getMetricBuffer(client) {
+	return _getBufferMap().get(client);
+}
+function _getBufferMap() {
+	return getGlobalSingleton("clientToMetricBufferMap", () => /* @__PURE__ */ new WeakMap());
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/tracing/spans/extractGenAiSpans.js
+function extractGenAiSpansFromEvent(event, client) {
+	if (event.type !== "transaction" || !event.spans?.length || !event.sdkProcessingMetadata?.hasGenAiSpans || hasSpanStreamingEnabled(client)) return;
+	const genAiSpans = [];
+	const remainingSpans = [];
+	for (const span of event.spans) if (span.op?.startsWith("gen_ai.")) genAiSpans.push(spanJsonToSerializedStreamedSpan(span));
+	else remainingSpans.push(span);
+	if (genAiSpans.length === 0) return;
+	event.spans = remainingSpans;
+	return createSpanContainerItem(genAiSpans, client);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/promisebuffer.js
+const SENTRY_BUFFER_FULL_ERROR = /* @__PURE__ */ Symbol.for("SentryBufferFullError");
+function makePromiseBuffer(limit = 100) {
+	const buffer = /* @__PURE__ */ new Set();
+	function isReady() {
+		return buffer.size < limit;
+	}
+	function remove(task) {
+		buffer.delete(task);
+	}
+	function add(taskProducer) {
+		if (!isReady()) return rejectedSyncPromise(SENTRY_BUFFER_FULL_ERROR);
+		const task = taskProducer();
+		buffer.add(task);
+		task.then(() => remove(task), () => remove(task));
+		return task;
+	}
+	function drain(timeout) {
+		if (!buffer.size) return resolvedSyncPromise(true);
+		const drainPromise = Promise.allSettled(Array.from(buffer)).then(() => true);
+		if (!timeout) return drainPromise;
+		const promises = [drainPromise, new Promise((resolve) => safeUnref(setTimeout(() => resolve(false), timeout)))];
+		return Promise.race(promises);
+	}
+	return {
+		get $() {
+			return Array.from(buffer);
+		},
+		add,
+		drain
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/ratelimit.js
+const DEFAULT_RETRY_AFTER = 6e4;
+function parseRetryAfterHeader(header, now = safeDateNow()) {
+	const headerDelay = parseInt(`${header}`, 10);
+	if (!isNaN(headerDelay)) return headerDelay * 1e3;
+	const headerDate = Date.parse(`${header}`);
+	if (!isNaN(headerDate)) return headerDate - now;
+	return DEFAULT_RETRY_AFTER;
+}
+function disabledUntil(limits, dataCategory) {
+	return limits[dataCategory] || limits.all || 0;
+}
+function isRateLimited(limits, dataCategory, now = safeDateNow()) {
+	return disabledUntil(limits, dataCategory) > now;
+}
+function updateRateLimits(limits, { statusCode, headers }, now = safeDateNow()) {
+	const updatedRateLimits = { ...limits };
+	const rateLimitHeader = headers?.["x-sentry-rate-limits"];
+	const retryAfterHeader = headers?.["retry-after"];
+	if (rateLimitHeader) for (const limit of rateLimitHeader.trim().split(",")) {
+		const [retryAfter, categories, , , namespaces] = limit.split(":", 5);
+		const headerDelay = parseInt(retryAfter, 10);
+		const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1e3;
+		if (!categories) updatedRateLimits.all = now + delay;
+		else for (const category of categories.split(";")) if (category === "metric_bucket") {
+			if (!namespaces || namespaces.split(";").includes("custom")) updatedRateLimits[category] = now + delay;
+		} else updatedRateLimits[category] = now + delay;
+	}
+	else if (retryAfterHeader) updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);
+	else if (statusCode === 429) updatedRateLimits.all = now + 6e4;
+	return updatedRateLimits;
+}
+function createTransport(options, makeRequest, buffer = makePromiseBuffer(options.bufferSize || 64)) {
+	let rateLimits = {};
+	const flush = (timeout) => buffer.drain(timeout);
+	function send(envelope) {
+		const filteredEnvelopeItems = [];
+		forEachEnvelopeItem(envelope, (item, type) => {
+			const dataCategory = envelopeItemTypeToDataCategory(type);
+			if (isRateLimited(rateLimits, dataCategory)) options.recordDroppedEvent("ratelimit_backoff", dataCategory);
+			else filteredEnvelopeItems.push(item);
+		});
+		if (filteredEnvelopeItems.length === 0) return Promise.resolve({});
+		const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems);
+		const recordEnvelopeLoss = (reason) => {
+			if (envelopeContainsItemType(filteredEnvelope, ["client_report"])) {
+				DEBUG_BUILD && debug.warn(`Dropping client report. Will not send outcomes (reason: ${reason}).`);
+				return;
+			}
+			forEachEnvelopeItem(filteredEnvelope, (item, type) => {
+				options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));
+			});
+		};
+		const requestTask = () => makeRequest({ body: serializeEnvelope(filteredEnvelope) }).then((response) => {
+			if (response.statusCode === 413) {
+				DEBUG_BUILD && debug.error("Sentry responded with status code 413. Envelope was discarded due to exceeding size limits.");
+				recordEnvelopeLoss("send_error");
+				return response;
+			}
+			if (DEBUG_BUILD && response.statusCode !== void 0 && (response.statusCode < 200 || response.statusCode >= 300)) debug.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
+			rateLimits = updateRateLimits(rateLimits, response);
+			return response;
+		}, (error) => {
+			recordEnvelopeLoss("network_error");
+			DEBUG_BUILD && debug.error("Encountered error running transport request:", error);
+			throw error;
+		});
+		return buffer.add(requestTask).then((result) => result, (error) => {
+			if (error === SENTRY_BUFFER_FULL_ERROR) {
+				DEBUG_BUILD && debug.error("Skipped sending event because buffer is full.");
+				recordEnvelopeLoss("queue_overflow");
+				return Promise.resolve({});
+			} else throw error;
+		});
+	}
+	return {
+		send,
+		flush
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/clientreport.js
+function createClientReportEnvelope(discarded_events, dsn, timestamp) {
+	const clientReportItem = [{ type: "client_report" }, {
+		timestamp: timestamp || dateTimestampInSeconds(),
+		discarded_events
+	}];
+	return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/eventUtils.js
+function getPossibleEventMessages(event) {
+	const possibleMessages = [];
+	if (event.message) possibleMessages.push(event.message);
+	try {
+		const lastException = event.exception.values[event.exception.values.length - 1];
+		if (lastException?.value) {
+			possibleMessages.push(lastException.value);
+			if (lastException.type) possibleMessages.push(`${lastException.type}: ${lastException.value}`);
+		}
+	} catch {}
+	return possibleMessages;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/transactionEvent.js
+function convertTransactionEventToSpanJson(event) {
+	const { trace_id, parent_span_id, span_id, status, origin, data, op } = event.contexts?.trace ?? {};
+	return {
+		data: data ?? {},
+		description: event.transaction,
+		op,
+		parent_span_id,
+		span_id: span_id ?? "",
+		start_timestamp: event.start_timestamp ?? 0,
+		status: status ?? "ok",
+		timestamp: event.timestamp,
+		trace_id: trace_id ?? "",
+		origin,
+		profile_id: data?.[SEMANTIC_ATTRIBUTE_PROFILE_ID],
+		exclusive_time: data?.[SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME],
+		measurements: event.measurements,
+		is_segment: true
+	};
+}
+function convertSpanJsonToTransactionEvent(span) {
+	return {
+		type: "transaction",
+		timestamp: span.timestamp,
+		start_timestamp: span.start_timestamp,
+		transaction: span.description,
+		contexts: { trace: {
+			trace_id: span.trace_id,
+			span_id: span.span_id,
+			parent_span_id: span.parent_span_id,
+			op: span.op,
+			status: span.status,
+			origin: span.origin,
+			data: {
+				...span.data,
+				...span.profile_id && { ["sentry.profile_id"]: span.profile_id },
+				...span.exclusive_time && { ["sentry.exclusive_time"]: span.exclusive_time }
+			}
+		} },
+		measurements: span.measurements
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/warnAboutIgnoredTransactionOptions.js
+function maybeWarnAboutIgnoredTransactionOptions(options) {
+	if (options.traceLifecycle !== "stream" || !(options.beforeSendTransaction || options.ignoreTransactions?.length)) return;
+	consoleSandbox(() => {
+		console.warn("[Sentry] `beforeSendTransaction` and `ignoreTransactions` are ignored with `traceLifecycle: 'stream'` (enabled by default). Use `beforeSendSpan` and `ignoreSpans` instead, or set `traceLifecycle: 'static'`.");
+	});
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/data-collection/resolveDataCollectionOptions.js
+const DEFAULTS = {
+	userInfo: true,
+	cookies: true,
+	httpHeaders: {
+		request: true,
+		response: true
+	},
+	httpBodies: [
+		"incomingRequest",
+		"outgoingRequest",
+		"incomingResponse",
+		"outgoingResponse"
+	],
+	urlQueryParams: true,
+	graphQL: {
+		document: true,
+		variables: true
+	},
+	genAI: {
+		inputs: true,
+		outputs: true
+	},
+	databaseQueryData: true,
+	queues: true,
+	stackFrameVariables: true,
+	frameContextLines: 5
+};
+function isCollectBehavior(value) {
+	return typeof value === "boolean" || "allow" in value || "deny" in value;
+}
+function resolveHttpHeaders(httpHeaders) {
+	if (httpHeaders === void 0) return { ...DEFAULTS.httpHeaders };
+	if (isCollectBehavior(httpHeaders)) return {
+		request: httpHeaders,
+		response: httpHeaders
+	};
+	return {
+		request: httpHeaders.request ?? DEFAULTS.httpHeaders.request,
+		response: httpHeaders.response ?? DEFAULTS.httpHeaders.response
+	};
+}
+function resolveDataCollectionOptions(options) {
+	const dc = options.dataCollection ?? {};
+	return {
+		userInfo: dc.userInfo ?? DEFAULTS.userInfo,
+		cookies: dc.cookies ?? DEFAULTS.cookies,
+		httpHeaders: resolveHttpHeaders(dc.httpHeaders),
+		httpBodies: dc.httpBodies ?? DEFAULTS.httpBodies,
+		urlQueryParams: dc.urlQueryParams ?? DEFAULTS.urlQueryParams,
+		graphQL: {
+			document: dc.graphQL?.document ?? DEFAULTS.graphQL.document,
+			variables: dc.graphQL?.variables ?? DEFAULTS.graphQL.variables
+		},
+		genAI: {
+			inputs: dc.genAI?.inputs ?? DEFAULTS.genAI.inputs,
+			outputs: dc.genAI?.outputs ?? DEFAULTS.genAI.outputs
+		},
+		databaseQueryData: dc.databaseQueryData ?? DEFAULTS.databaseQueryData,
+		queues: dc.queues ?? DEFAULTS.queues,
+		stackFrameVariables: dc.stackFrameVariables ?? DEFAULTS.stackFrameVariables,
+		frameContextLines: dc.frameContextLines ?? DEFAULTS.frameContextLines
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/client.js
+const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
+const MISSING_RELEASE_FOR_SESSION_ERROR = "Discarded session because of missing or non-string release";
+const INTERNAL_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("SentryInternalError");
+const DO_NOT_SEND_EVENT_SYMBOL = /* @__PURE__ */ Symbol.for("SentryDoNotSendEventError");
+const DEFAULT_FLUSH_INTERVAL = 5e3;
+function _makeInternalError(message) {
+	return {
+		message,
+		[INTERNAL_ERROR_SYMBOL]: true
+	};
+}
+function _makeDoNotSendEventError(message) {
+	return {
+		message,
+		[DO_NOT_SEND_EVENT_SYMBOL]: true
+	};
+}
+function _isInternalError(error) {
+	return isObjectLike(error) && INTERNAL_ERROR_SYMBOL in error;
+}
+function _isDoNotSendEventError(error) {
+	return isObjectLike(error) && DO_NOT_SEND_EVENT_SYMBOL in error;
+}
+function setupWeightBasedFlushing(client, afterCaptureHook, flushHook, estimateSizeFn, flushFn) {
+	let weight = 0;
+	let flushTimeout;
+	let isTimerActive = false;
+	client.on(flushHook, () => {
+		weight = 0;
+		clearTimeout(flushTimeout);
+		isTimerActive = false;
+	});
+	client.on(afterCaptureHook, (item) => {
+		weight += estimateSizeFn(item);
+		if (weight >= 8e5) flushFn(client);
+		else if (!isTimerActive) {
+			const flushInterval = client.getOptions()._flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+			if (flushInterval > 0) {
+				isTimerActive = true;
+				flushTimeout = safeUnref(setTimeout(() => {
+					flushFn(client);
+				}, flushInterval));
+			}
+		}
+	});
+	client.on("flush", () => {
+		flushFn(client);
+	});
+}
+var Client = class {
+	/**
+	* Initializes this client instance.
+	*
+	* @param options Options for the client.
+	*/
+	constructor(options) {
+		this._options = {
+			attachStacktrace: true,
+			...options,
+			traceLifecycle: options.traceLifecycle === "static" ? "static" : "stream"
+		};
+		this._integrations = {};
+		this._numProcessing = 0;
+		this._outcomes = {};
+		this._hooks = {};
+		this._eventProcessors = [];
+		this._promiseBuffer = makePromiseBuffer(options.transportOptions?.bufferSize ?? 64);
+		this._dataCollection = resolveDataCollectionOptions(options);
+		this._unhandledSessionStatus = "crashed";
+		if (options.dsn) this._dsn = makeDsn(options.dsn);
+		else DEBUG_BUILD && debug.warn("No DSN provided, client will not send events.");
+		const { beforeSendSpan, traceLifecycle } = this._options;
+		if (DEBUG_BUILD && beforeSendSpan && isStaticBeforeSendSpanCallback(beforeSendSpan) !== (traceLifecycle === "static")) consoleSandbox(() => {
+			console.warn(`Ignoring \`beforeSendSpan\`: ${traceLifecycle === "static" ? "wrap it with" : "remove"} \`Sentry.withStaticSpan\` to use it with \`traceLifecycle: "${traceLifecycle}"\`.`);
+		});
+		if (this._dsn) {
+			const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options.tunnel, options._metadata ? options._metadata.sdk : void 0);
+			this._transport = options.transport({
+				tunnel: this._options.tunnel,
+				recordDroppedEvent: this.recordDroppedEvent.bind(this),
+				...options.transportOptions,
+				url
+			});
+		}
+		setupWeightBasedFlushing(this, "afterCaptureLog", "flushLogs", estimateLogSizeInBytes, _INTERNAL_flushLogsBuffer);
+		setupWeightBasedFlushing(this, "afterCaptureMetric", "flushMetrics", estimateMetricSizeInBytes, _INTERNAL_flushMetricsBuffer);
+	}
+	/**
+	* Captures an exception event and sends it to Sentry.
+	*
+	* Unlike `captureException` exported from every SDK, this method requires that you pass it the current scope.
+	*/
+	captureException(exception, hint, scope) {
+		const eventId = uuid4();
+		if (checkOrSetAlreadyCaught(exception)) {
+			DEBUG_BUILD && debug.log(ALREADY_SEEN_ERROR);
+			return eventId;
+		}
+		const hintWithEventId = {
+			event_id: eventId,
+			...hint
+		};
+		this._process(() => this.eventFromException(exception, hintWithEventId).then((event) => this._captureEvent(event, hintWithEventId, scope)).then((res) => res), "error");
+		return hintWithEventId.event_id;
+	}
+	/**
+	* Captures a message event and sends it to Sentry.
+	*
+	* Unlike `captureMessage` exported from every SDK, this method requires that you pass it the current scope.
+	*/
+	captureMessage(message, level, hint, currentScope) {
+		const hintWithEventId = {
+			event_id: uuid4(),
+			...hint
+		};
+		const eventMessage = isParameterizedString(message) ? message : String(message);
+		const isMessage = isPrimitive(message);
+		const promisedEvent = isMessage ? this.eventFromMessage(eventMessage, level, hintWithEventId) : this.eventFromException(message, hintWithEventId);
+		this._process(() => promisedEvent.then((event) => this._captureEvent(event, hintWithEventId, currentScope)), isMessage ? "unknown" : "error");
+		return hintWithEventId.event_id;
+	}
+	/**
+	* Captures a manually created event and sends it to Sentry.
+	*
+	* Unlike `captureEvent` exported from every SDK, this method requires that you pass it the current scope.
+	*/
+	captureEvent(event, hint, currentScope) {
+		const eventId = uuid4();
+		if (hint?.originalException && checkOrSetAlreadyCaught(hint.originalException)) {
+			DEBUG_BUILD && debug.log(ALREADY_SEEN_ERROR);
+			return eventId;
+		}
+		const hintWithEventId = {
+			event_id: eventId,
+			...hint
+		};
+		const sdkProcessingMetadata = event.sdkProcessingMetadata || {};
+		const capturedSpanScope = sdkProcessingMetadata.capturedSpanScope;
+		const capturedSpanIsolationScope = sdkProcessingMetadata.capturedSpanIsolationScope;
+		const dataCategory = getDataCategoryByType(event.type);
+		this._process(() => this._captureEvent(event, hintWithEventId, capturedSpanScope || currentScope, capturedSpanIsolationScope), dataCategory);
+		return hintWithEventId.event_id;
+	}
+	/**
+	* Captures a session.
+	*/
+	captureSession(session) {
+		this.sendSession(session);
+		updateSession(session, { init: false });
+	}
+	/**
+	* Get the current Dsn.
+	*/
+	getDsn() {
+		return this._dsn;
+	}
+	/**
+	* Get the current options.
+	*/
+	getOptions() {
+		return this._options;
+	}
+	/**
+	* Get the resolved data collection configuration.
+	*/
+	getDataCollectionOptions() {
+		return this._dataCollection;
+	}
+	/**
+	* Get the SDK metadata.
+	* @see SdkMetadata
+	*/
+	getSdkMetadata() {
+		return this._options._metadata;
+	}
+	/**
+	* Returns the transport that is used by the client.
+	* Please note that the transport gets lazy initialized so it will only be there once the first event has been sent.
+	*/
+	getTransport() {
+		return this._transport;
+	}
+	/**
+	* Wait for all events to be sent or the timeout to expire, whichever comes first.
+	*
+	* @param timeout Maximum time in ms the client should wait for events to be flushed. Omitting this parameter will
+	*   cause the client to wait until all events are sent before resolving the promise.
+	* @returns A promise that will resolve with `true` if all events are sent before the timeout, or `false` if there are
+	* still events in the queue when the timeout is reached.
+	*/
+	async flush(timeout) {
+		const transport = this._transport;
+		this.emit("flush");
+		if (!transport) return true;
+		const clientFinished = await this._isClientDoneProcessing(timeout);
+		const transportFlushed = await transport.flush(timeout);
+		return clientFinished && transportFlushed;
+	}
+	/**
+	* Flush the event queue and set the client to `enabled = false`. See {@link Client.flush}.
+	*
+	* @param {number} timeout Maximum time in ms the client should wait before shutting down. Omitting this parameter will cause
+	*   the client to wait until all events are sent before disabling itself.
+	* @returns {Promise<boolean>} A promise which resolves to `true` if the flush completes successfully before the timeout, or `false` if
+	* it doesn't.
+	*/
+	async close(timeout) {
+		const result = await this.flush(timeout);
+		this.getOptions().enabled = false;
+		this.emit("close");
+		return result;
+	}
+	/**
+	* Get all installed event processors.
+	*/
+	getEventProcessors() {
+		return this._eventProcessors;
+	}
+	/**
+	* Adds an event processor that applies to any event processed by this client.
+	*/
+	addEventProcessor(eventProcessor) {
+		this._eventProcessors.push(eventProcessor);
+	}
+	/**
+	* Initialize this client.
+	* Call this after the client was set on a scope.
+	*/
+	init() {
+		if (this._isEnabled() || this._options.integrations.some(({ name }) => name.startsWith("Spotlight"))) {
+			this._setupIntegrations();
+			maybeWarnAboutIgnoredTransactionOptions(this._options);
+		}
+	}
+	/**
+	* Gets an installed integration by its name.
+	*
+	* @returns {Integration|undefined} The installed integration or `undefined` if no integration with that `name` was installed.
+	*/
+	getIntegrationByName(integrationName) {
+		return this._integrations[integrationName];
+	}
+	/**
+	* Returns the names of all installed integrations.
+	*/
+	getIntegrationNames() {
+		return Object.keys(this._integrations);
+	}
+	/**
+	* Add an integration to the client.
+	* This can be used to e.g. lazy load integrations.
+	* In most cases, this should not be necessary,
+	* and you're better off just passing the integrations via `integrations: []` at initialization time.
+	* However, if you find the need to conditionally load & add an integration, you can use `addIntegration` to do so.
+	*/
+	addIntegration(integration) {
+		const isAlreadyInstalled = this._integrations[integration.name];
+		if (!isAlreadyInstalled && integration.beforeSetup) integration.beforeSetup(this);
+		setupIntegration(this, integration, this._integrations);
+		if (!isAlreadyInstalled) afterSetupIntegrations(this, [integration]);
+	}
+	/**
+	* Send a fully prepared event to Sentry.
+	*/
+	sendEvent(event, hint = {}) {
+		this.emit("beforeSendEvent", event, hint);
+		const genAiSpanItem = extractGenAiSpansFromEvent(event, this);
+		let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
+		for (const attachment of hint.attachments || []) env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment));
+		if (genAiSpanItem) env = addItemToEnvelope(env, genAiSpanItem);
+		this.sendEnvelope(env).then((sendResponse) => this.emit("afterSendEvent", event, sendResponse));
+	}
+	/**
+	* Send a session or session aggregrates to Sentry.
+	*/
+	sendSession(session) {
+		const { release: clientReleaseOption, environment: clientEnvironmentOption = DEFAULT_ENVIRONMENT } = this._options;
+		if ("aggregates" in session) {
+			const sessionAttrs = session.attrs || {};
+			if (!sessionAttrs.release && !clientReleaseOption) {
+				DEBUG_BUILD && debug.warn(MISSING_RELEASE_FOR_SESSION_ERROR);
+				return;
+			}
+			sessionAttrs.release = sessionAttrs.release || clientReleaseOption;
+			sessionAttrs.environment = sessionAttrs.environment || clientEnvironmentOption;
+			session.attrs = sessionAttrs;
+		} else {
+			if (!session.release && !clientReleaseOption) {
+				DEBUG_BUILD && debug.warn(MISSING_RELEASE_FOR_SESSION_ERROR);
+				return;
+			}
+			session.release = session.release || clientReleaseOption;
+			session.environment = session.environment || clientEnvironmentOption;
+		}
+		this.emit("beforeSendSession", session);
+		const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
+		this.sendEnvelope(env);
+	}
+	/**
+	* Record on the client that an event got dropped (ie, an event that will not be sent to Sentry).
+	*/
+	recordDroppedEvent(reason, category, count = 1) {
+		if (this._options.sendClientReports) {
+			const key = `${reason}:${category}`;
+			DEBUG_BUILD && debug.log(`Recording outcome: "${key}"${count > 1 ? ` (${count} times)` : ""}`);
+			this._outcomes[key] = (this._outcomes[key] || 0) + count;
+		}
+	}
+	/**
+	* Register a hook on this client.
+	*/
+	on(hook, callback) {
+		const hookCallbacks = this._hooks[hook] = this._hooks[hook] || /* @__PURE__ */ new Set();
+		const uniqueCallback = (...args) => callback(...args);
+		hookCallbacks.add(uniqueCallback);
+		return () => {
+			hookCallbacks.delete(uniqueCallback);
+		};
+	}
+	/**
+	* Emit a hook that was previously registered via `on()`.
+	*/
+	emit(hook, ...rest) {
+		const callbacks = this._hooks[hook];
+		if (callbacks) callbacks.forEach((callback) => callback(...rest));
+	}
+	/**
+	* Send an envelope to Sentry.
+	*/
+	async sendEnvelope(envelope) {
+		this.emit("beforeEnvelope", envelope);
+		if (this._isEnabled() && this._transport) try {
+			const result = await this._transport.send(envelope);
+			this.emit("afterEnvelope", envelope);
+			return result;
+		} catch (reason) {
+			DEBUG_BUILD && debug.error("Error while sending envelope:", reason);
+			return {};
+		}
+		DEBUG_BUILD && debug.error("Transport disabled");
+		return {};
+	}
+	/**
+	* Register a cleanup function to be called when the client is disposed.
+	* This is useful for integrations that need to clean up global state.
+	*
+	* NOTE: This is a no-op in the base `Client` class. Subclasses like `ServerRuntimeClient`
+	* override this method to actually register and execute cleanup callbacks.
+	*/
+	registerCleanup(callback) {}
+	/**
+	* Disposes of the client and releases all resources.
+	*
+	* Subclasses should override this method to clean up their own resources, including invoking
+	* any callbacks registered via {@link Client.registerCleanup}. The base implementation is a
+	* no-op and does NOT execute registered cleanup callbacks.
+	*
+	* After calling dispose(), the client should not be used anymore.
+	*/
+	dispose() {}
+	/** Setup integrations for this client. */
+	_setupIntegrations() {
+		const { integrations } = this._options;
+		this._integrations = setupIntegrations(this, integrations);
+		afterSetupIntegrations(this, integrations);
+	}
+	/** Updates existing session based on the provided event */
+	_updateSessionFromEvent(session, event) {
+		let unhandled = event.level === "fatal";
+		let errored = false;
+		const exceptions = event.exception?.values;
+		if (exceptions) {
+			errored = true;
+			unhandled = false;
+			for (const ex of exceptions) if (ex.mechanism?.handled === false) {
+				unhandled = true;
+				break;
+			}
+		}
+		const sessionNonTerminal = session.status === "ok";
+		if (sessionNonTerminal && session.errors === 0 || sessionNonTerminal && unhandled) {
+			updateSession(session, {
+				...unhandled && { status: this._unhandledSessionStatus },
+				errors: session.errors || Number(errored || unhandled)
+			});
+			this.captureSession(session);
+		}
+	}
+	/**
+	* Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying
+	* "no" (resolving to `false`) in order to give the client a chance to potentially finish first.
+	*
+	* @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not
+	* passing anything) will make the promise wait as long as it takes for processing to finish before resolving to
+	* `true`.
+	* @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and
+	* `false` otherwise
+	*/
+	async _isClientDoneProcessing(timeout) {
+		let ticked = 0;
+		while (!timeout || ticked < timeout) {
+			await new Promise((resolve) => setTimeout(resolve, 1));
+			if (!this._numProcessing) return true;
+			ticked++;
+		}
+		return false;
+	}
+	/** Determines whether this SDK is enabled and a transport is present. */
+	_isEnabled() {
+		return this.getOptions().enabled !== false && this._transport !== void 0;
+	}
+	/**
+	* Adds common information to events.
+	*
+	* The information includes release and environment from `options`,
+	* breadcrumbs and context (extra, tags and user) from the scope.
+	*
+	* Information that is already present in the event is never overwritten. For
+	* nested objects, such as the context, keys are merged.
+	*
+	* @param event The original event.
+	* @param hint May contain additional information about the original exception.
+	* @param currentScope A scope containing event metadata.
+	* @returns A new event with more information.
+	*/
+	_prepareEvent(event, hint, currentScope, isolationScope) {
+		const options = this.getOptions();
+		const integrations = this.getIntegrationNames();
+		if (!hint.integrations && integrations.length) hint.integrations = integrations;
+		this.emit("preprocessEvent", event, hint);
+		if (!event.type) isolationScope.setLastEventId(event.event_id || hint.event_id);
+		return prepareEvent(options, event, hint, currentScope, this, isolationScope).then((evt) => {
+			if (evt === null) return evt;
+			this.emit("postprocessEvent", evt, hint);
+			evt.contexts = {
+				trace: {
+					...evt.contexts?.trace,
+					...getTraceContextFromScope(currentScope)
+				},
+				...evt.contexts
+			};
+			evt.sdkProcessingMetadata = {
+				dynamicSamplingContext: getDynamicSamplingContextFromScope(this, currentScope),
+				...evt.sdkProcessingMetadata
+			};
+			return evt;
+		});
+	}
+	/**
+	* Processes the event and logs an error in case of rejection
+	* @param event
+	* @param hint
+	* @param scope
+	*/
+	_captureEvent(event, hint = {}, currentScope = getCurrentScope(), isolationScope = getIsolationScope()) {
+		if (DEBUG_BUILD && isErrorEvent(event)) debug.log(`Captured error event \`${getPossibleEventMessages(event)[0] || "<unknown>"}\``);
+		return this._processEvent(event, hint, currentScope, isolationScope).then((finalEvent) => {
+			return finalEvent.event_id;
+		}, (reason) => {
+			if (DEBUG_BUILD) {
+				if (_isDoNotSendEventError(reason)) debug.log(reason.message);
+				else if (_isInternalError(reason)) debug.warn(reason.message);
+				else debug.warn(reason);
+			}
+		});
+	}
+	/**
+	* Processes an event (either error or message) and sends it to Sentry.
+	*
+	* This also adds breadcrumbs and context information to the event. However,
+	* platform specific meta data (such as the User's IP address) must be added
+	* by the SDK implementor.
+	*
+	*
+	* @param event The event to send to Sentry.
+	* @param hint May contain additional information about the original exception.
+	* @param currentScope A scope containing event metadata.
+	* @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
+	*/
+	_processEvent(event, hint, currentScope, isolationScope) {
+		const options = this.getOptions();
+		const { sampleRate } = options;
+		const isTransaction = isTransactionEvent(event);
+		const isError = isErrorEvent(event);
+		const beforeSendLabel = `before send for type \`${event.type || "error"}\``;
+		let beforeSendDropReason = "before_send";
+		const parsedSampleRate = typeof sampleRate === "undefined" ? void 0 : parseSampleRate(sampleRate);
+		const dataCategory = getDataCategoryByType(event.type);
+		return this._prepareEvent(event, hint, currentScope, isolationScope).then((prepared) => {
+			if (prepared === null) throw _makeDoNotSendEventError("An event processor returned `null`, will not send event.");
+			if (hint.data?.__sentry__ === true) return prepared;
+			return _validateBeforeSendResult(processBeforeSend(this, options, prepared, hint, () => {
+				beforeSendDropReason = "callback_error";
+			}), beforeSendLabel);
+		}).then((processedEvent) => {
+			if (processedEvent === null) {
+				this.recordDroppedEvent(beforeSendDropReason, dataCategory);
+				if (isTransaction) {
+					const spans = event.spans || [];
+					this.recordDroppedEvent(beforeSendDropReason, "span", 1 + spans.length);
+				}
+				throw _makeDoNotSendEventError(`${beforeSendLabel} ${beforeSendDropReason === "callback_error" ? "threw an error" : "returned `null`"}, will not send event.`);
+			}
+			const session = currentScope.getSession() || isolationScope.getSession();
+			if (isError && session) this._updateSessionFromEvent(session, processedEvent);
+			if (isError && typeof parsedSampleRate === "number" && safeMathRandom() > parsedSampleRate) {
+				this.recordDroppedEvent("sample_rate", "error");
+				throw _makeDoNotSendEventError(`Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`);
+			}
+			if (isTransaction) {
+				const droppedSpanCount = (processedEvent.sdkProcessingMetadata?.spanCountBeforeProcessing || 0) - (processedEvent.spans ? processedEvent.spans.length : 0);
+				if (droppedSpanCount > 0) this.recordDroppedEvent("before_send", "span", droppedSpanCount);
+			}
+			const transactionInfo = processedEvent.transaction_info;
+			if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {
+				const source = "custom";
+				processedEvent.transaction_info = {
+					...transactionInfo,
+					source
+				};
+			}
+			this.sendEvent(processedEvent, hint);
+			return processedEvent;
+		}).then(null, (reason) => {
+			if (_isDoNotSendEventError(reason) || _isInternalError(reason)) throw reason;
+			this.captureException(reason, {
+				mechanism: {
+					handled: false,
+					type: "internal"
+				},
+				data: { __sentry__: true },
+				originalException: reason
+			});
+			throw _makeInternalError(`Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.
+Reason: ${reason}`);
+		});
+	}
+	/**
+	* Occupies the client with processing and event
+	*/
+	_process(taskProducer, dataCategory) {
+		this._numProcessing++;
+		this._promiseBuffer.add(taskProducer).then((value) => {
+			this._numProcessing--;
+			return value;
+		}, (reason) => {
+			this._numProcessing--;
+			if (reason === SENTRY_BUFFER_FULL_ERROR) this.recordDroppedEvent("queue_overflow", dataCategory);
+			return reason;
+		});
+	}
+	/**
+	* Clears outcomes on this client and returns them.
+	*/
+	_clearOutcomes() {
+		const outcomes = this._outcomes;
+		this._outcomes = {};
+		return Object.entries(outcomes).map(([key, quantity]) => {
+			const [reason, category] = key.split(":");
+			return {
+				reason,
+				category,
+				quantity
+			};
+		});
+	}
+	/**
+	* Sends client reports as an envelope.
+	*/
+	_flushOutcomes() {
+		DEBUG_BUILD && debug.log("Flushing outcomes...");
+		const outcomes = this._clearOutcomes();
+		if (outcomes.length === 0) {
+			DEBUG_BUILD && debug.log("No outcomes to send");
+			return;
+		}
+		if (!this._dsn) {
+			DEBUG_BUILD && debug.log("No dsn provided, will not send outcomes");
+			return;
+		}
+		DEBUG_BUILD && debug.log("Sending outcomes:", outcomes);
+		const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));
+		this.sendEnvelope(envelope);
+	}
+};
+function _validateBeforeSendResult(beforeSendResult, beforeSendLabel) {
+	const invalidValueError = `${beforeSendLabel} must return \`null\` or a valid event.`;
+	if (isThenable(beforeSendResult)) return beforeSendResult.then((event) => {
+		if (!isPlainObject(event) && event !== null) throw _makeInternalError(invalidValueError);
+		return event;
+	}, (e) => {
+		throw _makeInternalError(`${beforeSendLabel} rejected with ${e}`);
+	});
+	else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) throw _makeInternalError(invalidValueError);
+	return beforeSendResult;
+}
+function processBeforeSend(client, options, event, hint, onCallbackError) {
+	const { beforeSend, ignoreSpans, beforeSendTransaction } = options;
+	const beforeSendSpan = isStaticBeforeSendSpanCallback(options.beforeSendSpan) && options.beforeSendSpan;
+	let processedEvent = event;
+	if (isErrorEvent(processedEvent) && beforeSend) {
+		const errorEvent = processedEvent;
+		return safeCallback(DEBUG_BUILD ? "The `beforeSend` callback threw an error, dropping the event:" : "", () => beforeSend(errorEvent, hint), () => {
+			onCallbackError();
+			return null;
+		});
+	}
+	if (isTransactionEvent(processedEvent)) {
+		if (beforeSendSpan || ignoreSpans) {
+			const rootSpanJson = convertTransactionEventToSpanJson(processedEvent);
+			if (ignoreSpans?.length && shouldIgnoreSpan({
+				description: rootSpanJson.description,
+				op: rootSpanJson.op,
+				attributes: rootSpanJson.data
+			}, ignoreSpans)) return null;
+			if (beforeSendSpan) processedEvent = merge(event, convertSpanJsonToTransactionEvent(applyBeforeSendSpanCallback(rootSpanJson, beforeSendSpan)));
+			if (processedEvent.spans) {
+				const processedSpans = [];
+				const initialSpans = processedEvent.spans;
+				for (const span of initialSpans) {
+					if (ignoreSpans?.length && shouldIgnoreSpan({
+						description: span.description,
+						op: span.op,
+						attributes: span.data
+					}, ignoreSpans)) {
+						reparentChildSpans(initialSpans, span);
+						continue;
+					}
+					if (beforeSendSpan) processedSpans.push(applyBeforeSendSpanCallback(span, beforeSendSpan));
+					else processedSpans.push(span);
+				}
+				const droppedSpans = processedEvent.spans.length - processedSpans.length;
+				if (droppedSpans) client.recordDroppedEvent("before_send", "span", droppedSpans);
+				processedEvent.spans = processedSpans;
+			}
+		}
+		if (beforeSendTransaction) {
+			if (processedEvent.spans) {
+				const spanCountBefore = processedEvent.spans.length;
+				processedEvent.sdkProcessingMetadata = {
+					...event.sdkProcessingMetadata,
+					spanCountBeforeProcessing: spanCountBefore
+				};
+			}
+			return safeCallback(DEBUG_BUILD ? "The `beforeSendTransaction` callback threw an error, dropping the event:" : "", () => beforeSendTransaction(processedEvent, hint), () => {
+				onCallbackError();
+				return null;
+			});
+		}
+	}
+	return processedEvent;
+}
+function isErrorEvent(event) {
+	return event.type === void 0;
+}
+function isTransactionEvent(event) {
+	return event.type === "transaction";
+}
+function estimateMetricSizeInBytes(metric) {
+	let weight = 0;
+	if (metric.name) weight += metric.name.length * 2;
+	weight += 8;
+	return weight + estimateAttributesSizeInBytes(metric.attributes);
+}
+function estimateLogSizeInBytes(log) {
+	let weight = 0;
+	if (log.message) weight += log.message.length * 2;
+	return weight + estimateAttributesSizeInBytes(log.attributes);
+}
+function estimateAttributesSizeInBytes(attributes) {
+	if (!attributes) return 0;
+	let weight = 0;
+	Object.values(attributes).forEach((value) => {
+		if (Array.isArray(value)) weight += value.length * estimatePrimitiveSizeInBytes(value[0]);
+		else if (isPrimitive(value)) weight += estimatePrimitiveSizeInBytes(value);
+		else weight += 100;
+	});
+	return weight;
+}
+function estimatePrimitiveSizeInBytes(value) {
+	if (typeof value === "string") return value.length * 2;
+	else if (typeof value === "number") return 8;
+	else if (typeof value === "boolean") return 4;
+	return 0;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/checkin.js
+function createCheckInEnvelope(checkIn, dynamicSamplingContext, metadata, tunnel, dsn) {
+	const headers = { sent_at: new Date(safeDateNow()).toISOString() };
+	if (metadata?.sdk) headers.sdk = {
+		name: metadata.sdk.name,
+		version: metadata.sdk.version
+	};
+	if (!!tunnel && !!dsn) headers.dsn = dsnToString(dsn);
+	if (dynamicSamplingContext) headers.trace = dynamicSamplingContext;
+	return createEnvelope(headers, [createCheckInEnvelopeItem(checkIn)]);
+}
+function createCheckInEnvelopeItem(checkIn) {
+	return [{ type: "check_in" }, checkIn];
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/aggregate-errors.js
+function applyAggregateErrorsToEvent(exceptionFromErrorImplementation, parser, key, limit, event, hint) {
+	if (!event.exception?.values || !hint || !isError(hint.originalException)) return;
+	const originalException = event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : void 0;
+	if (originalException) event.exception.values = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, hint.originalException, key, event.exception.values, originalException, 0);
+}
+function aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error, key, prevExceptions, exception, exceptionId) {
+	if (prevExceptions.length >= limit + 1) return prevExceptions;
+	let newExceptions = [...prevExceptions];
+	if (isError(error[key])) {
+		applyExceptionGroupFieldsForParentException(exception, exceptionId, error);
+		const newException = exceptionFromErrorImplementation(parser, error[key]);
+		const newExceptionId = newExceptions.length;
+		applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);
+		newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error[key], key, [newException, ...newExceptions], newException, newExceptionId);
+	}
+	if (isExceptionGroup(error)) error.errors.forEach((childError, i) => {
+		if (isError(childError)) {
+			applyExceptionGroupFieldsForParentException(exception, exceptionId, error);
+			const newException = exceptionFromErrorImplementation(parser, childError);
+			const newExceptionId = newExceptions.length;
+			applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);
+			newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, childError, key, [newException, ...newExceptions], newException, newExceptionId);
+		}
+	});
+	return newExceptions;
+}
+function isExceptionGroup(error) {
+	return Array.isArray(error.errors);
+}
+function applyExceptionGroupFieldsForParentException(exception, exceptionId, error) {
+	exception.mechanism = {
+		handled: true,
+		type: "auto.core.linked_errors",
+		...isExceptionGroup(error) && { is_exception_group: true },
+		...exception.mechanism,
+		exception_id: exceptionId
+	};
+}
+function applyExceptionGroupFieldsForChildException(exception, source, exceptionId, parentId) {
+	exception.mechanism = {
+		handled: true,
+		...exception.mechanism,
+		type: "chained",
+		source,
+		exception_id: exceptionId,
+		parent_id: parentId
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/eventbuilder.js
+function parseStackFrames(stackParser, error) {
+	return stackParser(error.stack || "", 1);
+}
+function hasSentryFetchUrlHost(error) {
+	return isError(error) && "__sentry_fetch_url_host__" in error && typeof error.__sentry_fetch_url_host__ === "string";
+}
+function _enhanceErrorWithSentryInfo(error) {
+	if (hasSentryFetchUrlHost(error)) return `${error.message} (${error.__sentry_fetch_url_host__})`;
+	return error.message;
+}
+function exceptionFromError(stackParser, error) {
+	const exception = {
+		type: error.name || error.constructor.name,
+		value: _enhanceErrorWithSentryInfo(error)
+	};
+	const frames = parseStackFrames(stackParser, error);
+	if (frames.length) exception.stacktrace = { frames };
+	return exception;
+}
+function getErrorPropertyFromObject(obj) {
+	for (const prop in obj) if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+		const value = obj[prop];
+		if (isError(value)) return value;
+	}
+}
+function getMessageForObject(exception) {
+	if ("name" in exception && typeof exception.name === "string") {
+		let message = `'${exception.name}' captured as exception`;
+		if ("message" in exception && typeof exception.message === "string") message += ` with message '${exception.message}'`;
+		return message;
+	} else if ("message" in exception && typeof exception.message === "string") return exception.message;
+	const keys = extractExceptionKeysForMessage(exception);
+	if (isErrorEvent$1(exception)) return `Event \`ErrorEvent\` captured as exception with message \`${exception.message}\``;
+	const className = getObjectClassName(exception);
+	return `${className && className !== "Object" ? `'${className}'` : "Object"} captured as exception with keys: ${keys}`;
+}
+function getObjectClassName(obj) {
+	try {
+		const prototype = Object.getPrototypeOf(obj);
+		return prototype ? prototype.constructor.name : void 0;
+	} catch {}
+}
+function getException(client, mechanism, exception, hint) {
+	if (isError(exception)) return [exception, void 0];
+	mechanism.synthetic = true;
+	if (isPlainObject(exception)) {
+		const normalizeDepth = client?.getOptions().normalizeDepth;
+		const extras = { ["__serialized__"]: normalizeToSize(exception, normalizeDepth) };
+		const errorFromProp = getErrorPropertyFromObject(exception);
+		if (errorFromProp) return [errorFromProp, extras];
+		const message = getMessageForObject(exception);
+		const ex2 = hint?.syntheticException || new Error(message);
+		ex2.message = message;
+		return [ex2, extras];
+	}
+	const ex = hint?.syntheticException || new Error(exception);
+	ex.message = `${exception}`;
+	return [ex, void 0];
+}
+function eventFromUnknownInput(client, stackParser, exception, hint) {
+	const mechanism = hint?.data && hint.data.mechanism || {
+		handled: true,
+		type: "generic"
+	};
+	const [ex, extras] = getException(client, mechanism, exception, hint);
+	const event = { exception: { values: [exceptionFromError(stackParser, ex)] } };
+	if (extras) event.extra = extras;
+	addExceptionTypeValue(event, void 0, void 0);
+	addExceptionMechanism(event, mechanism);
+	return {
+		...event,
+		event_id: hint?.event_id
+	};
+}
+function eventFromMessage(stackParser, message, level = "info", hint, attachStacktrace) {
+	const event = {
+		event_id: hint?.event_id,
+		level
+	};
+	if (attachStacktrace && hint?.syntheticException) {
+		const frames = parseStackFrames(stackParser, hint.syntheticException);
+		if (frames.length) {
+			event.exception = { values: [{
+				value: message,
+				stacktrace: { frames }
+			}] };
+			addExceptionMechanism(event, { synthetic: true });
+		}
+	}
+	if (isParameterizedString(message)) {
+		const { __sentry_template_string__, __sentry_template_values__ } = message;
+		event.logentry = {
+			message: __sentry_template_string__,
+			params: __sentry_template_values__
+		};
+		return event;
+	}
+	event.message = message;
+	return event;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/integrations/linkederrors.js
+const DEFAULT_KEY = "cause";
+const DEFAULT_LIMIT = 5;
+const INTEGRATION_NAME$1 = "LinkedErrors";
+const _linkedErrorsIntegration = ((options = {}) => {
+	const limit = options.limit || DEFAULT_LIMIT;
+	const key = options.key || DEFAULT_KEY;
+	return {
+		name: INTEGRATION_NAME$1,
+		preprocessEvent(event, hint, client) {
+			applyAggregateErrorsToEvent(exceptionFromError, client.getOptions().stackParser, key, limit, event, hint);
+		}
+	};
+});
+const linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/path.js
+function normalizeArray(parts, allowAboveRoot) {
+	let up = 0;
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const last = parts[i];
+		if (last === ".") parts.splice(i, 1);
+		else if (last === "..") {
+			parts.splice(i, 1);
+			up++;
+		} else if (up) {
+			parts.splice(i, 1);
+			up--;
+		}
+	}
+	if (allowAboveRoot) for (; up--;) parts.unshift("..");
+	return parts;
+}
+const splitPathRe = /^(\S+:\\|\/?)([\s\S]*?)((?:\.{1,2}|[^/\\]+?|)(\.[^./\\]*|))(?:[/\\]*)$/;
+function splitPath(filename) {
+	const truncated = filename.length > 1024 ? `<truncated>${filename.slice(-1024)}` : filename;
+	const parts = splitPathRe.exec(truncated);
+	return parts ? parts.slice(1) : [];
+}
+function resolve$1(...args) {
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+		const path = i >= 0 ? args[i] : "/";
+		if (!path) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = path.charAt(0) === "/";
+	}
+	resolvedPath = normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
+	return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+}
+function trim(arr) {
+	let start = 0;
+	for (; start < arr.length; start++) if (arr[start] !== "") break;
+	let end = arr.length - 1;
+	for (; end >= 0; end--) if (arr[end] !== "") break;
+	if (start > end) return [];
+	return arr.slice(start, end - start + 1);
+}
+function relative(from, to) {
+	from = resolve$1(from).slice(1);
+	to = resolve$1(to).slice(1);
+	const fromParts = trim(from.split("/"));
+	const toParts = trim(to.split("/"));
+	const length = Math.min(fromParts.length, toParts.length);
+	let samePartsLength = length;
+	for (let i = 0; i < length; i++) if (fromParts[i] !== toParts[i]) {
+		samePartsLength = i;
+		break;
+	}
+	let outputParts = [];
+	for (let i = samePartsLength; i < fromParts.length; i++) outputParts.push("..");
+	outputParts = outputParts.concat(toParts.slice(samePartsLength));
+	return outputParts.join("/");
+}
+function basename$1(path, ext) {
+	let f = splitPath(path)[2] || "";
+	if (ext && f.slice(ext.length * -1) === ext) f = f.slice(0, f.length - ext.length);
+	return f;
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/integrations/rewriteframes.js
+const INTEGRATION_NAME = "RewriteFrames";
+const rewriteFramesIntegration = defineIntegration((options = {}) => {
+	const root = options.root;
+	const prefix = options.prefix || "app:///";
+	const isBrowser = "window" in GLOBAL_OBJ && !!GLOBAL_OBJ.window;
+	const iteratee = options.iteratee || generateIteratee({
+		isBrowser,
+		root,
+		prefix
+	});
+	function _processExceptionsEvent(event) {
+		try {
+			return {
+				...event,
+				exception: {
+					...event.exception,
+					values: event.exception.values.map((value) => ({
+						...value,
+						...value.stacktrace && { stacktrace: _processStacktrace(value.stacktrace) }
+					}))
+				}
+			};
+		} catch {
+			return event;
+		}
+	}
+	function _processStacktrace(stacktrace) {
+		return {
+			...stacktrace,
+			frames: stacktrace?.frames?.map((f) => iteratee(f))
+		};
+	}
+	return {
+		name: INTEGRATION_NAME,
+		processEvent(originalEvent) {
+			let processedEvent = originalEvent;
+			if (originalEvent.exception && Array.isArray(originalEvent.exception.values)) processedEvent = _processExceptionsEvent(processedEvent);
+			return processedEvent;
+		}
+	};
+});
+function generateIteratee({ isBrowser, root, prefix }) {
+	return (frame) => {
+		if (!frame.filename) return frame;
+		const isWindowsFrame = /^[a-zA-Z]:\\/.test(frame.filename) || frame.filename.includes("\\") && !frame.filename.includes("/");
+		const startsWithSlash = /^\//.test(frame.filename);
+		if (isBrowser) {
+			if (root) {
+				const oldFilename = frame.filename;
+				if (oldFilename.indexOf(root) === 0) frame.filename = oldFilename.replace(root, prefix);
+			}
+		} else if (isWindowsFrame || startsWithSlash) {
+			const filename = isWindowsFrame ? frame.filename.replace(/^[a-zA-Z]:/, "").replace(/\\/g, "/") : frame.filename;
+			frame.filename = `${prefix}${root ? relative(root, filename) : basename$1(filename)}`;
+		}
+		return frame;
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/transports/userAgent.js
+function addUserAgentToTransportHeaders(options) {
+	const sdkMetadata = options._metadata?.sdk;
+	const sdkUserAgent = sdkMetadata?.name && sdkMetadata?.version ? `${sdkMetadata?.name}/${sdkMetadata?.version}` : void 0;
+	options.transportOptions = {
+		...options.transportOptions,
+		headers: {
+			...sdkUserAgent && { "user-agent": sdkUserAgent },
+			...options.transportOptions?.headers
+		}
+	};
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/server-runtime-client.js
+var ServerRuntimeClient = class extends Client {
+	/**
+	* Creates a new Edge SDK instance.
+	* @param options Configuration options for this SDK.
+	*/
+	constructor(options) {
+		addUserAgentToTransportHeaders(options);
+		if ((typeof __SENTRY_TRACING__ === "undefined" || __SENTRY_TRACING__) && options.traceLifecycle !== "static" && !options.integrations.some((i) => i.name === "SpanStreaming")) options.integrations.push(spanStreamingIntegration());
+		super(options);
+		this._disposeCallbacks = [];
+		this._setUpMetricsProcessing();
+	}
+	/**
+	* @inheritDoc
+	*/
+	eventFromException(exception, hint) {
+		const event = eventFromUnknownInput(this, this._options.stackParser, exception, hint);
+		event.level = "error";
+		return resolvedSyncPromise(event);
+	}
+	/**
+	* @inheritDoc
+	*/
+	eventFromMessage(message, level = "info", hint) {
+		return resolvedSyncPromise(eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace));
+	}
+	/**
+	* @inheritDoc
+	*/
+	captureException(exception, hint, scope) {
+		setCurrentRequestSessionErroredOrCrashed(hint);
+		return super.captureException(exception, hint, scope);
+	}
+	/**
+	* @inheritDoc
+	*/
+	captureEvent(event, hint, scope) {
+		if (!event.type && event.exception?.values && event.exception.values.length > 0) setCurrentRequestSessionErroredOrCrashed(hint);
+		return super.captureEvent(event, hint, scope);
+	}
+	/**
+	* Create a cron monitor check in and send it to Sentry.
+	*
+	* @param checkIn An object that describes a check in.
+	* @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want
+	* to create a monitor automatically when sending a check in.
+	*/
+	captureCheckIn(checkIn, monitorConfig, scope) {
+		const id = "checkInId" in checkIn && checkIn.checkInId ? checkIn.checkInId : uuid4();
+		if (!this._isEnabled()) {
+			DEBUG_BUILD && debug.warn("SDK not enabled, will not capture check-in.");
+			return id;
+		}
+		const { release, environment, tunnel } = this.getOptions();
+		const serializedCheckIn = {
+			check_in_id: id,
+			monitor_slug: checkIn.monitorSlug,
+			status: checkIn.status,
+			release,
+			environment
+		};
+		if ("duration" in checkIn) serializedCheckIn.duration = checkIn.duration;
+		if (monitorConfig) serializedCheckIn.monitor_config = {
+			schedule: monitorConfig.schedule,
+			checkin_margin: monitorConfig.checkinMargin,
+			max_runtime: monitorConfig.maxRuntime,
+			timezone: monitorConfig.timezone,
+			failure_issue_threshold: monitorConfig.failureIssueThreshold,
+			recovery_threshold: monitorConfig.recoveryThreshold
+		};
+		const [dynamicSamplingContext, traceContext] = _getTraceInfoFromScope(this, scope);
+		if (traceContext) serializedCheckIn.contexts = { trace: traceContext };
+		const envelope = createCheckInEnvelope(serializedCheckIn, dynamicSamplingContext, this.getSdkMetadata(), tunnel, this.getDsn());
+		DEBUG_BUILD && debug.log("Sending checkin:", checkIn.monitorSlug, checkIn.status);
+		this.sendEnvelope(envelope);
+		return id;
+	}
+	/**
+	* @inheritDoc
+	*/
+	registerCleanup(callback) {
+		this._disposeCallbacks.push(callback);
+	}
+	/**
+	* Disposes of the client and releases all resources.
+	*
+	* This method clears all internal state to allow the client to be garbage collected.
+	* It clears hooks, event processors, integrations, transport, and other internal references.
+	*
+	* Call this method after flushing to allow the client to be garbage collected.
+	* After calling dispose(), the client should not be used anymore.
+	*
+	* Subclasses should override this method to clean up their own resources and call `super.dispose()`.
+	*/
+	dispose() {
+		DEBUG_BUILD && debug.log("Disposing client...");
+		for (const callback of this._disposeCallbacks) try {
+			callback();
+		} catch {}
+		this._disposeCallbacks.length = 0;
+		for (const hookName of Object.keys(this._hooks)) this._hooks[hookName]?.clear();
+		this._hooks = {};
+		this._eventProcessors.length = 0;
+		this._integrations = {};
+		this._outcomes = {};
+		this._transport = void 0;
+		this._promiseBuffer = makePromiseBuffer(64);
+	}
+	/**
+	* @inheritDoc
+	*/
+	_prepareEvent(event, hint, currentScope, isolationScope) {
+		if (this._options.platform) event.platform = event.platform || this._options.platform;
+		if (this._options.runtime) event.contexts = {
+			...event.contexts,
+			runtime: event.contexts?.runtime || this._options.runtime
+		};
+		if (this._options.serverName) event.server_name = event.server_name || this._options.serverName;
+		return super._prepareEvent(event, hint, currentScope, isolationScope);
+	}
+	/**
+	* Process a server-side metric before it is captured.
+	*/
+	_setUpMetricsProcessing() {
+		this.on("processMetric", (metric) => {
+			if (this._options.serverName) metric.attributes = {
+				"server.address": this._options.serverName,
+				...metric.attributes
+			};
+		});
+	}
+};
+function setCurrentRequestSessionErroredOrCrashed(eventHint) {
+	const requestSession = getIsolationScope().getScopeData().sdkProcessingMetadata.requestSession;
+	if (requestSession) {
+		const isHandledException = eventHint?.mechanism?.handled ?? true;
+		if (isHandledException && requestSession.status !== "crashed") requestSession.status = "errored";
+		else if (!isHandledException) requestSession.status = "crashed";
+	}
+}
+//#endregion
+//#region node_modules/@sentry/core/build/esm/utils/node-stack-trace.js
+function filenameIsInApp(filename, isNative = false) {
+	return !(isNative || filename && !filename.startsWith("/") && !filename.match(/^[A-Z]:/) && !filename.startsWith(".") && !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//)) && filename !== void 0 && !filename.includes("node_modules/");
+}
+function node(getModule) {
+	const FILENAME_MATCH = /^\s*[-]{4,}$/;
+	const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+	const DATA_URI_MATCH = /at (?:async )?(.+?) \(data:(.*?),/;
+	return (line) => {
+		const dataUriMatch = line.match(DATA_URI_MATCH);
+		if (dataUriMatch) return {
+			filename: `<data:${dataUriMatch[2]}>`,
+			function: dataUriMatch[1]
+		};
+		const lineMatch = line.match(FULL_MATCH);
+		if (lineMatch) {
+			let object;
+			let method;
+			let functionName;
+			let typeName;
+			let methodName;
+			if (lineMatch[1]) {
+				functionName = lineMatch[1];
+				let methodStart = functionName.lastIndexOf(".");
+				if (functionName[methodStart - 1] === ".") methodStart--;
+				if (methodStart > 0) {
+					object = functionName.slice(0, methodStart);
+					method = functionName.slice(methodStart + 1);
+					const objectEnd = object.indexOf(".Module");
+					if (objectEnd > 0) {
+						functionName = functionName.slice(objectEnd + 1);
+						object = object.slice(0, objectEnd);
+					}
+				}
+				typeName = void 0;
+			}
+			if (method) {
+				typeName = object;
+				methodName = method;
+			}
+			if (method === "<anonymous>") {
+				methodName = void 0;
+				functionName = void 0;
+			}
+			if (functionName === void 0) {
+				methodName = methodName || "?";
+				functionName = typeName ? `${typeName}.${methodName}` : methodName;
+			}
+			let filename = normalizeStackTracePath(lineMatch[2]);
+			const isNative = lineMatch[5] === "native";
+			if (!filename && lineMatch[5] && !isNative) filename = lineMatch[5];
+			const maybeDecodedFilename = filename ? _safeDecodeURI(filename) : void 0;
+			return {
+				filename: maybeDecodedFilename ?? filename,
+				module: maybeDecodedFilename && getModule?.(maybeDecodedFilename),
+				function: functionName,
+				lineno: _parseIntOrUndefined(lineMatch[3]),
+				colno: _parseIntOrUndefined(lineMatch[4]),
+				in_app: filenameIsInApp(filename || "", isNative)
+			};
+		}
+		if (line.match(FILENAME_MATCH)) return { filename: line };
+	};
+}
+function nodeStackLineParser(getModule) {
+	return [90, node(getModule)];
+}
+function _parseIntOrUndefined(input) {
+	return parseInt(input || "", 10) || void 0;
+}
+function _safeDecodeURI(filename) {
+	try {
+		return decodeURI(filename);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/report/sentry.ts
+/** How long a report may hold the terminal before the CLI exits without it. */
+const FLUSH_MS = 2e3;
+/**
+* send delivers one report, and answers its event id only once Sentry has accepted it, so a
+* person is never given a reference for a report that never arrived.
+*/
+async function send(delivery) {
+	const { telemetry, occasion, status } = delivery;
+	const outcome = { isAccepted: false };
+	const client = new ServerRuntimeClient({
+		dsn: telemetry.dsn,
+		release: telemetry.release,
+		environment: telemetry.environment,
+		platform: "node",
+		runtime: {
+			name: "node",
+			version: process.version
+		},
+		sampleRate: 1,
+		maxBreadcrumbs: 0,
+		sendClientReports: false,
+		normalizeDepth: 6,
+		stackParser: createStackParser(nodeStackLineParser()),
+		integrations: [linkedErrorsIntegration(), rewriteFramesIntegration({ root: dirname(fileURLToPath(import.meta.url)) })],
+		transport: (options) => createTransport(options, async (request) => {
+			const body = typeof request.body === "string" ? request.body : new TextDecoder().decode(request.body);
+			const statusCode = await toPosted(options.url, toScrubbedEnvelope(body, delivery.secrets));
+			outcome.isAccepted = statusCode >= 200 && statusCode < 300;
+			return { statusCode };
+		})
+	});
+	client.init();
+	const scope = new Scope();
+	scope.setClient(client);
+	scope.setLevel(occasion.level);
+	scope.setTags(toTags(delivery));
+	scope.setContext("invocation", {
+		command: occasion.invocation.command,
+		flags: occasion.invocation.flags
+	});
+	for (const [name, section] of Object.entries(toPrivate(status ?? {}))) if (section !== null && typeof section === "object" && !Array.isArray(section)) scope.setContext(`status.${name}`, section);
+	const person = toIdentity(status)?.person?.key;
+	if (person) scope.setUser({ id: person });
+	const id = scope.captureException(delivery.error, { mechanism: {
+		type: occasion.mechanism,
+		handled: occasion.level !== "fatal"
+	} });
+	return await client.flush(FLUSH_MS) && outcome.isAccepted ? id : void 0;
+}
+/**
+* toPosted sends an envelope and answers the status Sentry gave. Flushing only stops waiting,
+* and an aborted fetch still leaves its connection attempt holding the process open, so the
+* request is destroyed when its own deadline passes, even while it is still connecting.
+*/
+function toPosted(url, body) {
+	return new Promise((resolve, reject) => {
+		const target = new URL(url);
+		const request$2 = (target.protocol === "http:" ? request : request$1)(target, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-sentry-envelope",
+				"Content-Length": Buffer.byteLength(body)
+			}
+		}, (response) => {
+			clearTimeout(deadline);
+			response.resume();
+			resolve(response.statusCode ?? 0);
+		});
+		const deadline = setTimeout(() => request$2.destroy(/* @__PURE__ */ new Error("Sentry did not answer in time")), FLUSH_MS);
+		request$2.on("error", (error) => {
+			clearTimeout(deadline);
+			reject(error);
+		});
+		request$2.end(body);
+	});
+}
+/**
+* toScrubbedEnvelope scrubs the whole envelope as text, which reaches every message, frame
+* and context at once. A Windows home directory appears escaped inside JSON, so both
+* spellings are replaced.
+*/
+function toScrubbedEnvelope(body, secrets) {
+	const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
+	const escaped = JSON.stringify(home).slice(1, -1);
+	return toScrubbed(escaped === home || home.length <= 1 ? body : body.split(escaped).join("~"), secrets, home);
+}
+function toIdentity(status) {
+	return (status?.["api"])?.identity;
+}
+/**
+* toPrivate removes people's and organizations' names from the status report. The keys that
+* identify them stay, which is enough to find them without sending who they are.
+*/
+function toPrivate(status) {
+	const identity = toIdentity(status);
+	if (!identity) return status;
+	const api = status["api"];
+	const { organization, person } = identity;
+	return {
+		...status,
+		api: {
+			...api,
+			identity: {
+				...api["identity"],
+				organization: organization ? {
+					...organization,
+					name: void 0
+				} : void 0,
+				person: person ? {
+					...person,
+					firstName: void 0,
+					lastName: void 0
+				} : void 0
+			}
+		}
+	};
+}
+/** toTags picks the few values worth searching by, each with few distinct values. */
+function toTags(delivery) {
+	const { occasion, status } = delivery;
+	const cli = status?.["cli"];
+	const host = status?.["host"];
+	const credential = status?.["credential"];
+	const api = status?.["api"];
+	const tags = {
+		command: occasion.invocation.command,
+		mode: occasion.mode,
+		"os.platform": process.platform,
+		"os.arch": host?.arch ?? process.arch,
+		"node.version": process.version,
+		wsl: String(host?.wsl !== void 0 && host.wsl !== null && host.wsl !== false),
+		interactive: String(cli?.interactive === true),
+		ci: String(Boolean(process.env["CI"])),
+		"auth.kind": credential?.kind ?? "unknown",
+		"api.reachable": String(api?.reachable ?? "unknown")
+	};
+	if (api?.url) tags["api.host"] = new URL(api.url).host;
+	const organization = toIdentity(status)?.organization?.key;
+	if (organization) tags["organization"] = organization;
+	return tags;
+}
+//#endregion
+export { send };