@loopstack/loopstack-studio 0.20.3 → 0.21.0-rc.0

package/dist/node_modules/vscode-jsonrpc/lib/common/events.js

@@ -0,0 +1,64 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+import { require_ral } from "./ral.js";
+var require_events = /* @__PURE__ */ __commonJSMin(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.Emitter = e.Event = void 0;
+	var n = require_ral(), r;
+	(function(e) {
+		let t = { dispose() {} };
+		e.None = function() {
+			return t;
+		};
+	})(r || (e.Event = r = {}));
+	var i = class {
+		add(e, t = null, n) {
+			this._callbacks || (this._callbacks = [], this._contexts = []), this._callbacks.push(e), this._contexts.push(t), Array.isArray(n) && n.push({ dispose: () => this.remove(e, t) });
+		}
+		remove(e, t = null) {
+			if (!this._callbacks) return;
+			let n = !1;
+			for (let r = 0, i = this._callbacks.length; r < i; r++) if (this._callbacks[r] === e) if (this._contexts[r] === t) {
+				this._callbacks.splice(r, 1), this._contexts.splice(r, 1);
+				return;
+			} else n = !0;
+			if (n) throw Error("When adding a listener with a context, you should remove it with the same context");
+		}
+		invoke(...e) {
+			if (!this._callbacks) return [];
+			let t = [], r = this._callbacks.slice(0), i = this._contexts.slice(0);
+			for (let a = 0, o = r.length; a < o; a++) try {
+				t.push(r[a].apply(i[a], e));
+			} catch (e) {
+				(0, n.default)().console.error(e);
+			}
+			return t;
+		}
+		isEmpty() {
+			return !this._callbacks || this._callbacks.length === 0;
+		}
+		dispose() {
+			this._callbacks = void 0, this._contexts = void 0;
+		}
+	}, a = class e {
+		constructor(e) {
+			this._options = e;
+		}
+		get event() {
+			return this._event ||= (t, n, r) => {
+				this._callbacks ||= new i(), this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty() && this._options.onFirstListenerAdd(this), this._callbacks.add(t, n);
+				let a = { dispose: () => {
+					this._callbacks && (this._callbacks.remove(t, n), a.dispose = e._noop, this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty() && this._options.onLastListenerRemove(this));
+				} };
+				return Array.isArray(r) && r.push(a), a;
+			}, this._event;
+		}
+		fire(e) {
+			this._callbacks && this._callbacks.invoke.call(this._callbacks, e);
+		}
+		dispose() {
+			this._callbacks &&= (this._callbacks.dispose(), void 0);
+		}
+	};
+	e.Emitter = a, a._noop = function() {};
+}));
+export default require_events();
+export { require_events };

package/dist/node_modules/vscode-jsonrpc/lib/common/is.js

@@ -0,0 +1,34 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+var require_is = /* @__PURE__ */ __commonJSMin(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.stringArray = e.array = e.func = e.error = e.number = e.string = e.boolean = void 0;
+	function t(e) {
+		return e === !0 || e === !1;
+	}
+	e.boolean = t;
+	function n(e) {
+		return typeof e == "string" || e instanceof String;
+	}
+	e.string = n;
+	function r(e) {
+		return typeof e == "number" || e instanceof Number;
+	}
+	e.number = r;
+	function i(e) {
+		return e instanceof Error;
+	}
+	e.error = i;
+	function a(e) {
+		return typeof e == "function";
+	}
+	e.func = a;
+	function o(e) {
+		return Array.isArray(e);
+	}
+	e.array = o;
+	function s(e) {
+		return o(e) && e.every((e) => n(e));
+	}
+	e.stringArray = s;
+}));
+export default require_is();
+export { require_is };

package/dist/node_modules/vscode-jsonrpc/lib/common/linkedMap.js

