@loopstack/loopstack-studio 0.28.0 → 0.29.1

package/dist/node_modules/langium/lib/languages/grammar-config.js

@@ -1,13 +0,0 @@
-import { isTerminalRule } from "./generated/ast.js";
-import { DefaultNameRegexp } from "../utils/cst-utils.js";
-import { isMultilineComment } from "../utils/regexp-utils.js";
-import { isCommentTerminal, terminalRegex } from "../utils/grammar-utils.js";
-function createGrammarConfig(a) {
-	let o = [], s = a.Grammar;
-	for (let i of s.rules) isTerminalRule(i) && isCommentTerminal(i) && isMultilineComment(terminalRegex(i)) && o.push(i.name);
-	return {
-		multilineCommentRules: o,
-		nameRegexp: DefaultNameRegexp
-	};
-}
-export { createGrammarConfig };

package/dist/node_modules/langium/lib/parser/async-parser.js

@@ -1,83 +0,0 @@
-import { Deferred, OperationCancelled } from "../utils/promise-utils.js";
-import { event_exports } from "../utils/event.js";
-var DefaultAsyncParser = class {
-	constructor(e) {
-		this.syncParser = e.parser.LangiumParser;
-	}
-	parse(e, t) {
-		return Promise.resolve(this.syncParser.parse(e));
-	}
-}, AbstractThreadedAsyncParser = class {
-	constructor(e) {
-		this.threadCount = 8, this.terminationDelay = 200, this.workerPool = [], this.queue = [], this.hydrator = e.serializer.Hydrator;
-	}
-	initializeWorkers() {
-		for (; this.workerPool.length < this.threadCount;) {
-			let e = this.createWorker();
-			e.onReady(() => {
-				if (this.queue.length > 0) {
-					let t = this.queue.shift();
-					t && (e.lock(), t.resolve(e));
-				}
-			}), this.workerPool.push(e);
-		}
-	}
-	async parse(t, n) {
-		let r = await this.acquireParserWorker(n), i = new Deferred(), a, o = n.onCancellationRequested(() => {
-			a = setTimeout(() => {
-				this.terminateWorker(r);
-			}, this.terminationDelay);
-		});
-		return r.parse(t).then((e) => {
-			let t = this.hydrator.hydrate(e);
-			i.resolve(t);
-		}).catch((e) => {
-			i.reject(e);
-		}).finally(() => {
-			o.dispose(), clearTimeout(a);
-		}), i.promise;
-	}
-	terminateWorker(e) {
-		e.terminate();
-		let t = this.workerPool.indexOf(e);
-		t >= 0 && this.workerPool.splice(t, 1);
-	}
-	async acquireParserWorker(n) {
-		this.initializeWorkers();
-		for (let e of this.workerPool) if (e.ready) return e.lock(), e;
-		let r = new Deferred();
-		return n.onCancellationRequested(() => {
-			let e = this.queue.indexOf(r);
-			e >= 0 && this.queue.splice(e, 1), r.reject(OperationCancelled);
-		}), this.queue.push(r), r.promise;
-	}
-}, ParserWorker = class {
-	get ready() {
-		return this._ready;
-	}
-	get onReady() {
-		return this.onReadyEmitter.event;
-	}
-	constructor(t, r, i, a) {
-		this.onReadyEmitter = new event_exports.Emitter(), this.deferred = new Deferred(), this._ready = !0, this._parsing = !1, this.sendMessage = t, this._terminate = a, r((e) => {
-			let t = e;
-			this.deferred.resolve(t), this.unlock();
-		}), i((e) => {
-			this.deferred.reject(e), this.unlock();
-		});
-	}
-	terminate() {
-		this.deferred.reject(OperationCancelled), this._terminate();
-	}
-	lock() {
-		this._ready = !1;
-	}
-	unlock() {
-		this._parsing = !1, this._ready = !0, this.onReadyEmitter.fire();
-	}
-	parse(t) {
-		if (this._parsing) throw Error("Parser worker is busy");
-		return this._parsing = !0, this.deferred = new Deferred(), this.sendMessage(t), this.deferred.promise;
-	}
-};
-export { AbstractThreadedAsyncParser, DefaultAsyncParser, ParserWorker };

package/dist/node_modules/langium/lib/parser/completion-parser-builder.js

@@ -1,7 +0,0 @@
-import { LangiumCompletionParser } from "./langium-parser.js";
-import { createParser } from "./parser-builder-base.js";
-function createCompletionParser(n) {
-	let r = n.Grammar, i = n.parser.Lexer, a = new LangiumCompletionParser(n);
-	return createParser(r, a, i.definition), a.finalize(), a;
-}
-export { createCompletionParser };

