@8wave/ai-elements 0.103.0-beta.4 → 0.103.0-beta.5

package/dist/_chunks/browser-DuzNfJq0.js

@@ -0,0 +1,3272 @@
+//#region ../../node_modules/.pnpm/@opentelemetry+semantic-conventions@1.43.0/node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
+var e = "error.type", t = "exception.message", n = "exception.type", r = "service.name", i = "telemetry.sdk.language", a = "webjs", o = "telemetry.sdk.name", s = "telemetry.sdk.version", c = "url.full", l = "1.9.1", u = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+function ee(e) {
+	let t = /* @__PURE__ */ new Set([e]), n = /* @__PURE__ */ new Set(), r = e.match(u);
+	if (!r) return () => !1;
+	let i = {
+		major: +r[1],
+		minor: +r[2],
+		patch: +r[3],
+		prerelease: r[4]
+	};
+	if (i.prerelease != null) return function(t) {
+		return t === e;
+	};
+	function a(e) {
+		return n.add(e), !1;
+	}
+	function o(e) {
+		return t.add(e), !0;
+	}
+	return function(e) {
+		if (t.has(e)) return !0;
+		if (n.has(e)) return !1;
+		let r = e.match(u);
+		if (!r) return a(e);
+		let s = {
+			major: +r[1],
+			minor: +r[2],
+			patch: +r[3],
+			prerelease: r[4]
+		};
+		return s.prerelease != null || i.major !== s.major ? a(e) : i.major === 0 ? i.minor === s.minor && i.patch <= s.patch ? o(e) : a(e) : i.minor <= s.minor ? o(e) : a(e);
+	};
+}
+var d = ee(l), te = l.split(".")[0], f = Symbol.for(`opentelemetry.js.api.${te}`), p = typeof globalThis == "object" ? globalThis : typeof self == "object" ? self : typeof window == "object" ? window : typeof global == "object" ? global : {};
+function m(e, t, n, r = !1) {
+	let i = p[f] = p[f] ?? { version: l };
+	if (!r && i[e]) {
+		let t = /* @__PURE__ */ Error(`@opentelemetry/api: Attempted duplicate registration of API: ${e}`);
+		return n.error(t.stack || t.message), !1;
+	}
+	if (i.version !== "1.9.1") {
+		let t = /* @__PURE__ */ Error(`@opentelemetry/api: Registration of version v${i.version} for ${e} does not match previously registered API v${l}`);
+		return n.error(t.stack || t.message), !1;
+	}
+	return i[e] = t, n.debug(`@opentelemetry/api: Registered a global for ${e} v${l}.`), !0;
+}
+function h(e) {
+	let t = p[f]?.version;
+	if (!(!t || !d(t))) return p[f]?.[e];
+}
+function g(e, t) {
+	t.debug(`@opentelemetry/api: Unregistering a global for ${e} v${l}.`);
+	let n = p[f];
+	n && delete n[e];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+var ne = class {
+	constructor(e) {
+		this._namespace = e.namespace || "DiagComponentLogger";
+	}
+	debug(...e) {
+		return _("debug", this._namespace, e);
+	}
+	error(...e) {
+		return _("error", this._namespace, e);
+	}
+	info(...e) {
+		return _("info", this._namespace, e);
+	}
+	warn(...e) {
+		return _("warn", this._namespace, e);
+	}
+	verbose(...e) {
+		return _("verbose", this._namespace, e);
+	}
+};
+function _(e, t, n) {
+	let r = h("diag");
+	if (r) return r[e](t, ...n);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/types.js
+var v;
+(function(e) {
+	e[e.NONE = 0] = "NONE", e[e.ERROR = 30] = "ERROR", e[e.WARN = 50] = "WARN", e[e.INFO = 60] = "INFO", e[e.DEBUG = 70] = "DEBUG", e[e.VERBOSE = 80] = "VERBOSE", e[e.ALL = 9999] = "ALL";
+})(v ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function re(e, t) {
+	e < v.NONE ? e = v.NONE : e > v.ALL && (e = v.ALL), t ||= {};
+	function n(n, r) {
+		let i = t[n];
+		return typeof i == "function" && e >= r ? i.bind(t) : function() {};
+	}
+	return {
+		error: n("error", v.ERROR),
+		warn: n("warn", v.WARN),
+		info: n("info", v.INFO),
+		debug: n("debug", v.DEBUG),
+		verbose: n("verbose", v.VERBOSE)
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/diag.js
+var ie = "diag", y = class e {
+	static instance() {
+		return this._instance ||= new e(), this._instance;
+	}
+	constructor() {
+		function e(e) {
+			return function(...t) {
+				let n = h("diag");
+				if (n) return n[e](...t);
+			};
+		}
+		let t = this;
+		t.setLogger = (e, n = { logLevel: v.INFO }) => {
+			if (e === t) {
+				let e = /* @__PURE__ */ Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+				return t.error(e.stack ?? e.message), !1;
+			}
+			typeof n == "number" && (n = { logLevel: n });
+			let r = h("diag"), i = re(n.logLevel ?? v.INFO, e);
+			if (r && !n.suppressOverrideMessage) {
+				let e = (/* @__PURE__ */ Error()).stack ?? "<failed to generate stacktrace>";
+				r.warn(`Current logger will be overwritten from ${e}`), i.warn(`Current logger will overwrite one already registered from ${e}`);
+			}
+			return m("diag", i, t, !0);
+		}, t.disable = () => {
+			g(ie, t);
+		}, t.createComponentLogger = (e) => new ne(e), t.verbose = e("verbose"), t.debug = e("debug"), t.info = e("info"), t.warn = e("warn"), t.error = e("error");
+	}
+}, ae = class e {
+	constructor(e) {
+		this._entries = e ? new Map(e) : /* @__PURE__ */ new Map();
+	}
+	getEntry(e) {
+		let t = this._entries.get(e);
+		if (t) return Object.assign({}, t);
+	}
+	getAllEntries() {
+		return Array.from(this._entries.entries());
+	}
+	setEntry(t, n) {
+		let r = new e(this._entries);
+		return r._entries.set(t, n), r;
+	}
+	removeEntry(t) {
+		let n = new e(this._entries);
+		return n._entries.delete(t), n;
+	}
+	removeEntries(...t) {
+		let n = new e(this._entries);
+		for (let e of t) n._entries.delete(e);
+		return n;
+	}
+	clear() {
+		return new e();
+	}
+}, oe = Symbol("BaggageEntryMetadata"), se = y.instance();
+function ce(e = {}) {
+	return new ae(new Map(Object.entries(e)));
+}
+function le(e) {
+	return typeof e != "string" && (se.error(`Cannot create baggage metadata from unknown type: ${typeof e}`), e = ""), {
+		__TYPE__: oe,
+		toString() {
+			return e;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/context.js
+function ue(e) {
+	return Symbol.for(e);
+}
+var b = new class e {
+	constructor(t) {
+		let n = this;
+		n._currentContext = t ? new Map(t) : /* @__PURE__ */ new Map(), n.getValue = (e) => n._currentContext.get(e), n.setValue = (t, r) => {
+			let i = new e(n._currentContext);
+			return i._currentContext.set(t, r), i;
+		}, n.deleteValue = (t) => {
+			let r = new e(n._currentContext);
+			return r._currentContext.delete(t), r;
+		};
+	}
+}(), de = class {
+	constructor() {}
+	createGauge(e, t) {
+		return Ce;
+	}
+	createHistogram(e, t) {
+		return we;
+	}
+	createCounter(e, t) {
+		return Se;
+	}
+	createUpDownCounter(e, t) {
+		return Te;
+	}
+	createObservableGauge(e, t) {
+		return De;
+	}
+	createObservableCounter(e, t) {
+		return Ee;
+	}
+	createObservableUpDownCounter(e, t) {
+		return Oe;
+	}
+	addBatchObservableCallback(e, t) {}
+	removeBatchObservableCallback(e) {}
+}, fe = class {}, pe = class extends fe {
+	add(e, t) {}
+}, me = class extends fe {
+	add(e, t) {}
+}, he = class extends fe {
+	record(e, t) {}
+}, ge = class extends fe {
+	record(e, t) {}
+}, _e = class {
+	addCallback(e) {}
+	removeCallback(e) {}
+}, ve = class extends _e {}, ye = class extends _e {}, be = class extends _e {}, xe = new de(), Se = new pe(), Ce = new he(), we = new ge(), Te = new me(), Ee = new ve(), De = new ye(), Oe = new be();
+function ke() {
+	return xe;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
+var Ae = {
+	get(e, t) {
+		if (e != null) return e[t];
+	},
+	keys(e) {
+		return e == null ? [] : Object.keys(e);
+	}
+}, je = { set(e, t, n) {
+	e != null && (e[t] = n);
+} }, Me = class {
+	active() {
+		return b;
+	}
+	with(e, t, n, ...r) {
+		return t.call(n, ...r);
+	}
+	bind(e, t) {
+		return t;
+	}
+	enable() {
+		return this;
+	}
+	disable() {
+		return this;
+	}
+}, Ne = "context", Pe = new Me(), x = class e {
+	constructor() {}
+	static getInstance() {
+		return this._instance ||= new e(), this._instance;
+	}
+	setGlobalContextManager(e) {
+		return m(Ne, e, y.instance());
+	}
+	active() {
+		return this._getContextManager().active();
+	}
+	with(e, t, n, ...r) {
+		return this._getContextManager().with(e, t, n, ...r);
+	}
+	bind(e, t) {
+		return this._getContextManager().bind(e, t);
+	}
+	_getContextManager() {
+		return h(Ne) || Pe;
+	}
+	disable() {
+		this._getContextManager().disable(), g(Ne, y.instance());
+	}
+}, S;
+(function(e) {
+	e[e.NONE = 0] = "NONE", e[e.SAMPLED = 1] = "SAMPLED";
+})(S ||= {});
+var Fe = {
+	traceId: "00000000000000000000000000000000",
+	spanId: "0000000000000000",
+	traceFlags: S.NONE
+}, C = class {
+	constructor(e = Fe) {
+		this._spanContext = e;
+	}
+	spanContext() {
+		return this._spanContext;
+	}
+	setAttribute(e, t) {
+		return this;
+	}
+	setAttributes(e) {
+		return this;
+	}
+	addEvent(e, t) {
+		return this;
+	}
+	addLink(e) {
+		return this;
+	}
+	addLinks(e) {
+		return this;
+	}
+	setStatus(e) {
+		return this;
+	}
+	updateName(e) {
+		return this;
+	}
+	end(e) {}
+	isRecording() {
+		return !1;
+	}
+	recordException(e, t) {}
+}, Ie = ue("OpenTelemetry Context Key SPAN");
+function Le(e) {
+	return e.getValue(Ie) || void 0;
+}
+function Re() {
+	return Le(x.getInstance().active());
+}
+function ze(e, t) {
+	return e.setValue(Ie, t);
+}
+function Be(e) {
+	return e.deleteValue(Ie);
+}
+function Ve(e, t) {
+	return ze(e, new C(t));
+}
+function He(e) {
+	return Le(e)?.spanContext();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+var Ue = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1
+]);
+function We(e, t) {
+	if (typeof e != "string" || e.length !== t) return !1;
+	let n = 0;
+	for (let t = 0; t < e.length; t += 4) n += (Ue[e.charCodeAt(t)] | 0) + (Ue[e.charCodeAt(t + 1)] | 0) + (Ue[e.charCodeAt(t + 2)] | 0) + (Ue[e.charCodeAt(t + 3)] | 0);
+	return n === t;
+}
+function Ge(e) {
+	return We(e, 32) && e !== "00000000000000000000000000000000";
+}
+function Ke(e) {
+	return We(e, 16) && e !== "0000000000000000";
+}
+function qe(e) {
+	return Ge(e.traceId) && Ke(e.spanId);
+}
+function Je(e) {
+	return new C(e);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+var Ye = x.getInstance(), Xe = class {
+	startSpan(e, t, n = Ye.active()) {
+		if (t?.root) return new C();
+		let r = n && He(n);
+		return Ze(r) && qe(r) ? new C(r) : new C();
+	}
+	startActiveSpan(e, t, n, r) {
+		let i, a, o;
+		if (arguments.length < 2) return;
+		arguments.length === 2 ? o = t : arguments.length === 3 ? (i = t, o = n) : (i = t, a = n, o = r);
+		let s = a ?? Ye.active(), c = this.startSpan(e, i, s), l = ze(s, c);
+		return Ye.with(l, o, void 0, c);
+	}
+};
+function Ze(e) {
+	return typeof e == "object" && !!e && "spanId" in e && typeof e.spanId == "string" && "traceId" in e && typeof e.traceId == "string" && "traceFlags" in e && typeof e.traceFlags == "number";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+var Qe = new Xe(), $e = class {
+	constructor(e, t, n, r) {
+		this._provider = e, this.name = t, this.version = n, this.options = r;
+	}
+	startSpan(e, t, n) {
+		return this._getTracer().startSpan(e, t, n);
+	}
+	startActiveSpan(e, t, n, r) {
+		let i = this._getTracer();
+		return Reflect.apply(i.startActiveSpan, i, arguments);
+	}
+	_getTracer() {
+		if (this._delegate) return this._delegate;
+		let e = this._provider.getDelegateTracer(this.name, this.version, this.options);
+		return e ? (this._delegate = e, this._delegate) : Qe;
+	}
+}, et = new class {
+	getTracer(e, t, n) {
+		return new Xe();
+	}
+}(), tt = class {
+	getTracer(e, t, n) {
+		return this.getDelegateTracer(e, t, n) ?? new $e(this, e, t, n);
+	}
+	getDelegate() {
+		return this._delegate ?? et;
+	}
+	setDelegate(e) {
+		this._delegate = e;
+	}
+	getDelegateTracer(e, t, n) {
+		return this._delegate?.getTracer(e, t, n);
+	}
+}, nt;
+(function(e) {
+	e[e.NOT_RECORD = 0] = "NOT_RECORD", e[e.RECORD = 1] = "RECORD", e[e.RECORD_AND_SAMPLED = 2] = "RECORD_AND_SAMPLED";
+})(nt ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+var rt;
+(function(e) {
+	e[e.INTERNAL = 0] = "INTERNAL", e[e.SERVER = 1] = "SERVER", e[e.CLIENT = 2] = "CLIENT", e[e.PRODUCER = 3] = "PRODUCER", e[e.CONSUMER = 4] = "CONSUMER";
+})(rt ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/status.js
+var w;
+(function(e) {
+	e[e.UNSET = 0] = "UNSET", e[e.OK = 1] = "OK", e[e.ERROR = 2] = "ERROR";
+})(w ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context-api.js
+var T = x.getInstance(), E = y.instance(), it = new class {
+	getMeter(e, t, n) {
+		return xe;
+	}
+}(), at = "metrics", ot = class e {
+	constructor() {}
+	static getInstance() {
+		return this._instance ||= new e(), this._instance;
+	}
+	setGlobalMeterProvider(e) {
+		return m(at, e, y.instance());
+	}
+	getMeterProvider() {
+		return h(at) || it;
+	}
+	getMeter(e, t, n) {
+		return this.getMeterProvider().getMeter(e, t, n);
+	}
+	disable() {
+		g(at, y.instance());
+	}
+}.getInstance(), st = class {
+	inject(e, t) {}
+	extract(e, t) {
+		return e;
+	}
+	fields() {
+		return [];
+	}
+}, ct = ue("OpenTelemetry Baggage Key");
+function lt(e) {
+	return e.getValue(ct) || void 0;
+}
+function ut() {
+	return lt(x.getInstance().active());
+}
+function dt(e, t) {
+	return e.setValue(ct, t);
+}
+function ft(e) {
+	return e.deleteValue(ct);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/propagation.js
+var pt = "propagation", mt = new st(), D = class e {
+	constructor() {
+		this.createBaggage = ce, this.getBaggage = lt, this.getActiveBaggage = ut, this.setBaggage = dt, this.deleteBaggage = ft;
+	}
+	static getInstance() {
+		return this._instance ||= new e(), this._instance;
+	}
+	setGlobalPropagator(e) {
+		return m(pt, e, y.instance());
+	}
+	inject(e, t, n = je) {
+		return this._getGlobalPropagator().inject(e, t, n);
+	}
+	extract(e, t, n = Ae) {
+		return this._getGlobalPropagator().extract(e, t, n);
+	}
+	fields() {
+		return this._getGlobalPropagator().fields();
+	}
+	disable() {
+		g(pt, y.instance());
+	}
+	_getGlobalPropagator() {
+		return h(pt) || mt;
+	}
+}.getInstance(), ht = "trace", O = class e {
+	constructor() {
+		this._proxyTracerProvider = new tt(), this.wrapSpanContext = Je, this.isSpanContextValid = qe, this.deleteSpan = Be, this.getSpan = Le, this.getActiveSpan = Re, this.getSpanContext = He, this.setSpan = ze, this.setSpanContext = Ve;
+	}
+	static getInstance() {
+		return this._instance ||= new e(), this._instance;
+	}
+	setGlobalTracerProvider(e) {
+		let t = m(ht, this._proxyTracerProvider, y.instance());
+		return t && this._proxyTracerProvider.setDelegate(e), t;
+	}
+	getTracerProvider() {
+		return h(ht) || this._proxyTracerProvider;
+	}
+	getTracer(e, t) {
+		return this.getTracerProvider().getTracer(e, t);
+	}
+	disable() {
+		g(ht, y.instance()), this._proxyTracerProvider = new tt();
+	}
+}.getInstance(), gt = ue("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function _t(e) {
+	return e.setValue(gt, !0);
+}
+function vt(e) {
+	return e.getValue(gt) === !0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var yt = "baggage", bt = 4096;
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+function xt(e) {
+	return e.reduce((e, t) => {
+		let n = `${e}${e === "" ? "" : ","}${t}`;
+		return n.length > 8192 ? e : n;
+	}, "");
+}
+function St(e) {
+	return e.getAllEntries().map(([e, t]) => {
+		let n = `${encodeURIComponent(e)}=${encodeURIComponent(t.value)}`;
+		return t.metadata !== void 0 && (n += ";" + t.metadata.toString()), n;
+	});
+}
+function Ct(e) {
+	if (!e) return;
+	let t = e.indexOf(";"), n = t === -1 ? e : e.substring(0, t), r = n.indexOf("=");
+	if (r <= 0) return;
+	let i = n.substring(0, r).trim(), a = n.substring(r + 1).trim();
+	if (!i || !a) return;
+	let o, s;
+	try {
+		o = decodeURIComponent(i), s = decodeURIComponent(a);
+	} catch {
+		return;
+	}
+	let c;
+	return t !== -1 && t < e.length - 1 && (c = le(e.substring(t + 1))), {
+		key: o,
+		value: s,
+		metadata: c
+	};
+}
+function wt(e, t, n, r) {
+	let i = 0;
+	for (; i < e.length && n < 180;) {
+		let a = e.indexOf(",", i), o = a === -1 ? e.length : a, s = o - i;
+		if (s <= 4096) {
+			let a = Ct(e.substring(i, o));
+			if (a) {
+				let e = (n === 0 ? 0 : 1) + s;
+				if (r + e > 8192) break;
+				t[a.key] = a.metadata ? {
+					value: a.value,
+					metadata: a.metadata
+				} : { value: a.value }, n++, r += e;
+			}
+		}
+		if (a === -1) break;
+		i = a + 1;
+	}
+	return [n, r];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
+var Tt = class {
+	inject(e, t, n) {
+		let r = D.getBaggage(e);
+		if (!r || vt(e)) return;
+		let i = xt(St(r).filter((e) => e.length <= bt).slice(0, 180));
+		i.length > 0 && n.set(t, yt, i);
+	}
+	extract(e, t, n) {
+		let r = n.get(t, yt);
+		if (!r) return e;
+		let i = {}, a = 0, o = 0;
+		if (Array.isArray(r)) for (let e = 0; e < r.length; e++) [a, o] = wt(r[e], i, a, o);
+		else [a] = wt(r, i, a, o);
+		return a === 0 ? e : D.setBaggage(e, D.createBaggage(i));
+	}
+	fields() {
+		return [yt];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/common/attributes.js
+function k(e) {
+	let t = {};
+	if (typeof e != "object" || !e) return t;
+	for (let n in e) {
+		if (!Object.prototype.hasOwnProperty.call(e, n)) continue;
+		if (!Et(n)) {
+			E.warn(`Invalid attribute key: ${n}`);
+			continue;
+		}
+		let r = e[n];
+		if (!Dt(r)) {
+			E.warn(`Invalid attribute value set for key: ${n}`);
+			continue;
+		}
+		t[n] = Array.isArray(r) ? r.slice() : r;
+	}
+	return t;
+}
+function Et(e) {
+	return typeof e == "string" && e !== "";
+}
+function Dt(e) {
+	return e == null ? !0 : Array.isArray(e) ? Ot(e) : kt(typeof e);
+}
+function Ot(e) {
+	let t;
+	for (let n of e) {
+		if (n == null) continue;
+		let e = typeof n;
+		if (e !== t) {
+			if (!t) {
+				if (kt(e)) {
+					t = e;
+					continue;
+				}
+				return !1;
+			}
+			return !1;
+		}
+	}
+	return !0;
+}
+function kt(e) {
+	switch (e) {
+		case "number":
+		case "boolean":
+		case "string": return !0;
+	}
+	return !1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+function At() {
+	return (e) => {
+		E.error(jt(e));
+	};
+}
+function jt(e) {
+	return typeof e == "string" ? e : JSON.stringify(Mt(e));
+}
+function Mt(e) {
+	let t = {}, n = e;
+	for (; n !== null;) Object.getOwnPropertyNames(n).forEach((e) => {
+		if (t[e]) return;
+		let r = n[e];
+		r && (t[e] = String(r));
+	}), n = Object.getPrototypeOf(n);
+	return t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+var Nt = At();
+function A(e) {
+	try {
+		Nt(e);
+	} catch {}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/version.js
+var Pt = "2.10.0", Ft = "process.runtime.name", It = {
+	[o]: "opentelemetry",
+	[Ft]: "browser",
+	[i]: a,
+	[s]: Pt
+}, j = performance, Lt = 9, Rt = 10 ** 6, zt = 10 ** Lt;
+function M(e) {
+	let t = e / 1e3;
+	return [Math.trunc(t), Math.round(e % 1e3 * Rt)];
+}
+function N(e) {
+	return Wt(M(j.timeOrigin), M(typeof e == "number" ? e : j.now()));
+}
+function P(e) {
+	if (Ht(e)) return e;
+	if (typeof e == "number") return e < j.timeOrigin / 2 ? N(e) : M(e);
+	if (e instanceof Date) return M(e.getTime());
+	throw TypeError("Invalid input type");
+}
+function Bt(e, t) {
+	let n = t[0] - e[0], r = t[1] - e[1];
+	return r < 0 && (--n, r += zt), [n, r];
+}
+function F(e) {
+	return e[0] * zt + e[1];
+}
+function Vt(e) {
+	return e[0] * 1e3 + e[1] / 1e6;
+}
+function Ht(e) {
+	return Array.isArray(e) && e.length === 2 && typeof e[0] == "number" && typeof e[1] == "number";
+}
+function Ut(e) {
+	return Ht(e) || typeof e == "number" || e instanceof Date;
+}
+function Wt(e, t) {
+	let n = [e[0] + t[0], e[1] + t[1]];
+	return n[1] >= zt && (n[1] -= zt, n[0] += 1), n;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var I;
+(function(e) {
+	e[e.SUCCESS = 0] = "SUCCESS", e[e.FAILED = 1] = "FAILED";
+})(I ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/propagation/composite.js
+var Gt = class {
+	_propagators;
+	_fields;
+	constructor(e = {}) {
+		this._propagators = e.propagators ?? [];
+		let t = /* @__PURE__ */ new Set();
+		for (let e of this._propagators) {
+			let n = typeof e.fields == "function" ? e.fields() : [];
+			for (let e of n) t.add(e);
+		}
+		this._fields = Array.from(t);
+	}
+	inject(e, t, n) {
+		for (let r of this._propagators) try {
+			r.inject(e, t, n);
+		} catch (e) {
+			E.warn(`Failed to inject with ${r.constructor.name}. Err: ${e.message}`);
+		}
+	}
+	extract(e, t, n) {
+		return this._propagators.reduce((e, r) => {
+			try {
+				return r.extract(e, t, n);
+			} catch (e) {
+				E.warn(`Failed to extract with ${r.constructor.name}. Err: ${e.message}`);
+			}
+			return e;
+		}, e);
+	}
+	fields() {
+		return this._fields.slice();
+	}
+}, Kt = "[_0-9a-z-*/]", qt = RegExp(`^(?:${`[a-z]${Kt}{0,255}`}|${`[a-z0-9]${Kt}{0,240}@[a-z]${Kt}{0,13}`})$`), Jt = /^[ -~]{0,255}[!-~]$/, Yt = /,|=/;
+function Xt(e) {
+	return qt.test(e);
+}
+function Zt(e) {
+	return Jt.test(e) && !Yt.test(e);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/trace/TraceState.js
+var Qt = 32, $t = 512, en = ",", tn = "=", nn = class e {
+	_length;
+	_rawTraceState;
+	_internalState;
+	constructor(e) {
+		this._rawTraceState = typeof e == "string" ? e : "", this._length = this._rawTraceState.length;
+	}
+	set(e, t) {
+		if (!Xt(e) || !Zt(t)) return this;
+		let n = this._getState(), r = n.get(e), i = this._length;
+		if (i += typeof r == "string" ? t.length - r.length : e.length + t.length + (n.size > 0 ? 2 : 1), i > $t) return this;
+		let a = new Map(n);
+		return a.delete(e), a.set(e, t), this._fromState(a, i);
+	}
+	unset(e) {
+		let t = this._getState(), n = t.get(e);
+		if (typeof n != "string") return this;
+		let r = this._length - (e.length + n.length + 1);
+		t.size > 1 && --r;
+		let i = new Map(t);
+		return i.delete(e), this._fromState(i, r);
+	}
+	get(e) {
+		return this._getState().get(e);
+	}
+	serialize() {
+		let e = "", t = 0;
+		for (let n of this._getState()) t > 0 && (e = en + e), e = `${n[0]}${tn}${n[1]}` + e, t++;
+		return e;
+	}
+	_getState() {
+		if (this._internalState) return this._internalState;
+		let e = this._rawTraceState.split(en), t = /* @__PURE__ */ new Map(), n = 0;
+		for (let r of e) {
+			let e = r.trim(), i = e.indexOf(tn);
+			if (i === -1) continue;
+			let a = e.slice(0, i), o = e.slice(i + 1);
+			if (!Xt(a) || !Zt(o)) continue;
+			let s = n + e.length + +(t.size > 0);
+			if (!(s > $t) && (t.set(a, o), n = s, t.size >= Qt)) break;
+		}
+		return this._length = n, this._internalState = new Map(Array.from(t.entries()).reverse()), this._internalState;
+	}
+	_fromState(t, n) {
+		let r = Object.create(e.prototype);
+		return r._internalState = t, r._length = n, r;
+	}
+}, rn = "traceparent", an = "tracestate", on = "00", sn = /* @__PURE__ */ RegExp("^\\s?((?!ff)[\\da-f]{2})-((?![0]{32})[\\da-f]{32})-((?![0]{16})[\\da-f]{16})-([\\da-f]{2})(-.*)?\\s?$");
+function cn(e) {
+	let t = sn.exec(e);
+	return !t || t[1] === "00" && t[5] ? null : {
+		traceId: t[2],
+		spanId: t[3],
+		traceFlags: parseInt(t[4], 16)
+	};
+}
+var ln = class {
+	inject(e, t, n) {
+		let r = O.getSpanContext(e);
+		if (!r || vt(e) || !qe(r)) return;
+		let i = `${on}-${r.traceId}-${r.spanId}-0${Number(r.traceFlags || S.NONE).toString(16)}`;
+		n.set(t, rn, i), r.traceState && n.set(t, an, r.traceState.serialize());
+	}
+	extract(e, t, n) {
+		let r = n.get(t, rn);
+		if (!r) return e;
+		let i = Array.isArray(r) ? r[0] : r;
+		if (typeof i != "string") return e;
+		let a = cn(i);
+		if (!a) return e;
+		a.isRemote = !0;
+		let o = n.get(t, an);
+		if (o) {
+			let e = Array.isArray(o) ? o.join(",") : o;
+			a.traceState = new nn(typeof e == "string" ? e : void 0);
+		}
+		return O.setSpanContext(e, a);
+	}
+	fields() {
+		return [rn, an];
+	}
+}, un = "[object Object]", dn = "[object Null]", fn = "[object Undefined]", pn = Function.prototype.toString, mn = pn.call(Object), hn = Object.getPrototypeOf, gn = Object.prototype, _n = gn.hasOwnProperty, L = Symbol ? Symbol.toStringTag : void 0, vn = gn.toString;
+function yn(e) {
+	if (!bn(e) || xn(e) !== un) return !1;
+	let t = hn(e);
+	if (t === null) return !0;
+	let n = _n.call(t, "constructor") && t.constructor;
+	return typeof n == "function" && n instanceof n && pn.call(n) === mn;
+}
+function bn(e) {
+	return typeof e == "object" && !!e;
+}
+function xn(e) {
+	return e == null ? e === void 0 ? fn : dn : L && L in Object(e) ? Sn(e) : Cn(e);
+}
+function Sn(e) {
+	let t = _n.call(e, L), n = e[L], r = !1;
+	try {
+		e[L] = void 0, r = !0;
+	} catch {}
+	let i = vn.call(e);
+	return r && (t ? e[L] = n : delete e[L]), i;
+}
+function Cn(e) {
+	return vn.call(e);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/utils/merge.js
+var wn = 20;
+function Tn(...e) {
+	let t = e.shift(), n = /* @__PURE__ */ new WeakMap();
+	for (; e.length > 0;) t = Dn(t, e.shift(), 0, n);
+	return t;
+}
+function En(e) {
+	return kn(e) ? e.slice() : e;
+}
+function Dn(e, t, n = 0, r) {
+	let i;
+	if (!(n > wn)) {
+		if (n++, jn(e) || jn(t) || An(t)) i = En(t);
+		else if (kn(e)) {
+			if (i = e.slice(), kn(t)) for (let e = 0, n = t.length; e < n; e++) i.push(En(t[e]));
+			else if (R(t)) {
+				let e = Object.keys(t);
+				for (let n = 0, r = e.length; n < r; n++) {
+					let r = e[n];
+					r !== "__proto__" && r !== "constructor" && r !== "prototype" && (i[r] = En(t[r]));
+				}
+			}
+		} else if (R(e)) {
+			if (R(t)) {
+				if (!Mn(e, t)) return t;
+				i = Object.assign({}, e);
+				let a = Object.keys(t);
+				for (let o = 0, s = a.length; o < s; o++) {
+					let s = a[o];
+					if (s === "__proto__" || s === "constructor" || s === "prototype") continue;
+					let c = t[s];
+					if (jn(c)) c === void 0 ? delete i[s] : i[s] = c;
+					else {
+						let a = i[s], o = c;
+						if (On(e, s, r) || On(t, s, r)) delete i[s];
+						else {
+							if (R(a) && R(o)) {
+								let n = r.get(a) || [], i = r.get(o) || [];
+								n.push({
+									obj: e,
+									key: s
+								}), i.push({
+									obj: t,
+									key: s
+								}), r.set(a, n), r.set(o, i);
+							}
+							i[s] = Dn(i[s], c, n, r);
+						}
+					}
+				}
+			} else i = t;
+		}
+		return i;
+	}
+}
+function On(e, t, n) {
+	let r = n.get(e[t]) || [];
+	for (let n = 0, i = r.length; n < i; n++) {
+		let i = r[n];
+		if (i.key === t && i.obj === e) return !0;
+	}
+	return !1;
+}
+function kn(e) {
+	return Array.isArray(e);
+}
+function An(e) {
+	return typeof e == "function";
+}
+function R(e) {
+	return !jn(e) && !kn(e) && !An(e) && typeof e == "object";
+}
+function jn(e) {
+	return typeof e == "string" || typeof e == "number" || typeof e == "boolean" || e === void 0 || e instanceof Date || e instanceof RegExp || e === null;
+}
+function Mn(e, t) {
+	return !(!yn(e) || !yn(t));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/utils/url.js
+function Nn(e, t) {
+	return typeof t == "string" ? e === t : !!e.match(t);
+}
+function Pn(e, t) {
+	if (!t) return !1;
+	for (let n of t) if (Nn(e, n)) return !0;
+	return !1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+core@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Fn = class {
+	_promise;
+	_resolve;
+	_reject;
+	constructor() {
+		this._promise = new Promise((e, t) => {
+			this._resolve = e, this._reject = t;
+		});
+	}
+	get promise() {
+		return this._promise;
+	}
+	resolve(e) {
+		this._resolve(e);
+	}
+	reject(e) {
+		this._reject(e);
+	}
+}, In = class {
+	_isCalled = !1;
+	_deferred = new Fn();
+	_callback;
+	_that;
+	constructor(e, t) {
+		this._callback = e, this._that = t;
+	}
+	get isCalled() {
+		return this._isCalled;
+	}
+	get promise() {
+		return this._deferred.promise;
+	}
+	call(...e) {
+		if (!this._isCalled) {
+			this._isCalled = !0;
+			try {
+				Promise.resolve(this._callback.call(this._that, ...e)).then((e) => this._deferred.resolve(e), (e) => this._deferred.reject(e));
+			} catch (e) {
+				this._deferred.reject(e);
+			}
+		}
+		return this._deferred.promise;
+	}
+}, Ln;
+function Rn() {
+	if (Ln === void 0) try {
+		let e = globalThis.process.argv0;
+		Ln = e ? `unknown_service:${e}` : "unknown_service";
+	} catch {
+		Ln = "unknown_service";
+	}
+	return Ln;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+resources@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/resources/build/esm/utils.js
+var z = (e) => typeof e == "object" && !!e && typeof e.then == "function", zn = class e {
+	_rawAttributes;
+	_asyncAttributesPending = !1;
+	_schemaUrl;
+	_memoizedAttributes;
+	static FromAttributeList(t, n) {
+		let r = new e({}, n);
+		return r._rawAttributes = Hn(t), r._asyncAttributesPending = t.filter(([e, t]) => z(t)).length > 0, r;
+	}
+	constructor(e, t) {
+		let n = e.attributes ?? {};
+		this._rawAttributes = Object.entries(n).map(([e, t]) => (z(t) && (this._asyncAttributesPending = !0), [e, t])), this._rawAttributes = Hn(this._rawAttributes), this._schemaUrl = Un(t?.schemaUrl);
+	}
+	get asyncAttributesPending() {
+		return this._asyncAttributesPending;
+	}
+	async waitForAsyncAttributes() {
+		if (this.asyncAttributesPending) {
+			for (let e = 0; e < this._rawAttributes.length; e++) {
+				let [t, n] = this._rawAttributes[e];
+				this._rawAttributes[e] = [t, z(n) ? await n : n];
+			}
+			this._asyncAttributesPending = !1;
+		}
+	}
+	get attributes() {
+		if (this.asyncAttributesPending && E.error("Accessing resource attributes before async attributes settled"), this._memoizedAttributes) return this._memoizedAttributes;
+		let e = {};
+		for (let [t, n] of this._rawAttributes) {
+			if (z(n)) {
+				E.debug(`Unsettled resource attribute ${t} skipped`);
+				continue;
+			}
+			n != null && (e[t] ??= n);
+		}
+		return this._asyncAttributesPending || (this._memoizedAttributes = e), e;
+	}
+	getRawAttributes() {
+		return this._rawAttributes;
+	}
+	get schemaUrl() {
+		return this._schemaUrl;
+	}
+	merge(t) {
+		if (t == null) return this;
+		let n = Wn(this, t), r = n ? { schemaUrl: n } : void 0;
+		return e.FromAttributeList([...t.getRawAttributes(), ...this.getRawAttributes()], r);
+	}
+};
+function Bn(e, t) {
+	return zn.FromAttributeList(Object.entries(e), t);
+}
+function Vn() {
+	return Bn({
+		[r]: Rn(),
+		[i]: It[i],
+		[o]: It[o],
+		[s]: It[s]
+	});
+}
+function Hn(e) {
+	return e.map(([e, t]) => z(t) ? [e, t.catch((t) => {
+		E.debug("promise rejection for resource attribute: %s - %s", e, t);
+	})] : [e, t]);
+}
+function Un(e) {
+	if (typeof e == "string" || e === void 0) return e;
+	E.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", e);
+}
+function Wn(e, t) {
+	let n = e?.schemaUrl, r = t?.schemaUrl, i = n === void 0 || n === "", a = r === void 0 || r === "";
+	if (i) return r;
+	if (a || n === r) return n;
+	E.warn("Schema URL merge conflict: old resource has \"%s\", updating resource has \"%s\". Resulting resource will have undefined Schema URL.", n, r);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace/build/esm/enums.js
+var Gn = "exception", Kn = Symbol.for("nodejs.util.inspect.custom");
+function qn(e) {
+	let t = {};
+	for (let [n, r] of e.getRawAttributes()) typeof r?.then != "function" && r != null && (t[n] ??= r);
+	return t;
+}
+function Jn(e, t, n, r, i) {
+	if (typeof n == "number" && n < 0) {
+		let t = `[${e}]`;
+		return r?.stylize ? r.stylize(t, "special") : t;
+	}
+	return typeof i != "function" || !r ? t : `${e} ${i(t, {
+		...r,
+		depth: r.depth == null ? r.depth : r.depth - 1
+	})}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace/build/esm/Span.js
+var Yn = class {
+	_spanContext;
+	kind;
+	parentSpanContext;
+	attributes = {};
+	links = [];
+	events = [];
+	startTime;
+	resource;
+	instrumentationScope;
+	_droppedAttributesCount = 0;
+	_droppedEventsCount = 0;
+	_droppedLinksCount = 0;
+	_attributesCount = 0;
+	name;
+	status = { code: w.UNSET };
+	endTime = [0, 0];
+	_ended = !1;
+	_duration = [-1, -1];
+	_spanProcessor;
+	_spanLimits;
+	_attributeValueLengthLimit;
+	_recordEndMetrics;
+	_performanceStartTime;
+	_performanceOffset;
+	_startTimeProvided;
+	constructor(e) {
+		let t = Date.now();
+		if (this._spanContext = e.spanContext, this._performanceStartTime = j.now(), this._performanceOffset = t - (this._performanceStartTime + j.timeOrigin), this._startTimeProvided = e.startTime != null, this._spanLimits = e.spanLimits, this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit ?? 0, this._spanProcessor = e.spanProcessor, this.name = e.name, this.parentSpanContext = e.parentSpanContext, this.kind = e.kind, e.links) for (let t of e.links) this.addLink(t);
+		this.startTime = this._getTime(e.startTime ?? t), this.resource = e.resource, this.instrumentationScope = e.scope, this._recordEndMetrics = e.recordEndMetrics, e.attributes != null && this.setAttributes(e.attributes), this._spanProcessor.onStart(this, e.context);
+	}
+	spanContext() {
+		return this._spanContext;
+	}
+	setAttribute(e, t) {
+		if (t == null || this._isSpanEnded()) return this;
+		if (e.length === 0) return E.warn(`Invalid attribute key: ${e}`), this;
+		if (!Dt(t)) return E.warn(`Invalid attribute value set for key: ${e}`), this;
+		let { attributeCountLimit: n } = this._spanLimits, r = !Object.prototype.hasOwnProperty.call(this.attributes, e);
+		return n !== void 0 && this._attributesCount >= n && r ? (this._droppedAttributesCount++, this) : (this.attributes[e] = this._truncateToSize(t), r && this._attributesCount++, this);
+	}
+	setAttributes(e) {
+		for (let t in e) Object.prototype.hasOwnProperty.call(e, t) && this.setAttribute(t, e[t]);
+		return this;
+	}
+	addEvent(e, t, n) {
+		if (this._isSpanEnded()) return this;
+		let { eventCountLimit: r } = this._spanLimits;
+		if (r === 0) return E.warn("No events allowed."), this._droppedEventsCount++, this;
+		r !== void 0 && this.events.length >= r && (this._droppedEventsCount === 0 && E.debug("Dropping extra events."), this.events.shift(), this._droppedEventsCount++), Ut(t) && (Ut(n) || (n = t), t = void 0);
+		let i = k(t), { attributePerEventCountLimit: a } = this._spanLimits, o = {}, s = 0, c = 0;
+		for (let e in i) {
+			if (!Object.prototype.hasOwnProperty.call(i, e)) continue;
+			let t = i[e];
+			if (a !== void 0 && c >= a) {
+				s++;
+				continue;
+			}
+			o[e] = this._truncateToSize(t), c++;
+		}
+		return this.events.push({
+			name: e,
+			attributes: o,
+			time: this._getTime(n),
+			droppedAttributesCount: s
+		}), this;
+	}
+	addLink(e) {
+		if (this._isSpanEnded()) return this;
+		let { linkCountLimit: t } = this._spanLimits;
+		if (t === 0) return this._droppedLinksCount++, this;
+		t !== void 0 && this.links.length >= t && (this._droppedLinksCount === 0 && E.debug("Dropping extra links."), this.links.shift(), this._droppedLinksCount++);
+		let { attributePerLinkCountLimit: n } = this._spanLimits, r = k(e.attributes), i = {}, a = 0, o = 0;
+		for (let e in r) {
+			if (!Object.prototype.hasOwnProperty.call(r, e)) continue;
+			let t = r[e];
+			if (n !== void 0 && o >= n) {
+				a++;
+				continue;
+			}
+			i[e] = this._truncateToSize(t), o++;
+		}
+		let s = { context: e.context };
+		return o > 0 && (s.attributes = i), a > 0 && (s.droppedAttributesCount = a), this.links.push(s), this;
+	}
+	addLinks(e) {
+		for (let t of e) this.addLink(t);
+		return this;
+	}
+	setStatus(e) {
+		if (this._isSpanEnded() || e.code === w.UNSET || this.status.code === w.OK) return this;
+		let t = { code: e.code };
+		return e.code === w.ERROR && (typeof e.message == "string" ? t.message = e.message : e.message != null && E.warn(`Dropping invalid status.message of type '${typeof e.message}', expected 'string'`)), this.status = t, this;
+	}
+	updateName(e) {
+		return this._isSpanEnded() || (this.name = e), this;
+	}
+	end(e) {
+		if (this._isSpanEnded()) {
+			E.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
+			return;
+		}
+		this.endTime = this._getTime(e), this._duration = Bt(this.startTime, this.endTime), this._duration[0] < 0 && (E.warn("Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.", this.startTime, this.endTime), this.endTime = this.startTime.slice(), this._duration = [0, 0]), this._droppedEventsCount > 0 && E.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`), this._droppedLinksCount > 0 && E.warn(`Dropped ${this._droppedLinksCount} links because linkCountLimit reached`), this._spanProcessor.onEnding && this._spanProcessor.onEnding(this), this._recordEndMetrics?.(), this._ended = !0, this._spanProcessor.onEnd(this);
+	}
+	_getTime(e) {
+		if (typeof e == "number" && e <= j.now()) return N(e + this._performanceOffset);
+		if (typeof e == "number") return M(e);
+		if (e instanceof Date) return M(e.getTime());
+		if (Ht(e)) return e;
+		if (this._startTimeProvided) return M(Date.now());
+		let t = j.now() - this._performanceStartTime;
+		return Wt(this.startTime, M(t));
+	}
+	isRecording() {
+		return this._ended === !1;
+	}
+	recordException(e, r) {
+		let i = {};
+		typeof e == "string" ? i[t] = e : e && (e.code ? i[n] = e.code.toString() : e.name && (i[n] = e.name), e.message && (i[t] = e.message), e.stack && (i["exception.stacktrace"] = e.stack)), i["exception.type"] || i["exception.message"] ? this.addEvent(Gn, i, r) : E.warn(`Failed to record an exception ${e}`);
+	}
+	get duration() {
+		return this._duration;
+	}
+	get ended() {
+		return this._ended;
+	}
+	get droppedAttributesCount() {
+		return this._droppedAttributesCount;
+	}
+	get droppedEventsCount() {
+		return this._droppedEventsCount;
+	}
+	get droppedLinksCount() {
+		return this._droppedLinksCount;
+	}
+	_isSpanEnded() {
+		if (this._ended) {
+			let e = /* @__PURE__ */ Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
+			E.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, e);
+		}
+		return this._ended;
+	}
+	_truncateToLimitUtil(e, t) {
+		return e.length <= t ? e : e.substring(0, t);
+	}
+	_truncateToSize(e) {
+		let t = this._attributeValueLengthLimit;
+		return t <= 0 ? (E.warn(`Attribute value limit must be positive, got ${t}`), e) : typeof e == "string" ? this._truncateToLimitUtil(e, t) : Array.isArray(e) ? e.map((e) => typeof e == "string" ? this._truncateToLimitUtil(e, t) : e) : e;
+	}
+	[Kn](e, t, n) {
+		return Jn("SpanImpl", {
+			name: this.name,
+			kind: this.kind,
+			spanContext: this._spanContext,
+			parentSpanContext: this.parentSpanContext,
+			status: this.status,
+			startTime: this.startTime,
+			endTime: this.endTime,
+			duration: this._duration,
+			ended: this._ended,
+			attributes: this.attributes,
+			events: this.events,
+			links: this.links,
+			droppedAttributesCount: this._droppedAttributesCount,
+			droppedEventsCount: this._droppedEventsCount,
+			droppedLinksCount: this._droppedLinksCount,
+			instrumentationScope: this.instrumentationScope,
+			resource: { attributes: qn(this.resource) }
+		}, e, t, n);
+	}
+}, B;
+(function(e) {
+	e[e.NOT_RECORD = 0] = "NOT_RECORD", e[e.RECORD = 1] = "RECORD", e[e.RECORD_AND_SAMPLED = 2] = "RECORD_AND_SAMPLED";
+})(B ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace/build/esm/semconv.js
+var Xn = "otel.component.name", Zn = "otel.component.type", Qn = "otel.span.parent.origin", $n = "otel.span.sampling_result", er = "otel.sdk.processor.span.processed", tr = "otel.sdk.processor.span.queue.capacity", nr = "otel.sdk.processor.span.queue.size", rr = "otel.sdk.span.live", ir = "otel.sdk.span.started", ar = "batching_span_processor", or = class {
+	startedSpans;
+	liveSpans;
+	constructor(e) {
+		this.startedSpans = e.createCounter(ir, {
+			unit: "{span}",
+			description: "The number of created spans."
+		}), this.liveSpans = e.createUpDownCounter(rr, {
+			unit: "{span}",
+			description: "The number of currently live spans."
+		});
+	}
+	startSpan(e, t) {
+		let n = cr(t);
+		if (this.startedSpans.add(1, {
+			[Qn]: sr(e),
+			[$n]: n
+		}), t === B.NOT_RECORD) return () => {};
+		let r = { [$n]: n };
+		return this.liveSpans.add(1, r), () => {
+			this.liveSpans.add(-1, r);
+		};
+	}
+};
+function sr(e) {
+	return e ? e.isRemote ? "remote" : "local" : "none";
+}
+function cr(e) {
+	switch (e) {
+		case B.RECORD_AND_SAMPLED: return "RECORD_AND_SAMPLE";
+		case B.RECORD: return "RECORD_ONLY";
+		case B.NOT_RECORD: return "DROP";
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace/build/esm/version.js
+var lr = "2.10.0", ur = class {
+	_sampler;
+	_spanLimits;
+	_idGenerator;
+	instrumentationScope;
+	_resource;
+	_spanProcessor;
+	_tracerMetrics;
+	constructor(e, t) {
+		this.instrumentationScope = e, this._sampler = t.sampler, this._spanLimits = t.spanLimits, this._resource = t.resource, this._idGenerator = t.idGenerator, this._spanProcessor = t.spanProcessor;
+		let n = t.meterProvider.getMeter("@opentelemetry/sdk-trace", lr);
+		this._tracerMetrics = new or(n);
+	}
+	startSpan(e, t = {}, n = T.active()) {
+		t.root && (n = O.deleteSpan(n));
+		let r = O.getSpan(n);
+		if (vt(n)) return E.debug("Instrumentation suppressed, returning Noop Span"), O.wrapSpanContext(Fe);
+		let i = r?.spanContext(), a = this._idGenerator.generateSpanId(), o, s, c;
+		!i || !O.isSpanContextValid(i) ? s = this._idGenerator.generateTraceId() : (s = i.traceId, c = i.traceState, o = i);
+		let l = t.kind ?? rt.INTERNAL, u = (t.links ?? []).map((e) => ({
+			context: e.context,
+			attributes: k(e.attributes)
+		})), ee = k(t.attributes), d = this._sampler.shouldSample(n, s, e, l, ee, u), te = this._tracerMetrics.startSpan(i, d.decision);
+		c = d.traceState ?? c;
+		let f = d.decision === nt.RECORD_AND_SAMPLED ? S.SAMPLED : S.NONE, p = {
+			traceId: s,
+			spanId: a,
+			traceFlags: f,
+			traceState: c
+		};
+		if (d.decision === nt.NOT_RECORD) return E.debug("Recording is off, propagating context in a non-recording span"), O.wrapSpanContext(p);
+		let m = k(Object.assign(ee, d.attributes));
+		return new Yn({
+			resource: this._resource,
+			scope: this.instrumentationScope,
+			context: n,
+			spanContext: p,
+			name: e,
+			kind: l,
+			links: u,
+			parentSpanContext: o,
+			attributes: m,
+			startTime: t.startTime,
+			spanProcessor: this._spanProcessor,
+			spanLimits: this._spanLimits,
+			recordEndMetrics: te
+		});
+	}
+	startActiveSpan(e, t, n, r) {
+		let i, a, o;
+		if (arguments.length < 2) return;
+		arguments.length === 2 ? o = t : arguments.length === 3 ? (i = t, o = n) : (i = t, a = n, o = r);
+		let s = a ?? T.active(), c = this.startSpan(e, i, s), l = O.setSpan(s, c);
+		return T.with(l, o, void 0, c);
+	}
+	[Kn](e, t, n) {
+		return Jn("Tracer", {
+			instrumentationScope: this.instrumentationScope,
+			resource: { attributes: qn(this._resource) },
+			spanLimits: this._spanLimits
+		}, e, t, n);
+	}
+}, dr = class {
+	_spanProcessors;
+	constructor(e) {
+		this._spanProcessors = e;
+	}
+	forceFlush() {
+		let e = [];
+		for (let t of this._spanProcessors) e.push(t.forceFlush());
+		return new Promise((t) => {
+			Promise.all(e).then(() => {
+				t();
+			}).catch((e) => {
+				A(e || /* @__PURE__ */ Error("MultiSpanProcessor: forceFlush failed")), t();
+			});
+		});
+	}
+	onStart(e, t) {
+		for (let n of this._spanProcessors) n.onStart(e, t);
+	}
+	onEnding(e) {
+		for (let t of this._spanProcessors) t.onEnding && t.onEnding(e);
+	}
+	onEnd(e) {
+		for (let t of this._spanProcessors) t.onEnd(e);
+	}
+	shutdown() {
+		let e = [];
+		for (let t of this._spanProcessors) e.push(t.shutdown());
+		return new Promise((t, n) => {
+			Promise.all(e).then(() => {
+				t();
+			}, n);
+		});
+	}
+}, fr = class {
+	shouldSample() {
+		return { decision: B.NOT_RECORD };
+	}
+	toString() {
+		return "AlwaysOffSampler";
+	}
+}, V = class {
+	shouldSample() {
+		return { decision: B.RECORD_AND_SAMPLED };
+	}
+	toString() {
+		return "AlwaysOnSampler";
+	}
+}, H = class {
+	_root;
+	_remoteParentSampled;
+	_remoteParentNotSampled;
+	_localParentSampled;
+	_localParentNotSampled;
+	constructor(e) {
+		this._root = e.root, this._root ||= (A(/* @__PURE__ */ Error("ParentBasedSampler must have a root sampler configured")), new V()), this._remoteParentSampled = e.remoteParentSampled ?? new V(), this._remoteParentNotSampled = e.remoteParentNotSampled ?? new fr(), this._localParentSampled = e.localParentSampled ?? new V(), this._localParentNotSampled = e.localParentNotSampled ?? new fr();
+	}
+	shouldSample(e, t, n, r, i, a) {
+		let o = O.getSpanContext(e);
+		return !o || !qe(o) ? this._root.shouldSample(e, t, n, r, i, a) : o.isRemote ? o.traceFlags & S.SAMPLED ? this._remoteParentSampled.shouldSample(e, t, n, r, i, a) : this._remoteParentNotSampled.shouldSample(e, t, n, r, i, a) : o.traceFlags & S.SAMPLED ? this._localParentSampled.shouldSample(e, t, n, r, i, a) : this._localParentNotSampled.shouldSample(e, t, n, r, i, a);
+	}
+	toString() {
+		return `ParentBased{root=${this._root.toString()}, remoteParentSampled=${this._remoteParentSampled.toString()}, remoteParentNotSampled=${this._remoteParentNotSampled.toString()}, localParentSampled=${this._localParentSampled.toString()}, localParentNotSampled=${this._localParentNotSampled.toString()}}`;
+	}
+}, pr = /* @__PURE__ */ new Map(), mr = class {
+	processedSpans;
+	queueSize;
+	queueSizeCallback;
+	standardAttrs;
+	droppedAttrs;
+	constructor(t, n, r) {
+		let i = pr.get(t) ?? 0;
+		if (pr.set(t, i + 1), this.standardAttrs = {
+			[Zn]: t,
+			[Xn]: `${t}/${i}`
+		}, this.droppedAttrs = {
+			...this.standardAttrs,
+			[e]: "queue_full"
+		}, this.processedSpans = n.createCounter(er, {
+			unit: "{span}",
+			description: "The number of spans for which the processing has finished, either successful or failed."
+		}), r) {
+			let { capacity: e, getQueueSize: t } = r;
+			n.createUpDownCounter(tr, {
+				unit: "{span}",
+				description: "The maximum number of spans the queue of a given instance of an SDK span processor can hold."
+			}).add(e, this.standardAttrs), this.queueSize = n.createObservableUpDownCounter(nr, {
+				unit: "{span}",
+				description: "The number of spans in the queue of a given instance of an SDK span processor."
+			}), this.queueSizeCallback = (e) => e.observe(t(), this.standardAttrs), this.queueSize.addCallback(this.queueSizeCallback);
+		}
+	}
+	dropSpans(e) {
+		this.processedSpans.add(e, this.droppedAttrs);
+	}
+	finishSpans(t, n) {
+		if (!n) {
+			this.processedSpans.add(t, this.standardAttrs);
+			return;
+		}
+		let r = {
+			...this.standardAttrs,
+			[e]: n.name
+		};
+		this.processedSpans.add(t, r);
+	}
+	shutdown() {
+		this.queueSize && this.queueSizeCallback && this.queueSize.removeCallback(this.queueSizeCallback);
+	}
+}, hr = class {
+	_maxExportBatchSize;
+	_maxQueueSize;
+	_scheduledDelayMillis;
+	_exportTimeoutMillis;
+	_exporter;
+	_metrics;
+	_isExporting = !1;
+	_finishedSpans = [];
+	_timer;
+	_shutdownOnce;
+	_droppedSpansCount = 0;
+	constructor(e) {
+		this._exporter = e.exporter, this._maxExportBatchSize = e.maxExportBatchSize ?? 512, this._maxQueueSize = e.maxQueueSize ?? 2048, this._scheduledDelayMillis = e.scheduledDelayMillis ?? 5e3, this._exportTimeoutMillis = e.exportTimeoutMillis ?? 3e4, this._shutdownOnce = new In(this._shutdown, this), this._maxExportBatchSize > this._maxQueueSize && (E.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize"), this._maxExportBatchSize = this._maxQueueSize);
+		let t = e.selfObsMeterProvider ? e.selfObsMeterProvider.getMeter("@opentelemetry/sdk-trace") : ke();
+		this._metrics = new mr(ar, t, {
+			capacity: this._maxQueueSize,
+			getQueueSize: () => this._finishedSpans.length
+		});
+	}
+	forceFlush() {
+		return this._shutdownOnce.isCalled ? this._shutdownOnce.promise : this._flushAll();
+	}
+	onStart(e, t) {}
+	onEnd(e) {
+		this._shutdownOnce.isCalled || (e.spanContext().traceFlags & S.SAMPLED) !== 0 && this._addToBuffer(e);
+	}
+	shutdown() {
+		return this._shutdownOnce.call();
+	}
+	_shutdown() {
+		return Promise.resolve().then(() => this.onShutdown()).then(() => this._flushAll()).then(() => (this._metrics.shutdown(), this._exporter.shutdown()));
+	}
+	_addToBuffer(e) {
+		if (this._finishedSpans.length >= this._maxQueueSize) {
+			this._droppedSpansCount === 0 && E.debug("maxQueueSize reached, dropping spans"), this._droppedSpansCount++, this._metrics.dropSpans(1);
+			return;
+		}
+		this._droppedSpansCount > 0 && (E.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`), this._droppedSpansCount = 0), this._finishedSpans.push(e), this._maybeStartTimer();
+	}
+	_flushAll() {
+		return new Promise((e, t) => {
+			let n = [], r = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
+			for (let e = 0, t = r; e < t; e++) n.push(this._flushOneBatch());
+			Promise.all(n).then(() => {
+				e();
+			}).catch(t);
+		});
+	}
+	_flushOneBatch() {
+		return this._clearTimer(), this._finishedSpans.length === 0 ? Promise.resolve() : new Promise((e, t) => {
+			let n = setTimeout(() => {
+				t(/* @__PURE__ */ Error("Timeout"));
+			}, this._exportTimeoutMillis);
+			T.with(_t(T.active()), () => {
+				let r;
+				this._finishedSpans.length <= this._maxExportBatchSize ? (r = this._finishedSpans, this._finishedSpans = []) : r = this._finishedSpans.splice(0, this._maxExportBatchSize);
+				let i = () => this._exporter.export(r, (i) => {
+					clearTimeout(n), this._metrics.finishSpans(r.length, i.error), i.code === I.SUCCESS ? e() : t(i.error ?? /* @__PURE__ */ Error("BatchSpanProcessor: span export failed"));
+				}), a = null;
+				for (let e = 0, t = r.length; e < t; e++) {
+					let t = r[e];
+					t.resource.asyncAttributesPending && t.resource.waitForAsyncAttributes && (a ??= [], a.push(t.resource.waitForAsyncAttributes()));
+				}
+				a === null ? i() : Promise.all(a).then(i, (e) => {
+					A(e), t(e);
+				});
+			});
+		});
+	}
+	_maybeStartTimer() {
+		if (this._isExporting) return;
+		let e = () => {
+			this._isExporting = !0, this._flushOneBatch().finally(() => {
+				this._isExporting = !1, this._finishedSpans.length > 0 && (this._clearTimer(), this._maybeStartTimer());
+			}).catch((e) => {
+				this._isExporting = !1, A(e);
+			});
+		};
+		if (this._finishedSpans.length >= this._maxExportBatchSize) return e();
+		this._timer === void 0 && (this._timer = setTimeout(() => e(), this._scheduledDelayMillis), typeof this._timer != "number" && this._timer.unref());
+	}
+	_clearTimer() {
+		this._timer !== void 0 && (clearTimeout(this._timer), this._timer = void 0);
+	}
+}, gr = class extends hr {
+	_visibilityChangeListener;
+	_pageHideListener;
+	constructor(e) {
+		super(e), this.onInit(e);
+	}
+	onInit(e) {
+		e.disableAutoFlushOnDocumentHide !== !0 && typeof document < "u" && (this._visibilityChangeListener = () => {
+			document.visibilityState === "hidden" && this.forceFlush().catch((e) => {
+				A(e);
+			});
+		}, this._pageHideListener = () => {
+			this.forceFlush().catch((e) => {
+				A(e);
+			});
+		}, document.addEventListener("visibilitychange", this._visibilityChangeListener), document.addEventListener("pagehide", this._pageHideListener));
+	}
+	onShutdown() {
+		typeof document < "u" && (this._visibilityChangeListener && document.removeEventListener("visibilitychange", this._visibilityChangeListener), this._pageHideListener && document.removeEventListener("pagehide", this._pageHideListener));
+	}
+}, _r = 16, vr = 8, yr = new Uint8Array(_r), br = new Uint8Array(vr), xr = Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+function Sr(e) {
+	for (let t = 0; t < e.length; t++) e[t] = Math.random() * 256 >>> 0;
+	for (let t = 0; t < e.length; t++) if (e[t] > 0) return;
+	e[e.length - 1] = 1;
+}
+function Cr(e) {
+	let t = "";
+	for (let n = 0; n < e.length; n++) t += xr[e[n]];
+	return t;
+}
+var wr = class {
+	generateTraceId() {
+		return Sr(yr), Cr(yr);
+	}
+	generateSpanId() {
+		return Sr(br), Cr(br);
+	}
+}, U;
+(function(e) {
+	e[e.resolved = 0] = "resolved", e[e.timeout = 1] = "timeout", e[e.error = 2] = "error", e[e.unresolved = 3] = "unresolved";
+})(U ||= {});
+var Tr = class {
+	_resource;
+	_activeSpanProcessor;
+	_forceFlushTimeoutMillis;
+	_tracerOptions;
+	_tracers = /* @__PURE__ */ new Map();
+	constructor(e = {}) {
+		this._forceFlushTimeoutMillis = e.forceFlushTimeoutMillis ?? 3e4, this._resource = e.resource ?? Vn();
+		let t = e.spanProcessors ?? [];
+		this._activeSpanProcessor = new dr(t), this._tracerOptions = {
+			resource: this._resource,
+			sampler: e.sampler ?? new H({ root: new V() }),
+			spanLimits: {
+				attributeCountLimit: e.spanLimits?.attributeCountLimit ?? 128,
+				attributeValueLengthLimit: e.spanLimits?.attributeValueLengthLimit ?? Infinity,
+				eventCountLimit: e.spanLimits?.eventCountLimit ?? 128,
+				linkCountLimit: e.spanLimits?.linkCountLimit ?? 128,
+				attributePerEventCountLimit: e.spanLimits?.attributePerEventCountLimit ?? 128,
+				attributePerLinkCountLimit: e.spanLimits?.attributePerLinkCountLimit ?? 128
+			},
+			idGenerator: e.idGenerator || new wr(),
+			spanProcessor: this._activeSpanProcessor,
+			meterProvider: e.meterProvider ?? { getMeter() {
+				return ke();
+			} }
+		};
+	}
+	getTracer(e, t, n) {
+		let r = `${e}@${t || ""}:${n?.schemaUrl || ""}`;
+		return this._tracers.has(r) || this._tracers.set(r, new ur({
+			name: e,
+			version: t,
+			schemaUrl: n?.schemaUrl
+		}, this._tracerOptions)), this._tracers.get(r);
+	}
+	forceFlush() {
+		let e = this._forceFlushTimeoutMillis, t = this._activeSpanProcessor._spanProcessors.map((t) => new Promise((n) => {
+			let r, i = setTimeout(() => {
+				n(/* @__PURE__ */ Error(`Span processor did not completed within timeout period of ${e} ms`)), r = U.timeout;
+			}, e);
+			t.forceFlush().then(() => {
+				clearTimeout(i), r !== U.timeout && (r = U.resolved, n(r));
+			}).catch((e) => {
+				clearTimeout(i), r = U.error, n(e);
+			});
+		}));
+		return new Promise((e, n) => {
+			Promise.all(t).then((t) => {
+				let r = t.filter((e) => e !== U.resolved);
+				r.length > 0 ? n(r) : e();
+			}).catch((e) => n([e]));
+		});
+	}
+	shutdown() {
+		return this._activeSpanProcessor.shutdown();
+	}
+	[Kn](e, t, n) {
+		let r = this._activeSpanProcessor._spanProcessors;
+		return Jn("TracerProvider", {
+			resource: { attributes: qn(this._resource) },
+			tracers: Array.from(this._tracers.keys()),
+			spanProcessors: r.map((e) => e.constructor?.name ?? "SpanProcessor")
+		}, e, t, n);
+	}
+}, Er = class {
+	_ratio;
+	_upperBound;
+	constructor(e = 0) {
+		this._ratio = this._normalize(e), this._upperBound = this._ratio === 1 ? 4294967296 : Math.floor(this._ratio * 4294967295);
+	}
+	shouldSample(e, t) {
+		return { decision: Ge(t) && this._accumulate(t) < this._upperBound ? B.RECORD_AND_SAMPLED : B.NOT_RECORD };
+	}
+	toString() {
+		return `TraceIdRatioBased{${this._ratio}}`;
+	}
+	_normalize(e) {
+		return typeof e != "number" || isNaN(e) ? 0 : e >= 1 ? 1 : e <= 0 ? 0 : e;
+	}
+	_accumulate(e) {
+		let t = 0;
+		for (let n = 0; n < 32; n += 8) {
+			let r = 0;
+			for (let t = 0; t < 8; t++) {
+				let i = e.charCodeAt(n + t), a = i < 58 ? i - 48 : i < 71 ? i - 55 : i - 87;
+				r = r << 4 | a;
+			}
+			t = (t ^ r) >>> 0;
+		}
+		return t;
+	}
+}, W;
+(function(e) {
+	e.AlwaysOff = "always_off", e.AlwaysOn = "always_on", e.ParentBasedAlwaysOff = "parentbased_always_off", e.ParentBasedAlwaysOn = "parentbased_always_on", e.ParentBasedTraceIdRatio = "parentbased_traceidratio", e.TraceIdRatio = "traceidratio";
+})(W ||= {});
+var Dr = 1;
+function Or() {
+	return {
+		sampler: kr(),
+		forceFlushTimeoutMillis: 3e4,
+		generalLimits: {
+			attributeValueLengthLimit: Infinity,
+			attributeCountLimit: 128
+		},
+		spanLimits: {
+			attributeValueLengthLimit: Infinity,
+			attributeCountLimit: 128,
+			linkCountLimit: 128,
+			eventCountLimit: 128,
+			attributePerEventCountLimit: 128,
+			attributePerLinkCountLimit: 128
+		}
+	};
+}
+function kr() {
+	let e = W.ParentBasedAlwaysOn;
+	switch (e) {
+		case W.AlwaysOn: return new V();
+		case W.AlwaysOff: return new fr();
+		case W.ParentBasedAlwaysOn: return new H({ root: new V() });
+		case W.ParentBasedAlwaysOff: return new H({ root: new fr() });
+		case W.TraceIdRatio: return new Er(Ar());
+		case W.ParentBasedTraceIdRatio: return new H({ root: new Er(Ar()) });
+		default: return E.error(`OTEL_TRACES_SAMPLER value "${e}" invalid, defaulting to "${W.ParentBasedAlwaysOn}".`), new H({ root: new V() });
+	}
+}
+function Ar() {
+	return E.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${Dr}.`), Dr;
+}
+function jr(e) {
+	let t = Object.assign({}, e.spanLimits);
+	return t.attributeCountLimit = e.spanLimits?.attributeCountLimit ?? e.generalLimits?.attributeCountLimit ?? void 0 ?? void 0 ?? 128, t.attributeValueLengthLimit = e.spanLimits?.attributeValueLengthLimit ?? e.generalLimits?.attributeValueLengthLimit ?? void 0 ?? void 0 ?? Infinity, Object.assign({}, e, { spanLimits: t });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace-base@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider-shim.js
+var Mr = class extends Tr {
+	constructor(e = {}) {
+		let t = Tn({}, Or(), jr(e));
+		delete t.generalLimits, super(t);
+	}
+}, Nr = class extends gr {
+	constructor(e, t) {
+		t ||= {};
+		for (let [e, n] of [
+			["maxExportBatchSize", "OTEL_BSP_MAX_EXPORT_BATCH_SIZE"],
+			["maxQueueSize", "OTEL_BSP_MAX_QUEUE_SIZE"],
+			["scheduledDelayMillis", "OTEL_BSP_SCHEDULE_DELAY"],
+			["exportTimeoutMillis", "OTEL_BSP_EXPORT_TIMEOUT"]
+		]) t[e];
+		super({
+			exporter: e,
+			...t
+		});
+	}
+}, Pr = class {
+	_enabled = !1;
+	_currentContext = b;
+	_bindFunction(e = b, t) {
+		let n = this, r = function(...r) {
+			return n.with(e, () => t.apply(this, r));
+		};
+		return Object.defineProperty(r, "length", {
+			enumerable: !1,
+			configurable: !0,
+			writable: !1,
+			value: t.length
+		}), r;
+	}
+	active() {
+		return this._currentContext;
+	}
+	bind(e, t) {
+		return e === void 0 && (e = this.active()), typeof t == "function" ? this._bindFunction(e, t) : t;
+	}
+	disable() {
+		return this._currentContext = b, this._enabled = !1, this;
+	}
+	enable() {
+		return this._enabled ? this : (this._enabled = !0, this._currentContext = b, this);
+	}
+	with(e, t, n, ...r) {
+		let i = this._currentContext;
+		this._currentContext = e || b;
+		try {
+			return t.call(n, ...r);
+		} finally {
+			this._currentContext = i;
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace-web@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-web/build/esm/WebTracerProvider.js
+function Fr(e) {
+	if (e !== null) {
+		if (e === void 0) {
+			let e = new Pr();
+			e.enable(), T.setGlobalContextManager(e);
+			return;
+		}
+		e.enable(), T.setGlobalContextManager(e);
+	}
+}
+function Ir(e) {
+	if (e !== null) {
+		if (e === void 0) {
+			D.setGlobalPropagator(new Gt({ propagators: [new ln(), new Tt()] }));
+			return;
+		}
+		D.setGlobalPropagator(e);
+	}
+}
+var Lr = class extends Mr {
+	constructor(e = {}) {
+		super(e);
+	}
+	register(e = {}) {
+		O.setGlobalTracerProvider(this), Ir(e.propagator), Fr(e.contextManager);
+	}
+}, G;
+(function(e) {
+	e.CONNECT_END = "connectEnd", e.CONNECT_START = "connectStart", e.DECODED_BODY_SIZE = "decodedBodySize", e.DOM_COMPLETE = "domComplete", e.DOM_CONTENT_LOADED_EVENT_END = "domContentLoadedEventEnd", e.DOM_CONTENT_LOADED_EVENT_START = "domContentLoadedEventStart", e.DOM_INTERACTIVE = "domInteractive", e.DOMAIN_LOOKUP_END = "domainLookupEnd", e.DOMAIN_LOOKUP_START = "domainLookupStart", e.ENCODED_BODY_SIZE = "encodedBodySize", e.FETCH_START = "fetchStart", e.LOAD_EVENT_END = "loadEventEnd", e.LOAD_EVENT_START = "loadEventStart", e.NAVIGATION_START = "navigationStart", e.REDIRECT_END = "redirectEnd", e.REDIRECT_START = "redirectStart", e.REQUEST_START = "requestStart", e.RESPONSE_END = "responseEnd", e.RESPONSE_START = "responseStart", e.SECURE_CONNECTION_START = "secureConnectionStart", e.START_TIME = "startTime", e.UNLOAD_EVENT_END = "unloadEventEnd", e.UNLOAD_EVENT_START = "unloadEventStart";
+})(G ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+sdk-trace-web@2.10.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace-web/build/esm/semconv.js
+var Rr = "http.response_content_length", zr = "http.response_content_length_uncompressed", Br;
+function Vr() {
+	return Br ||= document.createElement("a"), Br;
+}
+function K(e, t) {
+	return t in e;
+}
+function q(e, t, n, r = !0) {
+	if (K(n, t) && typeof n[t] == "number" && !(r && n[t] === 0)) return e.addEvent(t, n[t]);
+}
+function Hr(e, t, n = !1, r, i) {
+	if (r === void 0 && (r = t[G.START_TIME] !== 0), n || (q(e, G.FETCH_START, t, r), q(e, G.DOMAIN_LOOKUP_START, t, r), q(e, G.DOMAIN_LOOKUP_END, t, r), q(e, G.CONNECT_START, t, r), q(e, G.SECURE_CONNECTION_START, t, r), q(e, G.CONNECT_END, t, r), q(e, G.REQUEST_START, t, r), q(e, G.RESPONSE_START, t, r), q(e, G.RESPONSE_END, t, r)), !i) {
+		let n = t[G.ENCODED_BODY_SIZE];
+		n !== void 0 && e.setAttribute(Rr, n);
+		let r = t[G.DECODED_BODY_SIZE];
+		r !== void 0 && n !== r && e.setAttribute(zr, r);
+	}
+}
+function Ur(e) {
+	return e.slice().sort((e, t) => {
+		let n = e[G.FETCH_START], r = t[G.FETCH_START];
+		return n > r ? 1 : n < r ? -1 : 0;
+	});
+}
+function Wr() {
+	return typeof location < "u" ? location.origin : void 0;
+}
+function Gr(e, t, n, r, i = /* @__PURE__ */ new WeakSet(), a) {
+	let o = Jr(e);
+	e = o.toString();
+	let s = qr(e, t, n, r, i, a);
+	if (s.length === 0) return { mainRequest: void 0 };
+	if (s.length === 1) return { mainRequest: s[0] };
+	let c = Ur(s);
+	if (o.origin !== Wr() && c.length > 1) {
+		let e = c[0], t = Kr(c, e[G.RESPONSE_END], n), r = e[G.RESPONSE_END];
+		return t[G.FETCH_START] < r && (t = e, e = void 0), {
+			corsPreFlightRequest: e,
+			mainRequest: t
+		};
+	}
+	return { mainRequest: s[0] };
+}
+function Kr(e, t, n) {
+	let r = F(n), i = F(P(t)), a = e[1], o, s = e.length;
+	for (let t = 1; t < s; t++) {
+		let n = e[t], s = F(P(n[G.FETCH_START])), c = r - F(P(n[G.RESPONSE_END]));
+		s >= i && (!o || c < o) && (o = c, a = n);
+	}
+	return a;
+}
+function qr(e, t, n, r, i, a) {
+	let o = F(t), s = F(n), c = r.filter((t) => {
+		let n = F(P(t[G.FETCH_START])), r = F(P(t[G.RESPONSE_END]));
+		return t.initiatorType.toLowerCase() === (a || "xmlhttprequest") && t.name === e && n >= o && r <= s;
+	});
+	return c.length > 0 && (c = c.filter((e) => !i.has(e))), c;
+}
+function Jr(e) {
+	if (typeof URL == "function") return new URL(e, typeof document < "u" ? document.baseURI : typeof location < "u" ? location.href : void 0);
+	let t = Vr();
+	return t.href = e, t;
+}
+function Yr(e, t) {
+	let n = t || [];
+	return (typeof n == "string" || n instanceof RegExp) && (n = [n]), Jr(e).origin === Wr() || n.some((t) => Nn(e, t));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
+var Xr = class {
+	_delegate;
+	constructor(e) {
+		this._delegate = e;
+	}
+	export(e, t) {
+		this._delegate.export(e, t);
+	}
+	forceFlush() {
+		return this._delegate.forceFlush();
+	}
+	shutdown() {
+		return this._delegate.shutdown();
+	}
+	setMetrics(e) {
+		this._delegate.setMetrics(e);
+	}
+}, Zr = class extends Error {
+	code;
+	name = "OTLPExporterError";
+	data;
+	constructor(e, t, n) {
+		super(e), this.data = n, this.code = t;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js
+function Qr(e) {
+	if (Number.isFinite(e) && e > 0) return e;
+	throw Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${e}')`);
+}
+function $r(e) {
+	if (e != null) return async () => e;
+}
+function ei(e, t, n) {
+	return {
+		timeoutMillis: Qr(e.timeoutMillis ?? t.timeoutMillis ?? n.timeoutMillis),
+		concurrencyLimit: e.concurrencyLimit ?? t.concurrencyLimit ?? n.concurrencyLimit,
+		compression: e.compression ?? t.compression ?? n.compression
+	};
+}
+function ti() {
+	return {
+		timeoutMillis: 1e4,
+		concurrencyLimit: 30,
+		compression: "none"
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js
+var ni = class {
+	_concurrencyLimit;
+	_sendingPromises = [];
+	constructor(e) {
+		this._concurrencyLimit = e;
+	}
+	pushPromise(e) {
+		if (this.hasReachedLimit()) throw Error("Concurrency Limit reached");
+		this._sendingPromises.push(e);
+		let t = () => {
+			let t = this._sendingPromises.indexOf(e);
+			this._sendingPromises.splice(t, 1);
+		};
+		e.then(t, t);
+	}
+	hasReachedLimit() {
+		return this._sendingPromises.length >= this._concurrencyLimit;
+	}
+	async awaitAll() {
+		await Promise.all(this._sendingPromises);
+	}
+};
+function ri(e) {
+	return new ni(e.concurrencyLimit);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js
+function ii(e) {
+	return Object.prototype.hasOwnProperty.call(e, "partialSuccess");
+}
+function ai() {
+	return { handleResponse(e) {
+		e == null || !ii(e) || e.partialSuccess == null || Object.keys(e.partialSuccess).length === 0 || E.warn("Received Partial Success response:", JSON.stringify(e.partialSuccess));
+	} };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
+var oi = class {
+	_metrics;
+	_diagLogger;
+	_transport;
+	_serializer;
+	_responseHandler;
+	_promiseQueue;
+	_timeout;
+	constructor(e, t, n, r, i, a) {
+		this._transport = e, this._serializer = t, this._responseHandler = n, this._promiseQueue = r, this._timeout = a, this._diagLogger = E.createComponentLogger({ namespace: "OTLPExportDelegate" }), this._metrics = i;
+	}
+	export(e, t) {
+		if (this._diagLogger.debug("items to be sent", e), this._promiseQueue.hasReachedLimit()) {
+			t({
+				code: I.FAILED,
+				error: /* @__PURE__ */ Error("Concurrent export limit reached")
+			});
+			return;
+		}
+		let n = this._serializer.serializeRequest(e);
+		if (n == null) {
+			t({
+				code: I.FAILED,
+				error: /* @__PURE__ */ Error("Nothing to send")
+			});
+			return;
+		}
+		let r = this._metrics.startExport(e);
+		this._promiseQueue.pushPromise(this._transport.send(n, this._timeout).then((e) => {
+			if (e.status === "success") {
+				if (r(void 0), e.data != null) try {
+					this._responseHandler.handleResponse(this._serializer.deserializeResponse(e.data));
+				} catch (t) {
+					this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", t, e.data);
+				}
+				t({ code: I.SUCCESS });
+				return;
+			}
+			if (e.status === "failure" && e.error) {
+				r(e.error), t({
+					code: I.FAILED,
+					error: e.error
+				});
+				return;
+			}
+			e.status === "retryable" ? (r("export_max_retries"), t({
+				code: I.FAILED,
+				error: e.error ?? new Zr("Export failed with retryable status")
+			})) : (r("export_failed"), t({
+				code: I.FAILED,
+				error: new Zr("Export failed with unknown error")
+			}));
+		}, (e) => {
+			r(e), t({
+				code: I.FAILED,
+				error: e
+			});
+		}));
+	}
+	forceFlush() {
+		return this._promiseQueue.awaitAll();
+	}
+	setMetrics(e) {
+		this._metrics = e;
+	}
+	async shutdown() {
+		this._diagLogger.debug("shutdown started"), await this.forceFlush(), this._transport.shutdown();
+	}
+};
+function si(e, t) {
+	return new oi(e.transport, e.serializer, ai(), e.promiseHandler, e.metrics, t.timeout);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-network-export-delegate.js
+function ci(e, t, n, r) {
+	return si({
+		transport: r,
+		serializer: t,
+		promiseHandler: ri(e),
+		metrics: n
+	}, { timeout: e.timeoutMillis });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/semconv.js
+var li = "http.response.status_code", ui = "otel.component.name", di = "otel.component.type", fi = "server.address", pi = "server.port", mi = "error.type", hi = "0.221.0", gi = /* @__PURE__ */ new Map(), _i = class {
+	inflight;
+	exported;
+	duration;
+	standardAttrs;
+	responseAttributesFromError;
+	helper;
+	constructor(e) {
+		let { componentType: t, metricsHelper: n, meterProvider: r, url: i, responseAttributesFromError: a } = e;
+		this.responseAttributesFromError = a;
+		let o = r ? r.getMeter("@opentelemetry/otlp-exporter", hi) : ke(), s = gi.get(t) ?? 0;
+		if (gi.set(t, s + 1), this.standardAttrs = {
+			[di]: t,
+			[ui]: `${t}/${s}`
+		}, i) {
+			let e = i;
+			i.includes("://") || (e = `http://${i}`);
+			try {
+				let t = new URL(e);
+				this.standardAttrs[fi] = t.hostname;
+				let n;
+				t.port ? n = Number(t.port) : t.protocol === "http:" ? n = 80 : t.protocol === "https:" && (n = 443), typeof n == "number" && (this.standardAttrs[pi] = n);
+			} catch {}
+		}
+		this.helper = n, this.inflight = o.createUpDownCounter(`otel.sdk.exporter.${this.helper.name}.inflight`, {
+			unit: `{${this.helper.name}}`,
+			description: `The number of ${this.helper.name}s which were passed to the exporter, but that have not been exported yet (neither successful, nor failed).`
+		}), this.exported = o.createCounter(`otel.sdk.exporter.${this.helper.name}.exported`, {
+			unit: `{${this.helper.name}}`,
+			description: `The number of ${this.helper.name}s for which the export has finished, either successful or failed.`
+		}), this.duration = o.createHistogram("otel.sdk.exporter.operation.duration", {
+			unit: "s",
+			description: "The duration of exporting a batch of telemetry records.",
+			advice: { explicitBucketBoundaries: [] }
+		});
+	}
+	startExport(e) {
+		let t = this.helper.countItems(e), n = N();
+		return this.inflight.add(t, this.standardAttrs), (e) => {
+			let r = N();
+			this.inflight.add(-t, this.standardAttrs);
+			let i = e ? {
+				...this.standardAttrs,
+				[mi]: e instanceof Error ? e.name : "export_failed"
+			} : this.standardAttrs;
+			this.exported.add(t, i);
+			let a = {
+				...i,
+				...this.responseAttributesFromError(e)
+			}, o = Vt(Bt(n, r)) / 1e3;
+			this.duration.record(o, a);
+		};
+	}
+}, vi = {
+	name: "span",
+	countItems: (e) => e.length
+}, yi = class {
+	emit(e) {}
+	enabled() {
+		return !1;
+	}
+}, bi = new yi(), xi = Symbol.for("io.opentelemetry.js.api.logs"), J = globalThis;
+function Si(e, t, n) {
+	return (r) => r === e ? t : n;
+}
+var Ci = new class {
+	getLogger(e, t, n) {
+		return new yi();
+	}
+}(), wi = class {
+	constructor(e, t, n, r) {
+		this._provider = e, this.name = t, this.version = n, this.options = r;
+	}
+	emit(e) {
+		this._getLogger().emit(e);
+	}
+	enabled(e) {
+		return this._getLogger().enabled(e);
+	}
+	_getLogger() {
+		if (this._delegate) return this._delegate;
+		let e = this._provider._getDelegateLogger(this.name, this.version, this.options);
+		return e ? (this._delegate = e, this._delegate) : bi;
+	}
+}, Ti = class {
+	getLogger(e, t, n) {
+		return this._getDelegateLogger(e, t, n) ?? new wi(this, e, t, n);
+	}
+	_getDelegate() {
+		return this._delegate ?? Ci;
+	}
+	_setDelegate(e) {
+		this._delegate = e;
+	}
+	_getDelegateLogger(e, t, n) {
+		return this._delegate?.getLogger(e, t, n);
+	}
+}, Ei = class e {
+	constructor() {
+		this._proxyLoggerProvider = new Ti();
+	}
+	static getInstance() {
+		return this._instance ||= new e(), this._instance;
+	}
+	setGlobalLoggerProvider(e) {
+		return J[xi] ? this.getLoggerProvider() : (J[xi] = Si(1, e, Ci), this._proxyLoggerProvider._setDelegate(e), e);
+	}
+	getLoggerProvider() {
+		return J[xi]?.call(J, 1) ?? this._proxyLoggerProvider;
+	}
+	getLogger(e, t, n) {
+		return this.getLoggerProvider().getLogger(e, t, n);
+	}
+	disable() {
+		delete J[xi], this._proxyLoggerProvider = new Ti();
+	}
+}.getInstance();
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
+function Di(e, t) {
+	let n = {
+		attributes: Y(e.attributes, t),
+		droppedAttributesCount: 0
+	}, r = e.schemaUrl;
+	return r && r !== "" && (n.schemaUrl = r), n;
+}
+function Oi(e, t) {
+	let n = {
+		name: e.name,
+		version: e.version
+	};
+	return e.attributes && Object.keys(e.attributes).length > 0 && (n.attributes = Y(e.attributes, t), n.droppedAttributesCount = e.droppedAttributesCount ?? 0), n;
+}
+function Y(e, t) {
+	return Object.keys(e).map((n) => ki(n, e[n], t));
+}
+function ki(e, t, n) {
+	return {
+		key: e,
+		value: Ai(t, n)
+	};
+}
+function Ai(e, t) {
+	let n = typeof e;
+	if (n === "string") return { stringValue: e };
+	if (n === "number") return Number.isInteger(e) ? { intValue: e } : { doubleValue: e };
+	if (n === "boolean") return { boolValue: e };
+	if (e instanceof Uint8Array) return { bytesValue: t.encodeUint8Array(e) };
+	if (Array.isArray(e)) {
+		let n = Array(e.length);
+		for (let r = 0; r < e.length; r++) n[r] = Ai(e[r], t);
+		return { arrayValue: { values: n } };
+	}
+	if (n === "object" && e != null) {
+		let n = Object.keys(e), r = Array(n.length);
+		for (let i = 0; i < n.length; i++) r[i] = {
+			key: n[i],
+			value: Ai(e[n[i]], t)
+		};
+		return { kvlistValue: { values: r } };
+	}
+	return {};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
+function ji(e) {
+	let t = BigInt(1e9);
+	return BigInt(Math.trunc(e[0])) * t + BigInt(Math.trunc(e[1]));
+}
+function Mi(e) {
+	return ji(e).toString();
+}
+var Ni = typeof BigInt < "u" ? Mi : F;
+function Pi(e) {
+	return e;
+}
+var Fi = {
+	encodeHrTime: Ni,
+	encodeSpanContext: Pi,
+	encodeOptionalSpanContext: Pi,
+	encodeUint8Array: (e) => {
+		if (typeof Buffer < "u") return Buffer.from(e).toString("base64");
+		let t = Array(e.length);
+		for (let n = 0; n < e.length; n++) t[n] = String.fromCharCode(e[n]);
+		return btoa(t.join(""));
+	}
+}, Ii = 256, Li = 512;
+function Ri(e, t) {
+	let n = e & 255 | Ii;
+	return t && (n |= Li), n;
+}
+function zi(e, t) {
+	let n = e.spanContext(), r = e.status, i = e.parentSpanContext?.spanId ? t.encodeSpanContext(e.parentSpanContext?.spanId) : void 0;
+	return {
+		traceId: t.encodeSpanContext(n.traceId),
+		spanId: t.encodeSpanContext(n.spanId),
+		parentSpanId: i,
+		traceState: n.traceState?.serialize(),
+		name: e.name,
+		kind: e.kind == null ? 0 : e.kind + 1,
+		startTimeUnixNano: t.encodeHrTime(e.startTime),
+		endTimeUnixNano: t.encodeHrTime(e.endTime),
+		attributes: Y(e.attributes, t),
+		droppedAttributesCount: e.droppedAttributesCount,
+		events: e.events.map((e) => Vi(e, t)),
+		droppedEventsCount: e.droppedEventsCount,
+		status: {
+			code: r.code,
+			message: r.message
+		},
+		links: e.links.map((e) => Bi(e, t)),
+		droppedLinksCount: e.droppedLinksCount,
+		flags: Ri(n.traceFlags, e.parentSpanContext?.isRemote)
+	};
+}
+function Bi(e, t) {
+	return {
+		attributes: e.attributes ? Y(e.attributes, t) : [],
+		spanId: t.encodeSpanContext(e.context.spanId),
+		traceId: t.encodeSpanContext(e.context.traceId),
+		traceState: e.context.traceState?.serialize(),
+		droppedAttributesCount: e.droppedAttributesCount || 0,
+		flags: Ri(e.context.traceFlags, e.context.isRemote)
+	};
+}
+function Vi(e, t) {
+	return {
+		attributes: e.attributes ? Y(e.attributes, t) : [],
+		name: e.name,
+		timeUnixNano: t.encodeHrTime(e.time),
+		droppedAttributesCount: e.droppedAttributesCount || 0
+	};
+}
+function Hi(e, t) {
+	return { resourceSpans: Wi(e, t) };
+}
+function Ui(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = t.get(n.resource);
+		e || (e = /* @__PURE__ */ new Map(), t.set(n.resource, e));
+		let r = `${n.instrumentationScope.name}@${n.instrumentationScope.version || ""}:${n.instrumentationScope.schemaUrl || ""}`, i = e.get(r);
+		i || (i = [], e.set(r, i)), i.push(n);
+	}
+	return t;
+}
+function Wi(e, t) {
+	let n = Ui(e), r = [], i = n.entries(), a = i.next();
+	for (; !a.done;) {
+		let [e, n] = a.value, o = [], s = n.values(), c = s.next();
+		for (; !c.done;) {
+			let e = c.value;
+			if (e.length > 0) {
+				let n = e.map((e) => zi(e, t));
+				o.push({
+					scope: Oi(e[0].instrumentationScope, t),
+					spans: n,
+					schemaUrl: e[0].instrumentationScope.schemaUrl
+				});
+			}
+			c = s.next();
+		}
+		let l = Di(e, t), u = {
+			resource: l,
+			scopeSpans: o,
+			schemaUrl: l.schemaUrl
+		};
+		r.push(u), a = i.next();
+	}
+	return r;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-transformer@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js
+var Gi = {
+	serializeRequest: (e) => {
+		let t = Hi(e, Fi);
+		return new TextEncoder().encode(JSON.stringify(t));
+	},
+	deserializeResponse: (e) => {
+		if (e.length === 0) return {};
+		let t = new TextDecoder();
+		try {
+			return JSON.parse(t.decode(e));
+		} catch (e) {
+			return E.warn(`Failed to parse trace export response: ${e.message}. Returning empty response`), {};
+		}
+	}
+}, Ki = 5, qi = 1e3, Ji = 5e3, Yi = 1.5, Xi = .2;
+function Zi() {
+	return 2 * Xi * Math.random() - Xi;
+}
+var Qi = class {
+	_transport;
+	constructor(e) {
+		this._transport = e;
+	}
+	retry(e, t, n) {
+		return new Promise((r, i) => {
+			setTimeout(() => {
+				this._transport.send(e, t).then(r, i);
+			}, n);
+		});
+	}
+	async send(e, t) {
+		let n = Ki, r = qi, i = Date.now() + t, a = await this._transport.send(e, t);
+		for (; a.status === "retryable" && n > 0;) {
+			n--;
+			let t = Math.max(Math.min(r * (1 + Zi()), Ji), 0);
+			r *= Yi;
+			let o = a.retryInMillis ?? t, s = i - Date.now();
+			if (o > s) return E.info(`Export retry time ${Math.round(o)}ms exceeds remaining timeout ${Math.round(s)}ms, not retrying further.`), a;
+			E.verbose(`Scheduling export retry in ${Math.round(o)}ms`), a = await this.retry(e, s, o);
+		}
+		return a.status === "success" ? E.verbose(`Export succeeded after ${Ki - n} retry attempts.`) : a.status === "retryable" ? E.info(`Export failed after maximum retry attempts (${Ki}).`) : E.info(`Export failed with non-retryable error: ${a.error}`), a;
+	}
+	shutdown() {
+		return this._transport.shutdown();
+	}
+};
+function $i(e) {
+	return new Qi(e.transport);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js
+function ea(e) {
+	return e === 429 || e === 502 || e === 503 || e === 504;
+}
+function ta(e) {
+	if (e == null) return;
+	let t = Number.parseInt(e, 10);
+	if (Number.isInteger(t)) return t > 0 ? t * 1e3 : -1;
+	let n = new Date(e).getTime() - Date.now();
+	return n >= 0 ? n : 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/fetch-transport.js
+var na = 61440, ra = 9, ia = 0, aa = 0, oa = class {
+	_parameters;
+	constructor(e) {
+		this._parameters = e;
+	}
+	async send(e, t) {
+		let n = new AbortController(), r = setTimeout(() => n.abort(), t), i = globalThis.fetch;
+		typeof i.__original == "function" && (i = i.__original);
+		let a = e.byteLength, o = ia + a > na, s = !o && !(aa >= ra);
+		if (s) ia += a, aa++;
+		else {
+			let e = o ? "size limit" : "count limit";
+			E.debug(`keepalive disabled: ${(a / 1024).toFixed(1)}KB payload, ${aa} pending (${e})`);
+		}
+		try {
+			let t = new URL(this._parameters.url), r = await i(t.href, {
+				method: "POST",
+				headers: await this._parameters.headers(),
+				body: e,
+				signal: n.signal,
+				keepalive: s,
+				mode: globalThis.location ? globalThis.location.origin === t.origin ? "same-origin" : "cors" : "no-cors"
+			});
+			return r.status >= 200 && r.status <= 299 ? (E.debug(`export response success (status: ${r.status})`), { status: "success" }) : ea(r.status) ? (E.warn(`export response retryable (status: ${r.status})`), {
+				status: "retryable",
+				retryInMillis: ta(r.headers.get("Retry-After"))
+			}) : (E.error(`export response failure (status: ${r.status})`), {
+				status: "failure",
+				error: /* @__PURE__ */ Error(`Fetch request failed with non-retryable status ${r.status}`)
+			});
+		} catch (e) {
+			return ca(e) ? (E.warn(`export request retryable (network error: ${e})`), {
+				status: "retryable",
+				error: Error("Fetch request encountered a network error", { cause: e })
+			}) : (E.error(`export request failure (error: ${e})`), {
+				status: "failure",
+				error: Error("Fetch request errored", { cause: e })
+			});
+		} finally {
+			clearTimeout(r), s && (ia -= a, aa--);
+		}
+	}
+	shutdown() {}
+};
+function sa(e) {
+	return new oa(e);
+}
+function ca(e) {
+	return e instanceof TypeError && !e.cause;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-browser-http-export-delegate.js
+function la(e, t, n) {
+	return ci(e, t, n, $i({ transport: sa(e) }));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js
+function ua(e) {
+	let t = {};
+	return Object.entries(e ?? {}).forEach(([e, n]) => {
+		n === void 0 ? E.warn(`Header "${e}" has invalid value (${n}) and will be ignored`) : t[e] = String(n);
+	}), t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js
+function da(e, t, n) {
+	return async () => {
+		let r = { ...await n() }, i = {};
+		return t != null && Object.assign(i, await t()), e != null && Object.assign(i, ua(await e())), Object.assign(i, r);
+	};
+}
+function fa(e) {
+	if (e != null) try {
+		let t = globalThis.location?.href;
+		return new URL(e, t).href;
+	} catch {
+		throw Error(`Configuration: Could not parse user-provided export URL: '${e}'`);
+	}
+}
+function pa(e, t, n) {
+	return {
+		...ei(e, t, n),
+		headers: da(e.headers, t.headers, n.headers),
+		url: fa(e.url) ?? t.url ?? n.url
+	};
+}
+function ma(e, t) {
+	return {
+		...ti(),
+		headers: async () => e,
+		url: "http://localhost:4318/" + t
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js
+function ha(e) {
+	return typeof e.headers == "function" ? e.headers : $r(e.headers);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-browser-http-options.js
+function ga(e, t, n) {
+	return pa({
+		url: e.url,
+		timeoutMillis: e.timeoutMillis,
+		headers: ha(e),
+		concurrencyLimit: e.concurrencyLimit
+	}, {}, ma(n, t));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+otlp-exporter-base@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/create-legacy-browser-delegate.js
+function _a(e, t, n, r) {
+	return new _i({
+		componentType: e,
+		metricsHelper: t,
+		url: n,
+		meterProvider: r,
+		responseAttributesFromError: (e) => {
+			if (!e) return { [li]: 200 };
+			if (!(e instanceof Error)) return {};
+			if (e.message.startsWith("Fetch request failed with non-retryable status ")) {
+				let t = e.message.substring(47);
+				return { [li]: Number(t) };
+			}
+			return {};
+		}
+	});
+}
+function va(e, t, n, r, i, a, o) {
+	let s = ga(e, a, o);
+	return la(s, t, _a(n, r, s.url, e.selfObsMeterProvider));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+exporter-trace-otlp-http@0.221.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/semconv.js
+var ya = "otlp_http_span_exporter", ba = class extends Xr {
+	constructor(e = {}) {
+		super(va(e, Gi, ya, vi, e.selfObsMeterProvider, "v1/traces", { "Content-Type": "application/json" }));
+	}
+}, X = console.error.bind(console);
+function Z(e, t, n) {
+	let r = !!e[t] && Object.prototype.propertyIsEnumerable.call(e, t);
+	Object.defineProperty(e, t, {
+		configurable: !0,
+		enumerable: r,
+		writable: !0,
+		value: n
+	});
+}
+var xa = (e, t, n) => {
+	if (!e || !e[t]) {
+		X("no original function " + String(t) + " to wrap");
+		return;
+	}
+	if (!n) {
+		X("no wrapper function"), X((/* @__PURE__ */ Error()).stack);
+		return;
+	}
+	let r = e[t];
+	if (typeof r != "function" || typeof n != "function") {
+		X("original object and wrapper must be functions");
+		return;
+	}
+	let i = n(r, t);
+	return Z(i, "__original", r), Z(i, "__unwrap", () => {
+		e[t] === i && Z(e, t, r);
+	}), Z(i, "__wrapped", !0), Z(e, t, i), i;
+}, Sa = (e, t, n) => {
+	if (e) Array.isArray(e) || (e = [e]);
+	else {
+		X("must provide one or more modules to patch"), X((/* @__PURE__ */ Error()).stack);
+		return;
+	}
+	if (!(t && Array.isArray(t))) {
+		X("must provide one or more functions to wrap on modules");
+		return;
+	}
+	e.forEach((e) => {
+		t.forEach((t) => {
+			xa(e, t, n);
+		});
+	});
+}, Ca = (e, t) => {
+	if (!e || !e[t]) {
+		X("no function to unwrap."), X((/* @__PURE__ */ Error()).stack);
+		return;
+	}
+	let n = e[t];
+	if (!n.__unwrap) X("no original to unwrap to -- has " + String(t) + " already been unwrapped?");
+	else {
+		n.__unwrap();
+		return;
+	}
+}, wa = (e, t) => {
+	if (e) Array.isArray(e) || (e = [e]);
+	else {
+		X("must provide one or more modules to patch"), X((/* @__PURE__ */ Error()).stack);
+		return;
+	}
+	if (!(t && Array.isArray(t))) {
+		X("must provide one or more functions to unwrap on modules");
+		return;
+	}
+	e.forEach((e) => {
+		t.forEach((t) => {
+			Ca(e, t);
+		});
+	});
+}, Ta = class {
+	_config = {};
+	_tracer;
+	_meter;
+	_logger;
+	_diag;
+	instrumentationName;
+	instrumentationVersion;
+	constructor(e, t, n) {
+		this.instrumentationName = e, this.instrumentationVersion = t, this.setConfig(n), this._diag = E.createComponentLogger({ namespace: e }), this._tracer = O.getTracer(e, t), this._meter = ot.getMeter(e, t), this._logger = Ei.getLogger(e, t), this._updateMetricInstruments();
+	}
+	_wrap = xa;
+	_unwrap = Ca;
+	_massWrap = Sa;
+	_massUnwrap = wa;
+	get meter() {
+		return this._meter;
+	}
+	setMeterProvider(e) {
+		this._meter = e.getMeter(this.instrumentationName, this.instrumentationVersion), this._updateMetricInstruments();
+	}
+	get logger() {
+		return this._logger;
+	}
+	setLoggerProvider(e) {
+		this._logger = e.getLogger(this.instrumentationName, this.instrumentationVersion);
+	}
+	getModuleDefinitions() {
+		let e = this.init() ?? [];
+		return Array.isArray(e) ? e : [e];
+	}
+	_updateMetricInstruments() {}
+	getConfig() {
+		return this._config;
+	}
+	setConfig(e) {
+		this._config = {
+			enabled: !0,
+			...e
+		};
+	}
+	setTracerProvider(e) {
+		this._tracer = e.getTracer(this.instrumentationName, this.instrumentationVersion);
+	}
+	get tracer() {
+		return this._tracer;
+	}
+	_runSpanCustomizationHook(e, t, n, r) {
+		if (e) try {
+			e(n, r);
+		} catch (e) {
+			this._diag.error("Error running span customization hook due to exception in handler", { triggerName: t }, e);
+		}
+	}
+}, Ea = class extends Ta {
+	constructor(e, t, n) {
+		super(e, t, n), this._config.enabled && this.enable();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation@0.221.0_@opentelemetry+api@1.9.1_supports-color@10.2.2/node_modules/@opentelemetry/instrumentation/build/esm/utils.js
+function Q(e, t, n) {
+	let r, i;
+	try {
+		i = e();
+	} catch (e) {
+		r = e;
+	} finally {
+		if (t(r, i), r && !n) throw r;
+		return i;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation-fetch@0.221.0_@opentelemetry+api@1.9.1_supports-color@10.2.2/node_modules/@opentelemetry/instrumentation-fetch/build/esm/semconv.js
+var Da = "http.request.body.size", Oa = E.createComponentLogger({ namespace: "@opentelemetry/opentelemetry-instrumentation-fetch/utils" });
+function ka(...e) {
+	if (e[0] instanceof URL || typeof e[0] == "string") {
+		let t = e[1];
+		if (!t?.body) return Promise.resolve();
+		if (t.body instanceof ReadableStream) {
+			let { body: e, length: n } = Aa(t.body);
+			return t.body = e, n;
+		}
+		return Promise.resolve(Ma(t.body));
+	}
+	{
+		let t = e[0];
+		return t?.body ? t.clone().text().then((e) => Pa(e)) : Promise.resolve();
+	}
+}
+function Aa(e) {
+	if (!e.pipeThrough) return Oa.warn("Platform has ReadableStream but not pipeThrough!"), {
+		body: e,
+		length: Promise.resolve(void 0)
+	};
+	let t = 0, n, r = new Promise((e) => {
+		n = e;
+	}), i = new TransformStream({
+		start() {},
+		async transform(e, n) {
+			let r = await e;
+			t += r.byteLength, n.enqueue(e);
+		},
+		flush() {
+			n(t);
+		}
+	});
+	return {
+		body: e.pipeThrough(i),
+		length: r
+	};
+}
+function ja(e) {
+	return typeof Document < "u" && e instanceof Document;
+}
+function Ma(e) {
+	if (ja(e)) return new XMLSerializer().serializeToString(document).length;
+	if (typeof e == "string") return Pa(e);
+	if (e instanceof Blob) return e.size;
+	if (e instanceof FormData) return Fa(e);
+	if (e instanceof URLSearchParams) return Pa(e.toString());
+	if (e.byteLength !== void 0) return e.byteLength;
+	Oa.warn("unknown body type");
+}
+var Na = new TextEncoder();
+function Pa(e) {
+	return Na.encode(e).byteLength;
+}
+function Fa(e) {
+	let t = 0;
+	for (let [n, r] of e.entries()) t += n.length, r instanceof Blob ? t += r.size : t += r.length;
+	return t;
+}
+function Ia(e) {
+	let t = za(), n = e.toUpperCase();
+	return n in t ? n : "_OTHER";
+}
+var La = {
+	CONNECT: !0,
+	DELETE: !0,
+	GET: !0,
+	HEAD: !0,
+	OPTIONS: !0,
+	PATCH: !0,
+	POST: !0,
+	PUT: !0,
+	TRACE: !0,
+	QUERY: !0
+}, Ra;
+function za() {
+	return Ra === void 0 && (Ra = La), Ra;
+}
+var Ba = {
+	"https:": "443",
+	"http:": "80"
+};
+function Va(e) {
+	let t = Number(e.port || Ba[e.protocol]);
+	if (t && !isNaN(t)) return t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation-fetch@0.221.0_@opentelemetry+api@1.9.1_supports-color@10.2.2/node_modules/@opentelemetry/instrumentation-fetch/build/esm/version.js
+var Ha = "0.221.0", Ua = 300, Wa = typeof PerformanceObserver < "u", Ga = class extends Ea {
+	component = "fetch";
+	version = Ha;
+	moduleName = this.component;
+	_usedResources = /* @__PURE__ */ new WeakSet();
+	_tasksCount = 0;
+	constructor(e = {}) {
+		super("@opentelemetry/instrumentation-fetch", Ha, e);
+	}
+	init() {}
+	_addChildSpan(e, t) {
+		let n = this.tracer.startSpan("CORS Preflight", { startTime: t[G.FETCH_START] }, O.setSpan(T.active(), e));
+		Hr(n, t, this.getConfig().ignoreNetworkEvents, void 0, !0), n.end(t[G.RESPONSE_END]);
+	}
+	_addFinalSpanAttributes(e, t) {
+		let n = Jr(t.url);
+		e.setAttribute("http.response.status_code", t.status), e.setAttribute("server.address", n.hostname);
+		let r = Va(n);
+		r && e.setAttribute("server.port", r);
+	}
+	_addHeaders(e, t) {
+		if (!Yr(t, this.getConfig().propagateTraceHeaderCorsUrls)) {
+			let e = {};
+			D.inject(T.active(), e), Object.keys(e).length > 0 && this._diag.debug("headers inject skipped due to CORS policy");
+			return;
+		}
+		if (e instanceof Request) D.inject(T.active(), e.headers, { set: (e, t, n) => e.set(t, typeof n == "string" ? n : String(n)) });
+		else {
+			let t = new Headers(e.headers);
+			D.inject(T.active(), t, { set: (e, t, n) => e.set(t, typeof n == "string" ? n : String(n)) }), e.headers = t;
+		}
+	}
+	_clearResources() {
+		this._tasksCount === 0 && this.getConfig().clearTimingResources && (performance.clearResourceTimings(), this._usedResources = /* @__PURE__ */ new WeakSet());
+	}
+	_createSpan(e, t = {}) {
+		if (Pn(e, this.getConfig().ignoreUrls)) {
+			this._diag.debug("ignoring span as url matches ignored url");
+			return;
+		}
+		let n = {}, r = t.method, i = Ia(t.method || "GET"), a = i;
+		return n["http.request.method"] = i, i !== r && (n["http.request.method_original"] = r), n[c] = e, this.tracer.startSpan(a, {
+			kind: rt.CLIENT,
+			attributes: n
+		});
+	}
+	_findResourceAndAddNetworkEvents(e, t, n) {
+		let r = t.entries;
+		if (!r.length) {
+			if (!performance.getEntriesByType) return;
+			r = performance.getEntriesByType("resource");
+		}
+		let i = Gr(t.spanUrl, t.startTime, n, r, this._usedResources, "fetch");
+		if (i.mainRequest) {
+			let t = i.mainRequest;
+			this._markResourceAsUsed(t);
+			let n = i.corsPreFlightRequest;
+			n && (this._addChildSpan(e, n), this._markResourceAsUsed(n)), Hr(e, t, this.getConfig().ignoreNetworkEvents, void 0, !0);
+		}
+	}
+	_markResourceAsUsed(e) {
+		this._usedResources.add(e);
+	}
+	_endSpan(t, n, r) {
+		let i = M(Date.now()), a = N();
+		this._addFinalSpanAttributes(t, r), r.status >= 400 && (t.setStatus({ code: w.ERROR }), t.setAttribute(e, String(r.status))), setTimeout(() => {
+			n.observer?.disconnect(), this._findResourceAndAddNetworkEvents(t, n, a), this._tasksCount--, this._clearResources(), t.end(i);
+		}, Ua);
+	}
+	_patchConstructor() {
+		return (e) => {
+			let t = this;
+			return function(...n) {
+				if (!t._isEnabled) return e.apply(this, n);
+				let r = this, i = Jr(n[0] instanceof Request ? n[0].url : String(n[0])).href, a;
+				a = n[0] instanceof Request ? n[1] == null ? n[0] : new Request(n[0], n[1]) : n[1] || {};
+				let o = t._createSpan(i, a);
+				if (!o) return e.apply(this, n);
+				let s = t._prepareSpanData(i);
+				t.getConfig().measureRequestSize && ka(...n).then((e) => {
+					e && o.setAttribute(Da, e);
+				}).catch((e) => {
+					t._diag.warn("getFetchBodyLength", e);
+				});
+				function c(e, n) {
+					t._applyAttributesAfterFetch(e, a, n), t._endSpan(e, s, {
+						status: n.status || 0,
+						statusText: n.message,
+						url: i
+					});
+				}
+				function l(e, n) {
+					t._applyAttributesAfterFetch(e, a, n), n.status >= 200 && n.status < 400 ? t._endSpan(e, s, n) : t._endSpan(e, s, {
+						status: n.status,
+						statusText: n.statusText,
+						url: i
+					});
+				}
+				function u(e, n) {
+					try {
+						let t = n.clone().body;
+						if (t) {
+							let r = t.getReader(), i = () => {
+								r.read().then(({ done: t }) => {
+									t ? l(e, n) : i();
+								}, (t) => {
+									c(e, t);
+								});
+							};
+							i();
+						} else l(e, n);
+					} catch (n) {
+						t._diag.error("Failed to read fetch response body", n), t._endSpan(e, s, {
+							status: 0,
+							url: i
+						});
+					}
+					return n;
+				}
+				function ee(e, n) {
+					try {
+						c(e, n);
+					} catch (r) {
+						t._diag.error("Failed to end span on fetch error", r), t._endSpan(e, s, {
+							status: n.status || 0,
+							url: i
+						});
+					}
+					throw n;
+				}
+				return T.with(O.setSpan(T.active(), o), () => (t._callRequestHook(o, a), t._addHeaders(a, i), t._tasksCount++, e.apply(r, a instanceof Request ? [a] : [i, a]).then(u.bind(r, o), ee.bind(r, o))));
+			};
+		};
+	}
+	_applyAttributesAfterFetch(e, t, n) {
+		let r = this.getConfig().applyCustomAttributesOnSpan;
+		r && Q(() => r(e, t, n), (e) => {
+			e && this._diag.error("applyCustomAttributesOnSpan", e);
+		}, !0);
+	}
+	_callRequestHook(e, t) {
+		let n = this.getConfig().requestHook;
+		n && Q(() => n(e, t), (e) => {
+			e && this._diag.error("requestHook", e);
+		}, !0);
+	}
+	_prepareSpanData(e) {
+		let t = N(), n = [];
+		if (typeof PerformanceObserver != "function") return {
+			entries: n,
+			startTime: t,
+			spanUrl: e
+		};
+		let r = new PerformanceObserver((t) => {
+			t.getEntries().forEach((t) => {
+				t.initiatorType === "fetch" && t.name === e && n.push(t);
+			});
+		});
+		return r.observe({ entryTypes: ["resource"] }), {
+			entries: n,
+			observer: r,
+			startTime: t,
+			spanUrl: e
+		};
+	}
+	enable() {
+		if (!Wa) {
+			this._diag.warn("this instrumentation is intended for web usage only, it does not instrument server-side fetch()");
+			return;
+		}
+		if (!this._isEnabled) {
+			if (this._isFetchPatched) {
+				this._diag.debug("fetch constructor already patched"), this._isEnabled = !0;
+				return;
+			}
+			try {
+				this._wrap(globalThis, "fetch", this._patchConstructor()), this._isFetchPatched = !0, this._isEnabled = !0;
+			} catch (e) {
+				this._diag.warn("Failed to patch globalThis.fetch; instrumentation will not be enabled. Another script may have locked globalThis.fetch via Object.defineProperty.", e);
+			}
+		}
+	}
+	disable() {
+		Wa && this._isEnabled && (this._isEnabled = !1, this._usedResources = /* @__PURE__ */ new WeakSet());
+	}
+}, $;
+(function(e) {
+	e.DOCUMENT_LOAD = "documentLoad", e.DOCUMENT_FETCH = "documentFetch", e.RESOURCE_FETCH = "resourceFetch";
+})($ ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation-document-load@0.66.0_@opentelemetry+api@1.9.1_supports-color@10.2.2/node_modules/@opentelemetry/instrumentation-document-load/build/esm/version.js
+var Ka = "0.66.0", qa = "@opentelemetry/instrumentation-document-load", Ja;
+(function(e) {
+	e.FIRST_PAINT = "firstPaint", e.FIRST_CONTENTFUL_PAINT = "firstContentfulPaint";
+})(Ja ||= {});
+//#endregion
+//#region ../../node_modules/.pnpm/@opentelemetry+instrumentation-document-load@0.66.0_@opentelemetry+api@1.9.1_supports-color@10.2.2/node_modules/@opentelemetry/instrumentation-document-load/build/esm/utils.js
+var Ya = () => {
+	let e = {}, t = j.getEntriesByType?.("navigation")[0];
+	if (t) Object.values(G).forEach((n) => {
+		if (K(t, n)) {
+			let r = t[n];
+			typeof r == "number" && (e[n] = r);
+		}
+	});
+	else {
+		let t = j.timing;
+		t && Object.values(G).forEach((n) => {
+			if (K(t, n)) {
+				let r = t[n];
+				typeof r == "number" && (e[n] = r);
+			}
+		});
+	}
+	return e;
+}, Xa = {
+	"first-paint": Ja.FIRST_PAINT,
+	"first-contentful-paint": Ja.FIRST_CONTENTFUL_PAINT
+}, Za = (e) => {
+	let t = j.getEntriesByType?.("paint");
+	t && t.forEach(({ name: t, startTime: n }) => {
+		K(Xa, t) && e.addEvent(Xa[t], n);
+	});
+}, Qa = class extends Ea {
+	component = "document-load";
+	version = "1";
+	moduleName = this.component;
+	constructor(e = {}) {
+		super(qa, Ka, e);
+	}
+	init() {}
+	_onDocumentLoaded() {
+		window.setTimeout(() => {
+			this._collectPerformance();
+		});
+	}
+	_addResourcesSpans(e) {
+		let t = j.getEntriesByType?.("resource");
+		t && t.forEach((t) => {
+			this._initResourceSpan(t, e);
+		});
+	}
+	_collectPerformance() {
+		let e = Array.from(document.getElementsByTagName("meta")).find((e) => e.getAttribute("name") === rn), t = Ya(), n = e && e.content || "";
+		T.with(D.extract(b, { traceparent: n }), () => {
+			let e = this._startSpan($.DOCUMENT_LOAD, G.FETCH_START, t);
+			e && (T.with(O.setSpan(T.active(), e), () => {
+				let e = this._startSpan($.DOCUMENT_FETCH, G.FETCH_START, t);
+				e && (e.setAttribute(c, location.href), T.with(O.setSpan(T.active(), e), () => {
+					Hr(e, t, this.getConfig().ignoreNetworkEvents), this._addCustomAttributesOnSpan(e, this.getConfig().applyCustomAttributesOnSpan?.documentFetch), this._endSpan(e, G.RESPONSE_END, t);
+				}));
+			}), e.setAttribute(c, location.href), e.setAttribute("user_agent.original", navigator.userAgent), this._addResourcesSpans(e), this.getConfig().ignoreNetworkEvents || (q(e, G.FETCH_START, t), q(e, G.UNLOAD_EVENT_START, t), q(e, G.UNLOAD_EVENT_END, t), q(e, G.DOM_INTERACTIVE, t), q(e, G.DOM_CONTENT_LOADED_EVENT_START, t), q(e, G.DOM_CONTENT_LOADED_EVENT_END, t), q(e, G.DOM_COMPLETE, t), q(e, G.LOAD_EVENT_START, t), q(e, G.LOAD_EVENT_END, t)), this.getConfig().ignorePerformancePaintEvents || Za(e), this._addCustomAttributesOnSpan(e, this.getConfig().applyCustomAttributesOnSpan?.documentLoad), this._endSpan(e, G.LOAD_EVENT_END, t));
+		});
+	}
+	_endSpan(e, t, n) {
+		e && (K(n, t) ? e.end(n[t]) : e.end());
+	}
+	_initResourceSpan(e, t) {
+		let n = this._startSpan($.RESOURCE_FETCH, G.FETCH_START, e, t);
+		n && (n.setAttribute(c, e.name), Hr(n, e, this.getConfig().ignoreNetworkEvents), this._addCustomAttributesOnResourceSpan(n, e, this.getConfig().applyCustomAttributesOnSpan?.resourceFetch), this._endSpan(n, G.RESPONSE_END, e));
+	}
+	_startSpan(e, t, n, r) {
+		if (K(n, t) && typeof n[t] == "number") return this.tracer.startSpan(e, { startTime: n[t] }, r ? O.setSpan(T.active(), r) : void 0);
+	}
+	_waitForPageLoad() {
+		window.document.readyState === "complete" ? this._onDocumentLoaded() : (this._onDocumentLoaded = this._onDocumentLoaded.bind(this), window.addEventListener("load", this._onDocumentLoaded));
+	}
+	_addCustomAttributesOnSpan(e, t) {
+		t && Q(() => t(e), (e) => {
+			e && this._diag.error("addCustomAttributesOnSpan", e);
+		}, !0);
+	}
+	_addCustomAttributesOnResourceSpan(e, t, n) {
+		n && Q(() => n(e, t), (e) => {
+			e && this._diag.error("addCustomAttributesOnResourceSpan", e);
+		}, !0);
+	}
+	enable() {
+		window.removeEventListener("load", this._onDocumentLoaded), this._waitForPageLoad();
+	}
+	disable() {
+		window.removeEventListener("load", this._onDocumentLoaded);
+	}
+}, $a = {
+	development: 1,
+	staging: .5,
+	production: .2
+};
+function eo(e) {
+	let t = typeof process < "u" ? process.env.OTEL_SAMPLING_RATE : void 0;
+	if (t !== void 0) {
+		let e = Number(t);
+		return Number.isFinite(e) ? Math.max(0, Math.min(1, e)) : 1;
+	}
+	return $a[e.toLowerCase()] ?? 1;
+}
+//#endregion
+//#region ../../packages/telemetry/src/utils.ts
+function to(e, t, n) {
+	return Promise.race([Promise.resolve(e).then(() => {}), new Promise((e) => {
+		setTimeout(() => {
+			console.warn(`[telemetry] ${n} timed out after ${t}ms — proceeding without confirmation`), e();
+		}, t);
+	})]);
+}
+//#endregion
+//#region ../../packages/telemetry/src/browser.ts
+var no = !1;
+function ro(e) {
+	if (no) return;
+	no = !0;
+	let t = () => {
+		to(e(), 2e3, "browser flush");
+	};
+	window.addEventListener("pagehide", t), window.addEventListener("beforeunload", t), document.addEventListener("visibilitychange", () => {
+		document.visibilityState === "hidden" && t();
+	});
+}
+function io(e) {
+	return e?.enabled === !1 ? null : {
+		serviceName: e?.serviceName ?? "frontend",
+		environment: e?.environment ?? "development",
+		exporterEndpoint: e?.exporterEndpoint ?? "http://localhost:4318",
+		samplingRate: eo(e?.environment ?? "development"),
+		otlpHeaders: e?.otlpHeaders ?? {},
+		signozApiKey: e?.signozApiKey ?? "",
+		logLevel: e?.logLevel ?? "info",
+		propagateCorsUrls: e?.propagateCorsUrls
+	};
+}
+function ao(e) {
+	let t = io(e);
+	if (!t) return {
+		shutdown: async () => {},
+		flush: async () => {}
+	};
+	let n = new Lr({
+		resource: Bn({
+			[r]: t.serviceName,
+			"deployment.environment": t.environment,
+			"service.version": "0.0.0"
+		}),
+		spanProcessors: [new Nr(new ba({
+			url: `${t.exporterEndpoint}/v1/traces`,
+			headers: t.otlpHeaders
+		}))]
+	});
+	return n.register(), D.setGlobalPropagator(new ln()), new Ga({ propagateTraceHeaderCorsUrls: t.propagateCorsUrls ? [t.propagateCorsUrls] : [] }).enable(), new Qa().enable(), ro(() => n.forceFlush()), {
+		shutdown: async () => {
+			try {
+				await to(n.shutdown(), 1e4, "browser shutdown");
+			} catch (e) {
+				console.error("[telemetry-browser] Error during shutdown", e);
+			}
+		},
+		flush: async () => {
+			try {
+				await to(n.forceFlush(), 1e4, "browser flush");
+			} catch (e) {
+				console.error("[telemetry-browser] Error during flush", e);
+			}
+		}
+	};
+}
+//#endregion
+export { ao as initializeTelemetryBrowser };
+
+//# sourceMappingURL=browser-DuzNfJq0.js.map