@@ -0,0 +1,235 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+var require_linkedMap = /* @__PURE__ */ __commonJSMin(((e) => {
+	var t;
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.LRUCache = e.LinkedMap = e.Touch = void 0;
+	var n;
+	(function(e) {
+		e.None = 0, e.First = 1, e.AsOld = e.First, e.Last = 2, e.AsNew = e.Last;
+	})(n || (e.Touch = n = {}));
+	var r = class {
+		constructor() {
+			this[t] = "LinkedMap", this._map = /* @__PURE__ */ new Map(), this._head = void 0, this._tail = void 0, this._size = 0, this._state = 0;
+		}
+		clear() {
+			this._map.clear(), this._head = void 0, this._tail = void 0, this._size = 0, this._state++;
+		}
+		isEmpty() {
+			return !this._head && !this._tail;
+		}
+		get size() {
+			return this._size;
+		}
+		get first() {
+			return this._head?.value;
+		}
+		get last() {
+			return this._tail?.value;
+		}
+		has(e) {
+			return this._map.has(e);
+		}
+		get(e, t = n.None) {
+			let r = this._map.get(e);
+			if (r) return t !== n.None && this.touch(r, t), r.value;
+		}
+		set(e, t, r = n.None) {
+			let i = this._map.get(e);
+			if (i) i.value = t, r !== n.None && this.touch(i, r);
+			else {
+				switch (i = {
+					key: e,
+					value: t,
+					next: void 0,
+					previous: void 0
+				}, r) {
+					case n.None:
+						this.addItemLast(i);
+						break;
+					case n.First:
+						this.addItemFirst(i);
+						break;
+					case n.Last:
+						this.addItemLast(i);
+						break;
+					default:
+						this.addItemLast(i);
+						break;
+				}
+				this._map.set(e, i), this._size++;
+			}
+			return this;
+		}
+		delete(e) {
+			return !!this.remove(e);
+		}
+		remove(e) {
+			let t = this._map.get(e);
+			if (t) return this._map.delete(e), this.removeItem(t), this._size--, t.value;
+		}
+		shift() {
+			if (!this._head && !this._tail) return;
+			if (!this._head || !this._tail) throw Error("Invalid list");
+			let e = this._head;
+			return this._map.delete(e.key), this.removeItem(e), this._size--, e.value;
+		}
+		forEach(e, t) {
+			let n = this._state, r = this._head;
+			for (; r;) {
+				if (t ? e.bind(t)(r.value, r.key, this) : e(r.value, r.key, this), this._state !== n) throw Error("LinkedMap got modified during iteration.");
+				r = r.next;
+			}
+		}
+		keys() {
+			let e = this._state, t = this._head, n = {
+				[Symbol.iterator]: () => n,
+				next: () => {
+					if (this._state !== e) throw Error("LinkedMap got modified during iteration.");
+					if (t) {
+						let e = {
+							value: t.key,
+							done: !1
+						};
+						return t = t.next, e;
+					} else return {
+						value: void 0,
+						done: !0
+					};
+				}
+			};
+			return n;
+		}
+		values() {
+			let e = this._state, t = this._head, n = {
+				[Symbol.iterator]: () => n,
+				next: () => {
+					if (this._state !== e) throw Error("LinkedMap got modified during iteration.");
+					if (t) {
+						let e = {
+							value: t.value,
+							done: !1
+						};
+						return t = t.next, e;
+					} else return {
+						value: void 0,
+						done: !0
+					};
+				}
+			};
+			return n;
+		}
+		entries() {
+			let e = this._state, t = this._head, n = {
+				[Symbol.iterator]: () => n,
+				next: () => {
+					if (this._state !== e) throw Error("LinkedMap got modified during iteration.");
+					if (t) {
+						let e = {
+							value: [t.key, t.value],
+							done: !1
+						};
+						return t = t.next, e;
+					} else return {
+						value: void 0,
+						done: !0
+					};
+				}
+			};
+			return n;
+		}
+		[(t = Symbol.toStringTag, Symbol.iterator)]() {
+			return this.entries();
+		}
+		trimOld(e) {
+			if (e >= this.size) return;
+			if (e === 0) {
+				this.clear();
+				return;
+			}
+			let t = this._head, n = this.size;
+			for (; t && n > e;) this._map.delete(t.key), t = t.next, n--;
+			this._head = t, this._size = n, t && (t.previous = void 0), this._state++;
+		}
+		addItemFirst(e) {
+			if (!this._head && !this._tail) this._tail = e;
+			else if (this._head) e.next = this._head, this._head.previous = e;
+			else throw Error("Invalid list");
+			this._head = e, this._state++;
+		}
+		addItemLast(e) {
+			if (!this._head && !this._tail) this._head = e;
+			else if (this._tail) e.previous = this._tail, this._tail.next = e;
+			else throw Error("Invalid list");
+			this._tail = e, this._state++;
+		}
+		removeItem(e) {
+			if (e === this._head && e === this._tail) this._head = void 0, this._tail = void 0;
+			else if (e === this._head) {
+				if (!e.next) throw Error("Invalid list");
+				e.next.previous = void 0, this._head = e.next;
+			} else if (e === this._tail) {
+				if (!e.previous) throw Error("Invalid list");
+				e.previous.next = void 0, this._tail = e.previous;
+			} else {
+				let t = e.next, n = e.previous;
+				if (!t || !n) throw Error("Invalid list");
+				t.previous = n, n.next = t;
+			}
+			e.next = void 0, e.previous = void 0, this._state++;
+		}
+		touch(e, t) {
+			if (!this._head || !this._tail) throw Error("Invalid list");
+			if (!(t !== n.First && t !== n.Last)) {
+				if (t === n.First) {
+					if (e === this._head) return;
+					let t = e.next, n = e.previous;
+					e === this._tail ? (n.next = void 0, this._tail = n) : (t.previous = n, n.next = t), e.previous = void 0, e.next = this._head, this._head.previous = e, this._head = e, this._state++;
+				} else if (t === n.Last) {
+					if (e === this._tail) return;
+					let t = e.next, n = e.previous;
+					e === this._head ? (t.previous = void 0, this._head = t) : (t.previous = n, n.next = t), e.next = void 0, e.previous = this._tail, this._tail.next = e, this._tail = e, this._state++;
+				}
+			}
+		}
+		toJSON() {
+			let e = [];
+			return this.forEach((t, n) => {
+				e.push([n, t]);
+			}), e;
+		}
+		fromJSON(e) {
+			this.clear();
+			for (let [t, n] of e) this.set(t, n);
+		}
+	};
+	e.LinkedMap = r, e.LRUCache = class extends r {
+		constructor(e, t = 1) {
+			super(), this._limit = e, this._ratio = Math.min(Math.max(0, t), 1);
+		}
+		get limit() {
+			return this._limit;
+		}
+		set limit(e) {
+			this._limit = e, this.checkTrim();
+		}
+		get ratio() {
+			return this._ratio;
+		}
+		set ratio(e) {
+			this._ratio = Math.min(Math.max(0, e), 1), this.checkTrim();
+		}
+		get(e, t = n.AsNew) {
+			return super.get(e, t);
+		}
+		peek(e) {
+			return super.get(e, n.None);
+		}
+		set(e, t) {
+			return super.set(e, t, n.Last), this.checkTrim(), this;
+		}
+		checkTrim() {
+			this.size > this._limit && this.trimOld(Math.round(this._limit * this._ratio));
+		}
+	};
+}));
+export default require_linkedMap();
+export { require_linkedMap };