package/dist/node_modules/langium/lib/parser/cst-node-builder.js

@@ -1,160 +0,0 @@
-import { tokenToRange } from "../utils/cst-utils.js";
-import { Position, init_main } from "../../../vscode-languageserver-types/lib/esm/main.js";
-init_main();
-var CstNodeBuilder = class {
-	constructor() {
-		this.nodeStack = [];
-	}
-	get current() {
-		return this.nodeStack[this.nodeStack.length - 1] ?? this.rootNode;
-	}
-	buildRootNode(e) {
-		return this.rootNode = new RootCstNodeImpl(e), this.rootNode.root = this.rootNode, this.nodeStack = [this.rootNode], this.rootNode;
-	}
-	buildCompositeNode(e) {
-		let a = new CompositeCstNodeImpl();
-		return a.grammarSource = e, a.root = this.rootNode, this.current.content.push(a), this.nodeStack.push(a), a;
-	}
-	buildLeafNode(a, o) {
-		let s = new LeafCstNodeImpl(a.startOffset, a.image.length, tokenToRange(a), a.tokenType, !o);
-		return s.grammarSource = o, s.root = this.rootNode, this.current.content.push(s), s;
-	}
-	removeNode(e) {
-		let a = e.container;
-		if (a) {
-			let o = a.content.indexOf(e);
-			o >= 0 && a.content.splice(o, 1);
-		}
-	}
-	addHiddenNodes(a) {
-		let o = [];
-		for (let s of a) {
-			let a = new LeafCstNodeImpl(s.startOffset, s.image.length, tokenToRange(s), s.tokenType, !0);
-			a.root = this.rootNode, o.push(a);
-		}
-		let s = this.current, c = !1;
-		if (s.content.length > 0) {
-			s.content.push(...o);
-			return;
-		}
-		for (; s.container;) {
-			let e = s.container.content.indexOf(s);
-			if (e > 0) {
-				s.container.content.splice(e, 0, ...o), c = !0;
-				break;
-			}
-			s = s.container;
-		}
-		c || this.rootNode.content.unshift(...o);
-	}
-	construct(e) {
-		let a = this.current;
-		typeof e.$type == "string" && !e.$infixName && (this.current.astNode = e), e.$cstNode = a;
-		let o = this.nodeStack.pop();
-		o?.content.length === 0 && this.removeNode(o);
-	}
-}, AbstractCstNode = class {
-	get hidden() {
-		return !1;
-	}
-	get astNode() {
-		let e = typeof this._astNode?.$type == "string" ? this._astNode : this.container?.astNode;
-		if (!e) throw Error("This node has no associated AST element");
-		return e;
-	}
-	set astNode(e) {
-		this._astNode = e;
-	}
-	get text() {
-		return this.root.fullText.substring(this.offset, this.end);
-	}
-}, LeafCstNodeImpl = class extends AbstractCstNode {
-	get offset() {
-		return this._offset;
-	}
-	get length() {
-		return this._length;
-	}
-	get end() {
-		return this._offset + this._length;
-	}
-	get hidden() {
-		return this._hidden;
-	}
-	get tokenType() {
-		return this._tokenType;
-	}
-	get range() {
-		return this._range;
-	}
-	constructor(e, a, o, s, c = !1) {
-		super(), this._hidden = c, this._offset = e, this._tokenType = s, this._length = a, this._range = o;
-	}
-}, CompositeCstNodeImpl = class extends AbstractCstNode {
-	constructor() {
-		super(...arguments), this.content = new CstNodeContainer(this);
-	}
-	get offset() {
-		return this.firstNonHiddenNode?.offset ?? 0;
-	}
-	get length() {
-		return this.end - this.offset;
-	}
-	get end() {
-		return this.lastNonHiddenNode?.end ?? 0;
-	}
-	get range() {
-		let e = this.firstNonHiddenNode, o = this.lastNonHiddenNode;
-		if (e && o) {
-			if (this._rangeCache === void 0) {
-				let { range: a } = e, { range: s } = o;
-				this._rangeCache = {
-					start: a.start,
-					end: s.end.line < a.start.line ? a.start : s.end
-				};
-			}
-			return this._rangeCache;
-		} else return {
-			start: Position.create(0, 0),
-			end: Position.create(0, 0)
-		};
-	}
-	get firstNonHiddenNode() {
-		for (let e of this.content) if (!e.hidden) return e;
-		return this.content[0];
-	}
-	get lastNonHiddenNode() {
-		for (let e = this.content.length - 1; e >= 0; e--) {
-			let a = this.content[e];
-			if (!a.hidden) return a;
-		}
-		return this.content[this.content.length - 1];
-	}
-}, CstNodeContainer = class e extends Array {
-	constructor(a) {
-		super(), this.parent = a, Object.setPrototypeOf(this, e.prototype);
-	}
-	push(...e) {
-		return this.addParents(e), super.push(...e);
-	}
-	unshift(...e) {
-		return this.addParents(e), super.unshift(...e);
-	}
-	splice(e, a, ...o) {
-		return this.addParents(o), super.splice(e, a, ...o);
-	}
-	addParents(e) {
-		for (let a of e) a.container = this.parent;
-	}
-}, RootCstNodeImpl = class extends CompositeCstNodeImpl {
-	get text() {
-		return this._text.substring(this.offset, this.end);
-	}
-	get fullText() {
-		return this._text;
-	}
-	constructor(e) {
-		super(), this._text = "", this._text = e ?? "";
-	}
-};
-export { AbstractCstNode, CompositeCstNodeImpl, CstNodeBuilder, LeafCstNodeImpl, RootCstNodeImpl };

