@tangle-network/sandbox-ui 0.134.11 → 0.135.0

package/dist/terminal-X6r5pjgv.js

@@ -0,0 +1,1704 @@
+import { t as usePtySession } from "./use-pty-session-B5Q_i9RI.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import "@xterm/xterm/css/xterm.css";
+import { Terminal } from "@xterm/xterm";
+import { FitAddon } from "@xterm/addon-fit";
+import { WebLinksAddon } from "@xterm/addon-web-links";
+//#region node_modules/.pnpm/@xterm+addon-unicode-graphemes@0.4.0/node_modules/@xterm/addon-unicode-graphemes/lib/addon-unicode-graphemes.mjs
+/**
+* Copyright (c) 2014-2024 The xterm.js authors. All rights reserved.
+* @license MIT
+*
+* Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+* @license MIT
+*
+* Originally forked from (with the author's permission):
+*   Fabrice Bellard's javascript vt100 for jslinux:
+*   http://bellard.org/jslinux/
+*   Copyright (c) 2011 Fabrice Bellard
+*/
+var be = [
+	[768, 879],
+	[1155, 1158],
+	[1160, 1161],
+	[1425, 1469],
+	[1471, 1471],
+	[1473, 1474],
+	[1476, 1477],
+	[1479, 1479],
+	[1536, 1539],
+	[1552, 1557],
+	[1611, 1630],
+	[1648, 1648],
+	[1750, 1764],
+	[1767, 1768],
+	[1770, 1773],
+	[1807, 1807],
+	[1809, 1809],
+	[1840, 1866],
+	[1958, 1968],
+	[2027, 2035],
+	[2305, 2306],
+	[2364, 2364],
+	[2369, 2376],
+	[2381, 2381],
+	[2385, 2388],
+	[2402, 2403],
+	[2433, 2433],
+	[2492, 2492],
+	[2497, 2500],
+	[2509, 2509],
+	[2530, 2531],
+	[2561, 2562],
+	[2620, 2620],
+	[2625, 2626],
+	[2631, 2632],
+	[2635, 2637],
+	[2672, 2673],
+	[2689, 2690],
+	[2748, 2748],
+	[2753, 2757],
+	[2759, 2760],
+	[2765, 2765],
+	[2786, 2787],
+	[2817, 2817],
+	[2876, 2876],
+	[2879, 2879],
+	[2881, 2883],
+	[2893, 2893],
+	[2902, 2902],
+	[2946, 2946],
+	[3008, 3008],
+	[3021, 3021],
+	[3134, 3136],
+	[3142, 3144],
+	[3146, 3149],
+	[3157, 3158],
+	[3260, 3260],
+	[3263, 3263],
+	[3270, 3270],
+	[3276, 3277],
+	[3298, 3299],
+	[3393, 3395],
+	[3405, 3405],
+	[3530, 3530],
+	[3538, 3540],
+	[3542, 3542],
+	[3633, 3633],
+	[3636, 3642],
+	[3655, 3662],
+	[3761, 3761],
+	[3764, 3769],
+	[3771, 3772],
+	[3784, 3789],
+	[3864, 3865],
+	[3893, 3893],
+	[3895, 3895],
+	[3897, 3897],
+	[3953, 3966],
+	[3968, 3972],
+	[3974, 3975],
+	[3984, 3991],
+	[3993, 4028],
+	[4038, 4038],
+	[4141, 4144],
+	[4146, 4146],
+	[4150, 4151],
+	[4153, 4153],
+	[4184, 4185],
+	[4448, 4607],
+	[4959, 4959],
+	[5906, 5908],
+	[5938, 5940],
+	[5970, 5971],
+	[6002, 6003],
+	[6068, 6069],
+	[6071, 6077],
+	[6086, 6086],
+	[6089, 6099],
+	[6109, 6109],
+	[6155, 6157],
+	[6313, 6313],
+	[6432, 6434],
+	[6439, 6440],
+	[6450, 6450],
+	[6457, 6459],
+	[6679, 6680],
+	[6912, 6915],
+	[6964, 6964],
+	[6966, 6970],
+	[6972, 6972],
+	[6978, 6978],
+	[7019, 7027],
+	[7616, 7626],
+	[7678, 7679],
+	[8203, 8207],
+	[8234, 8238],
+	[8288, 8291],
+	[8298, 8303],
+	[8400, 8431],
+	[12330, 12335],
+	[12441, 12442],
+	[43014, 43014],
+	[43019, 43019],
+	[43045, 43046],
+	[64286, 64286],
+	[65024, 65039],
+	[65056, 65059],
+	[65279, 65279],
+	[65529, 65531]
+];
+var Lt = [
+	[68097, 68099],
+	[68101, 68102],
+	[68108, 68111],
+	[68152, 68154],
+	[68159, 68159],
+	[119143, 119145],
+	[119155, 119170],
+	[119173, 119179],
+	[119210, 119213],
+	[119362, 119364],
+	[917505, 917505],
+	[917536, 917631],
+	[917760, 917999]
+];
+var y;
+function Ft(n, e) {
+	let t = 0, r = e.length - 1, i;
+	if (n < e[0][0] || n > e[r][1]) return !1;
+	for (; r >= t;) if (i = t + r >> 1, n > e[i][1]) t = i + 1;
+	else if (n < e[i][0]) r = i - 1;
+	else return !0;
+	return !1;
+}
+var J = class {
+	constructor() {
+		this.version = "6";
+		if (!y) {
+			y = /* @__PURE__ */ new Uint8Array(65536), y.fill(1), y[0] = 0, y.fill(0, 1, 32), y.fill(0, 127, 160), y.fill(2, 4352, 4448), y[9001] = 2, y[9002] = 2, y.fill(2, 11904, 42192), y[12351] = 1, y.fill(2, 44032, 55204), y.fill(2, 63744, 64256), y.fill(2, 65040, 65050), y.fill(2, 65072, 65136), y.fill(2, 65280, 65377), y.fill(2, 65504, 65511);
+			for (let e = 0; e < be.length; ++e) y.fill(0, be[e][0], be[e][1] + 1);
+		}
+	}
+	wcwidth(e) {
+		return e < 32 ? 0 : e < 127 ? 1 : e < 65536 ? y[e] : Ft(e, Lt) ? 0 : e >= 131072 && e <= 196605 || e >= 196608 && e <= 262141 ? 2 : 1;
+	}
+	charProperties(e, t) {
+		let r = this.wcwidth(e), i = r === 0 && t !== 0;
+		if (i) {
+			let o = w.extractWidth(t);
+			o === 0 ? i = !1 : o > r && (r = o);
+		}
+		return w.createPropertyValue(0, r, i);
+	}
+};
+var ve = class {
+	constructor() {
+		this.listeners = [], this.unexpectedErrorHandler = function(e) {
+			setTimeout(() => {
+				throw e.stack ? ee.isErrorNoTelemetry(e) ? new ee(e.message + `
+
+` + e.stack) : /* @__PURE__ */ new Error(e.message + `
+
+` + e.stack) : e;
+			}, 0);
+		};
+	}
+	addListener(e) {
+		return this.listeners.push(e), () => {
+			this._removeListener(e);
+		};
+	}
+	emit(e) {
+		this.listeners.forEach((t) => {
+			t(e);
+		});
+	}
+	_removeListener(e) {
+		this.listeners.splice(this.listeners.indexOf(e), 1);
+	}
+	setUnexpectedErrorHandler(e) {
+		this.unexpectedErrorHandler = e;
+	}
+	getUnexpectedErrorHandler() {
+		return this.unexpectedErrorHandler;
+	}
+	onUnexpectedError(e) {
+		this.unexpectedErrorHandler(e), this.emit(e);
+	}
+	onUnexpectedExternalError(e) {
+		this.unexpectedErrorHandler(e);
+	}
+};
+var St = new ve();
+function te(n) {
+	Ut(n) || St.onUnexpectedError(n);
+}
+var me = "Canceled";
+function Ut(n) {
+	return n instanceof $ ? !0 : n instanceof Error && n.name === me && n.message === me;
+}
+var $ = class extends Error {
+	constructor() {
+		super(me), this.name = this.message;
+	}
+};
+var ee = class n extends Error {
+	constructor(e) {
+		super(e), this.name = "CodeExpectedError";
+	}
+	static fromError(e) {
+		if (e instanceof n) return e;
+		let t = new n();
+		return t.message = e.message, t.stack = e.stack, t;
+	}
+	static isErrorNoTelemetry(e) {
+		return e.name === "CodeExpectedError";
+	}
+};
+function ge(n, e) {
+	let t = this, r = !1, i;
+	return function() {
+		if (r) return i;
+		if (r = !0, e) try {
+			i = n.apply(t, arguments);
+		} finally {
+			e();
+		}
+		else i = n.apply(t, arguments);
+		return i;
+	};
+}
+function Ot(n, e, t = 0, r = n.length) {
+	let i = t, o = r;
+	for (; i < o;) {
+		let f = Math.floor((i + o) / 2);
+		e(n[f]) ? i = f + 1 : o = f;
+	}
+	return i - 1;
+}
+var ne = class ne {
+	constructor(e) {
+		this._array = e;
+		this._findLastMonotonousLastIdx = 0;
+	}
+	findLastMonotonous(e) {
+		if (ne.assertInvariants) {
+			if (this._prevFindLastPredicate) {
+				for (let r of this._array) if (this._prevFindLastPredicate(r) && !e(r)) throw new Error("MonotonousArray: current predicate must be weaker than (or equal to) the previous predicate.");
+			}
+			this._prevFindLastPredicate = e;
+		}
+		let t = Ot(this._array, e, this._findLastMonotonousLastIdx);
+		return this._findLastMonotonousLastIdx = t + 1, t === -1 ? void 0 : this._array[t];
+	}
+};
+ne.assertInvariants = !1;
+var $e;
+((T) => {
+	function n(p) {
+		return p < 0;
+	}
+	T.isLessThan = n;
+	function e(p) {
+		return p <= 0;
+	}
+	T.isLessThanOrEqual = e;
+	function t(p) {
+		return p > 0;
+	}
+	T.isGreaterThan = t;
+	function r(p) {
+		return p === 0;
+	}
+	T.isNeitherLessOrGreaterThan = r, T.greaterThan = 1, T.lessThan = -1, T.neitherLessOrGreaterThan = 0;
+})($e ||= {});
+function et(n, e) {
+	return (t, r) => e(n(t), n(r));
+}
+var tt = (n, e) => n - e;
+var M = class M {
+	constructor(e) {
+		this.iterate = e;
+	}
+	forEach(e) {
+		this.iterate((t) => (e(t), !0));
+	}
+	toArray() {
+		let e = [];
+		return this.iterate((t) => (e.push(t), !0)), e;
+	}
+	filter(e) {
+		return new M((t) => this.iterate((r) => e(r) ? t(r) : !0));
+	}
+	map(e) {
+		return new M((t) => this.iterate((r) => t(e(r))));
+	}
+	some(e) {
+		let t = !1;
+		return this.iterate((r) => (t = e(r), !t)), t;
+	}
+	findFirst(e) {
+		let t;
+		return this.iterate((r) => e(r) ? (t = r, !1) : !0), t;
+	}
+	findLast(e) {
+		let t;
+		return this.iterate((r) => (e(r) && (t = r), !0)), t;
+	}
+	findLastMaxBy(e) {
+		let t, r = !0;
+		return this.iterate((i) => ((r || $e.isGreaterThan(e(i, t))) && (r = !1, t = i), !0)), t;
+	}
+};
+M.empty = new M((e) => {});
+function st(n, e) {
+	let t = Object.create(null);
+	for (let r of n) {
+		let i = e(r), o = t[i];
+		o || (o = t[i] = []), o.push(r);
+	}
+	return t;
+}
+var re = class {
+	constructor() {
+		this.map = /* @__PURE__ */ new Map();
+	}
+	add(e, t) {
+		let r = this.map.get(e);
+		r || (r = /* @__PURE__ */ new Set(), this.map.set(e, r)), r.add(t);
+	}
+	delete(e, t) {
+		let r = this.map.get(e);
+		r && (r.delete(t), r.size === 0 && this.map.delete(e));
+	}
+	forEach(e, t) {
+		let r = this.map.get(e);
+		r && r.forEach(t);
+	}
+	get(e) {
+		return this.map.get(e) || /* @__PURE__ */ new Set();
+	}
+};
+var _e;
+((Te) => {
+	function n(c) {
+		return c && typeof c == "object" && typeof c[Symbol.iterator] == "function";
+	}
+	Te.is = n;
+	let e = Object.freeze([]);
+	function t() {
+		return e;
+	}
+	Te.empty = t;
+	function* r(c) {
+		yield c;
+	}
+	Te.single = r;
+	function i(c) {
+		return n(c) ? c : r(c);
+	}
+	Te.wrap = i;
+	function o(c) {
+		return c || e;
+	}
+	Te.from = o;
+	function* f(c) {
+		for (let b = c.length - 1; b >= 0; b--) yield c[b];
+	}
+	Te.reverse = f;
+	function T(c) {
+		return !c || c[Symbol.iterator]().next().done === !0;
+	}
+	Te.isEmpty = T;
+	function p(c) {
+		return c[Symbol.iterator]().next().value;
+	}
+	Te.first = p;
+	function m(c, b) {
+		let g = 0;
+		for (let D of c) if (b(D, g++)) return !0;
+		return !1;
+	}
+	Te.some = m;
+	function _(c, b) {
+		for (let g of c) if (b(g)) return g;
+	}
+	Te.find = _;
+	function* x(c, b) {
+		for (let g of c) b(g) && (yield g);
+	}
+	Te.filter = x;
+	function* L(c, b) {
+		let g = 0;
+		for (let D of c) yield b(D, g++);
+	}
+	Te.map = L;
+	function* O(c, b) {
+		let g = 0;
+		for (let D of c) yield* b(D, g++);
+	}
+	Te.flatMap = O;
+	function* pe(...c) {
+		for (let b of c) yield* b;
+	}
+	Te.concat = pe;
+	function X(c, b, g) {
+		let D = g;
+		for (let z of c) D = b(D, z);
+		return D;
+	}
+	Te.reduce = X;
+	function* F(c, b, g = c.length) {
+		for (b < 0 && (b += c.length), g < 0 ? g += c.length : g > c.length && (g = c.length); b < g; b++) yield c[b];
+	}
+	Te.slice = F;
+	function he(c, b = Number.POSITIVE_INFINITY) {
+		let g = [];
+		if (b === 0) return [g, c];
+		let D = c[Symbol.iterator]();
+		for (let z = 0; z < b; z++) {
+			let xe = D.next();
+			if (xe.done) return [g, Te.empty()];
+			g.push(xe.value);
+		}
+		return [g, { [Symbol.iterator]() {
+			return D;
+		} }];
+	}
+	Te.consume = he;
+	async function K(c) {
+		let b = [];
+		for await (let g of c) b.push(g);
+		return Promise.resolve(b);
+	}
+	Te.asyncToArray = K;
+})(_e ||= {});
+var Pt = !1;
+var B = null;
+var ie = class ie {
+	constructor() {
+		this.livingDisposables = /* @__PURE__ */ new Map();
+	}
+	getDisposableData(e) {
+		let t = this.livingDisposables.get(e);
+		return t || (t = {
+			parent: null,
+			source: null,
+			isSingleton: !1,
+			value: e,
+			idx: ie.idx++
+		}, this.livingDisposables.set(e, t)), t;
+	}
+	trackDisposable(e) {
+		let t = this.getDisposableData(e);
+		t.source || (t.source = (/* @__PURE__ */ new Error()).stack);
+	}
+	setParent(e, t) {
+		let r = this.getDisposableData(e);
+		r.parent = t;
+	}
+	markAsDisposed(e) {
+		this.livingDisposables.delete(e);
+	}
+	markAsSingleton(e) {
+		this.getDisposableData(e).isSingleton = !0;
+	}
+	getRootParent(e, t) {
+		let r = t.get(e);
+		if (r) return r;
+		let i = e.parent ? this.getRootParent(this.getDisposableData(e.parent), t) : e;
+		return t.set(e, i), i;
+	}
+	getTrackedDisposables() {
+		let e = /* @__PURE__ */ new Map();
+		return [...this.livingDisposables.entries()].filter(([, r]) => r.source !== null && !this.getRootParent(r, e).isSingleton).flatMap(([r]) => r);
+	}
+	computeLeakingDisposables(e = 10, t) {
+		let r;
+		if (t) r = t;
+		else {
+			let p = /* @__PURE__ */ new Map(), m = [...this.livingDisposables.values()].filter((x) => x.source !== null && !this.getRootParent(x, p).isSingleton);
+			if (m.length === 0) return;
+			let _ = new Set(m.map((x) => x.value));
+			if (r = m.filter((x) => !(x.parent && _.has(x.parent))), r.length === 0) throw new Error("There are cyclic diposable chains!");
+		}
+		if (!r) return;
+		function i(p) {
+			function m(x, L) {
+				for (; x.length > 0 && L.some((O) => typeof O == "string" ? O === x[0] : x[0].match(O));) x.shift();
+			}
+			let _ = p.source.split(`
+`).map((x) => x.trim().replace("at ", "")).filter((x) => x !== "");
+			return m(_, [
+				"Error",
+				/^trackDisposable \(.*\)$/,
+				/^DisposableTracker.trackDisposable \(.*\)$/
+			]), _.reverse();
+		}
+		let o = new re();
+		for (let p of r) {
+			let m = i(p);
+			for (let _ = 0; _ <= m.length; _++) o.add(m.slice(0, _).join(`
+`), p);
+		}
+		r.sort(et((p) => p.idx, tt));
+		let f = "", T = 0;
+		for (let p of r.slice(0, e)) {
+			T++;
+			let m = i(p), _ = [];
+			for (let x = 0; x < m.length; x++) {
+				let L = m[x];
+				L = `(shared with ${o.get(m.slice(0, x + 1).join(`
+`)).size}/${r.length} leaks) at ${L}`;
+				let X = st([...o.get(m.slice(0, x).join(`
+`))].map((F) => i(F)[x]), (F) => F);
+				delete X[m[x]];
+				for (let [F, he] of Object.entries(X)) _.unshift(`    - stacktraces of ${he.length} other leaks continue with ${F}`);
+				_.unshift(L);
+			}
+			f += `
+
+
+==================== Leaking disposable ${T}/${r.length}: ${p.value.constructor.name} ====================
+${_.join(`
+`)}
+============================================================
+
+`;
+		}
+		return r.length > e && (f += `
+
+
+... and ${r.length - e} more leaking disposables
+
+`), {
+			leaks: r,
+			details: f
+		};
+	}
+};
+ie.idx = 0;
+function Mt(n) {
+	B = n;
+}
+if (Pt) {
+	let n = "__is_disposable_tracked__";
+	Mt(new class {
+		trackDisposable(e) {
+			let t = (/* @__PURE__ */ new Error("Potentially leaked disposable")).stack;
+			setTimeout(() => {
+				e[n] || console.log(t);
+			}, 3e3);
+		}
+		setParent(e, t) {
+			if (e && e !== k.None) try {
+				e[n] = !0;
+			} catch {}
+		}
+		markAsDisposed(e) {
+			if (e && e !== k.None) try {
+				e[n] = !0;
+			} catch {}
+		}
+		markAsSingleton(e) {}
+	}());
+}
+function Ee(n) {
+	return B?.trackDisposable(n), n;
+}
+function Ie(n) {
+	B?.markAsDisposed(n);
+}
+function ye(n, e) {
+	B?.setParent(n, e);
+}
+function Bt(n, e) {
+	if (B) for (let t of n) B.setParent(t, e);
+}
+function at(n) {
+	if (_e.is(n)) {
+		let e = [];
+		for (let t of n) if (t) try {
+			t.dispose();
+		} catch (r) {
+			e.push(r);
+		}
+		if (e.length === 1) throw e[0];
+		if (e.length > 1) throw new AggregateError(e, "Encountered errors while disposing of store");
+		return Array.isArray(n) ? [] : n;
+	} else if (n) return n.dispose(), n;
+}
+function lt(...n) {
+	let e = De(() => at(n));
+	return Bt(n, e), e;
+}
+function De(n) {
+	let e = Ee({ dispose: ge(() => {
+		Ie(e), n();
+	}) });
+	return e;
+}
+var se = class se {
+	constructor() {
+		this._toDispose = /* @__PURE__ */ new Set();
+		this._isDisposed = !1;
+		Ee(this);
+	}
+	dispose() {
+		this._isDisposed || (Ie(this), this._isDisposed = !0, this.clear());
+	}
+	get isDisposed() {
+		return this._isDisposed;
+	}
+	clear() {
+		if (this._toDispose.size !== 0) try {
+			at(this._toDispose);
+		} finally {
+			this._toDispose.clear();
+		}
+	}
+	add(e) {
+		if (!e) return e;
+		if (e === this) throw new Error("Cannot register a disposable on itself!");
+		return ye(e, this), this._isDisposed ? se.DISABLE_DISPOSED_WARNING || console.warn((/* @__PURE__ */ new Error("Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!")).stack) : this._toDispose.add(e), e;
+	}
+	delete(e) {
+		if (e) {
+			if (e === this) throw new Error("Cannot dispose a disposable on itself!");
+			this._toDispose.delete(e), e.dispose();
+		}
+	}
+	deleteAndLeak(e) {
+		e && this._toDispose.has(e) && (this._toDispose.delete(e), ye(e, null));
+	}
+};
+se.DISABLE_DISPOSED_WARNING = !1;
+var N = se;
+var k = class {
+	constructor() {
+		this._store = new N();
+		Ee(this), ye(this._store, this);
+	}
+	dispose() {
+		Ie(this), this._store.dispose();
+	}
+	_register(e) {
+		if (e === this) throw new Error("Cannot register a disposable on itself!");
+		return this._store.add(e);
+	}
+};
+k.None = Object.freeze({ dispose() {} });
+var W = class W {
+	constructor(e) {
+		this.element = e, this.next = W.Undefined, this.prev = W.Undefined;
+	}
+};
+W.Undefined = new W(void 0);
+var Nt = globalThis.performance && typeof globalThis.performance.now == "function";
+var oe = class n {
+	static create(e) {
+		return new n(e);
+	}
+	constructor(e) {
+		this._now = Nt && e === !1 ? Date.now : globalThis.performance.now.bind(globalThis.performance), this._startTime = this._now(), this._stopTime = -1;
+	}
+	stop() {
+		this._stopTime = this._now();
+	}
+	reset() {
+		this._startTime = this._now(), this._stopTime = -1;
+	}
+	elapsed() {
+		return this._stopTime !== -1 ? this._stopTime - this._startTime : this._now() - this._startTime;
+	}
+};
+var Wt = !1;
+var dt = !1;
+var Vt = !1;
+var Ht;
+((q) => {
+	q.None = () => k.None;
+	function e(u) {
+		if (Vt) {
+			let { onDidAddListener: s } = u, l = j.create(), a = 0;
+			u.onDidAddListener = () => {
+				++a === 2 && (console.warn("snapshotted emitter LIKELY used public and SHOULD HAVE BEEN created with DisposableStore. snapshotted here"), l.print()), s?.();
+			};
+		}
+	}
+	function t(u, s) {
+		return L(u, () => {}, 0, void 0, !0, void 0, s);
+	}
+	q.defer = t;
+	function r(u) {
+		return (s, l = null, a) => {
+			let d = !1, h;
+			return h = u((v) => {
+				if (!d) return h ? h.dispose() : d = !0, s.call(l, v);
+			}, null, a), d && h.dispose(), h;
+		};
+	}
+	q.once = r;
+	function i(u, s, l) {
+		return _((a, d = null, h) => u((v) => a.call(d, s(v)), null, h), l);
+	}
+	q.map = i;
+	function o(u, s, l) {
+		return _((a, d = null, h) => u((v) => {
+			s(v), a.call(d, v);
+		}, null, h), l);
+	}
+	q.forEach = o;
+	function f(u, s, l) {
+		return _((a, d = null, h) => u((v) => s(v) && a.call(d, v), null, h), l);
+	}
+	q.filter = f;
+	function T(u) {
+		return u;
+	}
+	q.signal = T;
+	function p(...u) {
+		return (s, l = null, a) => {
+			return x(lt(...u.map((h) => h((v) => s.call(l, v)))), a);
+		};
+	}
+	q.any = p;
+	function m(u, s, l, a) {
+		let d = l;
+		return i(u, (h) => (d = s(d, h), d), a);
+	}
+	q.reduce = m;
+	function _(u, s) {
+		let l, a = {
+			onWillAddFirstListener() {
+				l = u(d.fire, d);
+			},
+			onDidRemoveLastListener() {
+				l?.dispose();
+			}
+		};
+		s || e(a);
+		let d = new A(a);
+		return s?.add(d), d.event;
+	}
+	function x(u, s) {
+		return s instanceof Array ? s.push(u) : s && s.add(u), u;
+	}
+	function L(u, s, l = 100, a = !1, d = !1, h, v) {
+		let E, I, P, Z = 0, G, Ze = {
+			leakWarningThreshold: h,
+			onWillAddFirstListener() {
+				E = u((Rt) => {
+					Z++, I = s(I, Rt), a && !P && (Y.fire(I), I = void 0), G = () => {
+						let kt = I;
+						I = void 0, P = void 0, (!a || Z > 1) && Y.fire(kt), Z = 0;
+					}, typeof l == "number" ? (clearTimeout(P), P = setTimeout(G, l)) : P === void 0 && (P = 0, queueMicrotask(G));
+				});
+			},
+			onWillRemoveListener() {
+				d && Z > 0 && G?.();
+			},
+			onDidRemoveLastListener() {
+				G = void 0, E.dispose();
+			}
+		};
+		v || e(Ze);
+		let Y = new A(Ze);
+		return v?.add(Y), Y.event;
+	}
+	q.debounce = L;
+	function O(u, s = 0, l) {
+		return q.debounce(u, (a, d) => a ? (a.push(d), a) : [d], s, void 0, !0, void 0, l);
+	}
+	q.accumulate = O;
+	function pe(u, s = (a, d) => a === d, l) {
+		let a = !0, d;
+		return f(u, (h) => {
+			let v = a || !s(h, d);
+			return a = !1, d = h, v;
+		}, l);
+	}
+	q.latch = pe;
+	function X(u, s, l) {
+		return [q.filter(u, s, l), q.filter(u, (a) => !s(a), l)];
+	}
+	q.split = X;
+	function F(u, s = !1, l = [], a) {
+		let d = l.slice(), h = u((I) => {
+			d ? d.push(I) : E.fire(I);
+		});
+		a && a.add(h);
+		let v = () => {
+			d?.forEach((I) => E.fire(I)), d = null;
+		}, E = new A({
+			onWillAddFirstListener() {
+				h || (h = u((I) => E.fire(I)), a && a.add(h));
+			},
+			onDidAddFirstListener() {
+				d && (s ? setTimeout(v) : v());
+			},
+			onDidRemoveLastListener() {
+				h && h.dispose(), h = null;
+			}
+		});
+		return a && a.add(E), E.event;
+	}
+	q.buffer = F;
+	function he(u, s) {
+		return (a, d, h) => {
+			let v = s(new Te());
+			return u(function(E) {
+				let I = v.evaluate(E);
+				I !== K && a.call(d, I);
+			}, void 0, h);
+		};
+	}
+	q.chain = he;
+	let K = Symbol("HaltChainable");
+	class Te {
+		constructor() {
+			this.steps = [];
+		}
+		map(s) {
+			return this.steps.push(s), this;
+		}
+		forEach(s) {
+			return this.steps.push((l) => (s(l), l)), this;
+		}
+		filter(s) {
+			return this.steps.push((l) => s(l) ? l : K), this;
+		}
+		reduce(s, l) {
+			let a = l;
+			return this.steps.push((d) => (a = s(a, d), a)), this;
+		}
+		latch(s = (l, a) => l === a) {
+			let l = !0, a;
+			return this.steps.push((d) => {
+				let h = l || !s(d, a);
+				return l = !1, a = d, h ? d : K;
+			}), this;
+		}
+		evaluate(s) {
+			for (let l of this.steps) if (s = l(s), s === K) break;
+			return s;
+		}
+	}
+	function c(u, s, l = (a) => a) {
+		let a = (...E) => v.fire(l(...E)), d = () => u.on(s, a), h = () => u.removeListener(s, a), v = new A({
+			onWillAddFirstListener: d,
+			onDidRemoveLastListener: h
+		});
+		return v.event;
+	}
+	q.fromNodeEventEmitter = c;
+	function b(u, s, l = (a) => a) {
+		let a = (...E) => v.fire(l(...E)), d = () => u.addEventListener(s, a), h = () => u.removeEventListener(s, a), v = new A({
+			onWillAddFirstListener: d,
+			onDidRemoveLastListener: h
+		});
+		return v.event;
+	}
+	q.fromDOMEventEmitter = b;
+	function g(u) {
+		return new Promise((s) => r(u)(s));
+	}
+	q.toPromise = g;
+	function D(u) {
+		let s = new A();
+		return u.then((l) => {
+			s.fire(l);
+		}, () => {
+			s.fire(void 0);
+		}).finally(() => {
+			s.dispose();
+		}), s.event;
+	}
+	q.fromPromise = D;
+	function z(u, s) {
+		return u((l) => s.fire(l));
+	}
+	q.forward = z;
+	function xe(u, s, l) {
+		return s(l), u((a) => s(a));
+	}
+	q.runAndSubscribe = xe;
+	class Ct {
+		constructor(s, l) {
+			this._observable = s;
+			this._counter = 0;
+			this._hasChanged = !1;
+			let a = {
+				onWillAddFirstListener: () => {
+					s.addObserver(this);
+				},
+				onDidRemoveLastListener: () => {
+					s.removeObserver(this);
+				}
+			};
+			l || e(a), this.emitter = new A(a), l && l.add(this.emitter);
+		}
+		beginUpdate(s) {
+			this._counter++;
+		}
+		handlePossibleChange(s) {}
+		handleChange(s, l) {
+			this._hasChanged = !0;
+		}
+		endUpdate(s) {
+			this._counter--, this._counter === 0 && (this._observable.reportChanges(), this._hasChanged && (this._hasChanged = !1, this.emitter.fire(this._observable.get())));
+		}
+	}
+	function _n(u, s) {
+		return new Ct(u, s).emitter.event;
+	}
+	q.fromObservable = _n;
+	function yn(u) {
+		return (s, l, a) => {
+			let d = 0, h = !1, v = {
+				beginUpdate() {
+					d++;
+				},
+				endUpdate() {
+					d--, d === 0 && (u.reportChanges(), h && (h = !1, s.call(l)));
+				},
+				handlePossibleChange() {},
+				handleChange() {
+					h = !0;
+				}
+			};
+			u.addObserver(v), u.reportChanges();
+			let E = { dispose() {
+				u.removeObserver(v);
+			} };
+			return a instanceof N ? a.add(E) : Array.isArray(a) && a.push(E), E;
+		};
+	}
+	q.fromObservableLight = yn;
+})(Ht ||= {});
+var V = class V {
+	constructor(e) {
+		this.listenerCount = 0;
+		this.invocationCount = 0;
+		this.elapsedOverall = 0;
+		this.durations = [];
+		this.name = `${e}_${V._idPool++}`, V.all.add(this);
+	}
+	start(e) {
+		this._stopWatch = new oe(), this.listenerCount = e;
+	}
+	stop() {
+		if (this._stopWatch) {
+			let e = this._stopWatch.elapsed();
+			this.durations.push(e), this.elapsedOverall += e, this.invocationCount += 1, this._stopWatch = void 0;
+		}
+	}
+};
+V.all = /* @__PURE__ */ new Set(), V._idPool = 0;
+var Ae = V;
+var ct = -1;
+var le = class le {
+	constructor(e, t, r = (le._idPool++).toString(16).padStart(3, "0")) {
+		this._errorHandler = e;
+		this.threshold = t;
+		this.name = r;
+		this._warnCountdown = 0;
+	}
+	dispose() {
+		this._stacks?.clear();
+	}
+	check(e, t) {
+		let r = this.threshold;
+		if (r <= 0 || t < r) return;
+		this._stacks || (this._stacks = /* @__PURE__ */ new Map());
+		let i = this._stacks.get(e.value) || 0;
+		if (this._stacks.set(e.value, i + 1), this._warnCountdown -= 1, this._warnCountdown <= 0) {
+			this._warnCountdown = r * .5;
+			let [o, f] = this.getMostFrequentStack(), T = `[${this.name}] potential listener LEAK detected, having ${t} listeners already. MOST frequent listener (${f}):`;
+			console.warn(T), console.warn(o);
+			let p = new Ce(T, o);
+			this._errorHandler(p);
+		}
+		return () => {
+			let o = this._stacks.get(e.value) || 0;
+			this._stacks.set(e.value, o - 1);
+		};
+	}
+	getMostFrequentStack() {
+		if (!this._stacks) return;
+		let e, t = 0;
+		for (let [r, i] of this._stacks) (!e || t < i) && (e = [r, i], t = i);
+		return e;
+	}
+};
+le._idPool = 1;
+var we = le;
+var j = class n {
+	constructor(e) {
+		this.value = e;
+	}
+	static create() {
+		return new n((/* @__PURE__ */ new Error()).stack ?? "");
+	}
+	print() {
+		console.warn(this.value.split(`
+`).slice(2).join(`
+`));
+	}
+};
+var Ce = class extends Error {
+	constructor(e, t) {
+		super(e), this.name = "ListenerLeakError", this.stack = t;
+	}
+};
+var Re = class extends Error {
+	constructor(e, t) {
+		super(e), this.name = "ListenerRefusalError", this.stack = t;
+	}
+};
+var Kt = 0;
+var H = class {
+	constructor(e) {
+		this.value = e;
+		this.id = Kt++;
+	}
+};
+var zt = 2;
+var Gt = (n, e) => {
+	if (n instanceof H) e(n);
+	else for (let t = 0; t < n.length; t++) {
+		let r = n[t];
+		r && e(r);
+	}
+};
+var ae;
+if (Wt) {
+	let n = [];
+	setInterval(() => {
+		n.length !== 0 && (console.warn("[LEAKING LISTENERS] GC'ed these listeners that were NOT yet disposed:"), console.warn(n.join(`
+`)), n.length = 0);
+	}, 3e3), ae = new FinalizationRegistry((e) => {
+		typeof e == "string" && n.push(e);
+	});
+}
+var A = class {
+	constructor(e) {
+		this._size = 0;
+		this._options = e, this._leakageMon = ct > 0 || this._options?.leakWarningThreshold ? new we(e?.onListenerError ?? te, this._options?.leakWarningThreshold ?? ct) : void 0, this._perfMon = this._options?._profName ? new Ae(this._options._profName) : void 0, this._deliveryQueue = this._options?.deliveryQueue;
+	}
+	dispose() {
+		if (!this._disposed) {
+			if (this._disposed = !0, this._deliveryQueue?.current === this && this._deliveryQueue.reset(), this._listeners) {
+				if (dt) {
+					let e = this._listeners;
+					queueMicrotask(() => {
+						Gt(e, (t) => t.stack?.print());
+					});
+				}
+				this._listeners = void 0, this._size = 0;
+			}
+			this._options?.onDidRemoveLastListener?.(), this._leakageMon?.dispose();
+		}
+	}
+	get event() {
+		return this._event ??= (e, t, r) => {
+			if (this._leakageMon && this._size > this._leakageMon.threshold ** 2) {
+				let p = `[${this._leakageMon.name}] REFUSES to accept new listeners because it exceeded its threshold by far (${this._size} vs ${this._leakageMon.threshold})`;
+				console.warn(p);
+				let m = this._leakageMon.getMostFrequentStack() ?? ["UNKNOWN stack", -1], _ = new Re(`${p}. HINT: Stack shows most frequent listener (${m[1]}-times)`, m[0]);
+				return (this._options?.onListenerError || te)(_), k.None;
+			}
+			if (this._disposed) return k.None;
+			t && (e = e.bind(t));
+			let i = new H(e), o;
+			this._leakageMon && this._size >= Math.ceil(this._leakageMon.threshold * .2) && (i.stack = j.create(), o = this._leakageMon.check(i.stack, this._size + 1)), this._listeners ? this._listeners instanceof H ? (this._deliveryQueue ??= new ke(), this._listeners = [this._listeners, i]) : this._listeners.push(i) : (this._options?.onWillAddFirstListener?.(this), this._listeners = i, this._options?.onDidAddFirstListener?.(this)), this._size++;
+			let T = De(() => {
+				ae?.unregister(T), o?.(), this._removeListener(i);
+			});
+			if (r instanceof N ? r.add(T) : Array.isArray(r) && r.push(T), ae) {
+				let p = (/* @__PURE__ */ new Error()).stack.split(`
+`).slice(2, 3).join(`
+`).trim(), m = /(file:|vscode-file:\/\/vscode-app)?(\/[^:]*:\d+:\d+)/.exec(p);
+				ae.register(T, m?.[2] ?? p, T);
+			}
+			return T;
+		}, this._event;
+	}
+	_removeListener(e) {
+		if (this._options?.onWillRemoveListener?.(this), !this._listeners) return;
+		if (this._size === 1) {
+			this._listeners = void 0, this._options?.onDidRemoveLastListener?.(this), this._size = 0;
+			return;
+		}
+		let t = this._listeners, r = t.indexOf(e);
+		if (r === -1) throw console.log("disposed?", this._disposed), console.log("size?", this._size), console.log("arr?", JSON.stringify(this._listeners)), /* @__PURE__ */ new Error("Attempted to dispose unknown listener");
+		this._size--, t[r] = void 0;
+		let i = this._deliveryQueue.current === this;
+		if (this._size * zt <= t.length) {
+			let o = 0;
+			for (let f = 0; f < t.length; f++) t[f] ? t[o++] = t[f] : i && (this._deliveryQueue.end--, o < this._deliveryQueue.i && this._deliveryQueue.i--);
+			t.length = o;
+		}
+	}
+	_deliver(e, t) {
+		if (!e) return;
+		let r = this._options?.onListenerError || te;
+		if (!r) {
+			e.value(t);
+			return;
+		}
+		try {
+			e.value(t);
+		} catch (i) {
+			r(i);
+		}
+	}
+	_deliverQueue(e) {
+		let t = e.current._listeners;
+		for (; e.i < e.end;) this._deliver(t[e.i++], e.value);
+		e.reset();
+	}
+	fire(e) {
+		if (this._deliveryQueue?.current && (this._deliverQueue(this._deliveryQueue), this._perfMon?.stop()), this._perfMon?.start(this._size), this._listeners) if (this._listeners instanceof H) this._deliver(this._listeners, e);
+		else {
+			let t = this._deliveryQueue;
+			t.enqueue(this, e, this._listeners.length), this._deliverQueue(t);
+		}
+		this._perfMon?.stop();
+	}
+	hasListeners() {
+		return this._size > 0;
+	}
+};
+var ke = class {
+	constructor() {
+		this.i = -1;
+		this.end = 0;
+	}
+	enqueue(e, t, r) {
+		this.i = 0, this.end = r, this.current = e, this.value = t;
+	}
+	reset() {
+		this.i = this.end, this.current = void 0, this.value = void 0;
+	}
+};
+var w = class n {
+	constructor() {
+		this._providers = Object.create(null);
+		this._active = "";
+		this._onChange = new A();
+		this.onChange = this._onChange.event;
+		let e = new J();
+		this.register(e), this._active = e.version, this._activeProvider = e;
+	}
+	static extractShouldJoin(e) {
+		return (e & 1) !== 0;
+	}
+	static extractWidth(e) {
+		return e >> 1 & 3;
+	}
+	static extractCharKind(e) {
+		return e >> 3;
+	}
+	static createPropertyValue(e, t, r = !1) {
+		return (e & 16777215) << 3 | (t & 3) << 1 | (r ? 1 : 0);
+	}
+	dispose() {
+		this._onChange.dispose();
+	}
+	get versions() {
+		return Object.keys(this._providers);
+	}
+	get activeVersion() {
+		return this._active;
+	}
+	set activeVersion(e) {
+		if (!this._providers[e]) throw new Error(`unknown Unicode version "${e}"`);
+		this._active = e, this._activeProvider = this._providers[e], this._onChange.fire(e);
+	}
+	register(e) {
+		this._providers[e.version] = e;
+	}
+	wcwidth(e) {
+		return this._activeProvider.wcwidth(e);
+	}
+	getStringCellWidth(e) {
+		let t = 0, r = 0, i = e.length;
+		for (let o = 0; o < i; ++o) {
+			let f = e.charCodeAt(o);
+			if (55296 <= f && f <= 56319) {
+				if (++o >= i) return t + this.wcwidth(f);
+				let m = e.charCodeAt(o);
+				56320 <= m && m <= 57343 ? f = (f - 55296) * 1024 + m - 56320 + 65536 : t += this.wcwidth(m);
+			}
+			let T = this.charProperties(f, r), p = n.extractWidth(T);
+			n.extractShouldJoin(T) && (p -= n.extractWidth(r)), t += p, r = T;
+		}
+		return t;
+	}
+	charProperties(e, t) {
+		return this._activeProvider.charProperties(e, t);
+	}
+};
+var Ue = 0;
+var Tt = -3;
+var S = class {
+	constructor() {
+		this.table = /* @__PURE__ */ new Uint16Array(16);
+		this.trans = /* @__PURE__ */ new Uint16Array(288);
+	}
+};
+var Fe = class {
+	constructor(e, t) {
+		this.tag = 0;
+		this.bitcount = 0;
+		this.destLen = 0;
+		this.sourceIndex = 0;
+		this.source = e, this.dest = t, this.ltree = new S(), this.dtree = new S();
+	}
+};
+var xt = new S();
+var bt = new S();
+var Oe = /* @__PURE__ */ new Uint8Array(30);
+var Pe = /* @__PURE__ */ new Uint16Array(30);
+var vt = /* @__PURE__ */ new Uint8Array(30);
+var mt = /* @__PURE__ */ new Uint16Array(30);
+var jt = new Uint8Array([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+var ft = new S();
+var C = /* @__PURE__ */ new Uint8Array(320);
+function gt(n, e, t, r) {
+	var i = 0, o;
+	for (; i < t; ++i) n[i] = 0;
+	for (i = 0; i < 30 - t; ++i) n[i + t] = i / t | 0;
+	for (o = r, i = 0; i < 30; ++i) e[i] = o, o += 1 << n[i];
+}
+function Qt(n, e) {
+	var t = 0;
+	for (; t < 7; ++t) n.table[t] = 0;
+	for (n.table[7] = 24, n.table[8] = 152, n.table[9] = 112, t = 0; t < 24; ++t) n.trans[t] = 256 + t;
+	for (t = 0; t < 144; ++t) n.trans[24 + t] = t;
+	for (t = 0; t < 8; ++t) n.trans[168 + t] = 280 + t;
+	for (t = 0; t < 112; ++t) n.trans[176 + t] = 144 + t;
+	for (t = 0; t < 5; ++t) e.table[t] = 0;
+	for (e.table[5] = 32, t = 0; t < 32; ++t) e.trans[t] = t;
+}
+var pt = /* @__PURE__ */ new Uint16Array(16);
+function Le(n, e, t, r) {
+	var i = 0, o;
+	for (; i < 16; ++i) n.table[i] = 0;
+	for (i = 0; i < r; ++i) n.table[e[t + i]]++;
+	for (n.table[0] = 0, o = 0, i = 0; i < 16; ++i) pt[i] = o, o += n.table[i];
+	for (i = 0; i < r; ++i) e[t + i] && (n.trans[pt[e[t + i]]++] = i);
+}
+function Xt(n) {
+	n.bitcount-- || (n.tag = n.source[n.sourceIndex++], n.bitcount = 7);
+	var e = n.tag & 1;
+	return n.tag >>>= 1, e;
+}
+function R(n, e, t) {
+	if (!e) return t;
+	for (; n.bitcount < 24;) n.tag |= n.source[n.sourceIndex++] << n.bitcount, n.bitcount += 8;
+	var r = n.tag & 65535 >>> 16 - e;
+	return n.tag >>>= e, n.bitcount -= e, r + t;
+}
+function Se(n, e) {
+	for (; n.bitcount < 24;) n.tag |= n.source[n.sourceIndex++] << n.bitcount, n.bitcount += 8;
+	var t = 0, r = 0, i = 0, o = n.tag;
+	do
+		r = 2 * r + (o & 1), o >>>= 1, ++i, t += e.table[i], r -= e.table[i];
+	while (r >= 0);
+	return n.tag = o, n.bitcount -= i, e.trans[t + r];
+}
+function qt(n, e, t) {
+	var r = R(n, 5, 257), i = R(n, 5, 1), o = R(n, 4, 4), f = 0, T, p;
+	for (; f < 19; ++f) C[f] = 0;
+	for (f = 0; f < o; ++f) {
+		var m = R(n, 3, 0);
+		C[jt[f]] = m;
+	}
+	for (Le(ft, C, 0, 19), T = 0; T < r + i;) {
+		var _ = Se(n, ft);
+		switch (_) {
+			case 16:
+				var x = C[T - 1];
+				for (p = R(n, 2, 3); p; --p) C[T++] = x;
+				break;
+			case 17:
+				for (p = R(n, 3, 3); p; --p) C[T++] = 0;
+				break;
+			case 18:
+				for (p = R(n, 7, 11); p; --p) C[T++] = 0;
+				break;
+			default: C[T++] = _;
+		}
+	}
+	Le(e, C, 0, r), Le(t, C, r, i);
+}
+function ht(n, e, t) {
+	for (;;) {
+		var r = Se(n, e);
+		if (r === 256) return Ue;
+		if (r < 256) n.dest[n.destLen++] = r;
+		else {
+			var i, o, f, T;
+			for (r -= 257, i = R(n, Oe[r], Pe[r]), o = Se(n, t), f = n.destLen - R(n, vt[o], mt[o]), T = f; T < f + i; ++T) n.dest[n.destLen++] = n.dest[T];
+		}
+	}
+}
+function Zt(n) {
+	for (var e, t, r; n.bitcount > 8;) n.sourceIndex--, n.bitcount -= 8;
+	if (e = n.source[n.sourceIndex + 1], e = 256 * e + n.source[n.sourceIndex], t = n.source[n.sourceIndex + 3], t = 256 * t + n.source[n.sourceIndex + 2], e !== (~t & 65535)) return Tt;
+	for (n.sourceIndex += 4, r = e; r; --r) n.dest[n.destLen++] = n.source[n.sourceIndex++];
+	return n.bitcount = 0, Ue;
+}
+function Yt(n, e) {
+	var t = new Fe(n, e), r, i, o;
+	do {
+		switch (r = Xt(t), i = R(t, 2, 0), i) {
+			case 0:
+				o = Zt(t);
+				break;
+			case 1:
+				o = ht(t, xt, bt);
+				break;
+			case 2:
+				qt(t, t.ltree, t.dtree), o = ht(t, t.ltree, t.dtree);
+				break;
+			default: o = Tt;
+		}
+		if (o !== Ue) throw new Error("Data error");
+	} while (!r);
+	return t.destLen < t.dest.length ? typeof t.dest.slice == "function" ? t.dest.slice(0, t.destLen) : t.dest.subarray(0, t.destLen) : t.dest;
+}
+Qt(xt, bt);
+gt(Oe, Pe, 4, 3);
+gt(vt, mt, 2, 1);
+Oe[28] = 0;
+Pe[28] = 258;
+var Me = Yt;
+var We = 11;
+var U = 5;
+var Jt = We - U;
+var $t = 65536 >> We;
+var tn = (1 << Jt) - 1;
+var ue = 2;
+var Be = (1 << U) - 1;
+var _t = 65536 >> U;
+var ln = _t + (1024 >> U) + 32;
+var un = 1 << ue;
+var dn = new Uint8Array(new Uint32Array([305419896]).buffer)[0] === 18;
+var Ne = class {
+	constructor(e) {
+		let t = new DataView(e.buffer);
+		this.highStart = t.getUint32(0, !0), this.errorValue = t.getUint32(4, !0);
+		let r = t.getUint32(8, !0);
+		if (e = e.subarray(12), e = Me(e, new Uint8Array(r)), e = Me(e, new Uint8Array(r)), dn) {
+			let i = e.length;
+			for (let o = 0; o < i; o += 4) {
+				let f = e[o];
+				e[o] = e[o + 3], e[o + 3] = f;
+				let T = e[o + 1];
+				e[o + 1] = e[o + 2], e[o + 2] = T;
+			}
+		}
+		this.data = new Uint32Array(e.buffer);
+	}
+	get(e) {
+		let t;
+		return e < 0 || e > 1114111 ? this.errorValue : e < 55296 || e > 56319 && e <= 65535 ? (t = (this.data[e >> U] << ue) + (e & Be), this.data[t]) : e <= 65535 ? (t = (this.data[_t + (e - 55296 >> U)] << ue) + (e & Be), this.data[t]) : e < this.highStart ? (t = this.data[ln - $t + (e >> We)], t = this.data[t + (e >> U & tn)], t = (t << ue) + (e & Be), this.data[t]) : this.data[this.data.length - un];
+	}
+};
+var yt = Ne;
+var cn = "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";
+function fn(n) {
+	if (typeof Buffer < "u") return Buffer.from(n, "base64");
+	let e = atob(n), t = new Uint8Array(e.length);
+	for (let r = 0; r < t.length; ++r) t[r] = e.charCodeAt(r);
+	return t;
+}
+var pn = new yt(fn(cn));
+var de = 15;
+var ce = 0;
+var hn = 48;
+var Tn = 4;
+var Dt = 0;
+var je = 1;
+var Qe = 2;
+var Ge = 3;
+var xn = 4;
+var Ve = 5;
+var He = 6;
+var Ke = 7;
+var Et = 8;
+var ze = 9;
+var It = 10;
+var bn = 11;
+var vn = 32;
+function Xe(n) {
+	return (n & hn) >> Tn;
+}
+function At(n, e) {
+	let t = (n & de) >> ce, r = (e & de) >> ce;
+	return mn(t, r) ? r === Ge ? vn : r + 16 : r - 16;
+}
+function mn(n, e) {
+	return n >= Ve && n <= ze && (n == Ve && (e == Ve || e == He || e == Et || e == ze) || (n == Et || n == He) && (e == He || e == Ke) || (n == ze || n == Ke) && e == Ke) || e == Qe || e == It || n == je || e == xn || n == It && e == bn || e == Ge && n == Ge;
+}
+function qe(n) {
+	return pn.get(n);
+}
+var fe = class fe {
+	constructor(e = !0) {
+		this.ambiguousCharsAreWide = !1;
+		this.version = e ? "15-graphemes" : "15", this.handleGraphemes = e;
+	}
+	charProperties(e, t) {
+		if (e >= 32 && e < 127 && t >> 3 === 0) return fe._plainNarrowProperties;
+		let r = qe(e), i = Xe(r), o = !1;
+		if (i >= 2 ? i = i === 3 || this.ambiguousCharsAreWide || e === 65039 ? 2 : 1 : i = 1, t !== 0) {
+			let f = w.extractWidth(t);
+			this.handleGraphemes ? r = At(w.extractCharKind(t), r) : r = i === 0 ? 1 : 0, o = r > 0, o && (f > i ? i = f : r === 32 && (i = 2));
+		}
+		return w.createPropertyValue(r, i, o);
+	}
+	wcwidth(e) {
+		let t = qe(e), r = Xe(t), i = (t & de) >> ce;
+		return i === Qe || i === je ? 0 : r >= 2 && (r === 3 || this.ambiguousCharsAreWide) ? 2 : 1;
+	}
+};
+fe._plainNarrowProperties = w.createPropertyValue(Dt, 1, !1);
+var Q = fe;
+var wt = class {
+	constructor() {
+		this._oldVersion = "";
+	}
+	activate(e) {
+		this._provider15 || (this._provider15 = new Q(!1)), this._provider15Graphemes || (this._provider15Graphemes = new Q(!0));
+		let t = e.unicode;
+		this._unicode = t, t.register(this._provider15), t.register(this._provider15Graphemes), this._oldVersion = t.activeVersion, t.activeVersion = "15-graphemes";
+	}
+	dispose() {
+		this._unicode && (this._unicode.activeVersion = this._oldVersion);
+	}
+};
+//#endregion
+//#region src/terminal/terminal-view.tsx
+const DEFAULT_TERMINAL_THEME = {
+	background: "#0c0c0e",
+	foreground: "#d4d4d8",
+	cursor: "#34d399",
+	cursorAccent: "#0c0c0e",
+	selectionBackground: "#7c3aed33",
+	selectionForeground: "#d4d4d8",
+	black: "#18181b",
+	red: "#ef4444",
+	green: "#34d399",
+	yellow: "#fbbf24",
+	blue: "#60a5fa",
+	magenta: "#a78bfa",
+	cyan: "#22d3ee",
+	white: "#d4d4d8",
+	brightBlack: "#52525b",
+	brightRed: "#f87171",
+	brightGreen: "#6ee7b7",
+	brightYellow: "#fde68a",
+	brightBlue: "#93c5fd",
+	brightMagenta: "#c4b5fd",
+	brightCyan: "#67e8f9",
+	brightWhite: "#fafafa"
+};
+function TerminalView({ session, apiUrl, token, theme, title = "Terminal", subtitle = "Connected to PTY session", isActive = true, connectionId, incarnationId, control, fontSize = 13 }) {
+	const resolvedTheme = useMemo(() => ({
+		...DEFAULT_TERMINAL_THEME,
+		...theme
+	}), [theme]);
+	const resolvedFontSize = Number.isFinite(fontSize) && fontSize > 0 ? fontSize : 13;
+	const fontSizeRef = useRef(resolvedFontSize);
+	fontSizeRef.current = resolvedFontSize;
+	const containerRef = useRef(null);
+	const termRef = useRef(null);
+	const fitAddonRef = useRef(null);
+	const pendingWritesRef = useRef([]);
+	const writeRafRef = useRef(null);
+	const onData = useCallback((data) => {
+		if (!data) return;
+		pendingWritesRef.current.push(data);
+		if (writeRafRef.current !== null) return;
+		writeRafRef.current = requestAnimationFrame(() => {
+			writeRafRef.current = null;
+			const chunks = pendingWritesRef.current;
+			if (chunks.length === 0) return;
+			pendingWritesRef.current = [];
+			termRef.current?.write(chunks.length === 1 ? chunks[0] : chunks.join(""));
+		});
+	}, []);
+	const usesCallerSession = session !== void 0;
+	const shellSession = usePtySession({
+		enabled: !usesCallerSession,
+		apiUrl,
+		token,
+		onData,
+		connectionId,
+		incarnationId,
+		control
+	});
+	const { isConnected, error, sendCommand, resizeTerminal, reconnect } = session ?? shellSession;
+	const subscribeData = session?.subscribeData;
+	useEffect(() => subscribeData?.(onData), [subscribeData, onData]);
+	useEffect(() => {
+		if (!containerRef.current) return;
+		const term = new Terminal({
+			theme: resolvedTheme,
+			fontFamily: "\"JetBrains Mono\", \"Fira Code\", \"Cascadia Code\", Menlo, monospace",
+			fontSize: fontSizeRef.current,
+			lineHeight: 1.4,
+			cursorBlink: true,
+			cursorStyle: "bar",
+			scrollback: 5e3,
+			convertEol: true,
+			allowProposedApi: true
+		});
+		const fitAddon = new FitAddon();
+		const webLinksAddon = new WebLinksAddon();
+		term.loadAddon(new wt());
+		term.unicode.activeVersion = "15-graphemes";
+		term.loadAddon(fitAddon);
+		term.loadAddon(webLinksAddon);
+		term.open(containerRef.current);
+		let webglAddon = null;
+		let webglCancelled = false;
+		(async () => {
+			try {
+				const mod = await import("@xterm/addon-webgl");
+				if (webglCancelled) return;
+				try {
+					const addon = new mod.WebglAddon();
+					addon.onContextLoss(() => {
+						webglAddon?.dispose();
+						webglAddon = null;
+					});
+					webglAddon = addon;
+					term.loadAddon(addon);
+				} catch {}
+			} catch {}
+		})();
+		requestAnimationFrame(() => {
+			fitAddon.fit();
+		});
+		termRef.current = term;
+		fitAddonRef.current = fitAddon;
+		term.onData((data) => {
+			if (!usesCallerSession && data === "\f") {
+				termRef.current?.clear();
+				sendCommand("\r").catch(console.error);
+				return;
+			}
+			sendCommand(data).catch((err) => {
+				termRef.current?.writeln(`\r\n\x1b[31m${err instanceof Error ? err.message : "Send failed"}\x1b[0m`);
+			});
+		});
+		term.onResize(({ cols, rows }) => {
+			resizeTerminal(cols, rows).catch(console.error);
+		});
+		const ro = new ResizeObserver(() => {
+			requestAnimationFrame(() => {
+				fitAddon.fit();
+			});
+		});
+		ro.observe(containerRef.current);
+		return () => {
+			webglCancelled = true;
+			ro.disconnect();
+			if (writeRafRef.current !== null) {
+				cancelAnimationFrame(writeRafRef.current);
+				writeRafRef.current = null;
+			}
+			pendingWritesRef.current = [];
+			webglAddon?.dispose();
+			term.dispose();
+			termRef.current = null;
+			fitAddonRef.current = null;
+		};
+	}, [
+		sendCommand,
+		resizeTerminal,
+		title,
+		subtitle,
+		usesCallerSession
+	]);
+	useEffect(() => {
+		if (termRef.current) termRef.current.options.theme = resolvedTheme;
+	}, [resolvedTheme]);
+	useEffect(() => {
+		const term = termRef.current;
+		if (!term || term.options.fontSize === resolvedFontSize) return;
+		term.options.fontSize = resolvedFontSize;
+		const rafId = requestAnimationFrame(() => fitAddonRef.current?.fit());
+		return () => cancelAnimationFrame(rafId);
+	}, [resolvedFontSize]);
+	useEffect(() => {
+		if (isConnected && termRef.current) {
+			resizeTerminal(termRef.current.cols, termRef.current.rows).catch(console.error);
+			if (isActive) termRef.current.focus();
+		}
+	}, [
+		isConnected,
+		resizeTerminal,
+		isActive
+	]);
+	useEffect(() => {
+		if (isActive && termRef.current && fitAddonRef.current) setTimeout(() => {
+			fitAddonRef.current?.fit();
+			termRef.current?.focus();
+		}, 50);
+	}, [isActive]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "relative h-full w-full group cursor-text",
+		onClick: () => termRef.current?.focus(),
+		children: [/* @__PURE__ */ jsx("div", {
+			ref: containerRef,
+			className: "h-full w-full overflow-hidden relative z-0",
+			style: { backgroundColor: resolvedTheme.background }
+		}), (!isConnected || error) && /* @__PURE__ */ jsx("div", {
+			className: "absolute inset-0 flex items-center justify-center bg-surface-container-lowest",
+			children: /* @__PURE__ */ jsx("div", {
+				className: "text-center",
+				children: error ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("p", {
+					className: "text-sm text-[var(--surface-danger-text)] mb-3",
+					children: error
+				}), /* @__PURE__ */ jsx("button", {
+					onClick: reconnect,
+					className: "text-sm text-[var(--surface-success-text)] hover:opacity-80 underline cursor-pointer",
+					children: "Retry connection"
+				})] }) : /* @__PURE__ */ jsx("p", {
+					className: "text-[13px] text-muted-foreground",
+					children: "Connecting to terminal..."
+				})
+			})
+		})]
+	});
+}
+//#endregion
+export { TerminalView as n, DEFAULT_TERMINAL_THEME as t };