package/dist/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js

@@ -0,0 +1,93 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+var require_messageBuffer = /* @__PURE__ */ __commonJSMin(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.AbstractMessageBuffer = void 0;
+	var t = 13, n = 10, r = "\r\n";
+	e.AbstractMessageBuffer = class {
+		constructor(e = "utf-8") {
+			this._encoding = e, this._chunks = [], this._totalLength = 0;
+		}
+		get encoding() {
+			return this._encoding;
+		}
+		append(e) {
+			let t = typeof e == "string" ? this.fromString(e, this._encoding) : e;
+			this._chunks.push(t), this._totalLength += t.byteLength;
+		}
+		tryReadHeaders(e = !1) {
+			if (this._chunks.length === 0) return;
+			let i = 0, a = 0, o = 0, s = 0;
+			row: for (; a < this._chunks.length;) {
+				let e = this._chunks[a];
+				o = 0;
+				column: for (; o < e.length;) {
+					switch (e[o]) {
+						case t:
+							switch (i) {
+								case 0:
+									i = 1;
+									break;
+								case 2:
+									i = 3;
+									break;
+								default: i = 0;
+							}
+							break;
+						case n:
+							switch (i) {
+								case 1:
+									i = 2;
+									break;
+								case 3:
+									i = 4, o++;
+									break row;
+								default: i = 0;
+							}
+							break;
+						default: i = 0;
+					}
+					o++;
+				}
+				s += e.byteLength, a++;
+			}
+			if (i !== 4) return;
+			let c = this._read(s + o), l = /* @__PURE__ */ new Map(), u = this.toString(c, "ascii").split(r);
+			if (u.length < 2) return l;
+			for (let t = 0; t < u.length - 2; t++) {
+				let n = u[t], r = n.indexOf(":");
+				if (r === -1) throw Error(`Message header must separate key and value using ':'\n${n}`);
+				let i = n.substr(0, r), a = n.substr(r + 1).trim();
+				l.set(e ? i.toLowerCase() : i, a);
+			}
+			return l;
+		}
+		tryReadBody(e) {
+			if (!(this._totalLength < e)) return this._read(e);
+		}
+		get numberOfBytes() {
+			return this._totalLength;
+		}
+		_read(e) {
+			if (e === 0) return this.emptyBuffer();
+			if (e > this._totalLength) throw Error("Cannot read so many bytes!");
+			if (this._chunks[0].byteLength === e) {
+				let t = this._chunks[0];
+				return this._chunks.shift(), this._totalLength -= e, this.asNative(t);
+			}
+			if (this._chunks[0].byteLength > e) {
+				let t = this._chunks[0], n = this.asNative(t, e);
+				return this._chunks[0] = t.slice(e), this._totalLength -= e, n;
+			}
+			let t = this.allocNative(e), n = 0;
+			for (; e > 0;) {
+				let r = this._chunks[0];
+				if (r.byteLength > e) {
+					let i = r.slice(0, e);
+					t.set(i, n), n += e, this._chunks[0] = r.slice(e), this._totalLength -= e, e -= e;
+				} else t.set(r, n), n += r.byteLength, this._chunks.shift(), this._totalLength -= r.byteLength, e -= r.byteLength;
+			}
+			return t;
+		}
+	};
+}));
+export default require_messageBuffer();
+export { require_messageBuffer };