package/dist/node_modules/langium/lib/parser/indentation-aware.js

@@ -1,141 +0,0 @@
-import { Lexer } from "../../../chevrotain/lib/src/scan/lexer_public.js";
-import { createToken, createTokenInstance } from "../../../chevrotain/lib/src/scan/tokens_public.js";
-import "../../../chevrotain/lib/src/api.js";
-import { DefaultTokenBuilder } from "./token-builder.js";
-import { DEFAULT_TOKENIZE_OPTIONS, DefaultLexer, isTokenTypeArray } from "./lexer.js";
-const indentationBuilderDefaultOptions = {
-	indentTokenName: "INDENT",
-	dedentTokenName: "DEDENT",
-	whitespaceTokenName: "WS",
-	ignoreIndentationDelimiters: []
-};
-var LexingMode;
-(function(e) {
-	e.REGULAR = "indentation-sensitive", e.IGNORE_INDENTATION = "ignore-indentation";
-})(LexingMode ||= {});
-var IndentationAwareTokenBuilder = class extends DefaultTokenBuilder {
-	constructor(e = indentationBuilderDefaultOptions) {
-		super(), this.indentationStack = [0], this.whitespaceRegExp = /[ \t]+/y, this.options = {
-			...indentationBuilderDefaultOptions,
-			...e
-		}, this.indentTokenType = createToken({
-			name: this.options.indentTokenName,
-			pattern: this.indentMatcher.bind(this),
-			line_breaks: !1
-		}), this.dedentTokenType = createToken({
-			name: this.options.dedentTokenName,
-			pattern: this.dedentMatcher.bind(this),
-			line_breaks: !1
-		});
-	}
-	buildTokens(e, t) {
-		let n = super.buildTokens(e, t);
-		if (!isTokenTypeArray(n)) throw Error("Invalid tokens built by default builder");
-		let { indentTokenName: r, dedentTokenName: i, whitespaceTokenName: a, ignoreIndentationDelimiters: s } = this.options, l, u, d, f = [];
-		for (let e of n) {
-			for (let [t, n] of s) e.name === t ? e.PUSH_MODE = LexingMode.IGNORE_INDENTATION : e.name === n && (e.POP_MODE = !0);
-			e.name === i ? l = e : e.name === r ? u = e : e.name === a ? d = e : f.push(e);
-		}
-		if (!l || !u || !d) throw Error("Some indentation/whitespace tokens not found!");
-		return s.length > 0 ? {
-			modes: {
-				[LexingMode.REGULAR]: [
-					l,
-					u,
-					...f,
-					d
-				],
-				[LexingMode.IGNORE_INDENTATION]: [...f, d]
-			},
-			defaultMode: LexingMode.REGULAR
-		} : [
-			l,
-			u,
-			d,
-			...f
-		];
-	}
-	flushLexingReport(e) {
-		return {
-			...super.flushLexingReport(e),
-			remainingDedents: this.flushRemainingDedents(e)
-		};
-	}
-	isStartOfLine(e, t) {
-		return t === 0 || "\r\n".includes(e[t - 1]);
-	}
-	matchWhitespace(e, t, n, r) {
-		this.whitespaceRegExp.lastIndex = t;
-		let i = this.whitespaceRegExp.exec(e);
-		return {
-			currIndentLevel: i?.[0].length ?? 0,
-			prevIndentLevel: this.indentationStack.at(-1),
-			match: i
-		};
-	}
-	createIndentationTokenInstance(e, t, r, i) {
-		let a = this.getLineNumber(t, i);
-		return createTokenInstance(e, r, i, i + r.length, a, a, 1, r.length);
-	}
-	getLineNumber(e, t) {
-		return e.substring(0, t).split(/\r\n|\r|\n/).length;
-	}
-	indentMatcher(e, t, n, r) {
-		if (!this.isStartOfLine(e, t)) return null;
-		let { currIndentLevel: i, prevIndentLevel: a, match: o } = this.matchWhitespace(e, t, n, r);
-		return i <= a ? null : (this.indentationStack.push(i), o);
-	}
-	dedentMatcher(e, t, n, r) {
-		if (!this.isStartOfLine(e, t)) return null;
-		let { currIndentLevel: i, prevIndentLevel: a, match: o } = this.matchWhitespace(e, t, n, r);
-		if (i >= a) return null;
-		let s = this.indentationStack.lastIndexOf(i);
-		if (s === -1) return this.diagnostics.push({
-			severity: "error",
-			message: `Invalid dedent level ${i} at offset: ${t}. Current indentation stack: ${this.indentationStack}`,
-			offset: t,
-			length: o?.[0]?.length ?? 0,
-			line: this.getLineNumber(e, t),
-			column: 1
-		}), null;
-		let c = this.indentationStack.length - s - 1, l = e.substring(0, t).match(/[\r\n]+$/)?.[0].length ?? 1;
-		for (let r = 0; r < c; r++) {
-			let r = this.createIndentationTokenInstance(this.dedentTokenType, e, "", t - (l - 1));
-			n.push(r), this.indentationStack.pop();
-		}
-		return null;
-	}
-	buildTerminalToken(n) {
-		let r = super.buildTerminalToken(n), { indentTokenName: i, dedentTokenName: a, whitespaceTokenName: o } = this.options;
-		return r.name === i ? this.indentTokenType : r.name === a ? this.dedentTokenType : r.name === o ? createToken({
-			name: o,
-			pattern: this.whitespaceRegExp,
-			group: Lexer.SKIPPED
-		}) : r;
-	}
-	flushRemainingDedents(e) {
-		let t = [];
-		for (; this.indentationStack.length > 1;) t.push(this.createIndentationTokenInstance(this.dedentTokenType, e, "", e.length)), this.indentationStack.pop();
-		return this.indentationStack = [0], t;
-	}
-}, IndentationAwareLexer = class extends DefaultLexer {
-	constructor(e) {
-		if (super(e), e.parser.TokenBuilder instanceof IndentationAwareTokenBuilder) this.indentationTokenBuilder = e.parser.TokenBuilder;
-		else throw Error("IndentationAwareLexer requires an accompanying IndentationAwareTokenBuilder");
-	}
-	tokenize(e, t = DEFAULT_TOKENIZE_OPTIONS) {
-		let n = super.tokenize(e), r = n.report;
-		t?.mode === "full" && n.tokens.push(...r.remainingDedents), r.remainingDedents = [];
-		let { indentTokenType: a, dedentTokenType: o } = this.indentationTokenBuilder, s = a.tokenTypeIdx, c = o.tokenTypeIdx, l = [], u = n.tokens.length - 1;
-		for (let e = 0; e < u; e++) {
-			let t = n.tokens[e], r = n.tokens[e + 1];
-			if (t.tokenTypeIdx === s && r.tokenTypeIdx === c) {
-				e++;
-				continue;
-			}
-			l.push(t);
-		}
-		return u >= 0 && l.push(n.tokens[u]), n.tokens = l, n;
-	}
-};
-export { IndentationAwareLexer, IndentationAwareTokenBuilder, LexingMode, indentationBuilderDefaultOptions };

package/dist/node_modules/langium/lib/parser/langium-parser-builder.js

@@ -1,11 +0,0 @@
-import { LangiumParser } from "./langium-parser.js";
-import { createParser } from "./parser-builder-base.js";
-function createLangiumParser(e) {
-	let t = prepareLangiumParser(e);
-	return t.finalize(), t;
-}
-function prepareLangiumParser(n) {
-	let r = n.Grammar, i = n.parser.Lexer;
-	return createParser(r, new LangiumParser(n), i.definition);
-}
-export { createLangiumParser, prepareLangiumParser };