@atom8n/n8n-editor-ui 2.2.0

package/dist/assets/exports-Crx_gvt_.js

@@ -0,0 +1,1799 @@
+import { Dn as init_dist, En as global } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
+var DEBUG_BUILD = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
+var GLOBAL_OBJ = globalThis;
+var SDK_VERSION = "9.42.1";
+function getMainCarrier() {
+	getSentryCarrier(GLOBAL_OBJ);
+	return GLOBAL_OBJ;
+}
+function getSentryCarrier(carrier) {
+	const __SENTRY__ = carrier.__SENTRY__ = carrier.__SENTRY__ || {};
+	__SENTRY__.version = __SENTRY__.version || "9.42.1";
+	return __SENTRY__[SDK_VERSION] = __SENTRY__["9.42.1"] || {};
+}
+function getGlobalSingleton(name, creator, obj = GLOBAL_OBJ) {
+	const __SENTRY__ = obj.__SENTRY__ = obj.__SENTRY__ || {};
+	const carrier = __SENTRY__[SDK_VERSION] = __SENTRY__["9.42.1"] || {};
+	return carrier[name] || (carrier[name] = creator());
+}
+var CONSOLE_LEVELS = [
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"log",
+	"assert",
+	"trace"
+];
+var PREFIX = "Sentry Logger ";
+var originalConsoleMethods = {};
+function consoleSandbox(callback) {
+	if (!("console" in GLOBAL_OBJ)) return callback();
+	const console$1 = GLOBAL_OBJ.console;
+	const wrappedFuncs = {};
+	const wrappedLevels = Object.keys(originalConsoleMethods);
+	wrappedLevels.forEach((level) => {
+		const originalConsoleMethod = originalConsoleMethods[level];
+		wrappedFuncs[level] = console$1[level];
+		console$1[level] = originalConsoleMethod;
+	});
+	try {
+		return callback();
+	} finally {
+		wrappedLevels.forEach((level) => {
+			console$1[level] = wrappedFuncs[level];
+		});
+	}
+}
+function enable() {
+	_getLoggerSettings().enabled = true;
+}
+function disable() {
+	_getLoggerSettings().enabled = false;
+}
+function isEnabled() {
+	return _getLoggerSettings().enabled;
+}
+function log(...args) {
+	_maybeLog("log", ...args);
+}
+function warn(...args) {
+	_maybeLog("warn", ...args);
+}
+function error(...args) {
+	_maybeLog("error", ...args);
+}
+function _maybeLog(level, ...args) {
+	if (!DEBUG_BUILD) return;
+	if (isEnabled()) consoleSandbox(() => {
+		GLOBAL_OBJ.console[level](`${PREFIX}[${level}]:`, ...args);
+	});
+}
+function _getLoggerSettings() {
+	if (!DEBUG_BUILD) return { enabled: false };
+	return getGlobalSingleton("loggerSettings", () => ({ enabled: false }));
+}
+var debug = {
+	enable,
+	disable,
+	isEnabled,
+	log,
+	warn,
+	error
+};
+var STACKTRACE_FRAME_LIMIT = 50;
+var UNKNOWN_FUNCTION = "?";
+var WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+var STRIP_FRAME_REGEXP = /captureMessage|captureException/;
+function createStackParser(...parsers) {
+	const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map((p) => p[1]);
+	return (stack, skipFirstLines = 0, framesToPop = 0) => {
+		const frames = [];
+		const lines = stack.split("\n");
+		for (let i = skipFirstLines; i < lines.length; i++) {
+			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));
+	};
+}
+function stackParserFromStackParserOptions(stackParser) {
+	if (Array.isArray(stackParser)) return createStackParser(...stackParser);
+	return stackParser;
+}
+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] || {};
+}
+var defaultFunctionName = "<anonymous>";
+function getFunctionName(fn) {
+	try {
+		if (!fn || typeof fn !== "function") return defaultFunctionName;
+		return fn.name || defaultFunctionName;
+	} catch {
+		return defaultFunctionName;
+	}
+}
+function getFramesFromEvent(event) {
+	const exception = event.exception;
+	if (exception) {
+		const frames = [];
+		try {
+			exception.values.forEach((value) => {
+				if (value.stacktrace.frames) frames.push(...value.stacktrace.frames);
+			});
+			return frames;
+		} catch {
+			return;
+		}
+	}
+}
+var objectToString = Object.prototype.toString;
+function isError(wat) {
+	switch (objectToString.call(wat)) {
+		case "[object Error]":
+		case "[object Exception]":
+		case "[object DOMException]":
+		case "[object WebAssembly.Exception]": return true;
+		default: return isInstanceOf(wat, Error);
+	}
+}
+function isBuiltin(wat, className) {
+	return objectToString.call(wat) === `[object ${className}]`;
+}
+function isErrorEvent(wat) {
+	return isBuiltin(wat, "ErrorEvent");
+}
+function isDOMError(wat) {
+	return isBuiltin(wat, "DOMError");
+}
+function isDOMException(wat) {
+	return isBuiltin(wat, "DOMException");
+}
+function isString(wat) {
+	return isBuiltin(wat, "String");
+}
+function isParameterizedString(wat) {
+	return typeof wat === "object" && wat !== null && "__sentry_template_string__" in wat && "__sentry_template_values__" in wat;
+}
+function isPrimitive(wat) {
+	return wat === null || isParameterizedString(wat) || typeof wat !== "object" && typeof wat !== "function";
+}
+function isPlainObject(wat) {
+	return isBuiltin(wat, "Object");
+}
+function isEvent(wat) {
+	return typeof Event !== "undefined" && isInstanceOf(wat, Event);
+}
+function isElement(wat) {
+	return typeof Element !== "undefined" && isInstanceOf(wat, Element);
+}
+function isRegExp(wat) {
+	return isBuiltin(wat, "RegExp");
+}
+function isThenable(wat) {
+	return Boolean(wat?.then && typeof wat.then === "function");
+}
+function isSyntheticEvent(wat) {
+	return isPlainObject(wat) && "nativeEvent" in wat && "preventDefault" in wat && "stopPropagation" in wat;
+}
+function isInstanceOf(wat, base) {
+	try {
+		return wat instanceof base;
+	} catch {
+		return false;
+	}
+}
+function isVueViewModel(wat) {
+	return !!(typeof wat === "object" && wat !== null && (wat.__isVue || wat._isVue));
+}
+function isRequest(request) {
+	return typeof Request !== "undefined" && isInstanceOf(request, Request);
+}
+var WINDOW = GLOBAL_OBJ;
+var DEFAULT_MAX_STRING_LENGTH = 80;
+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>";
+	}
+}
+function _htmlElementAsString(el, keyAttrs) {
+	const elem = el;
+	const out = [];
+	if (!elem?.tagName) return "";
+	if (WINDOW.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("");
+}
+function getLocationHref() {
+	try {
+		return WINDOW.document.location.href;
+	} catch {
+		return "";
+	}
+}
+function getComponentName(elem) {
+	if (!WINDOW.HTMLElement) return null;
+	let currentElem = elem;
+	const MAX_TRAVERSE_HEIGHT = 5;
+	for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {
+		if (!currentElem) return null;
+		if (currentElem instanceof HTMLElement) {
+			if (currentElem.dataset["sentryComponent"]) return currentElem.dataset["sentryComponent"];
+			if (currentElem.dataset["sentryElement"]) return currentElem.dataset["sentryElement"];
+		}
+		currentElem = currentElem.parentNode;
+	}
+	return null;
+}
+function truncate(str, max = 0) {
+	if (typeof str !== "string" || max === 0) return str;
+	return str.length <= max ? str : `${str.slice(0, max)}...`;
+}
+function safeJoin(input, delimiter) {
+	if (!Array.isArray(input)) return "";
+	const output = [];
+	for (let i = 0; i < input.length; i++) {
+		const value = input[i];
+		try {
+			if (isVueViewModel(value)) output.push("[VueViewModel]");
+			else output.push(String(value));
+		} catch {
+			output.push("[value cannot be serialized]");
+		}
+	}
+	return output.join(delimiter);
+}
+function isMatchingPattern(value, pattern, requireExactStringMatch = false) {
+	if (!isString(value)) return false;
+	if (isRegExp(pattern)) return pattern.test(value);
+	if (isString(pattern)) return requireExactStringMatch ? value === pattern : value.includes(pattern);
+	return false;
+}
+function stringMatchesSomePattern(testString, patterns = [], requireExactStringMatch = false) {
+	return patterns.some((pattern) => isMatchingPattern(testString, pattern, requireExactStringMatch));
+}
+function fill(source, name, replacementFactory) {
+	if (!(name in source)) return;
+	const original = source[name];
+	if (typeof original !== "function") return;
+	const wrapped = replacementFactory(original);
+	if (typeof wrapped === "function") markFunctionWrapped(wrapped, original);
+	try {
+		source[name] = wrapped;
+	} catch {
+		DEBUG_BUILD && debug.log(`Failed to replace method "${name}" in object`, source);
+	}
+}
+function addNonEnumerableProperty(obj, name, value) {
+	try {
+		Object.defineProperty(obj, name, {
+			value,
+			writable: true,
+			configurable: true
+		});
+	} catch {
+		DEBUG_BUILD && debug.log(`Failed to add non-enumerable property "${name}" to object`, obj);
+	}
+}
+function markFunctionWrapped(wrapped, original) {
+	try {
+		wrapped.prototype = original.prototype = original.prototype || {};
+		addNonEnumerableProperty(wrapped, "__sentry_original__", original);
+	} catch {}
+}
+function getOriginalFunction(func) {
+	return func.__sentry_original__;
+}
+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;
+}
+function serializeEventTarget(target) {
+	try {
+		return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+	} catch {
+		return "<unknown>";
+	}
+}
+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 {};
+}
+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 "";
+}
+function getCrypto() {
+	const gbl = GLOBAL_OBJ;
+	return gbl.crypto || gbl.msCrypto;
+}
+function uuid4(crypto = getCrypto()) {
+	let getRandomByte = () => Math.random() * 16;
+	try {
+		if (crypto?.randomUUID) return crypto.randomUUID().replace(/-/g, "");
+		if (crypto?.getRandomValues) getRandomByte = () => {
+			const typedArray = 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];
+}
+function getEventDescription(event) {
+	const { message, event_id: eventId } = event;
+	if (message) return message;
+	const firstException = getFirstException(event);
+	if (firstException) {
+		if (firstException.type && firstException.value) return `${firstException.type}: ${firstException.value}`;
+		return firstException.type || firstException.value || eventId || "<unknown>";
+	}
+	return eventId || "<unknown>";
+}
+function addExceptionTypeValue(event, value, type) {
+	const exception = event.exception = event.exception || {};
+	const values = exception.values = exception.values || [];
+	const firstException = values[0] = values[0] || {};
+	if (!firstException.value) firstException.value = value || "";
+	if (!firstException.type) firstException.type = type || "Error";
+}
+function addExceptionMechanism(event, newMechanism) {
+	const firstException = getFirstException(event);
+	if (!firstException) return;
+	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;
+	}
+}
+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 {}
+}
+var ONE_SECOND_IN_MS = 1e3;
+function dateTimestampInSeconds() {
+	return Date.now() / ONE_SECOND_IN_MS;
+}
+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;
+	};
+}
+var _cachedTimestampInSeconds;
+function timestampInSeconds() {
+	return (_cachedTimestampInSeconds ?? (_cachedTimestampInSeconds = createUnixTimestampInSecondsFunc()))();
+}
+function makeSession(context) {
+	const startingTime = timestampInSeconds();
+	const session = {
+		sid: uuid4(),
+		init: true,
+		timestamp: startingTime,
+		started: startingTime,
+		duration: 0,
+		status: "ok",
+		errors: 0,
+		ignoreDuration: false,
+		toJSON: () => sessionToJSON(session)
+	};
+	if (context) updateSession(session, context);
+	return 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;
+}
+function closeSession(session, status) {
+	let context = {};
+	if (status) context = { status };
+	else if (session.status === "ok") context = { status: "exited" };
+	updateSession(session, context);
+}
+function sessionToJSON(session) {
+	return {
+		sid: `${session.sid}`,
+		init: session.init,
+		started: (/* @__PURE__ */ new Date(session.started * 1e3)).toISOString(),
+		timestamp: (/* @__PURE__ */ new Date(session.timestamp * 1e3)).toISOString(),
+		status: session.status,
+		errors: session.errors,
+		did: typeof session.did === "number" || typeof session.did === "string" ? `${session.did}` : void 0,
+		duration: session.duration,
+		abnormal_mechanism: session.abnormal_mechanism,
+		attrs: {
+			release: session.release,
+			environment: session.environment,
+			ip_address: session.ipAddress,
+			user_agent: session.userAgent
+		}
+	};
+}
+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;
+}
+function generateTraceId() {
+	return uuid4();
+}
+function generateSpanId() {
+	return uuid4().substring(16);
+}
+var SCOPE_SPAN_FIELD = "_sentrySpan";
+function _setSpanForScope(scope, span) {
+	if (span) addNonEnumerableProperty(scope, SCOPE_SPAN_FIELD, span);
+	else delete scope[SCOPE_SPAN_FIELD];
+}
+function _getSpanForScope(scope) {
+	return scope[SCOPE_SPAN_FIELD];
+}
+var DEFAULT_MAX_BREADCRUMBS = 100;
+var Scope = class Scope {
+	constructor() {
+		this._notifyingListeners = false;
+		this._scopeListeners = [];
+		this._eventProcessors = [];
+		this._breadcrumbs = [];
+		this._attachments = [];
+		this._user = {};
+		this._tags = {};
+		this._extra = {};
+		this._contexts = {};
+		this._sdkProcessingMetadata = {};
+		this._propagationContext = {
+			traceId: generateTraceId(),
+			sampleRand: Math.random()
+		};
+	}
+	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;
+	}
+	setClient(client) {
+		this._client = client;
+	}
+	setLastEventId(lastEventId) {
+		this._lastEventId = lastEventId;
+	}
+	getClient() {
+		return this._client;
+	}
+	lastEventId() {
+		return this._lastEventId;
+	}
+	addScopeListener(callback) {
+		this._scopeListeners.push(callback);
+	}
+	addEventProcessor(callback) {
+		this._eventProcessors.push(callback);
+		return this;
+	}
+	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;
+	}
+	getUser() {
+		return this._user;
+	}
+	setTags(tags) {
+		this._tags = {
+			...this._tags,
+			...tags
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	setTag(key, value) {
+		this._tags = {
+			...this._tags,
+			[key]: value
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	setExtras(extras) {
+		this._extra = {
+			...this._extra,
+			...extras
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	setExtra(key, extra) {
+		this._extra = {
+			...this._extra,
+			[key]: extra
+		};
+		this._notifyScopeListeners();
+		return this;
+	}
+	setFingerprint(fingerprint) {
+		this._fingerprint = fingerprint;
+		this._notifyScopeListeners();
+		return this;
+	}
+	setLevel(level) {
+		this._level = level;
+		this._notifyScopeListeners();
+		return this;
+	}
+	setTransactionName(name) {
+		this._transactionName = name;
+		this._notifyScopeListeners();
+		return this;
+	}
+	setContext(key, context) {
+		if (context === null) delete this._contexts[key];
+		else this._contexts[key] = context;
+		this._notifyScopeListeners();
+		return this;
+	}
+	setSession(session) {
+		if (!session) delete this._session;
+		else this._session = session;
+		this._notifyScopeListeners();
+		return this;
+	}
+	getSession() {
+		return this._session;
+	}
+	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;
+	}
+	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;
+	}
+	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;
+	}
+	getLastBreadcrumb() {
+		return this._breadcrumbs[this._breadcrumbs.length - 1];
+	}
+	clearBreadcrumbs() {
+		this._breadcrumbs = [];
+		this._notifyScopeListeners();
+		return this;
+	}
+	addAttachment(attachment) {
+		this._attachments.push(attachment);
+		return this;
+	}
+	clearAttachments() {
+		this._attachments = [];
+		return this;
+	}
+	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)
+		};
+	}
+	setSDKProcessingMetadata(newData) {
+		this._sdkProcessingMetadata = merge(this._sdkProcessingMetadata, newData, 2);
+		return this;
+	}
+	setPropagationContext(context) {
+		this._propagationContext = context;
+		return this;
+	}
+	getPropagationContext() {
+		return this._propagationContext;
+	}
+	captureException(exception, hint) {
+		const eventId = hint?.event_id || uuid4();
+		if (!this._client) {
+			DEBUG_BUILD && debug.warn("No client configured on scope - will not capture exception!");
+			return eventId;
+		}
+		const syntheticException = /* @__PURE__ */ new Error("Sentry syntheticException");
+		this._client.captureException(exception, {
+			originalException: exception,
+			syntheticException,
+			...hint,
+			event_id: eventId
+		}, this);
+		return eventId;
+	}
+	captureMessage(message, level, hint) {
+		const eventId = hint?.event_id || uuid4();
+		if (!this._client) {
+			DEBUG_BUILD && debug.warn("No client configured on scope - will not capture message!");
+			return eventId;
+		}
+		const syntheticException = new Error(message);
+		this._client.captureMessage(message, level, {
+			originalException: message,
+			syntheticException,
+			...hint,
+			event_id: eventId
+		}, this);
+		return eventId;
+	}
+	captureEvent(event, hint) {
+		const eventId = hint?.event_id || uuid4();
+		if (!this._client) {
+			DEBUG_BUILD && debug.warn("No client configured on scope - will not capture event!");
+			return eventId;
+		}
+		this._client.captureEvent(event, {
+			...hint,
+			event_id: eventId
+		}, this);
+		return eventId;
+	}
+	_notifyScopeListeners() {
+		if (!this._notifyingListeners) {
+			this._notifyingListeners = true;
+			this._scopeListeners.forEach((callback) => {
+				callback(this);
+			});
+			this._notifyingListeners = false;
+		}
+	}
+};
+function getDefaultCurrentScope() {
+	return getGlobalSingleton("defaultCurrentScope", () => new Scope());
+}
+function getDefaultIsolationScope() {
+	return getGlobalSingleton("defaultIsolationScope", () => new Scope());
+}
+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;
+	}
+	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;
+	}
+	getClient() {
+		return this.getStackTop().client;
+	}
+	getScope() {
+		return this.getStackTop().scope;
+	}
+	getIsolationScope() {
+		return this._isolationScope;
+	}
+	getStackTop() {
+		return this._stack[this._stack.length - 1];
+	}
+	_pushScope() {
+		const scope = this.getScope().clone();
+		this._stack.push({
+			client: this.getClient(),
+			scope
+		});
+		return scope;
+	}
+	_popScope() {
+		if (this._stack.length <= 1) return false;
+		return !!this._stack.pop();
+	}
+};
+function getAsyncContextStack() {
+	const sentry = getSentryCarrier(getMainCarrier());
+	return sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope());
+}
+function withScope$1(callback) {
+	return getAsyncContextStack().withScope(callback);
+}
+function withSetScope(scope, callback) {
+	const stack = getAsyncContextStack();
+	return stack.withScope(() => {
+		stack.getStackTop().scope = scope;
+		return callback(scope);
+	});
+}
+function withIsolationScope$1(callback) {
+	return getAsyncContextStack().withScope(() => {
+		return callback(getAsyncContextStack().getIsolationScope());
+	});
+}
+function getStackAsyncContextStrategy() {
+	return {
+		withIsolationScope: withIsolationScope$1,
+		withScope: withScope$1,
+		withSetScope,
+		withSetIsolationScope: (_isolationScope, callback) => {
+			return withIsolationScope$1(callback);
+		},
+		getCurrentScope: () => getAsyncContextStack().getScope(),
+		getIsolationScope: () => getAsyncContextStack().getIsolationScope()
+	};
+}
+function getAsyncContextStrategy(carrier) {
+	const sentry = getSentryCarrier(carrier);
+	if (sentry.acs) return sentry.acs;
+	return getStackAsyncContextStrategy();
+}
+function getCurrentScope() {
+	return getAsyncContextStrategy(getMainCarrier()).getCurrentScope();
+}
+function getIsolationScope() {
+	return getAsyncContextStrategy(getMainCarrier()).getIsolationScope();
+}
+function getGlobalScope() {
+	return getGlobalSingleton("globalScope", () => new Scope());
+}
+function withScope(...rest) {
+	const acs = getAsyncContextStrategy(getMainCarrier());
+	if (rest.length === 2) {
+		const [scope, callback] = rest;
+		if (!scope) return acs.withScope(callback);
+		return acs.withSetScope(scope, callback);
+	}
+	return acs.withScope(rest[0]);
+}
+function getClient() {
+	return getCurrentScope().getClient();
+}
+function getTraceContextFromScope(scope) {
+	const { traceId, parentSpanId, propagationSpanId } = scope.getPropagationContext();
+	const traceContext = {
+		trace_id: traceId,
+		span_id: propagationSpanId || generateSpanId()
+	};
+	if (parentSpanId) traceContext.parent_span_id = parentSpanId;
+	return traceContext;
+}
+var SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = "sentry.source";
+var SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = "sentry.sample_rate";
+var SEMANTIC_ATTRIBUTE_SENTRY_OP = "sentry.op";
+var SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = "sentry.origin";
+var SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT = "sentry.measurement_unit";
+var SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE = "sentry.measurement_value";
+var SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME = "sentry.custom_span_name";
+var SEMANTIC_ATTRIBUTE_PROFILE_ID = "sentry.profile_id";
+var SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME = "sentry.exclusive_time";
+var SCOPE_ON_START_SPAN_FIELD = "_sentryScope";
+var ISOLATION_SCOPE_ON_START_SPAN_FIELD = "_sentryIsolationScope";
+function setCapturedScopesOnSpan(span, scope, isolationScope) {
+	if (span) {
+		addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);
+		addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);
+	}
+}
+function getCapturedScopesOnSpan(span) {
+	return {
+		scope: span[SCOPE_ON_START_SPAN_FIELD],
+		isolationScope: span[ISOLATION_SCOPE_ON_START_SPAN_FIELD]
+	};
+}
+var SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;
+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;
+}
+function parseBaggageHeader(baggageHeader) {
+	if (!baggageHeader || !isString(baggageHeader) && !Array.isArray(baggageHeader)) return;
+	if (Array.isArray(baggageHeader)) return baggageHeader.reduce((acc, curr) => {
+		const currBaggageObject = baggageHeaderToObject(curr);
+		Object.entries(currBaggageObject).forEach(([key, value]) => {
+			acc[key] = value;
+		});
+		return acc;
+	}, {});
+	return baggageHeaderToObject(baggageHeader);
+}
+function baggageHeaderToObject(baggageHeader) {
+	return baggageHeader.split(",").map((baggageEntry) => baggageEntry.split("=").map((keyOrValue) => {
+		try {
+			return decodeURIComponent(keyOrValue.trim());
+		} catch {
+			return;
+		}
+	})).reduce((acc, [key, value]) => {
+		if (key && value) acc[key] = value;
+		return acc;
+	}, {});
+}
+var TRACE_FLAG_NONE = 0;
+var TRACE_FLAG_SAMPLED = 1;
+var hasShownSpanDropWarning = false;
+function spanToTransactionTraceContext(span) {
+	const { spanId: span_id, traceId: trace_id } = span.spanContext();
+	const { data, op, parent_span_id, status, origin, links } = spanToJSON(span);
+	return {
+		parent_span_id,
+		span_id,
+		trace_id,
+		data,
+		op,
+		status,
+		origin,
+		links
+	};
+}
+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
+	};
+}
+function convertSpanLinksForEnvelope(links) {
+	if (links && links.length > 0) return links.map(({ context: { spanId, traceId, traceFlags,...restContext }, attributes }) => ({
+		span_id: spanId,
+		trace_id: traceId,
+		sampled: traceFlags === 1,
+		attributes,
+		...restContext
+	}));
+	else return;
+}
+function spanTimeInputToSeconds(input) {
+	if (typeof input === "number") return ensureTimestampInSeconds(input);
+	if (Array.isArray(input)) return input[0] + input[1] / 1e9;
+	if (input instanceof Date) return ensureTimestampInSeconds(input.getTime());
+	return timestampInSeconds();
+}
+function ensureTimestampInSeconds(timestamp) {
+	return timestamp > 9999999999 ? timestamp / 1e3 : timestamp;
+}
+function 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;
+}
+function spanIsSentrySpan(span) {
+	return typeof span.getSpanJSON === "function";
+}
+function spanIsSampled(span) {
+	const { traceFlags } = span.spanContext();
+	return traceFlags === 1;
+}
+function getStatusMessage(status) {
+	if (!status || status.code === 0) return;
+	if (status.code === 1) return "ok";
+	return status.message || "unknown_error";
+}
+var CHILD_SPANS_FIELD = "_sentryChildSpans";
+var ROOT_SPAN_FIELD = "_sentryRootSpan";
+function addChildSpanToSpan(span, childSpan) {
+	addNonEnumerableProperty(childSpan, ROOT_SPAN_FIELD, span[ROOT_SPAN_FIELD] || span);
+	if (span[CHILD_SPANS_FIELD]) span[CHILD_SPANS_FIELD].add(childSpan);
+	else addNonEnumerableProperty(span, CHILD_SPANS_FIELD, new Set([childSpan]));
+}
+function getSpanDescendants(span) {
+	const resultSet = /* @__PURE__ */ new Set();
+	function addSpanChildren(span$1) {
+		if (resultSet.has(span$1)) return;
+		else if (spanIsSampled(span$1)) {
+			resultSet.add(span$1);
+			const childSpans = span$1[CHILD_SPANS_FIELD] ? Array.from(span$1[CHILD_SPANS_FIELD]) : [];
+			for (const childSpan of childSpans) addSpanChildren(childSpan);
+		}
+	}
+	addSpanChildren(span);
+	return Array.from(resultSet);
+}
+function getRootSpan(span) {
+	return span[ROOT_SPAN_FIELD] || span;
+}
+function getActiveSpan() {
+	const acs = getAsyncContextStrategy(getMainCarrier());
+	if (acs.getActiveSpan) return acs.getActiveSpan();
+	return _getSpanForScope(getCurrentScope());
+}
+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;
+	}
+}
+function hasSpansEnabled(maybeOptions) {
+	if (typeof __SENTRY_TRACING__ === "boolean" && !__SENTRY_TRACING__) return false;
+	const options = maybeOptions || getClient()?.getOptions();
+	return !!options && (options.tracesSampleRate != null || !!options.tracesSampler);
+}
+var DEFAULT_ENVIRONMENT = "production";
+var ORG_ID_REGEX = /^o(\d+)\./;
+var DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+function isValidProtocol(protocol) {
+	return protocol === "http" || protocol === "https";
+}
+function dsnToString(dsn, withPassword = false) {
+	const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
+	return `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ""}@${host}${port ? `:${port}` : ""}/${path ? `${path}/` : path}${projectId}`;
+}
+function dsnFromString(str) {
+	const match = DSN_REGEX.exec(str);
+	if (!match) {
+		consoleSandbox(() => {
+			console.error(`Invalid Sentry Dsn: ${str}`);
+		});
+		return;
+	}
+	const [protocol, publicKey, pass = "", host = "", port = "", lastPath = ""] = match.slice(1);
+	let path = "";
+	let projectId = lastPath;
+	const split = projectId.split("/");
+	if (split.length > 1) {
+		path = split.slice(0, -1).join("/");
+		projectId = split.pop();
+	}
+	if (projectId) {
+		const projectMatch = projectId.match(/^\d+/);
+		if (projectMatch) projectId = projectMatch[0];
+	}
+	return dsnFromComponents({
+		host,
+		pass,
+		path,
+		projectId,
+		port,
+		protocol,
+		publicKey
+	});
+}
+function dsnFromComponents(components) {
+	return {
+		protocol: components.protocol,
+		publicKey: components.publicKey || "",
+		pass: components.pass || "",
+		host: components.host,
+		port: components.port || "",
+		path: components.path || "",
+		projectId: components.projectId
+	};
+}
+function validateDsn(dsn) {
+	if (!DEBUG_BUILD) return true;
+	const { port, projectId, protocol } = dsn;
+	if ([
+		"protocol",
+		"publicKey",
+		"host",
+		"projectId"
+	].find((component) => {
+		if (!dsn[component]) {
+			debug.error(`Invalid Sentry Dsn: ${component} missing`);
+			return true;
+		}
+		return false;
+	})) return false;
+	if (!projectId.match(/^\d+$/)) {
+		debug.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+		return false;
+	}
+	if (!isValidProtocol(protocol)) {
+		debug.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+		return false;
+	}
+	if (port && isNaN(parseInt(port, 10))) {
+		debug.error(`Invalid Sentry Dsn: Invalid port ${port}`);
+		return false;
+	}
+	return true;
+}
+function extractOrgIdFromDsnHost(host) {
+	return host.match(ORG_ID_REGEX)?.[1];
+}
+function makeDsn(from) {
+	const components = typeof from === "string" ? dsnFromString(from) : dsnFromComponents(from);
+	if (!components || !validateDsn(components)) return;
+	return components;
+}
+var FROZEN_DSC_FIELD = "_frozenDsc";
+function freezeDscOnSpan(span, dsc) {
+	addNonEnumerableProperty(span, FROZEN_DSC_FIELD, dsc);
+}
+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;
+}
+function getDynamicSamplingContextFromScope(client, scope) {
+	const propagationContext = scope.getPropagationContext();
+	return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);
+}
+function getDynamicSamplingContextFromSpan(span) {
+	const client = getClient();
+	if (!client) return {};
+	const rootSpan = getRootSpan(span);
+	const rootSpanJson = 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$1) {
+		if (typeof rootSpanSampleRate === "number" || typeof rootSpanSampleRate === "string") dsc$1.sample_rate = `${rootSpanSampleRate}`;
+		return dsc$1;
+	}
+	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;
+}
+init_dist();
+function normalize(input, depth = 100, maxProperties = Infinity) {
+	try {
+		return visit("", input, depth, maxProperties);
+	} catch (err) {
+		return { ERROR: `**non-serializable** (${err})` };
+	}
+}
+function normalizeToSize(object, depth = 3, maxSize = 100 * 1024) {
+	const normalized = normalize(object, depth);
+	if (jsonSize(normalized) > maxSize) return normalizeToSize(object, depth - 1, maxSize);
+	return normalized;
+}
+function visit(key, value, depth = Infinity, maxProperties = Infinity, memo = memoBuilder()) {
+	const [memoize, unmemoize] = memo;
+	if (value == null || ["boolean", "string"].includes(typeof value) || typeof value === "number" && Number.isFinite(value)) return value;
+	const stringified = stringifyValue(key, value);
+	if (!stringified.startsWith("[object ")) return stringified;
+	if (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;
+}
+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";
+}
+function utf8Length(value) {
+	return ~-encodeURI(value).split(/%..|./).length;
+}
+function jsonSize(value) {
+	return utf8Length(JSON.stringify(value));
+}
+function memoBuilder() {
+	const inner = /* @__PURE__ */ new WeakSet();
+	function memoize(obj) {
+		if (inner.has(obj)) return true;
+		inner.add(obj);
+		return false;
+	}
+	function unmemoize(obj) {
+		inner.delete(obj);
+	}
+	return [memoize, unmemoize];
+}
+var STATE_PENDING = 0;
+var STATE_RESOLVED = 1;
+var STATE_REJECTED = 2;
+function resolvedSyncPromise(value) {
+	return new SyncPromise((resolve) => {
+		resolve(value);
+	});
+}
+function rejectedSyncPromise(reason) {
+	return new SyncPromise((_, reject) => {
+		reject(reason);
+	});
+}
+var SyncPromise = class SyncPromise {
+	constructor(executor) {
+		this._state = STATE_PENDING;
+		this._handlers = [];
+		this._runExecutor(executor);
+	}
+	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();
+		});
+	}
+	catch(onrejected) {
+		return this.then((val) => val, onrejected);
+	}
+	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);
+			});
+		});
+	}
+	_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;
+		});
+	}
+	_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);
+		}
+	}
+};
+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 && 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);
+		}
+	});
+}
+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);
+}
+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
+	};
+}
+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;
+}
+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;
+}
+var parsedStackResults;
+var lastKeysCount;
+var cachedFilenameDebugIds;
+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;
+}
+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;
+	});
+}
+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);
+}
+function applyDebugIds(event, stackParser) {
+	const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);
+	event.exception?.values?.forEach((exception) => {
+		exception.stacktrace?.frames?.forEach((frame) => {
+			if (frame.filename) frame.debug_id = filenameDebugIdMap[frame.filename];
+		});
+	});
+}
+function applyDebugMeta(event) {
+	const filenameDebugIdMap = {};
+	event.exception?.values?.forEach((exception) => {
+		exception.stacktrace?.frames?.forEach((frame) => {
+			if (frame.debug_id) {
+				if (frame.abs_path) filenameDebugIdMap[frame.abs_path] = frame.debug_id;
+				else if (frame.filename) filenameDebugIdMap[frame.filename] = frame.debug_id;
+				delete frame.debug_id;
+			}
+		});
+	});
+	if (Object.keys(filenameDebugIdMap).length === 0) return;
+	event.debug_meta = event.debug_meta || {};
+	event.debug_meta.images = event.debug_meta.images || [];
+	const images = event.debug_meta.images;
+	Object.entries(filenameDebugIdMap).forEach(([filename, debug_id]) => {
+		images.push({
+			type: "sourcemap",
+			code_file: filename,
+			debug_id
+		});
+	});
+}
+function applyIntegrationsMetadata(event, integrationNames) {
+	if (integrationNames.length > 0) {
+		event.sdk = event.sdk || {};
+		event.sdk.integrations = [...event.sdk.integrations || [], ...integrationNames];
+	}
+}
+function normalizeEvent(event, depth, maxBreadth) {
+	if (!event) return null;
+	const normalized = {
+		...event,
+		...event.breadcrumbs && { breadcrumbs: event.breadcrumbs.map((b) => ({
+			...b,
+			...b.data && { data: normalize(b.data, depth, maxBreadth) }
+		})) },
+		...event.user && { user: normalize(event.user, depth, maxBreadth) },
+		...event.contexts && { contexts: normalize(event.contexts, depth, maxBreadth) },
+		...event.extra && { extra: normalize(event.extra, depth, maxBreadth) }
+	};
+	if (event.contexts?.trace && normalized.contexts) {
+		normalized.contexts.trace = event.contexts.trace;
+		if (event.contexts.trace.data) normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);
+	}
+	if (event.spans) normalized.spans = event.spans.map((span) => {
+		return {
+			...span,
+			...span.data && { data: normalize(span.data, depth, maxBreadth) }
+		};
+	});
+	if (event.contexts?.flags && normalized.contexts) normalized.contexts.flags = normalize(event.contexts.flags, 3, maxBreadth);
+	return normalized;
+}
+function getFinalScope(scope, captureContext) {
+	if (!captureContext) return scope;
+	const finalScope = scope ? scope.clone() : new Scope();
+	finalScope.update(captureContext);
+	return finalScope;
+}
+function parseEventHintOrCaptureContext(hint) {
+	if (!hint) return;
+	if (hintIsScopeOrFunction(hint)) return { captureContext: hint };
+	if (hintIsScopeContext(hint)) return { captureContext: hint };
+	return hint;
+}
+function hintIsScopeOrFunction(hint) {
+	return hint instanceof Scope || typeof hint === "function";
+}
+var captureContextKeys = [
+	"user",
+	"level",
+	"extra",
+	"contexts",
+	"tags",
+	"fingerprint",
+	"propagationContext"
+];
+function hintIsScopeContext(hint) {
+	return Object.keys(hint).some((key) => captureContextKeys.includes(key));
+}
+function captureException(exception, hint) {
+	return getCurrentScope().captureException(exception, parseEventHintOrCaptureContext(hint));
+}
+function captureMessage(message, captureContext) {
+	const level = typeof captureContext === "string" ? captureContext : void 0;
+	const context = typeof captureContext !== "string" ? { captureContext } : void 0;
+	return getCurrentScope().captureMessage(message, level, context);
+}
+function captureEvent(event, hint) {
+	return getCurrentScope().captureEvent(event, hint);
+}
+function setTag(key, value) {
+	getIsolationScope().setTag(key, value);
+}
+function startSession(context) {
+	const isolationScope = getIsolationScope();
+	const currentScope = getCurrentScope();
+	const { userAgent } = GLOBAL_OBJ.navigator || {};
+	const session = makeSession({
+		user: currentScope.getUser() || isolationScope.getUser(),
+		...userAgent && { userAgent },
+		...context
+	});
+	const currentSession = isolationScope.getSession();
+	if (currentSession?.status === "ok") updateSession(currentSession, { status: "exited" });
+	endSession();
+	isolationScope.setSession(session);
+	return session;
+}
+function endSession() {
+	const isolationScope = getIsolationScope();
+	const session = getCurrentScope().getSession() || isolationScope.getSession();
+	if (session) closeSession(session);
+	_sendSessionUpdate();
+	isolationScope.setSession();
+}
+function _sendSessionUpdate() {
+	const isolationScope = getIsolationScope();
+	const client = getClient();
+	const session = isolationScope.getSession();
+	if (session && client) client.captureSession(session);
+}
+function captureSession(end = false) {
+	if (end) {
+		endSession();
+		return;
+	}
+	_sendSessionUpdate();
+}
+export { generateTraceId as $, spanTimeInputToSeconds as A, isThenable as At, SEMANTIC_ATTRIBUTE_SENTRY_OP as B, getGlobalSingleton as Bt, convertSpanLinksForEnvelope as C, isEvent as Ct, getStatusMessage as D, isPrimitive as Dt, getSpanDescendants as E, isPlainObject as Et, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME as F, stackParserFromStackParserOptions as Ft, getCurrentScope as G, DEBUG_BUILD as Gt, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE as H, getSentryCarrier as Ht, SEMANTIC_ATTRIBUTE_PROFILE_ID as I, CONSOLE_LEVELS as It, withScope as J, getIsolationScope as K, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME as L, consoleSandbox as Lt, spanToTransactionTraceContext as M, createStackParser as Mt, getCapturedScopesOnSpan as N, getFramesFromEvent as Nt, showSpanDropWarning as O, isRequest as Ot, setCapturedScopesOnSpan as P, getFunctionName as Pt, generateSpanId as Q, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT as R, debug as Rt, addChildSpanToSpan as S, isErrorEvent as St, getRootSpan as T, isParameterizedString as Tt, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE as U, SDK_VERSION as Ut, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN as V, getMainCarrier as Vt, getClient as W, GLOBAL_OBJ as Wt, _getSpanForScope as X, getAsyncContextStrategy as Y, _setSpanForScope as Z, makeDsn as _, getLocationHref as _t, setTag as a, addExceptionTypeValue as at, TRACE_FLAG_NONE as b, isDOMException as bt, SyncPromise as c, uuid4 as ct, normalize as d, fill as dt, merge as et, normalizeToSize as f, getOriginalFunction as ft, dsnToString as g, getComponentName as gt, getDynamicSamplingContextFromSpan as h, stringMatchesSomePattern as ht, captureSession as i, addExceptionMechanism as it, spanToJSON as j, UNKNOWN_FUNCTION as jt, spanIsSampled as k, isString as kt, rejectedSyncPromise as l, addNonEnumerableProperty as lt, getDynamicSamplingContextFromScope as m, safeJoin as mt, captureException as n, dateTimestampInSeconds as nt, startSession as o, checkOrSetAlreadyCaught as ot, freezeDscOnSpan as p, markFunctionWrapped as pt, getTraceContextFromScope as q, captureMessage as r, timestampInSeconds as rt, prepareEvent as s, getEventDescription as st, captureEvent as t, updateSession as tt, resolvedSyncPromise as u, extractExceptionKeysForMessage as ut, DEFAULT_ENVIRONMENT as v, htmlTreeAsString as vt, getActiveSpan as w, isInstanceOf as wt, TRACE_FLAG_SAMPLED as x, isError as xt, hasSpansEnabled as y, isDOMError as yt, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE as z, originalConsoleMethods as zt };