package/dist/node_modules/vscode-jsonrpc/lib/common/messageReader.js

@@ -0,0 +1,129 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+import { require_ral } from "./ral.js";
+import { require_is } from "./is.js";
+import { require_events } from "./events.js";
+import { require_semaphore } from "./semaphore.js";
+var require_messageReader = /* @__PURE__ */ __commonJSMin(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.ReadableStreamMessageReader = e.AbstractMessageReader = e.MessageReader = void 0;
+	var a = require_ral(), o = require_is(), s = require_events(), c = require_semaphore(), l;
+	(function(e) {
+		function t(e) {
+			let t = e;
+			return t && o.func(t.listen) && o.func(t.dispose) && o.func(t.onError) && o.func(t.onClose) && o.func(t.onPartialMessage);
+		}
+		e.is = t;
+	})(l || (e.MessageReader = l = {}));
+	var u = class {
+		constructor() {
+			this.errorEmitter = new s.Emitter(), this.closeEmitter = new s.Emitter(), this.partialMessageEmitter = new s.Emitter();
+		}
+		dispose() {
+			this.errorEmitter.dispose(), this.closeEmitter.dispose();
+		}
+		get onError() {
+			return this.errorEmitter.event;
+		}
+		fireError(e) {
+			this.errorEmitter.fire(this.asError(e));
+		}
+		get onClose() {
+			return this.closeEmitter.event;
+		}
+		fireClose() {
+			this.closeEmitter.fire(void 0);
+		}
+		get onPartialMessage() {
+			return this.partialMessageEmitter.event;
+		}
+		firePartialMessage(e) {
+			this.partialMessageEmitter.fire(e);
+		}
+		asError(e) {
+			return e instanceof Error ? e : /* @__PURE__ */ Error(`Reader received error. Reason: ${o.string(e.message) ? e.message : "unknown"}`);
+		}
+	};
+	e.AbstractMessageReader = u;
+	var d;
+	(function(e) {
+		function t(e) {
+			let t, n, r = /* @__PURE__ */ new Map(), i, o = /* @__PURE__ */ new Map();
+			if (e === void 0 || typeof e == "string") t = e ?? "utf-8";
+			else {
+				if (t = e.charset ?? "utf-8", e.contentDecoder !== void 0 && (n = e.contentDecoder, r.set(n.name, n)), e.contentDecoders !== void 0) for (let t of e.contentDecoders) r.set(t.name, t);
+				if (e.contentTypeDecoder !== void 0 && (i = e.contentTypeDecoder, o.set(i.name, i)), e.contentTypeDecoders !== void 0) for (let t of e.contentTypeDecoders) o.set(t.name, t);
+			}
+			return i === void 0 && (i = (0, a.default)().applicationJson.decoder, o.set(i.name, i)), {
+				charset: t,
+				contentDecoder: n,
+				contentDecoders: r,
+				contentTypeDecoder: i,
+				contentTypeDecoders: o
+			};
+		}
+		e.fromOptions = t;
+	})(d ||= {}), e.ReadableStreamMessageReader = class extends u {
+		constructor(e, t) {
+			super(), this.readable = e, this.options = d.fromOptions(t), this.buffer = (0, a.default)().messageBuffer.create(this.options.charset), this._partialMessageTimeout = 1e4, this.nextMessageLength = -1, this.messageToken = 0, this.readSemaphore = new c.Semaphore(1);
+		}
+		set partialMessageTimeout(e) {
+			this._partialMessageTimeout = e;
+		}
+		get partialMessageTimeout() {
+			return this._partialMessageTimeout;
+		}
+		listen(e) {
+			this.nextMessageLength = -1, this.messageToken = 0, this.partialMessageTimer = void 0, this.callback = e;
+			let t = this.readable.onData((e) => {
+				this.onData(e);
+			});
+			return this.readable.onError((e) => this.fireError(e)), this.readable.onClose(() => this.fireClose()), t;
+		}
+		onData(e) {
+			try {
+				for (this.buffer.append(e);;) {
+					if (this.nextMessageLength === -1) {
+						let e = this.buffer.tryReadHeaders(!0);
+						if (!e) return;
+						let t = e.get("content-length");
+						if (!t) {
+							this.fireError(/* @__PURE__ */ Error(`Header must provide a Content-Length property.\n${JSON.stringify(Object.fromEntries(e))}`));
+							return;
+						}
+						let n = parseInt(t);
+						if (isNaN(n)) {
+							this.fireError(/* @__PURE__ */ Error(`Content-Length value must be a number. Got ${t}`));
+							return;
+						}
+						this.nextMessageLength = n;
+					}
+					let e = this.buffer.tryReadBody(this.nextMessageLength);
+					if (e === void 0) {
+						this.setPartialMessageTimer();
+						return;
+					}
+					this.clearPartialMessageTimer(), this.nextMessageLength = -1, this.readSemaphore.lock(async () => {
+						let t = this.options.contentDecoder === void 0 ? e : await this.options.contentDecoder.decode(e), n = await this.options.contentTypeDecoder.decode(t, this.options);
+						this.callback(n);
+					}).catch((e) => {
+						this.fireError(e);
+					});
+				}
+			} catch (e) {
+				this.fireError(e);
+			}
+		}
+		clearPartialMessageTimer() {
+			this.partialMessageTimer &&= (this.partialMessageTimer.dispose(), void 0);
+		}
+		setPartialMessageTimer() {
+			this.clearPartialMessageTimer(), !(this._partialMessageTimeout <= 0) && (this.partialMessageTimer = (0, a.default)().timer.setTimeout((e, t) => {
+				this.partialMessageTimer = void 0, e === this.messageToken && (this.firePartialMessage({
+					messageToken: e,
+					waitingTime: t
+				}), this.setPartialMessageTimer());
+			}, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout));
+		}
+	};
+}));
+export default require_messageReader();
+export { require_messageReader };

