@capxul/cli 4.20.0-beta.1

package/dist/esm-DUNJOL6b.mjs

@@ -0,0 +1,4092 @@
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/debug-build.js
+/**
+* This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+*
+* ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+*/
+const DEBUG_BUILD$1 = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/worldwide.js
+/** Internal global with common properties and Sentry extensions  */
+/** Get's the global object for the current JavaScript runtime */
+const GLOBAL_OBJ = globalThis;
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/version.js
+const SDK_VERSION = "9.47.1";
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/carrier.js
+/**
+* An object that contains globally accessible properties and maintains a scope stack.
+* @hidden
+*/
+/**
+* Returns the global shim registry.
+*
+* FIXME: This function is problematic, because despite always returning a valid Carrier,
+* it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check
+* at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.
+**/
+function getMainCarrier() {
+	getSentryCarrier(GLOBAL_OBJ);
+	return GLOBAL_OBJ;
+}
+/** Will either get the existing sentry carrier, or create a new one. */
+function getSentryCarrier(carrier) {
+	const __SENTRY__ = carrier.__SENTRY__ = carrier.__SENTRY__ || {};
+	__SENTRY__.version = __SENTRY__.version || "9.47.1";
+	return __SENTRY__[SDK_VERSION] = __SENTRY__["9.47.1"] || {};
+}
+/**
+* Returns a global singleton contained in the global `__SENTRY__[]` object.
+*
+* If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+* function and added to the `__SENTRY__` object.
+*
+* @param name name of the global singleton on __SENTRY__
+* @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+* @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value
+* @returns the singleton
+*/
+function getGlobalSingleton(name, creator, obj = GLOBAL_OBJ) {
+	const __SENTRY__ = obj.__SENTRY__ = obj.__SENTRY__ || {};
+	const carrier = __SENTRY__[SDK_VERSION] = __SENTRY__["9.47.1"] || {};
+	return carrier[name] || (carrier[name] = creator());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/debug-logger.js
+/** Prefix for logging strings */
+const PREFIX = "Sentry Logger ";
+/** This may be mutated by the console instrumentation. */
+const originalConsoleMethods = {};
+/**
+* Temporarily disable sentry console instrumentations.
+*
+* @param callback The function to run against the original `console` messages
+* @returns The results of the callback
+*/
+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$1) return;
+	if (isEnabled()) consoleSandbox(() => {
+		GLOBAL_OBJ.console[level](`${PREFIX}[${level}]:`, ...args);
+	});
+}
+function _getLoggerSettings() {
+	if (!DEBUG_BUILD$1) return { enabled: false };
+	return getGlobalSingleton("loggerSettings", () => ({ enabled: false }));
+}
+/**
+* This is a logger singleton which either logs things or no-ops if logging is not enabled.
+*/
+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/.pnpm/@sentry+core@9.47.1/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/;
+/**
+* Creates a stack parser with the supplied line parsers
+*
+* StackFrames are returned in the correct order for Sentry Exception
+* frames and with Sentry SDK internal frames removed from the top and bottom
+*
+*/
+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++) {
+			const line = lines[i];
+			if (line.length > 1024) continue;
+			const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
+			if (cleanedLine.match(/\S*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));
+	};
+}
+/**
+* Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.
+* Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the
+* function that caused the crash is the last frame in the array.
+* @hidden
+*/
+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>";
+/**
+* Safely extract function name from itself
+*/
+function getFunctionName(fn) {
+	try {
+		if (!fn || typeof fn !== "function") return defaultFunctionName;
+		return fn.name || defaultFunctionName;
+	} catch {
+		return defaultFunctionName;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/is.js
+const objectToString = Object.prototype.toString;
+/**
+* Checks whether given value's type is one of a few Error or Error-like
+* {@link isError}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+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);
+	}
+}
+/**
+* Checks whether given value is an instance of the given built-in class.
+*
+* @param wat The value to be checked
+* @param className
+* @returns A boolean representing the result.
+*/
+function isBuiltin(wat, className) {
+	return objectToString.call(wat) === `[object ${className}]`;
+}
+/**
+* Checks whether given value's type is ErrorEvent
+* {@link isErrorEvent}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isErrorEvent$1(wat) {
+	return isBuiltin(wat, "ErrorEvent");
+}
+/**
+* Checks whether given value's type is DOMError
+* {@link isDOMError}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isDOMError(wat) {
+	return isBuiltin(wat, "DOMError");
+}
+/**
+* Checks whether given value's type is DOMException
+* {@link isDOMException}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isDOMException(wat) {
+	return isBuiltin(wat, "DOMException");
+}
+/**
+* Checks whether given value's type is a string
+* {@link isString}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isString(wat) {
+	return isBuiltin(wat, "String");
+}
+/**
+* Checks whether given string is parameterized
+* {@link isParameterizedString}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isParameterizedString(wat) {
+	return typeof wat === "object" && wat !== null && "__sentry_template_string__" in wat && "__sentry_template_values__" in wat;
+}
+/**
+* Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)
+* {@link isPrimitive}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isPrimitive(wat) {
+	return wat === null || isParameterizedString(wat) || typeof wat !== "object" && typeof wat !== "function";
+}
+/**
+* Checks whether given value's type is an object literal, or a class instance.
+* {@link isPlainObject}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isPlainObject(wat) {
+	return isBuiltin(wat, "Object");
+}
+/**
+* Checks whether given value's type is an Event instance
+* {@link isEvent}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isEvent(wat) {
+	return typeof Event !== "undefined" && isInstanceOf(wat, Event);
+}
+/**
+* Checks whether given value's type is an Element instance
+* {@link isElement}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isElement(wat) {
+	return typeof Element !== "undefined" && isInstanceOf(wat, Element);
+}
+/**
+* Checks whether given value has a then function.
+* @param wat A value to be checked.
+*/
+function isThenable(wat) {
+	return Boolean(wat?.then && typeof wat.then === "function");
+}
+/**
+* Checks whether given value's type is a SyntheticEvent
+* {@link isSyntheticEvent}.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isSyntheticEvent(wat) {
+	return isPlainObject(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
+}
+/**
+* Checks whether given value's type is an instance of provided constructor.
+* {@link isInstanceOf}.
+*
+* @param wat A value to be checked.
+* @param base A constructor to be used in a check.
+* @returns A boolean representing the result.
+*/
+function isInstanceOf(wat, base) {
+	try {
+		return wat instanceof base;
+	} catch {
+		return false;
+	}
+}
+/**
+* Checks whether given value's type is a Vue ViewModel.
+*
+* @param wat A value to be checked.
+* @returns A boolean representing the result.
+*/
+function isVueViewModel(wat) {
+	return !!(typeof wat === "object" && wat !== null && (wat.__isVue || wat._isVue));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/browser.js
+const WINDOW$2 = GLOBAL_OBJ;
+const DEFAULT_MAX_STRING_LENGTH = 80;
+/**
+* Given a child DOM element, returns a query-selector statement describing that
+* and its ancestors
+* e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
+* @returns generated DOM path
+*/
+function htmlTreeAsString(elem, options = {}) {
+	if (!elem) return "<unknown>";
+	try {
+		let currentElem = elem;
+		const MAX_TRAVERSE_HEIGHT = 5;
+		const out = [];
+		let height = 0;
+		let len = 0;
+		const separator = " > ";
+		const sepLength = 3;
+		let nextStr;
+		const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;
+		const maxStringLength = !Array.isArray(options) && options.maxStringLength || DEFAULT_MAX_STRING_LENGTH;
+		while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
+			nextStr = _htmlElementAsString(currentElem, keyAttrs);
+			if (nextStr === "html" || height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength) break;
+			out.push(nextStr);
+			len += nextStr.length;
+			currentElem = currentElem.parentNode;
+		}
+		return out.reverse().join(separator);
+	} catch {
+		return "<unknown>";
+	}
+}
+/**
+* Returns a simple, query-selector representation of a DOM element
+* e.g. [HTMLElement] => input#foo.btn[name=baz]
+* @returns generated DOM path
+*/
+function _htmlElementAsString(el, keyAttrs) {
+	const elem = el;
+	const out = [];
+	if (!elem?.tagName) return "";
+	if (WINDOW$2.HTMLElement) {
+		if (elem instanceof HTMLElement && elem.dataset) {
+			if (elem.dataset["sentryComponent"]) return elem.dataset["sentryComponent"];
+			if (elem.dataset["sentryElement"]) return elem.dataset["sentryElement"];
+		}
+	}
+	out.push(elem.tagName.toLowerCase());
+	const keyAttrPairs = keyAttrs?.length ? keyAttrs.filter((keyAttr) => elem.getAttribute(keyAttr)).map((keyAttr) => [keyAttr, elem.getAttribute(keyAttr)]) : null;
+	if (keyAttrPairs?.length) keyAttrPairs.forEach((keyAttrPair) => {
+		out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
+	});
+	else {
+		if (elem.id) out.push(`#${elem.id}`);
+		const className = elem.className;
+		if (className && isString(className)) {
+			const classes = className.split(/\s+/);
+			for (const c of classes) out.push(`.${c}`);
+		}
+	}
+	for (const k of [
+		"aria-label",
+		"type",
+		"name",
+		"title",
+		"alt"
+	]) {
+		const attr = elem.getAttribute(k);
+		if (attr) out.push(`[${k}="${attr}"]`);
+	}
+	return out.join("");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/string.js
+/**
+* Truncates given string to the maximum characters count
+*
+* @param str An object that contains serializable values
+* @param max Maximum number of characters in truncated string (0 = unlimited)
+* @returns string Encoded
+*/
+function truncate(str, max = 0) {
+	if (typeof str !== "string" || max === 0) return str;
+	return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/object.js
+/**
+* Defines a non-enumerable property on the given object.
+*
+* @param obj The object on which to set the property
+* @param name The name of the property to be set
+* @param value The value to which to set the property
+*/
+function addNonEnumerableProperty(obj, name, value) {
+	try {
+		Object.defineProperty(obj, name, {
+			value,
+			writable: true,
+			configurable: true
+		});
+	} catch {
+		DEBUG_BUILD$1 && debug.log(`Failed to add non-enumerable property "${name}" to object`, obj);
+	}
+}
+/**
+* Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their
+* non-enumerable properties attached.
+*
+* @param value Initial source that we have to transform in order for it to be usable by the serializer
+* @returns An Event or Error turned into an object - or the value argument itself, when value is neither an Event nor
+*  an Error.
+*/
+function convertToPlainObject(value) {
+	if (isError(value)) return {
+		message: value.message,
+		name: value.name,
+		stack: value.stack,
+		...getOwnProperties(value)
+	};
+	else if (isEvent(value)) {
+		const newObj = {
+			type: value.type,
+			target: serializeEventTarget(value.target),
+			currentTarget: serializeEventTarget(value.currentTarget),
+			...getOwnProperties(value)
+		};
+		if (typeof CustomEvent !== "undefined" && isInstanceOf(value, CustomEvent)) newObj.detail = value.detail;
+		return newObj;
+	} else return value;
+}
+/** Creates a string representation of the target of an `Event` object */
+function serializeEventTarget(target) {
+	try {
+		return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+	} catch {
+		return "<unknown>";
+	}
+}
+/** Filters out all but an object's own properties */
+function getOwnProperties(obj) {
+	if (typeof obj === "object" && obj !== null) {
+		const extractedProps = {};
+		for (const property in obj) if (Object.prototype.hasOwnProperty.call(obj, property)) extractedProps[property] = obj[property];
+		return extractedProps;
+	} else return {};
+}
+/**
+* Given any captured exception, extract its keys and create a sorted
+* and truncated list that will be used inside the event message.
+* eg. `Non-error exception captured with keys: foo, bar, baz`
+*/
+function extractExceptionKeysForMessage(exception, maxLength = 40) {
+	const keys = Object.keys(convertToPlainObject(exception));
+	keys.sort();
+	const firstKey = keys[0];
+	if (!firstKey) return "[object has no keys]";
+	if (firstKey.length >= maxLength) return truncate(firstKey, maxLength);
+	for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {
+		const serialized = keys.slice(0, includedKeys).join(", ");
+		if (serialized.length > maxLength) continue;
+		if (includedKeys === keys.length) return serialized;
+		return truncate(serialized, maxLength);
+	}
+	return "";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/misc.js
+function getCrypto() {
+	const gbl = GLOBAL_OBJ;
+	return gbl.crypto || gbl.msCrypto;
+}
+/**
+* UUID4 generator
+* @param crypto Object that provides the crypto API.
+* @returns string Generated UUID4.
+*/
+function uuid4(crypto = getCrypto()) {
+	let getRandomByte = () => Math.random() * 16;
+	try {
+		if (crypto?.randomUUID) return crypto.randomUUID().replace(/-/g, "");
+		if (crypto?.getRandomValues) getRandomByte = () => {
+			const typedArray = /* @__PURE__ */ new Uint8Array(1);
+			crypto.getRandomValues(typedArray);
+			return typedArray[0];
+		};
+	} catch {}
+	return "10000000100040008000100000000000".replace(/[018]/g, (c) => (c ^ (getRandomByte() & 15) >> c / 4).toString(16));
+}
+function getFirstException(event) {
+	return event.exception?.values?.[0];
+}
+/**
+* Adds exception values, type and value to an synthetic Exception.
+* @param event The event to modify.
+* @param value Value of the exception.
+* @param type Type of the exception.
+* @hidden
+*/
+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";
+}
+/**
+* Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
+*
+* @param event The event to modify.
+* @param newMechanism Mechanism data to add to the event.
+* @hidden
+*/
+function addExceptionMechanism(event, newMechanism) {
+	const firstException = getFirstException(event);
+	if (!firstException) return;
+	const defaultMechanism = {
+		type: "generic",
+		handled: true
+	};
+	const currentMechanism = firstException.mechanism;
+	firstException.mechanism = {
+		...defaultMechanism,
+		...currentMechanism,
+		...newMechanism
+	};
+	if (newMechanism && "data" in newMechanism) {
+		const mergedData = {
+			...currentMechanism?.data,
+			...newMechanism.data
+		};
+		firstException.mechanism.data = mergedData;
+	}
+}
+/**
+* Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
+* in question), and marks it captured if not.
+*
+* This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and
+* record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so
+* that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because
+* the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not
+* caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This
+* function helps us ensure that even if we encounter the same error more than once, we only record it the first time we
+* see it.
+*
+* Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on
+* them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent
+* object wrapper forms so that this check will always work. However, because we need to flag the exact object which
+* will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification
+* must be done before the exception captured.
+*
+* @param A thrown exception to check or flag as having been seen
+* @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/time.js
+const ONE_SECOND_IN_MS = 1e3;
+/**
+* A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}
+* for accessing a high-resolution monotonic clock.
+*/
+/**
+* Returns a timestamp in seconds since the UNIX epoch using the Date API.
+*/
+function dateTimestampInSeconds() {
+	return Date.now() / ONE_SECOND_IN_MS;
+}
+/**
+* Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+* support the API.
+*
+* Wrapping the native API works around differences in behavior from different browsers.
+*/
+function createUnixTimestampInSecondsFunc() {
+	const { performance } = GLOBAL_OBJ;
+	if (!performance?.now || !performance.timeOrigin) return dateTimestampInSeconds;
+	const timeOrigin = performance.timeOrigin;
+	return () => {
+		return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;
+	};
+}
+let _cachedTimestampInSeconds;
+/**
+* Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+* availability of the Performance API.
+*
+* BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+* asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+* skew can grow to arbitrary amounts like days, weeks or months.
+* See https://github.com/getsentry/sentry-javascript/issues/2590.
+*/
+function timestampInSeconds() {
+	return (_cachedTimestampInSeconds ?? (_cachedTimestampInSeconds = createUnixTimestampInSecondsFunc()))();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/session.js
+/**
+* Updates a session object with the properties passed in the context.
+*
+* Note that this function mutates the passed object and returns void.
+* (Had to do this instead of returning a new and updated session because closing and sending a session
+* makes an update to the session after it was passed to the sending logic.
+* @see Client.captureSession )
+*
+* @param session the `Session` to update
+* @param context the `SessionContext` holding the properties that should be updated in @param session
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/merge.js
+/**
+* Shallow merge two objects.
+* Does not mutate the passed in objects.
+* Undefined/empty values in the merge object will overwrite existing values.
+*
+* By default, this merges 2 levels deep.
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/propagationContext.js
+/**
+* Generate a random, valid trace ID.
+*/
+function generateTraceId() {
+	return uuid4();
+}
+/**
+* Generate a random, valid span ID.
+*/
+function generateSpanId() {
+	return uuid4().substring(16);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/spanOnScope.js
+const SCOPE_SPAN_FIELD = "_sentrySpan";
+/**
+* Set the active span for a given scope.
+* NOTE: This should NOT be used directly, but is only used internally by the trace methods.
+*/
+function _setSpanForScope(scope, span) {
+	if (span) addNonEnumerableProperty(scope, SCOPE_SPAN_FIELD, span);
+	else delete scope[SCOPE_SPAN_FIELD];
+}
+/**
+* Get the active span for a given scope.
+* NOTE: This should NOT be used directly, but is only used internally by the trace methods.
+*/
+function _getSpanForScope(scope) {
+	return scope[SCOPE_SPAN_FIELD];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/scope.js
+/**
+* Default value for maximum number of breadcrumbs added to an event.
+*/
+const DEFAULT_MAX_BREADCRUMBS = 100;
+/**
+* A context to be used for capturing an event.
+* This can either be a Scope, or a partial ScopeContext,
+* or a callback that receives the current scope and returns a new scope to use.
+*/
+/**
+* Holds additional event information.
+*/
+var Scope = class Scope {
+	/** Flag if notifying is happening. */
+	/** Callback for client to receive scope changes. */
+	/** Callback list that will be called during event processing. */
+	/** Array of breadcrumbs. */
+	/** User */
+	/** Tags */
+	/** Extra */
+	/** Contexts */
+	/** Attachments */
+	/** Propagation Context for distributed tracing */
+	/**
+	* A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+	* sent to Sentry
+	*/
+	/** Fingerprint */
+	/** Severity */
+	/**
+	* Transaction Name
+	*
+	* IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
+	* It's purpose is to assign a transaction to the scope that's added to non-transaction events.
+	*/
+	/** Session */
+	/** The client on this scope */
+	/** Contains the last event id of a captured event.  */
+	constructor() {
+		this._notifyingListeners = false;
+		this._scopeListeners = [];
+		this._eventProcessors = [];
+		this._breadcrumbs = [];
+		this._attachments = [];
+		this._user = {};
+		this._tags = {};
+		this._extra = {};
+		this._contexts = {};
+		this._sdkProcessingMetadata = {};
+		this._propagationContext = {
+			traceId: generateTraceId(),
+			sampleRand: Math.random()
+		};
+	}
+	/**
+	* Clone all data from this scope into a new scope.
+	*/
+	clone() {
+		const newScope = new Scope();
+		newScope._breadcrumbs = [...this._breadcrumbs];
+		newScope._tags = { ...this._tags };
+		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;
+		_setSpanForScope(newScope, _getSpanForScope(this));
+		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 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) {
+		this._tags = {
+			...this._tags,
+			[key]: value
+		};
+		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, extra, user, contexts, level, fingerprint = [], propagationContext } = (scopeToMerge instanceof Scope ? scopeToMerge.getScopeData() : isPlainObject(scopeToMerge) ? captureContext : void 0) || {};
+		this._tags = {
+			...this._tags,
+			...tags
+		};
+		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;
+		return this;
+	}
+	/**
+	* Clears the current scope and resets its properties.
+	* Note: The client will not be cleared.
+	*/
+	clear() {
+		this._breadcrumbs = [];
+		this._tags = {};
+		this._extra = {};
+		this._user = {};
+		this._contexts = {};
+		this._level = void 0;
+		this._transactionName = void 0;
+		this._fingerprint = void 0;
+		this._session = void 0;
+		_setSpanForScope(this, void 0);
+		this._attachments = [];
+		this.setPropagationContext({
+			traceId: generateTraceId(),
+			sampleRand: Math.random()
+		});
+		this._notifyScopeListeners();
+		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._client?.recordDroppedEvent("buffer_overflow", "log_item");
+		}
+		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,
+			extra: this._extra,
+			user: this._user,
+			level: this._level,
+			fingerprint: this._fingerprint || [],
+			eventProcessors: this._eventProcessors,
+			propagationContext: this._propagationContext,
+			sdkProcessingMetadata: this._sdkProcessingMetadata,
+			transactionName: this._transactionName,
+			span: _getSpanForScope(this)
+		};
+	}
+	/**
+	* 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$1 && 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$1 && debug.warn("No client configured on scope - will not capture message!");
+			return eventId;
+		}
+		const 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 = hint?.event_id || uuid4();
+		if (!this._client) {
+			DEBUG_BUILD$1 && 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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/defaultScopes.js
+/** Get the default current scope. */
+function getDefaultCurrentScope() {
+	return getGlobalSingleton("defaultCurrentScope", () => new Scope());
+}
+/** Get the default isolation scope. */
+function getDefaultIsolationScope() {
+	return getGlobalSingleton("defaultIsolationScope", () => new Scope());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/asyncContext/stackStrategy.js
+/**
+* This is an object that holds a stack of scopes.
+*/
+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 maybePromiseResult.then((res) => {
+			this._popScope();
+			return res;
+		}, (e) => {
+			this._popScope();
+			throw e;
+		});
+		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();
+	}
+};
+/**
+* Get the global async context stack.
+* This will be removed during the v8 cycle and is only here to make migration easier.
+*/
+function getAsyncContextStack() {
+	const sentry = getSentryCarrier(getMainCarrier());
+	return sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope());
+}
+function withScope(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());
+	});
+}
+/**
+* Get the stack-based async context strategy.
+*/
+function getStackAsyncContextStrategy() {
+	return {
+		withIsolationScope,
+		withScope,
+		withSetScope,
+		withSetIsolationScope: (_isolationScope, callback) => {
+			return withIsolationScope(callback);
+		},
+		getCurrentScope: () => getAsyncContextStack().getScope(),
+		getIsolationScope: () => getAsyncContextStack().getIsolationScope()
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/asyncContext/index.js
+/**
+* Get the current async context strategy.
+* If none has been setup, the default will be used.
+*/
+function getAsyncContextStrategy(carrier) {
+	const sentry = getSentryCarrier(carrier);
+	if (sentry.acs) return sentry.acs;
+	return getStackAsyncContextStrategy();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/currentScopes.js
+/**
+* Get the currently active scope.
+*/
+function getCurrentScope() {
+	return getAsyncContextStrategy(getMainCarrier()).getCurrentScope();
+}
+/**
+* Get the currently active isolation scope.
+* The isolation scope is active for the current execution context.
+*/
+function getIsolationScope() {
+	return getAsyncContextStrategy(getMainCarrier()).getIsolationScope();
+}
+/**
+* Get the global scope.
+* This scope is applied to _all_ events.
+*/
+function getGlobalScope() {
+	return getGlobalSingleton("globalScope", () => new Scope());
+}
+/**
+* Get the currently active client.
+*/
+function getClient() {
+	return getCurrentScope().getClient();
+}
+/**
+* Get a trace context for the given scope.
+*/
+function getTraceContextFromScope(scope) {
+	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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/semanticAttributes.js
+/**
+* Use this attribute to represent the source of a span.
+* Should be one of: custom, url, route, view, component, task, unknown
+*
+*/
+const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = "sentry.source";
+/**
+* Use this attribute to represent the operation of a span.
+*/
+const SEMANTIC_ATTRIBUTE_SENTRY_OP = "sentry.op";
+/**
+* Use this attribute to represent the origin of a span.
+*/
+const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = "sentry.origin";
+/**
+* The id of the profile that this span occurred in.
+*/
+const SEMANTIC_ATTRIBUTE_PROFILE_ID = "sentry.profile_id";
+const SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME = "sentry.exclusive_time";
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/tracing/utils.js
+const SCOPE_ON_START_SPAN_FIELD = "_sentryScope";
+const ISOLATION_SCOPE_ON_START_SPAN_FIELD = "_sentryIsolationScope";
+/**
+* Grabs the scope and isolation scope off a span that were active when the span was started.
+*/
+function getCapturedScopesOnSpan(span) {
+	return {
+		scope: span[SCOPE_ON_START_SPAN_FIELD],
+		isolationScope: span[ISOLATION_SCOPE_ON_START_SPAN_FIELD]
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/baggage.js
+const SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;
+/**
+* Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the "sentry-" prefixed values
+* from it.
+*
+* @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.
+* @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.
+*/
+function baggageHeaderToDynamicSamplingContext(baggageHeader) {
+	const baggageObject = parseBaggageHeader(baggageHeader);
+	if (!baggageObject) return;
+	const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {
+		if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {
+			const nonPrefixedKey = key.slice(7);
+			acc[nonPrefixedKey] = value;
+		}
+		return acc;
+	}, {});
+	if (Object.keys(dynamicSamplingContext).length > 0) return dynamicSamplingContext;
+	else return;
+}
+/**
+* Take a baggage header and parse it into an object.
+*/
+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);
+}
+/**
+* Will parse a baggage header, which is a simple key-value map, into a flat object.
+*
+* @param baggageHeader The baggage header to parse.
+* @returns a flat object containing all the key-value pairs from `baggageHeader`.
+*/
+function baggageHeaderToObject(baggageHeader) {
+	return baggageHeader.split(",").map((baggageEntry) => baggageEntry.split("=").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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/parseSampleRate.js
+/**
+* Parse a sample rate from a given value.
+* This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1).
+* If a string is passed, we try to convert it to a number.
+*
+* Any invalid sample rate will return `undefined`.
+*/
+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;
+}
+let hasShownSpanDropWarning = false;
+/**
+* Convert a span to a trace context, which can be sent as the `trace` context in a non-transaction event.
+*/
+function spanToTraceContext(span) {
+	const { spanId, traceId: trace_id, isRemote } = span.spanContext();
+	const parent_span_id = isRemote ? spanId : spanToJSON(span).parent_span_id;
+	const scope = getCapturedScopesOnSpan(span).scope;
+	return {
+		parent_span_id,
+		span_id: isRemote ? scope?.getPropagationContext().propagationSpanId || generateSpanId() : spanId,
+		trace_id
+	};
+}
+/**
+*  Converts the span links array to a flattened version to be sent within an envelope.
+*
+*  If the links array is empty, it returns `undefined` so the empty value can be dropped before it's sent.
+*/
+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;
+}
+/**
+* Convert a span time input into a timestamp in seconds.
+*/
+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();
+}
+/**
+* Converts a timestamp to second, if it was in milliseconds, or keeps it as second.
+*/
+function ensureTimestampInSeconds(timestamp) {
+	return timestamp > 9999999999 ? timestamp / 1e3 : timestamp;
+}
+/**
+* Convert a span to a JSON representation.
+*/
+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 {
+			span_id,
+			trace_id,
+			data: attributes,
+			description: name,
+			parent_span_id: "parentSpanId" in span ? span.parentSpanId : "parentSpanContext" in span ? span.parentSpanContext?.spanId : void 0,
+			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,
+		data: {}
+	};
+}
+function spanIsOpenTelemetrySdkTraceBaseSpan(span) {
+	const castSpan = span;
+	return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;
+}
+/** Exported only for tests. */
+/**
+* Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.
+* :( So instead we approximate this by checking if it has the `getSpanJSON` method.
+*/
+function spanIsSentrySpan(span) {
+	return typeof span.getSpanJSON === "function";
+}
+/**
+* Returns true if a span is sampled.
+* In most cases, you should just use `span.isRecording()` instead.
+* However, this has a slightly different semantic, as it also returns false if the span is finished.
+* So in the case where this distinction is important, use this method.
+*/
+function spanIsSampled(span) {
+	const { traceFlags } = span.spanContext();
+	return traceFlags === 1;
+}
+/** Get the status message to use for a JSON representation of a span. */
+function getStatusMessage(status) {
+	if (!status || status.code === 0) return;
+	if (status.code === 1) return "ok";
+	return status.message || "unknown_error";
+}
+const ROOT_SPAN_FIELD = "_sentryRootSpan";
+/**
+* Returns the root span of a given span.
+*/
+function getRootSpan(span) {
+	return span[ROOT_SPAN_FIELD] || span;
+}
+/**
+* Logs a warning once if `beforeSendSpan` is used to drop spans.
+*/
+function showSpanDropWarning() {
+	if (!hasShownSpanDropWarning) {
+		consoleSandbox(() => {
+			console.warn("[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly.");
+		});
+		hasShownSpanDropWarning = true;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/hasSpansEnabled.js
+/**
+* Determines if span recording is currently enabled.
+*
+* Spans are recorded when at least one of `tracesSampleRate` and `tracesSampler`
+* is defined in the SDK config. This function does not make any assumption about
+* sampling decisions, it only checks if the SDK is configured to record spans.
+*
+* Important: This function only determines if span recording is enabled. Trace
+* continuation and propagation is separately controlled and not covered by this function.
+* If this function returns `false`, traces can still be propagated (which is what
+* we refer to by "Tracing without Performance")
+* @see https://develop.sentry.dev/sdk/telemetry/traces/tracing-without-performance/
+*
+* @param maybeOptions An SDK options object to be passed to this function.
+* If this option is not provided, the function will use the current client's options.
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/constants.js
+const DEFAULT_ENVIRONMENT = "production";
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/dsn.js
+/** Regular expression used to extract org ID from a DSN host. */
+const ORG_ID_REGEX = /^o(\d+)\./;
+/** Regular expression used to parse a Dsn. */
+const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+function isValidProtocol(protocol) {
+	return protocol === "http" || protocol === "https";
+}
+/**
+* Renders the string representation of this Dsn.
+*
+* By default, this will render the public representation without the password
+* component. To get the deprecated private representation, set `withPassword`
+* to true.
+*
+* @param withPassword When set to true, the password will be included.
+*/
+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}`;
+}
+/**
+* Parses a Dsn from a given string.
+*
+* @param str A Dsn as string
+* @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string
+*/
+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$1) 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;
+}
+/**
+* Extract the org ID from a DSN host.
+*
+* @param host The host from a DSN
+* @returns The org ID if found, undefined otherwise
+*/
+function extractOrgIdFromDsnHost(host) {
+	return host.match(ORG_ID_REGEX)?.[1];
+}
+/**
+* Creates a valid Sentry Dsn object, identifying a Sentry instance and project.
+* @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source
+*/
+function makeDsn(from) {
+	const components = typeof from === "string" ? dsnFromString(from) : dsnFromComponents(from);
+	if (!components || !validateDsn(components)) return;
+	return components;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/tracing/dynamicSamplingContext.js
+/**
+* If you change this value, also update the terser plugin config to
+* avoid minification of the object property!
+*/
+const FROZEN_DSC_FIELD = "_frozenDsc";
+/**
+* Creates a dynamic sampling context from a client.
+*
+* Dispatches the `createDsc` lifecycle hook as a side effect.
+*/
+function getDynamicSamplingContextFromClient(trace_id, client) {
+	const options = client.getOptions();
+	const { publicKey: public_key, host } = client.getDsn() || {};
+	let org_id;
+	if (options.orgId) org_id = String(options.orgId);
+	else if (host) org_id = extractOrgIdFromDsnHost(host);
+	const dsc = {
+		environment: options.environment || "production",
+		release: options.release,
+		public_key,
+		trace_id,
+		org_id
+	};
+	client.emit("createDsc", dsc);
+	return dsc;
+}
+/**
+* Get the dynamic sampling context for the currently active scopes.
+*/
+function getDynamicSamplingContextFromScope(client, scope) {
+	const propagationContext = scope.getPropagationContext();
+	return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);
+}
+/**
+* Creates a dynamic sampling context from a span (and client and scope)
+*
+* @param span the span from which a few values like the root span name and sample rate are extracted.
+*
+* @returns a dynamic sampling context
+*/
+function getDynamicSamplingContextFromSpan(span) {
+	const client = getClient();
+	if (!client) return {};
+	const rootSpan = getRootSpan(span);
+	const rootSpanJson = spanToJSON(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(dsc) {
+		if (typeof rootSpanSampleRate === "number" || typeof rootSpanSampleRate === "string") dsc.sample_rate = `${rootSpanSampleRate}`;
+		return dsc;
+	}
+	const frozenDsc = rootSpan[FROZEN_DSC_FIELD];
+	if (frozenDsc) return applyLocalSampleRateToDsc(frozenDsc);
+	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[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];
+	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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/normalize.js
+/**
+* Recursively normalizes the given object.
+*
+* - Creates a copy to prevent original input mutation
+* - Skips non-enumerable properties
+* - When stringifying, calls `toJSON` if implemented
+* - Removes circular references
+* - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
+* - Translates known global objects/classes to a string representations
+* - Takes care of `Error` object serialization
+* - Optionally limits depth of final output
+* - Optionally limits number of properties/elements included in any single object/array
+*
+* @param input The object to be normalized.
+* @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
+* @param maxProperties The max number of elements or properties to be included in any single array or
+* object in the normalized output.
+* @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
+*/
+function normalize(input, depth = 100, maxProperties = Infinity) {
+	try {
+		return visit("", input, depth, maxProperties);
+	} catch (err) {
+		return { ERROR: `**non-serializable** (${err})` };
+	}
+}
+/** JSDoc */
+function normalizeToSize(object, depth = 3, maxSize = 102400) {
+	const normalized = normalize(object, depth);
+	if (jsonSize(normalized) > maxSize) return normalizeToSize(object, depth - 1, maxSize);
+	return normalized;
+}
+/**
+* Visits a node to perform normalization on it
+*
+* @param key The key corresponding to the given node
+* @param value The node to be visited
+* @param depth Optional number indicating the maximum recursion depth
+* @param maxProperties Optional maximum number of properties/elements included in any single object/array
+* @param memo Optional Memo class handling decycling
+*/
+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 (value["__sentry_skip_normalization__"]) return value;
+	const remainingDepth = typeof value["__sentry_override_normalization_depth__"] === "number" ? value["__sentry_override_normalization_depth__"] : 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;
+}
+/**
+* Stringify the given value. Handles various known special values and types.
+*
+* Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn
+* the number 1231 into "[Object Number]", nor on `null`, as it will throw.
+*
+* @param value The value to stringify
+* @returns A stringified representation of the given value
+*/
+function stringifyValue(key, value) {
+	try {
+		if (key === "domain" && value && typeof value === "object" && value._events) return "[Domain]";
+		if (key === "domainEmitter") return "[DomainEmitter]";
+		if (typeof global !== "undefined" && value === global) return "[Global]";
+		if (typeof window !== "undefined" && value === window) return "[Window]";
+		if (typeof document !== "undefined" && value === document) return "[Document]";
+		if (isVueViewModel(value)) return "[VueViewModel]";
+		if (isSyntheticEvent(value)) return "[SyntheticEvent]";
+		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)}]`;
+		const objName = getConstructorName(value);
+		if (/^HTML(\w*)Element$/.test(objName)) return `[HTMLElement: ${objName}]`;
+		return `[object ${objName}]`;
+	} catch (err) {
+		return `**non-serializable** (${err})`;
+	}
+}
+function getConstructorName(value) {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype?.constructor ? prototype.constructor.name : "null prototype";
+}
+/** Calculates bytes size of input string */
+function utf8Length(value) {
+	return ~-encodeURI(value).split(/%..|./).length;
+}
+/** Calculates bytes size of input object */
+function jsonSize(value) {
+	return utf8Length(JSON.stringify(value));
+}
+/**
+* Helper to decycle json objects
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/envelope.js
+/**
+* Creates an envelope.
+* Make sure to always explicitly provide the generic to this function
+* so that the envelope types resolve correctly.
+*/
+function createEnvelope(headers, items = []) {
+	return [headers, items];
+}
+/**
+* Add an item to an envelope.
+* Make sure to always explicitly provide the generic to this function
+* so that the envelope types resolve correctly.
+*/
+function addItemToEnvelope(envelope, newItem) {
+	const [headers, items] = envelope;
+	return [headers, [...items, newItem]];
+}
+/**
+* Convenience function to loop through the items and item types of an envelope.
+* (This function was mostly created because working with envelope types is painful at the moment)
+*
+* If the callback returns true, the rest of the items will be skipped.
+*/
+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;
+}
+/**
+* Encode a string to UTF8 array.
+*/
+function encodeUTF8(input) {
+	const carrier = getSentryCarrier(GLOBAL_OBJ);
+	return carrier.encodePolyfill ? carrier.encodePolyfill(input) : new TextEncoder().encode(input);
+}
+/**
+* Serializes an envelope.
+*/
+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(`\n${JSON.stringify(itemHeaders)}\n`);
+		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;
+}
+/**
+* Creates attachment envelope items
+*/
+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 ITEM_TYPE_TO_DATA_CATEGORY_MAP = {
+	session: "session",
+	sessions: "session",
+	attachment: "attachment",
+	transaction: "transaction",
+	event: "error",
+	client_report: "internal",
+	user_report: "default",
+	profile: "profile",
+	profile_chunk: "profile",
+	replay_event: "replay",
+	replay_recording: "replay",
+	check_in: "monitor",
+	feedback: "feedback",
+	span: "span",
+	raw_security: "security",
+	log: "log_item"
+};
+/**
+* Maps the type of an envelope item to a data category.
+*/
+function envelopeItemTypeToDataCategory(type) {
+	return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];
+}
+/** Extracts the minimal SDK info from the metadata or an events */
+function getSdkMetadataForEnvelopeHeader(metadataOrEvent) {
+	if (!metadataOrEvent?.sdk) return;
+	const { name, version } = metadataOrEvent.sdk;
+	return {
+		name,
+		version
+	};
+}
+/**
+* Creates event envelope headers, based on event, sdk info and tunnel
+* Note: This function was extracted from the core package to make it available in Replay
+*/
+function createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn) {
+	const dynamicSamplingContext = event.sdkProcessingMetadata?.dynamicSamplingContext;
+	return {
+		event_id: event.event_id,
+		sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+		...sdkInfo && { sdk: sdkInfo },
+		...!!tunnel && dsn && { dsn: dsnToString(dsn) },
+		...dynamicSamplingContext && { trace: dynamicSamplingContext }
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/envelope.js
+/**
+* Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.
+* Merge with existing data if any.
+**/
+function enhanceEventWithSdkInfo(event, sdkInfo) {
+	if (!sdkInfo) return event;
+	event.sdk = event.sdk || {};
+	event.sdk.name = event.sdk.name || sdkInfo.name;
+	event.sdk.version = event.sdk.version || sdkInfo.version;
+	event.sdk.integrations = [...event.sdk.integrations || [], ...sdkInfo.integrations || []];
+	event.sdk.packages = [...event.sdk.packages || [], ...sdkInfo.packages || []];
+	return event;
+}
+/** Creates an envelope from a Session */
+function createSessionEnvelope(session, dsn, metadata, tunnel) {
+	const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);
+	return createEnvelope({
+		sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+		...sdkInfo && { sdk: sdkInfo },
+		...!!tunnel && dsn && { dsn: dsnToString(dsn) }
+	}, ["aggregates" in session ? [{ type: "sessions" }, session] : [{ type: "session" }, session.toJSON()]]);
+}
+/**
+* Create an Envelope from an event.
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/syncpromise.js
+/** SyncPromise internal states */
+const STATE_PENDING = 0;
+const STATE_RESOLVED = 1;
+const STATE_REJECTED = 2;
+/**
+* Creates a resolved sync promise.
+*
+* @param value the value to resolve the promise with
+* @returns the resolved sync promise
+*/
+function resolvedSyncPromise(value) {
+	return new SyncPromise((resolve) => {
+		resolve(value);
+	});
+}
+/**
+* Creates a rejected sync promise.
+*
+* @param value the value to reject the promise with
+* @returns the rejected sync promise
+*/
+function rejectedSyncPromise(reason) {
+	return new SyncPromise((_, reject) => {
+		reject(reason);
+	});
+}
+/**
+* Thenable class that behaves like a Promise and follows it's interface
+* but is not async internally
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/eventProcessors.js
+/**
+* Process an array of event processors, returning the processed event (or `null` if the event was dropped).
+*/
+function notifyEventProcessors(processors, event, hint, index = 0) {
+	return new SyncPromise((resolve, reject) => {
+		const processor = processors[index];
+		if (event === null || typeof processor !== "function") resolve(event);
+		else {
+			const result = processor({ ...event }, hint);
+			DEBUG_BUILD$1 && processor.id && result === null && debug.log(`Event processor "${processor.id}" dropped event`);
+			if (isThenable(result)) result.then((final) => notifyEventProcessors(processors, final, hint, index + 1).then(resolve)).then(null, reject);
+			else notifyEventProcessors(processors, result, hint, index + 1).then(resolve).then(null, reject);
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/applyScopeDataToEvent.js
+/**
+* Applies data from the scope to the event and runs all event processors on it.
+*/
+function applyScopeDataToEvent(event, data) {
+	const { fingerprint, span, breadcrumbs, sdkProcessingMetadata } = data;
+	applyDataToEvent(event, data);
+	if (span) applySpanToEvent(event, span);
+	applyFingerprintToEvent(event, fingerprint);
+	applyBreadcrumbsToEvent(event, breadcrumbs);
+	applySdkMetadataToEvent(event, sdkProcessingMetadata);
+}
+/** Merge data of two scopes together. */
+function mergeScopeData(data, mergeData) {
+	const { extra, tags, user, contexts, level, sdkProcessingMetadata, breadcrumbs, fingerprint, eventProcessors, attachments, propagationContext, transactionName, span } = mergeData;
+	mergeAndOverwriteScopeData(data, "extra", extra);
+	mergeAndOverwriteScopeData(data, "tags", tags);
+	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 (span) data.span = span;
+	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
+	};
+}
+/**
+* Merges certain scope data. Undefined values will overwrite any existing values.
+* Exported only for tests.
+*/
+function mergeAndOverwriteScopeData(data, prop, mergeVal) {
+	data[prop] = merge(data[prop], mergeVal, 1);
+}
+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 = spanToJSON(getRootSpan(span)).description;
+	if (transactionName && !event.transaction && event.type === "transaction") event.transaction = transactionName;
+}
+/**
+* Applies fingerprint from the scope to the event if there's one,
+* uses message if there's one instead or get rid of empty fingerprint
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/debug-ids.js
+let parsedStackResults;
+let lastKeysCount;
+let cachedFilenameDebugIds;
+/**
+* Returns a map of filenames to debug identifiers.
+*/
+function getFilenameToDebugIdMap(stackParser) {
+	const debugIdMap = GLOBAL_OBJ._sentryDebugIds;
+	if (!debugIdMap) return {};
+	const debugIdKeys = Object.keys(debugIdMap);
+	if (cachedFilenameDebugIds && debugIdKeys.length === lastKeysCount) return cachedFilenameDebugIds;
+	lastKeysCount = debugIdKeys.length;
+	cachedFilenameDebugIds = debugIdKeys.reduce((acc, stackKey) => {
+		if (!parsedStackResults) parsedStackResults = {};
+		const result = parsedStackResults[stackKey];
+		if (result) acc[result[0]] = result[1];
+		else {
+			const parsedStack = stackParser(stackKey);
+			for (let i = parsedStack.length - 1; i >= 0; i--) {
+				const filename = parsedStack[i]?.filename;
+				const debugId = debugIdMap[stackKey];
+				if (filename && debugId) {
+					acc[filename] = debugId;
+					parsedStackResults[stackKey] = [filename, debugId];
+					break;
+				}
+			}
+		}
+		return acc;
+	}, {});
+	return cachedFilenameDebugIds;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/prepareEvent.js
+/**
+* This type makes sure that we get either a CaptureContext, OR an EventHint.
+* It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:
+* { user: { id: '123' }, mechanism: { handled: false } }
+*/
+/**
+* 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 scope A scope containing event metadata.
+* @returns A new event with more information.
+* @hidden
+*/
+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) addExceptionMechanism(prepared, hint.mechanism);
+	const clientEventProcessors = client ? client.getEventProcessors() : [];
+	const data = getGlobalScope().getScopeData();
+	if (isolationScope) mergeScopeData(data, isolationScope.getScopeData());
+	if (finalScope) mergeScopeData(data, finalScope.getScopeData());
+	const attachments = [...hint.attachments || [], ...data.attachments];
+	if (attachments.length) hint.attachments = attachments;
+	applyScopeDataToEvent(prepared, data);
+	return notifyEventProcessors([...clientEventProcessors, ...data.eventProcessors], prepared, hint).then((evt) => {
+		if (evt) applyDebugMeta(evt);
+		if (typeof normalizeDepth === "number" && normalizeDepth > 0) return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
+		return evt;
+	});
+}
+/**
+* Enhances event using the client configuration.
+* It takes care of all "static" values like environment, release and `dist`,
+* as well as truncating overly long values.
+*
+* Only exported for tests.
+*
+* @param event event instance to be enhanced
+*/
+function applyClientOptions(event, options) {
+	const { environment, release, dist, maxValueLength = 250 } = 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) request.url = truncate(request.url, maxValueLength);
+}
+/**
+* Puts debug IDs into the stack frames of an error event.
+*/
+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];
+		});
+	});
+}
+/**
+* Moves debug IDs from the stack frames of an error event into the debug_meta field.
+*/
+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
+		});
+	});
+}
+/**
+* This function adds all used integrations to the SDK info in the event.
+* @param event The event that will be filled with all integrations.
+*/
+function applyIntegrationsMetadata(event, integrationNames) {
+	if (integrationNames.length > 0) {
+		event.sdk = event.sdk || {};
+		event.sdk.integrations = [...event.sdk.integrations || [], ...integrationNames];
+	}
+}
+/**
+* Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.
+* Normalized keys:
+* - `breadcrumbs.data`
+* - `user`
+* - `contexts`
+* - `extra`
+* @param event Event
+* @returns Normalized event
+*/
+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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/api.js
+const SENTRY_API_VERSION = "7";
+/** Returns the prefix to construct Sentry ingestion API endpoints. */
+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/`;
+}
+/** Returns the ingest API endpoint for target. */
+function _getIngestEndpoint(dsn) {
+	return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;
+}
+/** Returns a URL-encoded string with auth config suitable for a query string. */
+function _encodedAuth(dsn, sdkInfo) {
+	const params = { sentry_version: SENTRY_API_VERSION };
+	if (dsn.publicKey) params.sentry_key = dsn.publicKey;
+	if (sdkInfo) params.sentry_client = `${sdkInfo.name}/${sdkInfo.version}`;
+	return new URLSearchParams(params).toString();
+}
+/**
+* Returns the envelope endpoint URL with auth in the query string.
+*
+* Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
+*/
+function getEnvelopeEndpointWithUrlEncodedAuth(dsn, tunnel, sdkInfo) {
+	return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/integration.js
+const installedIntegrations = [];
+/**
+* Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default
+* integrations are added unless they were already provided before.
+* @param integrations array of integration instances
+* @param withDefault should enable default integrations
+*/
+function setupIntegrations(client, integrations) {
+	const integrationIndex = {};
+	integrations.forEach((integration) => {
+		if (integration) setupIntegration(client, integration, integrationIndex);
+	});
+	return integrationIndex;
+}
+/**
+* Execute the `afterAllSetup` hooks of the given integrations.
+*/
+function afterSetupIntegrations(client, integrations) {
+	for (const integration of integrations) if (integration?.afterAllSetup) integration.afterAllSetup(client);
+}
+/** Setup a single integration.  */
+function setupIntegration(client, integration, integrationIndex) {
+	if (integrationIndex[integration.name]) {
+		DEBUG_BUILD$1 && debug.log(`Integration skipped because it was already installed: ${integration.name}`);
+		return;
+	}
+	integrationIndex[integration.name] = integration;
+	if (installedIntegrations.indexOf(integration.name) === -1 && 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);
+	}
+	DEBUG_BUILD$1 && debug.log(`Integration installed: ${integration.name}`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/clientreport.js
+/**
+* Creates client report envelope
+* @param discarded_events An array of discard events
+* @param dsn A DSN that can be set on the header. Optional.
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/eventUtils.js
+/**
+* Get a list of possible event messages from a Sentry event.
+*/
+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/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/transactionEvent.js
+/**
+* Converts a transaction event to a span JSON object.
+*/
+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,
+		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
+	};
+}
+/**
+* Converts a span JSON object to a transaction event.
+*/
+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/.pnpm/@sentry+core@9.47.1/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 = Symbol.for("SentryInternalError");
+const DO_NOT_SEND_EVENT_SYMBOL = Symbol.for("SentryDoNotSendEventError");
+function _makeInternalError(message) {
+	return {
+		message,
+		[INTERNAL_ERROR_SYMBOL]: true
+	};
+}
+function _makeDoNotSendEventError(message) {
+	return {
+		message,
+		[DO_NOT_SEND_EVENT_SYMBOL]: true
+	};
+}
+function _isInternalError(error) {
+	return !!error && typeof error === "object" && INTERNAL_ERROR_SYMBOL in error;
+}
+function _isDoNotSendEventError(error) {
+	return !!error && typeof error === "object" && DO_NOT_SEND_EVENT_SYMBOL in error;
+}
+/**
+* Base implementation for all JavaScript SDK clients.
+*
+* Call the constructor with the corresponding options
+* specific to the client subclass. To access these options later, use
+* {@link Client.getOptions}.
+*
+* If a Dsn is specified in the options, it will be parsed and stored. Use
+* {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is
+* invalid, the constructor will throw a {@link SentryException}. Note that
+* without a valid Dsn, the SDK will not send any events to Sentry.
+*
+* Before sending an event, it is passed through
+* {@link Client._prepareEvent} to add SDK information and scope data
+* (breadcrumbs and context). To add more custom information, override this
+* method and extend the resulting prepared event.
+*
+* To issue automatically created events (e.g. via instrumentation), use
+* {@link Client.captureEvent}. It will prepare the event and pass it through
+* the callback lifecycle. To issue auto-breadcrumbs, use
+* {@link Client.addBreadcrumb}.
+*
+* @example
+* class NodeClient extends Client<NodeOptions> {
+*   public constructor(options: NodeOptions) {
+*     super(options);
+*   }
+*
+*   // ...
+* }
+*/
+var Client = class {
+	/** Options passed to the SDK. */
+	/** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */
+	/** Array of set up integrations. */
+	/** Number of calls being processed */
+	/** Holds flushable  */
+	/**
+	* Initializes this client instance.
+	*
+	* @param options Options for the client.
+	*/
+	constructor(options) {
+		this._options = options;
+		this._integrations = {};
+		this._numProcessing = 0;
+		this._outcomes = {};
+		this._hooks = {};
+		this._eventProcessors = [];
+		if (options.dsn) this._dsn = makeDsn(options.dsn);
+		else DEBUG_BUILD$1 && debug.warn("No DSN provided, client will not send events.");
+		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
+			});
+		}
+	}
+	/**
+	* 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$1 && 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)));
+		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 promisedEvent = isPrimitive(message) ? this.eventFromMessage(eventMessage, level, hintWithEventId) : this.eventFromException(message, hintWithEventId);
+		this._process(promisedEvent.then((event) => this._captureEvent(event, hintWithEventId, currentScope)));
+		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$1 && 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;
+		this._process(this._captureEvent(event, hintWithEventId, capturedSpanScope || currentScope, capturedSpanIsolationScope));
+		return hintWithEventId.event_id;
+	}
+	/**
+	* Captures a session.
+	*/
+	captureSession(session) {
+		this.sendSession(session);
+		updateSession(session, { init: false });
+	}
+	/**
+	* Create a cron monitor check in and send it to Sentry. This method is not available on all clients.
+	*
+	* @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.
+	* @param scope An optional scope containing event metadata.
+	* @returns A string representing the id of the check in.
+	*/
+	/**
+	* Get the current Dsn.
+	*/
+	getDsn() {
+		return this._dsn;
+	}
+	/**
+	* Get the current options.
+	*/
+	getOptions() {
+		return this._options;
+	}
+	/**
+	* 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.
+	*/
+	flush(timeout) {
+		const transport = this._transport;
+		if (transport) {
+			this.emit("flush");
+			return this._isClientDoneProcessing(timeout).then((clientFinished) => {
+				return transport.flush(timeout).then((transportFlushed) => clientFinished && transportFlushed);
+			});
+		} else return resolvedSyncPromise(true);
+	}
+	/**
+	* 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.
+	*/
+	close(timeout) {
+		return this.flush(timeout).then((result) => {
+			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();
+	}
+	/**
+	* 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];
+	}
+	/**
+	* 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];
+		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);
+		let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
+		for (const attachment of hint.attachments || []) env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment));
+		const promise = this.sendEnvelope(env);
+		if (promise) promise.then((sendResponse) => this.emit("afterSendEvent", event, sendResponse), null);
+	}
+	/**
+	* 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$1 && 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$1 && 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$1 && debug.log(`Recording outcome: "${key}"${count > 1 ? ` (${count} times)` : ""}`);
+			this._outcomes[key] = (this._outcomes[key] || 0) + count;
+		}
+	}
+	/**
+	* Register a callback for whenever a span is started.
+	* Receives the span as argument.
+	* @returns {() => void} A function that, when executed, removes the registered callback.
+	*/
+	/**
+	* Register a hook on this client.
+	*/
+	on(hook, callback) {
+		const hooks = this._hooks[hook] = this._hooks[hook] || [];
+		hooks.push(callback);
+		return () => {
+			const cbIndex = hooks.indexOf(callback);
+			if (cbIndex > -1) hooks.splice(cbIndex, 1);
+		};
+	}
+	/** Fire a hook whenever a span starts. */
+	/**
+	* 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.
+	*/
+	sendEnvelope(envelope) {
+		this.emit("beforeEnvelope", envelope);
+		if (this._isEnabled() && this._transport) return this._transport.send(envelope).then(null, (reason) => {
+			DEBUG_BUILD$1 && debug.error("Error while sending envelope:", reason);
+			return reason;
+		});
+		DEBUG_BUILD$1 && debug.error("Transport disabled");
+		return resolvedSyncPromise({});
+	}
+	/** 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 crashed = event.level === "fatal";
+		let errored = false;
+		const exceptions = event.exception?.values;
+		if (exceptions) {
+			errored = true;
+			for (const ex of exceptions) if (ex.mechanism?.handled === false) {
+				crashed = true;
+				break;
+			}
+		}
+		const sessionNonTerminal = session.status === "ok";
+		if (sessionNonTerminal && session.errors === 0 || sessionNonTerminal && crashed) {
+			updateSession(session, {
+				...crashed && { status: "crashed" },
+				errors: session.errors || Number(errored || crashed)
+			});
+			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
+	*/
+	_isClientDoneProcessing(timeout) {
+		return new SyncPromise((resolve) => {
+			let ticked = 0;
+			const tick = 1;
+			const interval = setInterval(() => {
+				if (this._numProcessing == 0) {
+					clearInterval(interval);
+					resolve(true);
+				} else {
+					ticked += tick;
+					if (timeout && ticked >= timeout) {
+						clearInterval(interval);
+						resolve(false);
+					}
+				}
+			}, tick);
+		});
+	}
+	/** 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 = Object.keys(this._integrations);
+		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: 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$1 && 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$1) {
+				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 eventType = event.type || "error";
+		const beforeSendLabel = `before send for type \`${eventType}\``;
+		const parsedSampleRate = typeof sampleRate === "undefined" ? void 0 : parseSampleRate(sampleRate);
+		if (isError && typeof parsedSampleRate === "number" && Math.random() > parsedSampleRate) {
+			this.recordDroppedEvent("sample_rate", "error");
+			return rejectedSyncPromise(_makeDoNotSendEventError(`Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`));
+		}
+		const dataCategory = eventType === "replay_event" ? "replay" : eventType;
+		return this._prepareEvent(event, hint, currentScope, isolationScope).then((prepared) => {
+			if (prepared === null) {
+				this.recordDroppedEvent("event_processor", dataCategory);
+				throw _makeDoNotSendEventError("An event processor returned `null`, will not send event.");
+			}
+			if (hint.data && hint.data.__sentry__ === true) return prepared;
+			return _validateBeforeSendResult(processBeforeSend(this, options, prepared, hint), beforeSendLabel);
+		}).then((processedEvent) => {
+			if (processedEvent === null) {
+				this.recordDroppedEvent("before_send", dataCategory);
+				if (isTransaction) {
+					const spanCount = 1 + (event.spans || []).length;
+					this.recordDroppedEvent("before_send", "span", spanCount);
+				}
+				throw _makeDoNotSendEventError(`${beforeSendLabel} returned \`null\`, will not send event.`);
+			}
+			const session = currentScope.getSession() || isolationScope.getSession();
+			if (isError && session) this._updateSessionFromEvent(session, processedEvent);
+			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, {
+				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.\nReason: ${reason}`);
+		});
+	}
+	/**
+	* Occupies the client with processing and event
+	*/
+	_process(promise) {
+		this._numProcessing++;
+		promise.then((value) => {
+			this._numProcessing--;
+			return value;
+		}, (reason) => {
+			this._numProcessing--;
+			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$1 && debug.log("Flushing outcomes...");
+		const outcomes = this._clearOutcomes();
+		if (outcomes.length === 0) {
+			DEBUG_BUILD$1 && debug.log("No outcomes to send");
+			return;
+		}
+		if (!this._dsn) {
+			DEBUG_BUILD$1 && debug.log("No dsn provided, will not send outcomes");
+			return;
+		}
+		DEBUG_BUILD$1 && debug.log("Sending outcomes:", outcomes);
+		const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));
+		this.sendEnvelope(envelope);
+	}
+};
+/**
+* Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.
+*/
+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;
+}
+/**
+* Process the matching `beforeSendXXX` callback.
+*/
+function processBeforeSend(client, options, event, hint) {
+	const { beforeSend, beforeSendTransaction, beforeSendSpan } = options;
+	let processedEvent = event;
+	if (isErrorEvent(processedEvent) && beforeSend) return beforeSend(processedEvent, hint);
+	if (isTransactionEvent(processedEvent)) {
+		if (beforeSendSpan) {
+			const processedRootSpanJson = beforeSendSpan(convertTransactionEventToSpanJson(processedEvent));
+			if (!processedRootSpanJson) showSpanDropWarning();
+			else processedEvent = merge(event, convertSpanJsonToTransactionEvent(processedRootSpanJson));
+			if (processedEvent.spans) {
+				const processedSpans = [];
+				for (const span of processedEvent.spans) {
+					const processedSpan = beforeSendSpan(span);
+					if (!processedSpan) {
+						showSpanDropWarning();
+						processedSpans.push(span);
+					} else processedSpans.push(processedSpan);
+				}
+				processedEvent.spans = processedSpans;
+			}
+		}
+		if (beforeSendTransaction) {
+			if (processedEvent.spans) {
+				const spanCountBefore = processedEvent.spans.length;
+				processedEvent.sdkProcessingMetadata = {
+					...event.sdkProcessingMetadata,
+					spanCountBeforeProcessing: spanCountBefore
+				};
+			}
+			return beforeSendTransaction(processedEvent, hint);
+		}
+	}
+	return processedEvent;
+}
+function isErrorEvent(event) {
+	return event.type === void 0;
+}
+function isTransactionEvent(event) {
+	return event.type === "transaction";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/logs/envelope.js
+/**
+* Creates a log container envelope item for a list of logs.
+*
+* @param items - The logs to include in the envelope.
+* @returns The created log container envelope item.
+*/
+function createLogContainerEnvelopeItem(items) {
+	return [{
+		type: "log",
+		item_count: items.length,
+		content_type: "application/vnd.sentry.items.log+json"
+	}, { items }];
+}
+/**
+* Creates an envelope for a list of logs.
+*
+* Logs from multiple traces can be included in the same envelope.
+*
+* @param logs - The logs to include in the envelope.
+* @param metadata - The metadata to include in the envelope.
+* @param tunnel - The tunnel to include in the envelope.
+* @param dsn - The DSN to include in the envelope.
+* @returns The created envelope.
+*/
+function createLogEnvelope(logs, metadata, tunnel, dsn) {
+	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)]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/logs/exports.js
+/**
+* Flushes the logs buffer to Sentry.
+*
+* @param client - A client.
+* @param maybeLogBuffer - A log buffer. Uses the log buffer for the given client if not provided.
+*
+* @experimental This method will experience breaking changes. This is not yet part of
+* the stable Sentry SDK API and can be changed or removed without warning.
+*/
+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());
+	_getBufferMap().set(client, []);
+	client.emit("flushLogs");
+	client.sendEnvelope(envelope);
+}
+/**
+* Returns the log buffer for a given client.
+*
+* Exported for testing purposes.
+*
+* @param client - The client to get the log buffer for.
+* @returns The log buffer for the given client.
+*/
+function _INTERNAL_getLogBuffer(client) {
+	return _getBufferMap().get(client);
+}
+function _getBufferMap() {
+	return getGlobalSingleton("clientToLogBufferMap", () => /* @__PURE__ */ new WeakMap());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/promisebuffer.js
+const SENTRY_BUFFER_FULL_ERROR = Symbol.for("SentryBufferFullError");
+/**
+* Creates an new PromiseBuffer object with the specified limit
+* @param limit max number of promises that can be stored in the buffer
+*/
+function makePromiseBuffer(limit) {
+	const buffer = [];
+	function isReady() {
+		return limit === void 0 || buffer.length < limit;
+	}
+	/**
+	* Remove a promise from the queue.
+	*
+	* @param task Can be any PromiseLike<T>
+	* @returns Removed promise.
+	*/
+	function remove(task) {
+		return buffer.splice(buffer.indexOf(task), 1)[0] || Promise.resolve(void 0);
+	}
+	/**
+	* Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.
+	*
+	* @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:
+	*        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor
+	*        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By
+	*        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer
+	*        limit check.
+	* @returns The original promise.
+	*/
+	function add(taskProducer) {
+		if (!isReady()) return rejectedSyncPromise(SENTRY_BUFFER_FULL_ERROR);
+		const task = taskProducer();
+		if (buffer.indexOf(task) === -1) buffer.push(task);
+		task.then(() => remove(task)).then(null, () => remove(task).then(null, () => {}));
+		return task;
+	}
+	/**
+	* Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.
+	*
+	* @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or
+	* not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to
+	* `true`.
+	* @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and
+	* `false` otherwise
+	*/
+	function drain(timeout) {
+		return new SyncPromise((resolve, reject) => {
+			let counter = buffer.length;
+			if (!counter) return resolve(true);
+			const capturedSetTimeout = setTimeout(() => {
+				if (timeout && timeout > 0) resolve(false);
+			}, timeout);
+			buffer.forEach((item) => {
+				resolvedSyncPromise(item).then(() => {
+					if (!--counter) {
+						clearTimeout(capturedSetTimeout);
+						resolve(true);
+					}
+				}, reject);
+			});
+		});
+	}
+	return {
+		$: buffer,
+		add,
+		drain
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/ratelimit.js
+const DEFAULT_RETRY_AFTER = 6e4;
+/**
+* Extracts Retry-After value from the request header or returns default value
+* @param header string representation of 'Retry-After' header
+* @param now current unix timestamp
+*
+*/
+function parseRetryAfterHeader(header, now = Date.now()) {
+	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;
+}
+/**
+* Gets the time that the given category is disabled until for rate limiting.
+* In case no category-specific limit is set but a general rate limit across all categories is active,
+* that time is returned.
+*
+* @return the time in ms that the category is disabled until or 0 if there's no active rate limit.
+*/
+function disabledUntil(limits, dataCategory) {
+	return limits[dataCategory] || limits.all || 0;
+}
+/**
+* Checks if a category is rate limited
+*/
+function isRateLimited(limits, dataCategory, now = Date.now()) {
+	return disabledUntil(limits, dataCategory) > now;
+}
+/**
+* Update ratelimits from incoming headers.
+*
+* @return the updated RateLimits object.
+*/
+function updateRateLimits(limits, { statusCode, headers }, now = Date.now()) {
+	const updatedRateLimits = { ...limits };
+	const rateLimitHeader = headers?.["x-sentry-rate-limits"];
+	const retryAfterHeader = headers?.["retry-after"];
+	if (rateLimitHeader)
+ /**
+	* rate limit headers are of the form
+	*     <header>,<header>,..
+	* where each <header> is of the form
+	*     <retry_after>: <categories>: <scope>: <reason_code>: <namespaces>
+	* where
+	*     <retry_after> is a delay in seconds
+	*     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form
+	*         <category>;<category>;...
+	*     <scope> is what's being limited (org, project, or key) - ignored by SDK
+	*     <reason_code> is an arbitrary string like "org_quota" - ignored by SDK
+	*     <namespaces> Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.
+	*         Only present if rate limit applies to the metric_bucket data category.
+	*/
+	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;
+}
+/**
+* Creates an instance of a Sentry `Transport`
+*
+* @param options
+* @param makeRequest
+*/
+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 resolvedSyncPromise({});
+		const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems);
+		const recordEnvelopeLoss = (reason) => {
+			forEachEnvelopeItem(filteredEnvelope, (item, type) => {
+				options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));
+			});
+		};
+		const requestTask = () => makeRequest({ body: serializeEnvelope(filteredEnvelope) }).then((response) => {
+			if (response.statusCode !== void 0 && (response.statusCode < 200 || response.statusCode >= 300)) DEBUG_BUILD$1 && debug.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);
+			rateLimits = updateRateLimits(rateLimits, response);
+			return response;
+		}, (error) => {
+			recordEnvelopeLoss("network_error");
+			DEBUG_BUILD$1 && 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$1 && debug.error("Skipped sending event because buffer is full.");
+				recordEnvelopeLoss("queue_overflow");
+				return resolvedSyncPromise({});
+			} else throw error;
+		});
+	}
+	return {
+		send,
+		flush
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/ipAddress.js
+/**
+* @internal
+*/
+function addAutoIpAddressToUser(objWithMaybeUser) {
+	if (objWithMaybeUser.user?.ip_address === void 0) objWithMaybeUser.user = {
+		...objWithMaybeUser.user,
+		ip_address: "{{auto}}"
+	};
+}
+/**
+* @internal
+*/
+function addAutoIpAddressToSession(session) {
+	if ("aggregates" in session) {
+		if (session.attrs?.["ip_address"] === void 0) session.attrs = {
+			...session.attrs,
+			ip_address: "{{auto}}"
+		};
+	} else if (session.ipAddress === void 0) session.ipAddress = "{{auto}}";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/sdkMetadata.js
+/**
+* A builder for the SDK metadata in the options for the SDK initialization.
+*
+* Note: This function is identical to `buildMetadata` in Remix and NextJS and SvelteKit.
+* We don't extract it for bundle size reasons.
+* @see https://github.com/getsentry/sentry-javascript/pull/7404
+* @see https://github.com/getsentry/sentry-javascript/pull/4196
+*
+* If you make changes to this function consider updating the others as well.
+*
+* @param options SDK options object that gets mutated
+* @param names list of package names
+*/
+function applySdkMetadata(options, name, names = [name], source = "npm") {
+	const metadata = options._metadata || {};
+	if (!metadata.sdk) metadata.sdk = {
+		name: `sentry.javascript.${name}`,
+		packages: names.map((name) => ({
+			name: `${source}:@sentry/${name}`,
+			version: SDK_VERSION
+		})),
+		version: SDK_VERSION
+	};
+	options._metadata = metadata;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/supports.js
+/**
+* isNative checks if the given function is a native implementation
+*/
+function isNativeFunction(func) {
+	return func && /^function\s+\w+\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/env.js
+/**
+* Get source of SDK.
+*/
+function getSDKSource() {
+	return "npm";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+browser@9.47.1/node_modules/@sentry/browser/build/npm/esm/helpers.js
+const WINDOW$1 = GLOBAL_OBJ;
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+browser@9.47.1/node_modules/@sentry/browser/build/npm/esm/eventbuilder.js
+/**
+* This function creates an exception from a JavaScript Error
+*/
+function exceptionFromError(stackParser, ex) {
+	const frames = parseStackFrames(stackParser, ex);
+	const exception = {
+		type: extractType(ex),
+		value: extractMessage(ex)
+	};
+	if (frames.length) exception.stacktrace = { frames };
+	if (exception.type === void 0 && exception.value === "") exception.value = "Unrecoverable error caught";
+	return exception;
+}
+function eventFromPlainObject(stackParser, exception, syntheticException, isUnhandledRejection) {
+	const normalizeDepth = getClient()?.getOptions().normalizeDepth;
+	const errorFromProp = getErrorPropertyFromObject(exception);
+	const extra = { __serialized__: normalizeToSize(exception, normalizeDepth) };
+	if (errorFromProp) return {
+		exception: { values: [exceptionFromError(stackParser, errorFromProp)] },
+		extra
+	};
+	const event = {
+		exception: { values: [{
+			type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? "UnhandledRejection" : "Error",
+			value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection })
+		}] },
+		extra
+	};
+	if (syntheticException) {
+		const frames = parseStackFrames(stackParser, syntheticException);
+		if (frames.length) event.exception.values[0].stacktrace = { frames };
+	}
+	return event;
+}
+function eventFromError(stackParser, ex) {
+	return { exception: { values: [exceptionFromError(stackParser, ex)] } };
+}
+/** Parses stack frames from an error */
+function parseStackFrames(stackParser, ex) {
+	const stacktrace = ex.stacktrace || ex.stack || "";
+	const skipLines = getSkipFirstStackStringLines(ex);
+	const framesToPop = getPopFirstTopFrames(ex);
+	try {
+		return stackParser(stacktrace, skipLines, framesToPop);
+	} catch {}
+	return [];
+}
+const reactMinifiedRegexp = /Minified React error #\d+;/i;
+/**
+* Certain known React errors contain links that would be falsely
+* parsed as frames. This function check for these errors and
+* returns number of the stack string lines to skip.
+*/
+function getSkipFirstStackStringLines(ex) {
+	if (ex && reactMinifiedRegexp.test(ex.message)) return 1;
+	return 0;
+}
+/**
+* If error has `framesToPop` property, it means that the
+* creator tells us the first x frames will be useless
+* and should be discarded. Typically error from wrapper function
+* which don't point to the actual location in the developer's code.
+*
+* Example: https://github.com/zertosh/invariant/blob/master/invariant.js#L46
+*/
+function getPopFirstTopFrames(ex) {
+	if (typeof ex.framesToPop === "number") return ex.framesToPop;
+	return 0;
+}
+function isWebAssemblyException(exception) {
+	if (typeof WebAssembly !== "undefined" && typeof WebAssembly.Exception !== "undefined") return exception instanceof WebAssembly.Exception;
+	else return false;
+}
+/**
+* Extracts from errors what we use as the exception `type` in error events.
+*
+* Usually, this is the `name` property on Error objects but WASM errors need to be treated differently.
+*/
+function extractType(ex) {
+	const name = ex?.name;
+	if (!name && isWebAssemblyException(ex)) return ex.message && Array.isArray(ex.message) && ex.message.length == 2 ? ex.message[0] : "WebAssembly.Exception";
+	return name;
+}
+/**
+* There are cases where stacktrace.message is an Event object
+* https://github.com/getsentry/sentry-javascript/issues/1949
+* In this specific case we try to extract stacktrace.message.error.message
+*/
+function extractMessage(ex) {
+	const message = ex?.message;
+	if (isWebAssemblyException(ex)) {
+		if (Array.isArray(ex.message) && ex.message.length == 2) return ex.message[1];
+		return "wasm exception";
+	}
+	if (!message) return "No error message";
+	if (message.error && typeof message.error.message === "string") return message.error.message;
+	return message;
+}
+/**
+* Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
+* @hidden
+*/
+function eventFromException(stackParser, exception, hint, attachStacktrace) {
+	const event = eventFromUnknownInput(stackParser, exception, hint?.syntheticException || void 0, attachStacktrace);
+	addExceptionMechanism(event);
+	event.level = "error";
+	if (hint?.event_id) event.event_id = hint.event_id;
+	return resolvedSyncPromise(event);
+}
+/**
+* Builds and Event from a Message
+* @hidden
+*/
+function eventFromMessage(stackParser, message, level = "info", hint, attachStacktrace) {
+	const event = eventFromString(stackParser, message, hint?.syntheticException || void 0, attachStacktrace);
+	event.level = level;
+	if (hint?.event_id) event.event_id = hint.event_id;
+	return resolvedSyncPromise(event);
+}
+/**
+* @hidden
+*/
+function eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace, isUnhandledRejection) {
+	let event;
+	if (isErrorEvent$1(exception) && exception.error) return eventFromError(stackParser, exception.error);
+	if (isDOMError(exception) || isDOMException(exception)) {
+		const domException = exception;
+		if ("stack" in exception) event = eventFromError(stackParser, exception);
+		else {
+			const name = domException.name || (isDOMError(domException) ? "DOMError" : "DOMException");
+			const message = domException.message ? `${name}: ${domException.message}` : name;
+			event = eventFromString(stackParser, message, syntheticException, attachStacktrace);
+			addExceptionTypeValue(event, message);
+		}
+		if ("code" in domException) event.tags = {
+			...event.tags,
+			"DOMException.code": `${domException.code}`
+		};
+		return event;
+	}
+	if (isError(exception)) return eventFromError(stackParser, exception);
+	if (isPlainObject(exception) || isEvent(exception)) {
+		event = eventFromPlainObject(stackParser, exception, syntheticException, isUnhandledRejection);
+		addExceptionMechanism(event, { synthetic: true });
+		return event;
+	}
+	event = eventFromString(stackParser, exception, syntheticException, attachStacktrace);
+	addExceptionTypeValue(event, `${exception}`, void 0);
+	addExceptionMechanism(event, { synthetic: true });
+	return event;
+}
+function eventFromString(stackParser, message, syntheticException, attachStacktrace) {
+	const event = {};
+	if (attachStacktrace && syntheticException) {
+		const frames = parseStackFrames(stackParser, 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;
+}
+function getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }) {
+	const keys = extractExceptionKeysForMessage(exception);
+	const captureType = isUnhandledRejection ? "promise rejection" : "exception";
+	if (isErrorEvent$1(exception)) return `Event \`ErrorEvent\` captured as ${captureType} with message \`${exception.message}\``;
+	if (isEvent(exception)) return `Event \`${getObjectClassName(exception)}\` (type=${exception.type}) captured as ${captureType}`;
+	return `Object captured as ${captureType} with keys: ${keys}`;
+}
+function getObjectClassName(obj) {
+	try {
+		const prototype = Object.getPrototypeOf(obj);
+		return prototype ? prototype.constructor.name : void 0;
+	} catch {}
+}
+/** If a plain object has a property that is an `Error`, return this error. */
+function getErrorPropertyFromObject(obj) {
+	for (const prop in obj) if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+		const value = obj[prop];
+		if (value instanceof Error) return value;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+browser@9.47.1/node_modules/@sentry/browser/build/npm/esm/client.js
+/**
+* A magic string that build tooling can leverage in order to inject a release value into the SDK.
+*/
+const DEFAULT_FLUSH_INTERVAL = 5e3;
+/**
+* The Sentry Browser SDK Client.
+*
+* @see BrowserOptions for documentation on configuration options.
+* @see SentryClient for usage documentation.
+*/
+var BrowserClient = class extends Client {
+	/**
+	* Creates a new Browser SDK instance.
+	*
+	* @param options Configuration options for this SDK.
+	*/
+	constructor(options) {
+		const opts = applyDefaultOptions(options);
+		applySdkMetadata(opts, "browser", ["browser"], WINDOW$1.SENTRY_SDK_SOURCE || getSDKSource());
+		super(opts);
+		const { sendDefaultPii, sendClientReports, enableLogs, _experiments } = this._options;
+		const shouldEnableLogs = enableLogs ?? _experiments?.enableLogs;
+		if (WINDOW$1.document && (sendClientReports || shouldEnableLogs)) WINDOW$1.document.addEventListener("visibilitychange", () => {
+			if (WINDOW$1.document.visibilityState === "hidden") {
+				if (sendClientReports) this._flushOutcomes();
+				if (shouldEnableLogs) _INTERNAL_flushLogsBuffer(this);
+			}
+		});
+		if (shouldEnableLogs) {
+			this.on("flush", () => {
+				_INTERNAL_flushLogsBuffer(this);
+			});
+			this.on("afterCaptureLog", () => {
+				if (this._logFlushIdleTimeout) clearTimeout(this._logFlushIdleTimeout);
+				this._logFlushIdleTimeout = setTimeout(() => {
+					_INTERNAL_flushLogsBuffer(this);
+				}, DEFAULT_FLUSH_INTERVAL);
+			});
+		}
+		if (sendDefaultPii) {
+			this.on("postprocessEvent", addAutoIpAddressToUser);
+			this.on("beforeSendSession", addAutoIpAddressToSession);
+		}
+	}
+	/**
+	* @inheritDoc
+	*/
+	eventFromException(exception, hint) {
+		return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);
+	}
+	/**
+	* @inheritDoc
+	*/
+	eventFromMessage(message, level = "info", hint) {
+		return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);
+	}
+	/**
+	* @inheritDoc
+	*/
+	_prepareEvent(event, hint, currentScope, isolationScope) {
+		event.platform = event.platform || "javascript";
+		return super._prepareEvent(event, hint, currentScope, isolationScope);
+	}
+};
+/** Exported only for tests. */
+function applyDefaultOptions(optionsArg) {
+	return {
+		release: typeof __SENTRY_RELEASE__ === "string" ? __SENTRY_RELEASE__ : WINDOW$1.SENTRY_RELEASE?.id,
+		sendClientReports: true,
+		parentSpanIsAlwaysRootSpan: true,
+		...optionsArg
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry-internal+browser-utils@9.47.1/node_modules/@sentry-internal/browser-utils/build/esm/debug-build.js
+/**
+* This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+*
+* ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+*/
+const DEBUG_BUILD = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry-internal+browser-utils@9.47.1/node_modules/@sentry-internal/browser-utils/build/esm/types.js
+const WINDOW = GLOBAL_OBJ;
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry-internal+browser-utils@9.47.1/node_modules/@sentry-internal/browser-utils/build/esm/getNativeImplementation.js
+/**
+* We generally want to use window.fetch / window.setTimeout.
+* However, in some cases this may be wrapped (e.g. by Zone.js for Angular),
+* so we try to get an unpatched version of this from a sandboxed iframe.
+*/
+const cachedImplementations = {};
+/**
+* Get the native implementation of a browser function.
+*
+* This can be used to ensure we get an unwrapped version of a function, in cases where a wrapped function can lead to problems.
+*
+* The following methods can be retrieved:
+* - `setTimeout`: This can be wrapped by e.g. Angular, causing change detection to be triggered.
+* - `fetch`: This can be wrapped by e.g. ad-blockers, causing an infinite loop when a request is blocked.
+*/
+function getNativeImplementation(name) {
+	const cached = cachedImplementations[name];
+	if (cached) return cached;
+	let impl = WINDOW[name];
+	if (isNativeFunction(impl)) return cachedImplementations[name] = impl.bind(WINDOW);
+	const document = WINDOW.document;
+	if (document && typeof document.createElement === "function") try {
+		const sandbox = document.createElement("iframe");
+		sandbox.hidden = true;
+		document.head.appendChild(sandbox);
+		const contentWindow = sandbox.contentWindow;
+		if (contentWindow?.[name]) impl = contentWindow[name];
+		document.head.removeChild(sandbox);
+	} catch (e) {
+		DEBUG_BUILD && debug.warn(`Could not create sandbox iframe for ${name} check, bailing to window.${name}: `, e);
+	}
+	if (!impl) return impl;
+	return cachedImplementations[name] = impl.bind(WINDOW);
+}
+/** Clear a cached implementation. */
+function clearCachedImplementation(name) {
+	cachedImplementations[name] = void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+browser@9.47.1/node_modules/@sentry/browser/build/npm/esm/transports/fetch.js
+/**
+* Creates a Transport that uses the Fetch API to send events to Sentry.
+*/
+function makeFetchTransport(options, nativeFetch = getNativeImplementation("fetch")) {
+	let pendingBodySize = 0;
+	let pendingCount = 0;
+	function makeRequest(request) {
+		const requestSize = request.body.length;
+		pendingBodySize += requestSize;
+		pendingCount++;
+		const requestOptions = {
+			body: request.body,
+			method: "POST",
+			referrerPolicy: "strict-origin",
+			headers: options.headers,
+			keepalive: pendingBodySize <= 6e4 && pendingCount < 15,
+			...options.fetchOptions
+		};
+		if (!nativeFetch) {
+			clearCachedImplementation("fetch");
+			return rejectedSyncPromise("No fetch implementation available");
+		}
+		try {
+			return nativeFetch(options.url, requestOptions).then((response) => {
+				pendingBodySize -= requestSize;
+				pendingCount--;
+				return {
+					statusCode: response.status,
+					headers: {
+						"x-sentry-rate-limits": response.headers.get("X-Sentry-Rate-Limits"),
+						"retry-after": response.headers.get("Retry-After")
+					}
+				};
+			});
+		} catch (e) {
+			clearCachedImplementation("fetch");
+			pendingBodySize -= requestSize;
+			pendingCount--;
+			return rejectedSyncPromise(e);
+		}
+	}
+	return createTransport(options, makeRequest);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sentry+browser@9.47.1/node_modules/@sentry/browser/build/npm/esm/stack-parsers.js
+const CHROME_PRIORITY = 30;
+const GECKO_PRIORITY = 50;
+function createFrame(filename, func, lineno, colno) {
+	const frame = {
+		filename,
+		function: func === "<anonymous>" ? "?" : func,
+		in_app: true
+	};
+	if (lineno !== void 0) frame.lineno = lineno;
+	if (colno !== void 0) frame.colno = colno;
+	return frame;
+}
+const chromeRegexNoFnName = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i;
+const chromeRegex = /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+const chromeStackParserFn = (line) => {
+	const noFnParts = chromeRegexNoFnName.exec(line);
+	if (noFnParts) {
+		const [, filename, line, col] = noFnParts;
+		return createFrame(filename, "?", +line, +col);
+	}
+	const parts = chromeRegex.exec(line);
+	if (parts) {
+		if (parts[2] && parts[2].indexOf("eval") === 0) {
+			const subMatch = chromeEvalRegex.exec(parts[2]);
+			if (subMatch) {
+				parts[2] = subMatch[1];
+				parts[3] = subMatch[2];
+				parts[4] = subMatch[3];
+			}
+		}
+		const [func, filename] = extractSafariExtensionDetails(parts[1] || "?", parts[2]);
+		return createFrame(filename, func, parts[3] ? +parts[3] : void 0, parts[4] ? +parts[4] : void 0);
+	}
+};
+const chromeStackLineParser = [CHROME_PRIORITY, chromeStackParserFn];
+const geckoREgex = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+const geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+const gecko = (line) => {
+	const parts = geckoREgex.exec(line);
+	if (parts) {
+		if (parts[3] && parts[3].indexOf(" > eval") > -1) {
+			const subMatch = geckoEvalRegex.exec(parts[3]);
+			if (subMatch) {
+				parts[1] = parts[1] || "eval";
+				parts[3] = subMatch[1];
+				parts[4] = subMatch[2];
+				parts[5] = "";
+			}
+		}
+		let filename = parts[3];
+		let func = parts[1] || "?";
+		[func, filename] = extractSafariExtensionDetails(func, filename);
+		return createFrame(filename, func, parts[4] ? +parts[4] : void 0, parts[5] ? +parts[5] : void 0);
+	}
+};
+const defaultStackParser = createStackParser(...[chromeStackLineParser, [GECKO_PRIORITY, gecko]]);
+/**
+* Safari web extensions, starting version unknown, can produce "frames-only" stacktraces.
+* What it means, is that instead of format like:
+*
+* Error: wat
+*   at function@url:row:col
+*   at function@url:row:col
+*   at function@url:row:col
+*
+* it produces something like:
+*
+*   function@url:row:col
+*   function@url:row:col
+*   function@url:row:col
+*
+* Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.
+* This function is extracted so that we can use it in both places without duplicating the logic.
+* Unfortunately "just" changing RegExp is too complicated now and making it pass all tests
+* and fix this case seems like an impossible, or at least way too time-consuming task.
+*/
+const extractSafariExtensionDetails = (func, filename) => {
+	const isSafariExtension = func.indexOf("safari-extension") !== -1;
+	const isSafariWebExtension = func.indexOf("safari-web-extension") !== -1;
+	return isSafariExtension || isSafariWebExtension ? [func.indexOf("@") !== -1 ? func.split("@")[0] : "?", isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`] : [func, filename];
+};
+//#endregion
+export { BrowserClient, defaultStackParser, makeFetchTransport };
+
+//# sourceMappingURL=esm-DUNJOL6b.mjs.map