@hediet/linkrpc-cli 0.0.3-next.20260922.2 → 0.0.3-next.20260924.1

package/dist/chunks/dist-BOcSU4-O.js

@@ -0,0 +1,1500 @@
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/logging/logging.js
+let globalObservableLogger;
+function addLogger(logger) {
+	if (!globalObservableLogger) globalObservableLogger = logger;
+	else if (globalObservableLogger instanceof ComposedLogger) globalObservableLogger.loggers.push(logger);
+	else globalObservableLogger = new ComposedLogger([globalObservableLogger, logger]);
+}
+function getLogger() {
+	return globalObservableLogger;
+}
+let globalObservableLoggerFn = void 0;
+function setLogObservableFn(fn) {
+	globalObservableLoggerFn = fn;
+}
+function logObservable(obs) {
+	if (globalObservableLoggerFn) globalObservableLoggerFn(obs);
+}
+var ComposedLogger = class {
+	constructor(loggers) {
+		this.loggers = loggers;
+	}
+	handleObservableCreated(observable, location) {
+		for (const logger of this.loggers) logger.handleObservableCreated(observable, location);
+	}
+	handleOnListenerCountChanged(observable, newCount) {
+		for (const logger of this.loggers) logger.handleOnListenerCountChanged(observable, newCount);
+	}
+	handleObservableUpdated(observable, info) {
+		for (const logger of this.loggers) logger.handleObservableUpdated(observable, info);
+	}
+	handleAutorunCreated(autorun, location) {
+		for (const logger of this.loggers) logger.handleAutorunCreated(autorun, location);
+	}
+	handleAutorunDisposed(autorun) {
+		for (const logger of this.loggers) logger.handleAutorunDisposed(autorun);
+	}
+	handleAutorunDependencyChanged(autorun, observable, change) {
+		for (const logger of this.loggers) logger.handleAutorunDependencyChanged(autorun, observable, change);
+	}
+	handleAutorunStarted(autorun) {
+		for (const logger of this.loggers) logger.handleAutorunStarted(autorun);
+	}
+	handleAutorunFinished(autorun) {
+		for (const logger of this.loggers) logger.handleAutorunFinished(autorun);
+	}
+	handleDerivedDependencyChanged(derived, observable, change) {
+		for (const logger of this.loggers) logger.handleDerivedDependencyChanged(derived, observable, change);
+	}
+	handleDerivedCleared(observable) {
+		for (const logger of this.loggers) logger.handleDerivedCleared(observable);
+	}
+	handleBeginTransaction(transaction) {
+		for (const logger of this.loggers) logger.handleBeginTransaction(transaction);
+	}
+	handleEndTransaction(transaction) {
+		for (const logger of this.loggers) logger.handleEndTransaction(transaction);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/debugLocation.js
+var DebugLocation;
+(function(DebugLocation) {
+	let enabled = false;
+	function enable() {
+		enabled = true;
+	}
+	DebugLocation.enable = enable;
+	function ofCaller() {
+		return ofNthCaller(1);
+	}
+	DebugLocation.ofCaller = ofCaller;
+	function ofNthCaller(n) {
+		if (!enabled) return;
+		const Err = Error;
+		const l = Err.stackTraceLimit;
+		Err.stackTraceLimit = 3;
+		const stack = (/* @__PURE__ */ new Error()).stack;
+		Err.stackTraceLimit = l;
+		return DebugLocationImpl.fromStack(stack, n + 1);
+	}
+	DebugLocation.ofNthCaller = ofNthCaller;
+})(DebugLocation || (DebugLocation = {}));
+var DebugLocationImpl = class DebugLocationImpl {
+	static fromStack(stack, parentIdx) {
+		const location = parseLine(stack.split("\n")[parentIdx + 1]);
+		if (location) return new DebugLocationImpl(location.fileName, location.line, location.column, location.id);
+		else return;
+	}
+	constructor(fileName, line, column, id) {
+		this.fileName = fileName;
+		this.line = line;
+		this.column = column;
+		this.id = id;
+	}
+};
+function parseLine(stackLine) {
+	if (!stackLine) return;
+	const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
+	if (match) return {
+		fileName: match[1],
+		line: parseInt(match[2]),
+		column: parseInt(match[3]),
+		id: stackLine
+	};
+	const match2 = stackLine.match(/at ([^\(\)]*):(\d+):(\d+)/);
+	if (match2) return {
+		fileName: match2[1],
+		line: parseInt(match2[2]),
+		column: parseInt(match2[3]),
+		id: stackLine
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/debugName.js
+var DebugNameData = class {
+	constructor(owner, debugNameSource, referenceFn) {
+		this.owner = owner;
+		this.debugNameSource = debugNameSource;
+		this.referenceFn = referenceFn;
+	}
+	getDebugName(target) {
+		return getDebugName(target, this);
+	}
+};
+const countPerName = /* @__PURE__ */ new Map();
+const cachedDebugName = /* @__PURE__ */ new WeakMap();
+function getDebugName(target, data) {
+	const cached = cachedDebugName.get(target);
+	if (cached) return cached;
+	const dbgName = computeDebugName(target, data);
+	if (dbgName) {
+		let count = countPerName.get(dbgName) ?? 0;
+		count++;
+		countPerName.set(dbgName, count);
+		const result = count === 1 ? dbgName : `${dbgName}#${count}`;
+		cachedDebugName.set(target, result);
+		return result;
+	}
+}
+function computeDebugName(self, data) {
+	const cached = cachedDebugName.get(self);
+	if (cached) return cached;
+	const ownerStr = data.owner ? formatOwner(data.owner) + `.` : "";
+	let result;
+	const debugNameSource = data.debugNameSource;
+	if (debugNameSource !== void 0) {
+		if (typeof debugNameSource === "function") {
+			result = debugNameSource();
+			if (result !== void 0) return ownerStr + result;
+		} else return ownerStr + debugNameSource;
+	}
+	const referenceFn = data.referenceFn;
+	if (referenceFn !== void 0) {
+		result = getFunctionName(referenceFn);
+		if (result !== void 0) return ownerStr + result;
+	}
+	if (data.owner !== void 0) {
+		const key = findKey(data.owner, self);
+		if (key !== void 0) return ownerStr + key;
+	}
+}
+function findKey(obj, value) {
+	for (const key in obj) if (obj[key] === value) return key;
+}
+const countPerClassName = /* @__PURE__ */ new Map();
+const ownerId = /* @__PURE__ */ new WeakMap();
+function formatOwner(owner) {
+	const id = ownerId.get(owner);
+	if (id) return id;
+	const className = getClassName(owner) ?? "Object";
+	let count = countPerClassName.get(className) ?? 0;
+	count++;
+	countPerClassName.set(className, count);
+	const result = count === 1 ? className : `${className}#${count}`;
+	ownerId.set(owner, result);
+	return result;
+}
+function getClassName(obj) {
+	const ctor = obj.constructor;
+	if (ctor) {
+		if (ctor.name === "Object") return;
+		return ctor.name;
+	}
+}
+function getFunctionName(fn) {
+	const fnSrc = fn.toString();
+	const match = /\/\*\*\s*@description\s*([^*]*)\*\//.exec(fnSrc);
+	return (match ? match[1] : void 0)?.trim();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/observables/baseObservable.js
+let _derived;
+/**
+* @internal
+* This is to allow splitting files.
+*/
+function _setDerivedOpts(derived) {
+	_derived = derived;
+}
+let _recomputeInitiallyAndOnChange;
+function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange) {
+	_recomputeInitiallyAndOnChange = recomputeInitiallyAndOnChange;
+}
+let _keepObserved;
+function _setKeepObserved(keepObserved) {
+	_keepObserved = keepObserved;
+}
+let _debugGetDependencyGraph;
+function _setDebugGetDependencyGraph(debugGetDependencyGraph) {
+	_debugGetDependencyGraph = debugGetDependencyGraph;
+}
+var ConvenientObservable = class {
+	get TChange() {
+		return null;
+	}
+	reportChanges() {
+		this.get();
+	}
+	/** @sealed */
+	read(reader) {
+		if (reader) return reader.readObservable(this);
+		else return this.get();
+	}
+	map(fnOrOwner, fnOrUndefined, debugLocation = DebugLocation.ofCaller()) {
+		const owner = fnOrUndefined === void 0 ? void 0 : fnOrOwner;
+		const fn = fnOrUndefined === void 0 ? fnOrOwner : fnOrUndefined;
+		return _derived({
+			owner,
+			debugName: () => {
+				const name = getFunctionName(fn);
+				if (name !== void 0) return name;
+				const match = /^\s*\(?\s*([a-zA-Z_$][a-zA-Z_$0-9]*)\s*\)?\s*=>\s*\1(?:\??)\.([a-zA-Z_$][a-zA-Z_$0-9]*)\s*$/.exec(fn.toString());
+				if (match) return `${this.debugName}.${match[2]}`;
+				if (!owner) return `${this.debugName} (mapped)`;
+			},
+			debugReferenceFn: fn
+		}, (reader) => fn(this.read(reader), reader), debugLocation);
+	}
+	/**
+	* @sealed
+	* Converts an observable of an observable value into a direct observable of the value.
+	*/
+	flatten() {
+		return _derived({
+			owner: void 0,
+			debugName: () => `${this.debugName} (flattened)`
+		}, (reader) => this.read(reader).read(reader));
+	}
+	recomputeInitiallyAndOnChange(store, handleValue) {
+		store.add(_recomputeInitiallyAndOnChange(this, handleValue));
+		return this;
+	}
+	/**
+	* Ensures that this observable is observed. This keeps the cache alive.
+	* However, in case of deriveds, it does not force eager evaluation (only when the value is read/get).
+	* Use `recomputeInitiallyAndOnChange` for eager evaluation.
+	*/
+	keepObserved(store) {
+		store.add(_keepObserved(this));
+		return this;
+	}
+	get debugValue() {
+		return this.get();
+	}
+	debugGetDependencyGraph() {
+		return _debugGetDependencyGraph(this);
+	}
+};
+var BaseObservable = class extends ConvenientObservable {
+	constructor(debugLocation) {
+		super();
+		this._observers = /* @__PURE__ */ new Set();
+		getLogger()?.handleObservableCreated(this, debugLocation);
+	}
+	addObserver(observer) {
+		const len = this._observers.size;
+		this._observers.add(observer);
+		if (len === 0) this.onFirstObserverAdded();
+		if (len !== this._observers.size) getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
+	}
+	removeObserver(observer) {
+		const deleted = this._observers.delete(observer);
+		if (deleted && this._observers.size === 0) this.onLastObserverRemoved();
+		if (deleted) getLogger()?.handleOnListenerCountChanged(this, this._observers.size);
+	}
+	onFirstObserverAdded() {}
+	onLastObserverRemoved() {}
+	log() {
+		const hadLogger = !!getLogger();
+		logObservable(this);
+		if (!hadLogger) getLogger()?.handleObservableCreated(this, DebugLocation.ofCaller());
+		return this;
+	}
+	debugGetObservers() {
+		return this._observers;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/commonFacade/deps.js
+function toDisposable(fn) {
+	return { dispose: fn };
+}
+var BugIndicatingError = class BugIndicatingError extends Error {
+	constructor(message) {
+		super(message || "An unexpected bug occurred.");
+		Object.setPrototypeOf(this, BugIndicatingError.prototype);
+	}
+};
+function onBugIndicatingError(error) {
+	throw error;
+}
+function onUnexpectedError(error) {
+	console.error("Unexpected error:", error);
+}
+/**
+* Compares two items for equality using strict equality.
+*/
+const strictEquals = (a, b) => a === b;
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/disposables.js
+var DisposableStore = class {
+	constructor() {
+		this.disposables = [];
+		this._isDisposed = false;
+	}
+	get isDisposed() {
+		return this._isDisposed;
+	}
+	dispose() {
+		this.clear();
+		this._isDisposed = true;
+	}
+	add(disposable) {
+		if (disposable) this.disposables.push(disposable);
+		return disposable;
+	}
+	remove(disposable) {
+		if (!disposable) return disposable;
+		const index = this.disposables.indexOf(disposable);
+		if (index !== -1) this.disposables.splice(index, 1);
+		return disposable;
+	}
+	clear() {
+		for (const disposable of this.disposables) disposable.dispose();
+		this.disposables = [];
+	}
+	leakItems() {
+		this.disposables = [];
+	}
+};
+var Disposable = class {
+	constructor() {
+		this._store = new DisposableStore();
+	}
+	dispose() {
+		this._store.dispose();
+	}
+	_register(t) {
+		this._store.add(t);
+		return t;
+	}
+	_registerOrDispose(t) {
+		if (t) {
+			if (this._store.isDisposed) t.dispose();
+			else this._store.add(t);
+		}
+		return t;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/observables/derivedImpl.js
+function derivedStateToString(state) {
+	switch (state) {
+		case 0: return "initial";
+		case 1: return "dependenciesMightHaveChanged";
+		case 2: return "stale";
+		case 3: return "upToDate";
+		default: return "<unknown>";
+	}
+}
+var Derived = class extends BaseObservable {
+	get debugName() {
+		return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+	}
+	constructor(_debugNameData, _computeFn, _changeTracker, _handleLastObserverRemoved = void 0, _equalityComparator, debugLocation) {
+		super(debugLocation);
+		this._debugNameData = _debugNameData;
+		this._computeFn = _computeFn;
+		this._changeTracker = _changeTracker;
+		this._handleLastObserverRemoved = _handleLastObserverRemoved;
+		this._equalityComparator = _equalityComparator;
+		this._state = 0;
+		this._value = void 0;
+		this._updateCount = 0;
+		this._dependencies = /* @__PURE__ */ new Set();
+		this._dependenciesToBeRemoved = /* @__PURE__ */ new Set();
+		this._changeSummary = void 0;
+		this._isUpdating = false;
+		this._isComputing = false;
+		this._didReportChange = false;
+		this._isInBeforeUpdate = false;
+		this._isReaderValid = false;
+		this._store = void 0;
+		this._delayedStore = void 0;
+		this._removedObserverToCallEndUpdateOn = null;
+		this._changeSummary = this._changeTracker?.createChangeSummary(void 0);
+	}
+	onLastObserverRemoved() {
+		/**
+		* We are not tracking changes anymore, thus we have to assume
+		* that our cache is invalid.
+		*/
+		this._state = 0;
+		this._value = void 0;
+		getLogger()?.handleDerivedCleared(this);
+		for (const d of this._dependencies) d.removeObserver(this);
+		this._dependencies.clear();
+		if (this._store !== void 0) {
+			this._store.dispose();
+			this._store = void 0;
+		}
+		if (this._delayedStore !== void 0) {
+			this._delayedStore.dispose();
+			this._delayedStore = void 0;
+		}
+		this._handleLastObserverRemoved?.();
+	}
+	get() {
+		if (this._isComputing && false);
+		if (this._observers.size === 0) {
+			let result;
+			try {
+				this._isReaderValid = true;
+				let changeSummary = void 0;
+				if (this._changeTracker) {
+					changeSummary = this._changeTracker.createChangeSummary(void 0);
+					this._changeTracker.beforeUpdate?.(this, changeSummary);
+				}
+				result = this._computeFn(this, changeSummary);
+			} finally {
+				this._isReaderValid = false;
+			}
+			this.onLastObserverRemoved();
+			return result;
+		} else {
+			do {
+				if (this._state === 1) for (const d of this._dependencies) {
+					/** might call {@link handleChange} indirectly, which could make us stale */
+					d.reportChanges();
+					if (this._state === 2) break;
+				}
+				if (this._state === 1) this._state = 3;
+				if (this._state !== 3) this._recompute();
+			} while (this._state !== 3);
+			return this._value;
+		}
+	}
+	_recompute() {
+		let didChange = false;
+		this._isComputing = true;
+		this._didReportChange = false;
+		const emptySet = this._dependenciesToBeRemoved;
+		this._dependenciesToBeRemoved = this._dependencies;
+		this._dependencies = emptySet;
+		try {
+			const changeSummary = this._changeSummary;
+			this._isReaderValid = true;
+			if (this._changeTracker) {
+				this._isInBeforeUpdate = true;
+				this._changeTracker.beforeUpdate?.(this, changeSummary);
+				this._isInBeforeUpdate = false;
+				this._changeSummary = this._changeTracker?.createChangeSummary(changeSummary);
+			}
+			const hadValue = this._state !== 0;
+			const oldValue = this._value;
+			this._state = 3;
+			const delayedStore = this._delayedStore;
+			if (delayedStore !== void 0) this._delayedStore = void 0;
+			try {
+				if (this._store !== void 0) {
+					this._store.dispose();
+					this._store = void 0;
+				}
+				/** might call {@link handleChange} indirectly, which could invalidate us */
+				this._value = this._computeFn(this, changeSummary);
+			} finally {
+				this._isReaderValid = false;
+				for (const o of this._dependenciesToBeRemoved) o.removeObserver(this);
+				this._dependenciesToBeRemoved.clear();
+				if (delayedStore !== void 0) delayedStore.dispose();
+			}
+			didChange = this._didReportChange || hadValue && !this._equalityComparator(oldValue, this._value);
+			getLogger()?.handleObservableUpdated(this, {
+				oldValue,
+				newValue: this._value,
+				change: void 0,
+				didChange,
+				hadValue
+			});
+		} catch (e) {
+			onBugIndicatingError(e);
+		}
+		this._isComputing = false;
+		if (!this._didReportChange && didChange) for (const r of this._observers) r.handleChange(this, void 0);
+		else this._didReportChange = false;
+	}
+	toString() {
+		return `LazyDerived<${this.debugName}>`;
+	}
+	beginUpdate(_observable) {
+		if (this._isUpdating) throw new BugIndicatingError("Cyclic deriveds are not supported yet!");
+		this._updateCount++;
+		this._isUpdating = true;
+		try {
+			const propagateBeginUpdate = this._updateCount === 1;
+			if (this._state === 3) {
+				this._state = 1;
+				if (!propagateBeginUpdate) for (const r of this._observers) r.handlePossibleChange(this);
+			}
+			if (propagateBeginUpdate) for (const r of this._observers) r.beginUpdate(this);
+		} finally {
+			this._isUpdating = false;
+		}
+	}
+	endUpdate(_observable) {
+		this._updateCount--;
+		if (this._updateCount === 0) {
+			const observers = [...this._observers];
+			for (const r of observers) r.endUpdate(this);
+			if (this._removedObserverToCallEndUpdateOn) {
+				const observers = [...this._removedObserverToCallEndUpdateOn];
+				this._removedObserverToCallEndUpdateOn = null;
+				for (const r of observers) r.endUpdate(this);
+			}
+		}
+	}
+	handlePossibleChange(observable) {
+		if (this._state === 3 && this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable)) {
+			this._state = 1;
+			for (const r of this._observers) r.handlePossibleChange(this);
+		}
+	}
+	handleChange(observable, change) {
+		if (this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable) || this._isInBeforeUpdate) {
+			getLogger()?.handleDerivedDependencyChanged(this, observable, change);
+			let shouldReact = false;
+			try {
+				shouldReact = this._changeTracker ? this._changeTracker.handleChange({
+					changedObservable: observable,
+					change,
+					didChange: (o) => o === observable
+				}, this._changeSummary) : true;
+			} catch (e) {
+				onBugIndicatingError(e);
+			}
+			const wasUpToDate = this._state === 3;
+			if (shouldReact && (this._state === 1 || wasUpToDate)) {
+				this._state = 2;
+				if (wasUpToDate) for (const r of this._observers) r.handlePossibleChange(this);
+			}
+		}
+	}
+	_ensureReaderValid() {
+		if (!this._isReaderValid) throw new BugIndicatingError("The reader object cannot be used outside its compute function!");
+	}
+	readObservable(observable) {
+		this._ensureReaderValid();
+		observable.addObserver(this);
+		/** This might call {@link handleChange} indirectly, which could invalidate us */
+		const value = observable.get();
+		this._dependencies.add(observable);
+		this._dependenciesToBeRemoved.delete(observable);
+		return value;
+	}
+	reportChange(change) {
+		this._ensureReaderValid();
+		this._didReportChange = true;
+		for (const r of this._observers) r.handleChange(this, change);
+	}
+	get store() {
+		this._ensureReaderValid();
+		if (this._store === void 0) this._store = new DisposableStore();
+		return this._store;
+	}
+	get delayedStore() {
+		this._ensureReaderValid();
+		if (this._delayedStore === void 0) this._delayedStore = new DisposableStore();
+		return this._delayedStore;
+	}
+	addObserver(observer) {
+		const shouldCallBeginUpdate = !this._observers.has(observer) && this._updateCount > 0;
+		super.addObserver(observer);
+		if (shouldCallBeginUpdate) {
+			if (this._removedObserverToCallEndUpdateOn && this._removedObserverToCallEndUpdateOn.has(observer)) this._removedObserverToCallEndUpdateOn.delete(observer);
+			else observer.beginUpdate(this);
+		}
+	}
+	removeObserver(observer) {
+		if (this._observers.has(observer) && this._updateCount > 0) {
+			if (!this._removedObserverToCallEndUpdateOn) this._removedObserverToCallEndUpdateOn = /* @__PURE__ */ new Set();
+			this._removedObserverToCallEndUpdateOn.add(observer);
+		}
+		super.removeObserver(observer);
+	}
+	debugGetState() {
+		return {
+			state: this._state,
+			stateStr: derivedStateToString(this._state),
+			updateCount: this._updateCount,
+			isComputing: this._isComputing,
+			dependencies: this._dependencies,
+			value: this._value
+		};
+	}
+	debugSetValue(newValue) {
+		this._value = newValue;
+	}
+	debugRecompute() {
+		if (!this._isComputing) this._recompute();
+		else this._state = 2;
+	}
+	setValue(newValue, tx, change) {
+		this._value = newValue;
+		const observers = this._observers;
+		tx.updateObserver(this, this);
+		for (const d of observers) d.handleChange(this, change);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/observables/derived.js
+function derived(computeFnOrOwner, computeFn, debugLocation = DebugLocation.ofCaller()) {
+	if (computeFn !== void 0) return new Derived(new DebugNameData(computeFnOrOwner, void 0, computeFn), computeFn, void 0, void 0, strictEquals, debugLocation);
+	return new Derived(new DebugNameData(void 0, void 0, computeFnOrOwner), computeFnOrOwner, void 0, void 0, strictEquals, debugLocation);
+}
+function derivedOpts(options, computeFn, debugLocation = DebugLocation.ofCaller()) {
+	return new Derived(new DebugNameData(options.owner, options.debugName, options.debugReferenceFn), computeFn, void 0, options.onLastObserverRemoved, options.equalsFn ?? strictEquals, debugLocation);
+}
+_setDerivedOpts(derivedOpts);
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/reactions/createEffectImpl.js
+function autorunStateToString(state) {
+	switch (state) {
+		case 1: return "dependenciesMightHaveChanged";
+		case 2: return "stale";
+		case 3: return "upToDate";
+		default: return "<unknown>";
+	}
+}
+var AutorunObserver = class {
+	get debugName() {
+		return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+	}
+	constructor(_debugNameData, _runFn, _changeTracker, debugLocation) {
+		this._debugNameData = _debugNameData;
+		this._runFn = _runFn;
+		this._changeTracker = _changeTracker;
+		this._state = 2;
+		this._updateCount = 0;
+		this._disposed = false;
+		this._dependencies = /* @__PURE__ */ new Set();
+		this._dependenciesToBeRemoved = /* @__PURE__ */ new Set();
+		this._isRunning = false;
+		this._store = void 0;
+		this._delayedStore = void 0;
+		this._changeSummary = this._changeTracker?.createChangeSummary(void 0);
+		getLogger()?.handleAutorunCreated(this, debugLocation);
+		this._run();
+	}
+	dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		for (const o of this._dependencies) o.removeObserver(this);
+		this._dependencies.clear();
+		if (this._store !== void 0) this._store.dispose();
+		if (this._delayedStore !== void 0) this._delayedStore.dispose();
+		getLogger()?.handleAutorunDisposed(this);
+	}
+	_run() {
+		const emptySet = this._dependenciesToBeRemoved;
+		this._dependenciesToBeRemoved = this._dependencies;
+		this._dependencies = emptySet;
+		this._state = 3;
+		try {
+			if (!this._disposed) {
+				getLogger()?.handleAutorunStarted(this);
+				const changeSummary = this._changeSummary;
+				const delayedStore = this._delayedStore;
+				if (delayedStore !== void 0) this._delayedStore = void 0;
+				try {
+					this._isRunning = true;
+					if (this._changeTracker) {
+						this._changeTracker.beforeUpdate?.(this, changeSummary);
+						this._changeSummary = this._changeTracker.createChangeSummary(changeSummary);
+					}
+					if (this._store !== void 0) {
+						this._store.dispose();
+						this._store = void 0;
+					}
+					this._runFn(this, changeSummary);
+				} catch (e) {
+					onBugIndicatingError(e);
+				} finally {
+					this._isRunning = false;
+					if (delayedStore !== void 0) delayedStore.dispose();
+				}
+			}
+		} finally {
+			if (!this._disposed) getLogger()?.handleAutorunFinished(this);
+			for (const o of this._dependenciesToBeRemoved) o.removeObserver(this);
+			this._dependenciesToBeRemoved.clear();
+		}
+	}
+	toString() {
+		return `Autorun<${this.debugName}>`;
+	}
+	beginUpdate(_observable) {
+		if (this._state === 3) this._state = 1;
+		this._updateCount++;
+	}
+	endUpdate(_observable) {
+		try {
+			if (this._updateCount === 1) do {
+				if (this._state === 1) {
+					this._state = 3;
+					for (const d of this._dependencies) {
+						d.reportChanges();
+						if (this._state === 2) break;
+					}
+				}
+				if (this._state !== 3) this._run();
+			} while (this._state !== 3);
+		} finally {
+			this._updateCount--;
+		}
+	}
+	handlePossibleChange(observable) {
+		if (this._state === 3 && this._isDependency(observable)) this._state = 1;
+	}
+	handleChange(observable, change) {
+		if (this._isDependency(observable)) {
+			getLogger()?.handleAutorunDependencyChanged(this, observable, change);
+			try {
+				if (this._changeTracker ? this._changeTracker.handleChange({
+					changedObservable: observable,
+					change,
+					didChange: (o) => o === observable
+				}, this._changeSummary) : true) this._state = 2;
+			} catch (e) {
+				onBugIndicatingError(e);
+			}
+		}
+	}
+	_isDependency(observable) {
+		return this._dependencies.has(observable) && !this._dependenciesToBeRemoved.has(observable);
+	}
+	_ensureNoRunning() {
+		if (!this._isRunning) throw new BugIndicatingError("The reader object cannot be used outside its compute function!");
+	}
+	readObservable(observable) {
+		this._ensureNoRunning();
+		if (this._disposed) return observable.get();
+		observable.addObserver(this);
+		const value = observable.get();
+		this._dependencies.add(observable);
+		this._dependenciesToBeRemoved.delete(observable);
+		return value;
+	}
+	get store() {
+		this._ensureNoRunning();
+		if (this._disposed) throw new BugIndicatingError("Cannot access store after dispose");
+		if (this._store === void 0) this._store = new DisposableStore();
+		return this._store;
+	}
+	get delayedStore() {
+		this._ensureNoRunning();
+		if (this._disposed) throw new BugIndicatingError("Cannot access store after dispose");
+		if (this._delayedStore === void 0) this._delayedStore = new DisposableStore();
+		return this._delayedStore;
+	}
+	debugGetState() {
+		return {
+			isRunning: this._isRunning,
+			updateCount: this._updateCount,
+			dependencies: this._dependencies,
+			state: this._state,
+			stateStr: autorunStateToString(this._state)
+		};
+	}
+	debugRerun() {
+		if (!this._isRunning) this._run();
+		else this._state = 2;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/reactions/createEffect.js
+/**
+* Runs immediately and whenever a transaction ends and an observed observable changed.
+* {@link fn} should start with a JS Doc using `@description` to name the effect.
+*/
+function createEffect(fn, debugLocation = DebugLocation.ofCaller()) {
+	return new AutorunObserver(new DebugNameData(void 0, void 0, fn), fn, void 0, debugLocation);
+}
+/**
+* @deprecated Use {@link createEffect} instead.
+*/
+const autorun = createEffect;
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/base.js
+/**
+* This function is used to indicate that the caller recovered from an error that indicates a bug.
+*/
+function handleBugIndicatingErrorRecovery(message) {
+	const err = /* @__PURE__ */ new Error("BugIndicatingErrorRecovery: " + message);
+	onUnexpectedError(err);
+	console.error("recovered from an error that indicates a bug", err);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/transaction.js
+/**
+* Starts a transaction in which many observables can be changed at once.
+* {@link fn} should start with a JS Doc using `@description` to give the transaction a debug name.
+* Reaction run on demand or when the transaction ends.
+*/
+function transaction(fn, getDebugName) {
+	const tx = new TransactionImpl(fn, getDebugName);
+	try {
+		fn(tx);
+	} finally {
+		tx.finish();
+	}
+}
+/**
+* Allows to chain transactions.
+*/
+function subtransaction(tx, fn, getDebugName) {
+	if (!tx) transaction(fn, getDebugName);
+	else fn(tx);
+}
+var TransactionImpl = class {
+	constructor(_fn, _getDebugName) {
+		this._fn = _fn;
+		this._getDebugName = _getDebugName;
+		this._updatingObservers = [];
+		getLogger()?.handleBeginTransaction(this);
+	}
+	getDebugName() {
+		if (this._getDebugName) return this._getDebugName();
+		return getFunctionName(this._fn);
+	}
+	updateObserver(observer, observable) {
+		if (!this._updatingObservers) {
+			handleBugIndicatingErrorRecovery("Transaction already finished!");
+			transaction((tx) => {
+				tx.updateObserver(observer, observable);
+			});
+			return;
+		}
+		this._updatingObservers.push({
+			observer,
+			observable
+		});
+		observer.beginUpdate(observable);
+	}
+	finish() {
+		const updatingObservers = this._updatingObservers;
+		if (!updatingObservers) {
+			handleBugIndicatingErrorRecovery("transaction.finish() has already been called!");
+			return;
+		}
+		for (let i = 0; i < updatingObservers.length; i++) {
+			const { observer, observable } = updatingObservers[i];
+			observer.endUpdate(observable);
+		}
+		this._updatingObservers = null;
+		getLogger()?.handleEndTransaction(this);
+	}
+	debugGetUpdatingObservers() {
+		return this._updatingObservers;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/observables/observableValue.js
+function observableValue(nameOrOwner, initialValue, debugLocation = DebugLocation.ofCaller()) {
+	let debugNameData;
+	if (typeof nameOrOwner === "string") debugNameData = new DebugNameData(void 0, nameOrOwner, void 0);
+	else debugNameData = new DebugNameData(nameOrOwner, void 0, void 0);
+	return new ObservableValue(debugNameData, initialValue, strictEquals, debugLocation);
+}
+var ObservableValue = class extends BaseObservable {
+	get debugName() {
+		return this._debugNameData.getDebugName(this) ?? "ObservableValue";
+	}
+	constructor(_debugNameData, initialValue, _equalityComparator, debugLocation) {
+		super(debugLocation);
+		this._debugNameData = _debugNameData;
+		this._equalityComparator = _equalityComparator;
+		this._value = initialValue;
+		getLogger()?.handleObservableUpdated(this, {
+			hadValue: false,
+			newValue: initialValue,
+			change: void 0,
+			didChange: true,
+			oldValue: void 0
+		});
+	}
+	get() {
+		return this._value;
+	}
+	set(value, tx, change) {
+		if (change === void 0 && this._equalityComparator(this._value, value)) return;
+		let _tx;
+		if (!tx) tx = _tx = new TransactionImpl(() => {}, () => `Setting ${this.debugName}`);
+		try {
+			const oldValue = this._value;
+			this._setValue(value);
+			getLogger()?.handleObservableUpdated(this, {
+				oldValue,
+				newValue: value,
+				change,
+				didChange: true,
+				hadValue: true
+			});
+			for (const observer of this._observers) {
+				tx.updateObserver(observer, this);
+				observer.handleChange(this, change);
+			}
+		} finally {
+			if (_tx) _tx.finish();
+		}
+	}
+	toString() {
+		return `${this.debugName}: ${this._value}`;
+	}
+	_setValue(newValue) {
+		this._value = newValue;
+	}
+	debugGetState() {
+		return { value: this._value };
+	}
+	debugSetValue(value) {
+		this._value = value;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/observables/observableFromEvent.js
+function observableFromEvent(...args) {
+	let owner;
+	let event;
+	let getValue;
+	let debugLocation;
+	if (args.length === 2) [event, getValue] = args;
+	else [owner, event, getValue, debugLocation] = args;
+	return new FromEventObservable(new DebugNameData(owner, void 0, getValue), event, getValue, () => FromEventObservable.globalTransaction, strictEquals, debugLocation ?? DebugLocation.ofCaller());
+}
+var FromEventObservable = class extends BaseObservable {
+	constructor(_debugNameData, event, _getValue, _getTransaction, _equalityComparator, debugLocation) {
+		super(debugLocation);
+		this._debugNameData = _debugNameData;
+		this.event = event;
+		this._getValue = _getValue;
+		this._getTransaction = _getTransaction;
+		this._equalityComparator = _equalityComparator;
+		this._hasValue = false;
+		this.handleEvent = (args) => {
+			const newValue = this._getValue(args);
+			const oldValue = this._value;
+			const didChange = !this._hasValue || !this._equalityComparator(oldValue, newValue);
+			let didRunTransaction = false;
+			if (didChange) {
+				this._value = newValue;
+				if (this._hasValue) {
+					didRunTransaction = true;
+					subtransaction(this._getTransaction(), (tx) => {
+						getLogger()?.handleObservableUpdated(this, {
+							oldValue,
+							newValue,
+							change: void 0,
+							didChange,
+							hadValue: this._hasValue
+						});
+						for (const o of this._observers) {
+							tx.updateObserver(o, this);
+							o.handleChange(this, void 0);
+						}
+					}, () => {
+						const name = this.getDebugName();
+						return "Event fired" + (name ? `: ${name}` : "");
+					});
+				}
+				this._hasValue = true;
+			}
+			if (!didRunTransaction) getLogger()?.handleObservableUpdated(this, {
+				oldValue,
+				newValue,
+				change: void 0,
+				didChange,
+				hadValue: this._hasValue
+			});
+		};
+	}
+	getDebugName() {
+		return this._debugNameData.getDebugName(this);
+	}
+	get debugName() {
+		const name = this.getDebugName();
+		return "From Event" + (name ? `: ${name}` : "");
+	}
+	onFirstObserverAdded() {
+		this._subscription = this.event(this.handleEvent);
+	}
+	onLastObserverRemoved() {
+		this._subscription.dispose();
+		this._subscription = void 0;
+		this._hasValue = false;
+		this._value = void 0;
+	}
+	get() {
+		if (this._subscription) {
+			if (!this._hasValue) this.handleEvent(void 0);
+			return this._value;
+		} else return this._getValue(void 0);
+	}
+	debugSetValue(value) {
+		this._value = value;
+	}
+	debugGetState() {
+		return {
+			value: this._value,
+			hasValue: this._hasValue
+		};
+	}
+};
+(function(observableFromEvent) {
+	observableFromEvent.Observer = FromEventObservable;
+	function batchEventsGlobally(tx, fn) {
+		let didSet = false;
+		if (FromEventObservable.globalTransaction === void 0) {
+			FromEventObservable.globalTransaction = tx;
+			didSet = true;
+		}
+		try {
+			fn();
+		} finally {
+			if (didSet) FromEventObservable.globalTransaction = void 0;
+		}
+	}
+	observableFromEvent.batchEventsGlobally = batchEventsGlobally;
+})(observableFromEvent || (observableFromEvent = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/utils/utils.js
+/**
+* This makes sure the observable is being observed and keeps its cache alive.
+*/
+function keepObserved(observable) {
+	const o = new KeepAliveObserver(false, void 0);
+	observable.addObserver(o);
+	return toDisposable(() => {
+		observable.removeObserver(o);
+	});
+}
+_setKeepObserved(keepObserved);
+/**
+* This converts the given observable into an autorun.
+*/
+function recomputeInitiallyAndOnChange(observable, handleValue) {
+	const o = new KeepAliveObserver(true, handleValue);
+	observable.addObserver(o);
+	try {
+		o.beginUpdate(observable);
+	} finally {
+		o.endUpdate(observable);
+	}
+	return toDisposable(() => {
+		observable.removeObserver(o);
+	});
+}
+_setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange);
+var KeepAliveObserver = class {
+	constructor(_forceRecompute, _handleValue) {
+		this._forceRecompute = _forceRecompute;
+		this._handleValue = _handleValue;
+		this._counter = 0;
+	}
+	beginUpdate(observable) {
+		this._counter++;
+	}
+	endUpdate(observable) {
+		if (this._counter === 1 && this._forceRecompute) {
+			if (this._handleValue) this._handleValue(observable.get());
+			else observable.reportChanges();
+		}
+		this._counter--;
+	}
+	handlePossibleChange(observable) {}
+	handleChange(observable, change) {}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/logging/consoleObservableLogger.js
+let consoleObservableLogger;
+function logObservableToConsole(obs) {
+	if (!consoleObservableLogger) {
+		consoleObservableLogger = new ConsoleObservableLogger();
+		addLogger(consoleObservableLogger);
+	}
+	consoleObservableLogger.addFilteredObj(obs);
+}
+var ConsoleObservableLogger = class {
+	constructor() {
+		this.indentation = 0;
+		this.changedObservablesSets = /* @__PURE__ */ new WeakMap();
+	}
+	addFilteredObj(obj) {
+		if (!this._filteredObjects) this._filteredObjects = /* @__PURE__ */ new Set();
+		this._filteredObjects.add(obj);
+	}
+	_isIncluded(obj) {
+		return this._filteredObjects?.has(obj) ?? true;
+	}
+	textToConsoleArgs(text) {
+		return consoleTextToArgs([normalText(repeat("|  ", this.indentation)), text]);
+	}
+	formatInfo(info) {
+		if (!info.hadValue) return [
+			normalText(` `),
+			styled(formatValue(info.newValue, 60), { color: "green" }),
+			normalText(` (initial)`)
+		];
+		return info.didChange ? [
+			normalText(` `),
+			styled(formatValue(info.oldValue, 70), {
+				color: "red",
+				strikeThrough: true
+			}),
+			normalText(` `),
+			styled(formatValue(info.newValue, 60), { color: "green" })
+		] : [normalText(` (unchanged)`)];
+	}
+	handleObservableCreated(observable) {
+		if (observable instanceof Derived) {
+			const derived = observable;
+			this.changedObservablesSets.set(derived, /* @__PURE__ */ new Set());
+		}
+	}
+	handleOnListenerCountChanged(observable, newCount) {}
+	handleObservableUpdated(observable, info) {
+		if (!this._isIncluded(observable)) return;
+		if (observable instanceof Derived) {
+			this._handleDerivedRecomputed(observable, info);
+			return;
+		}
+		console.log(...this.textToConsoleArgs([
+			formatKind("observable value changed"),
+			styled(observable.debugName, { color: "BlueViolet" }),
+			...this.formatInfo(info)
+		]));
+	}
+	formatChanges(changes) {
+		if (changes.size === 0) return;
+		return styled(" (changed deps: " + [...changes].map((o) => o.debugName).join(", ") + ")", { color: "gray" });
+	}
+	handleDerivedDependencyChanged(derived, observable, change) {
+		if (!this._isIncluded(derived)) return;
+		this.changedObservablesSets.get(derived)?.add(observable);
+	}
+	_handleDerivedRecomputed(derived, info) {
+		if (!this._isIncluded(derived)) return;
+		const changedObservables = this.changedObservablesSets.get(derived);
+		if (!changedObservables) return;
+		console.log(...this.textToConsoleArgs([
+			formatKind("derived recomputed"),
+			styled(derived.debugName, { color: "BlueViolet" }),
+			...this.formatInfo(info),
+			this.formatChanges(changedObservables),
+			{ data: [{ fn: derived._debugNameData.referenceFn ?? derived._computeFn }] }
+		]));
+		changedObservables.clear();
+	}
+	handleDerivedCleared(derived) {
+		if (!this._isIncluded(derived)) return;
+		console.log(...this.textToConsoleArgs([formatKind("derived cleared"), styled(derived.debugName, { color: "BlueViolet" })]));
+	}
+	handleFromEventObservableTriggered(observable, info) {
+		if (!this._isIncluded(observable)) return;
+		console.log(...this.textToConsoleArgs([
+			formatKind("observable from event triggered"),
+			styled(observable.debugName, { color: "BlueViolet" }),
+			...this.formatInfo(info),
+			{ data: [{ fn: observable._getValue }] }
+		]));
+	}
+	handleAutorunCreated(autorun) {
+		if (!this._isIncluded(autorun)) return;
+		this.changedObservablesSets.set(autorun, /* @__PURE__ */ new Set());
+	}
+	handleAutorunDisposed(autorun) {}
+	handleAutorunDependencyChanged(autorun, observable, change) {
+		if (!this._isIncluded(autorun)) return;
+		this.changedObservablesSets.get(autorun).add(observable);
+	}
+	handleAutorunStarted(autorun) {
+		const changedObservables = this.changedObservablesSets.get(autorun);
+		if (!changedObservables) return;
+		if (this._isIncluded(autorun)) console.log(...this.textToConsoleArgs([
+			formatKind("autorun"),
+			styled(autorun.debugName, { color: "BlueViolet" }),
+			this.formatChanges(changedObservables),
+			{ data: [{ fn: autorun._debugNameData.referenceFn ?? autorun._runFn }] }
+		]));
+		changedObservables.clear();
+		this.indentation++;
+	}
+	handleAutorunFinished(autorun) {
+		this.indentation--;
+	}
+	handleBeginTransaction(transaction) {
+		let transactionName = transaction.getDebugName();
+		if (transactionName === void 0) transactionName = "";
+		if (this._isIncluded(transaction)) console.log(...this.textToConsoleArgs([
+			formatKind("transaction"),
+			styled(transactionName, { color: "BlueViolet" }),
+			{ data: [{ fn: transaction._fn }] }
+		]));
+		this.indentation++;
+	}
+	handleEndTransaction() {
+		this.indentation--;
+	}
+};
+function consoleTextToArgs(text) {
+	const styles = new Array();
+	const data = [];
+	let firstArg = "";
+	function process(t) {
+		if ("length" in t) {
+			for (const item of t) if (item) process(item);
+		} else if ("text" in t) {
+			firstArg += `%c${t.text}`;
+			styles.push(t.style);
+			if (t.data) data.push(...t.data);
+		} else if ("data" in t) data.push(...t.data);
+	}
+	process(text);
+	const result = [firstArg, ...styles];
+	result.push(...data);
+	return result;
+}
+function normalText(text) {
+	return styled(text, { color: "black" });
+}
+function formatKind(kind) {
+	return styled(padStr(`${kind}: `, 10), {
+		color: "black",
+		bold: true
+	});
+}
+function styled(text, options = { color: "black" }) {
+	function objToCss(styleObj) {
+		return Object.entries(styleObj).reduce((styleString, [propName, propValue]) => {
+			return `${styleString}${propName}:${propValue};`;
+		}, "");
+	}
+	const style = { color: options.color };
+	if (options.strikeThrough) style["text-decoration"] = "line-through";
+	if (options.bold) style["font-weight"] = "bold";
+	return {
+		text,
+		style: objToCss(style)
+	};
+}
+function formatValue(value, availableLen) {
+	try {
+		return formatValueUnsafe(value, availableLen);
+	} catch {
+		return "[[???]]";
+	}
+}
+function formatValueUnsafe(value, availableLen) {
+	switch (typeof value) {
+		case "number": return "" + value;
+		case "string":
+			if (value.length + 2 <= availableLen) return `"${value}"`;
+			return `"${value.substr(0, availableLen - 7)}"+...`;
+		case "boolean": return value ? "true" : "false";
+		case "undefined": return "undefined";
+		case "object":
+			if (value === null) return "null";
+			if (Array.isArray(value)) return formatArray(value, availableLen);
+			return formatObject(value, availableLen);
+		case "symbol": return value.toString();
+		case "function": return `[[Function${value.name ? " " + value.name : ""}]]`;
+		default: return "" + value;
+	}
+}
+function formatArray(value, availableLen) {
+	let result = "[ ";
+	let first = true;
+	for (const val of value) {
+		if (!first) result += ", ";
+		if (result.length - 5 > availableLen) {
+			result += "...";
+			break;
+		}
+		first = false;
+		result += `${formatValue(val, availableLen - result.length)}`;
+	}
+	result += " ]";
+	return result;
+}
+function formatObject(value, availableLen) {
+	try {
+		if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) {
+			const val = value.toString();
+			if (val.length <= availableLen) return val;
+			return val.substring(0, availableLen - 3) + "...";
+		}
+	} catch {
+		return "[[Object]]";
+	}
+	const className = getClassName(value);
+	let result = className ? className + "(" : "{ ";
+	let first = true;
+	let entries;
+	try {
+		entries = Object.entries(value);
+	} catch {
+		return className ? `${className}(...)` : "[[Object]]";
+	}
+	for (const [key, val] of entries) {
+		if (!first) result += ", ";
+		if (result.length - 5 > availableLen) {
+			result += "...";
+			break;
+		}
+		first = false;
+		result += `${key}: ${formatValue(val, availableLen - result.length)}`;
+	}
+	result += className ? ")" : " }";
+	return result;
+}
+function repeat(str, count) {
+	let result = "";
+	for (let i = 1; i <= count; i++) result += str;
+	return result;
+}
+function padStr(str, length) {
+	while (str.length < length) str += " ";
+	return str;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/logging/debugGetDependencyGraph.js
+function debugGetDependencyGraph(obs, options) {
+	const debugNamePostProcessor = options?.debugNamePostProcessor ?? ((str) => str);
+	const info = Info.from(obs, debugNamePostProcessor);
+	if (!info) return "";
+	return formatObservableInfo(info, 0, /* @__PURE__ */ new Set()).trim();
+}
+function formatObservableInfo(info, indentLevel, alreadyListed) {
+	const indent = "		".repeat(indentLevel);
+	const lines = [];
+	if (alreadyListed.has(info.sourceObj)) {
+		lines.push(`${indent}* ${info.type} ${info.name} (already listed)`);
+		return lines.join("\n");
+	}
+	alreadyListed.add(info.sourceObj);
+	lines.push(`${indent}* ${info.type} ${info.name}:`);
+	lines.push(`${indent}  value: ${formatValue(info.value, 50)}`);
+	lines.push(`${indent}  state: ${info.state}`);
+	if (info.dependencies.length > 0) {
+		lines.push(`${indent}  dependencies:`);
+		for (const dep of info.dependencies) lines.push(formatObservableInfo(dep, indentLevel + 1, alreadyListed));
+	}
+	return lines.join("\n");
+}
+var Info = class Info {
+	static from(obs, debugNamePostProcessor) {
+		if (obs instanceof AutorunObserver) {
+			const state = obs.debugGetState();
+			return new Info(obs, debugNamePostProcessor(obs.debugName), "autorun", void 0, state.stateStr, Array.from(state.dependencies).map((dep) => Info.from(dep, debugNamePostProcessor) || Info.unknown(dep)));
+		} else if (obs instanceof Derived) {
+			const state = obs.debugGetState();
+			return new Info(obs, debugNamePostProcessor(obs.debugName), "derived", state.value, state.stateStr, Array.from(state.dependencies).map((dep) => Info.from(dep, debugNamePostProcessor) || Info.unknown(dep)));
+		} else if (obs instanceof ObservableValue) {
+			const state = obs.debugGetState();
+			return new Info(obs, debugNamePostProcessor(obs.debugName), "observableValue", state.value, "upToDate", []);
+		} else if (obs instanceof FromEventObservable) {
+			const state = obs.debugGetState();
+			return new Info(obs, debugNamePostProcessor(obs.debugName), "fromEvent", state.value, state.hasValue ? "upToDate" : "initial", []);
+		}
+	}
+	static unknown(obs) {
+		return new Info(obs, "(unknown)", "unknown", void 0, "unknown", []);
+	}
+	constructor(sourceObj, name, type, value, state, dependencies) {
+		this.sourceObj = sourceObj;
+		this.name = name;
+		this.type = type;
+		this.value = value;
+		this.state = state;
+		this.dependencies = dependencies;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/index.js
+_setDebugGetDependencyGraph(debugGetDependencyGraph);
+setLogObservableFn(logObservableToConsole);
+//#endregion
+//#region ../../node_modules/.pnpm/@vscode+observables@0.1.1-0/node_modules/@vscode/observables/dist/observableInternal/utils/promise.js
+var ObservableLazy = class {
+	/**
+	* The cached value.
+	* Does not force a computation of the value.
+	*/
+	get cachedValue() {
+		return this._value;
+	}
+	constructor(_computeValue) {
+		this._computeValue = _computeValue;
+		this._value = observableValue(this, void 0);
+	}
+	/**
+	* Returns the cached value.
+	* Computes the value if the value has not been cached yet.
+	*/
+	getValue() {
+		let v = this._value.get();
+		if (!v) {
+			v = this._computeValue();
+			this._value.set(v, void 0);
+		}
+		return v;
+	}
+};
+/**
+* A promise whose state is observable.
+*/
+var ObservablePromise = class ObservablePromise {
+	static fromFn(fn) {
+		return new ObservablePromise(fn());
+	}
+	constructor(promise) {
+		this._value = observableValue(this, void 0);
+		/**
+		* The current state of the promise.
+		* Is `undefined` if the promise didn't resolve yet.
+		*/
+		this.promiseResult = this._value;
+		this.resolvedValue = derived(this, (reader) => {
+			const result = this.promiseResult.read(reader);
+			if (!result) return;
+			return result.getDataOrThrow();
+		});
+		this.promise = promise.then((value) => {
+			transaction((tx) => {
+				/** @description onPromiseResolved */
+				this._value.set(new PromiseResult(value, void 0), tx);
+			});
+			return value;
+		}, (error) => {
+			transaction((tx) => {
+				/** @description onPromiseRejected */
+				this._value.set(new PromiseResult(void 0, error), tx);
+			});
+			throw error;
+		});
+	}
+};
+var PromiseResult = class {
+	constructor(data, error) {
+		this.data = data;
+		this.error = error;
+	}
+	/**
+	* Returns the value if the promise resolved, otherwise throws the error.
+	*/
+	getDataOrThrow() {
+		if (this.error) throw this.error;
+		return this.data;
+	}
+};
+/**
+* A lazy promise whose state is observable.
+*/
+var ObservableLazyPromise = class {
+	constructor(_computePromise) {
+		this._computePromise = _computePromise;
+		this._lazyValue = new ObservableLazy(() => new ObservablePromise(this._computePromise()));
+		/**
+		* Does not enforce evaluation of the promise compute function.
+		* Is undefined if the promise has not been computed yet.
+		*/
+		this.cachedPromiseResult = derived(this, (reader) => this._lazyValue.cachedValue.read(reader)?.promiseResult.read(reader));
+	}
+	getPromise() {
+		return this._lazyValue.getValue().promise;
+	}
+};
+//#endregion
+export { derived as a, autorun as i, ObservablePromise as n, Disposable as o, observableValue as r, ObservableLazyPromise as t };
+
+//# sourceMappingURL=dist-BOcSU4-O.js.map