package/dist/node_modules/vscode-jsonrpc/lib/common/messageWriter.js

@@ -0,0 +1,85 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+import { require_ral } from "./ral.js";
+import { require_is } from "./is.js";
+import { require_events } from "./events.js";
+import { require_semaphore } from "./semaphore.js";
+var require_messageWriter = /* @__PURE__ */ __commonJSMin(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.WriteableStreamMessageWriter = e.AbstractMessageWriter = e.MessageWriter = void 0;
+	var a = require_ral(), o = require_is(), s = require_semaphore(), c = require_events(), l = "Content-Length: ", u = "\r\n", d;
+	(function(e) {
+		function r(e) {
+			let r = e;
+			return r && o.func(r.dispose) && o.func(r.onClose) && o.func(r.onError) && o.func(r.write);
+		}
+		e.is = r;
+	})(d || (e.MessageWriter = d = {}));
+	var f = class {
+		constructor() {
+			this.errorEmitter = new c.Emitter(), this.closeEmitter = new c.Emitter();
+		}
+		dispose() {
+			this.errorEmitter.dispose(), this.closeEmitter.dispose();
+		}
+		get onError() {
+			return this.errorEmitter.event;
+		}
+		fireError(e, r, i) {
+			this.errorEmitter.fire([
+				this.asError(e),
+				r,
+				i
+			]);
+		}
+		get onClose() {
+			return this.closeEmitter.event;
+		}
+		fireClose() {
+			this.closeEmitter.fire(void 0);
+		}
+		asError(e) {
+			return e instanceof Error ? e : /* @__PURE__ */ Error(`Writer received error. Reason: ${o.string(e.message) ? e.message : "unknown"}`);
+		}
+	};
+	e.AbstractMessageWriter = f;
+	var p;
+	(function(e) {
+		function r(e) {
+			return e === void 0 || typeof e == "string" ? {
+				charset: e ?? "utf-8",
+				contentTypeEncoder: (0, a.default)().applicationJson.encoder
+			} : {
+				charset: e.charset ?? "utf-8",
+				contentEncoder: e.contentEncoder,
+				contentTypeEncoder: e.contentTypeEncoder ?? (0, a.default)().applicationJson.encoder
+			};
+		}
+		e.fromOptions = r;
+	})(p ||= {}), e.WriteableStreamMessageWriter = class extends f {
+		constructor(e, r) {
+			super(), this.writable = e, this.options = p.fromOptions(r), this.errorCount = 0, this.writeSemaphore = new s.Semaphore(1), this.writable.onError((e) => this.fireError(e)), this.writable.onClose(() => this.fireClose());
+		}
+		async write(e) {
+			return this.writeSemaphore.lock(async () => this.options.contentTypeEncoder.encode(e, this.options).then((e) => this.options.contentEncoder === void 0 ? e : this.options.contentEncoder.encode(e)).then((r) => {
+				let i = [];
+				return i.push(l, r.byteLength.toString(), u), i.push(u), this.doWrite(e, i, r);
+			}, (e) => {
+				throw this.fireError(e), e;
+			}));
+		}
+		async doWrite(e, r, i) {
+			try {
+				return await this.writable.write(r.join(""), "ascii"), this.writable.write(i);
+			} catch (r) {
+				return this.handleError(r, e), Promise.reject(r);
+			}
+		}
+		handleError(e, r) {
+			this.errorCount++, this.fireError(e, r, this.errorCount);
+		}
+		end() {
+			this.writable.end();
+		}
+	};
+}));
+export default require_messageWriter();
+export { require_messageWriter };