@loopstack/loopstack-studio 0.28.0 → 0.29.1

package/dist/node_modules/@chevrotain/gast/lib/src/model.js

@@ -1,151 +0,0 @@
-function tokenLabel(e) {
-	return hasTokenLabel(e) ? e.LABEL : e.name;
-}
-function hasTokenLabel(e) {
-	return typeof e.LABEL == "string" && e.LABEL !== "";
-}
-var AbstractProduction = class {
-	get definition() {
-		return this._definition;
-	}
-	set definition(e) {
-		this._definition = e;
-	}
-	constructor(e) {
-		this._definition = e;
-	}
-	accept(e) {
-		e.visit(this), this.definition.forEach((p) => {
-			p.accept(e);
-		});
-	}
-}, NonTerminal = class extends AbstractProduction {
-	constructor(e) {
-		super([]), this.idx = 1, Object.assign(this, pickOnlyDefined(e));
-	}
-	set definition(e) {}
-	get definition() {
-		return this.referencedRule === void 0 ? [] : this.referencedRule.definition;
-	}
-	accept(e) {
-		e.visit(this);
-	}
-}, Rule = class extends AbstractProduction {
-	constructor(e) {
-		super(e.definition), this.orgText = "", Object.assign(this, pickOnlyDefined(e));
-	}
-}, Alternative = class extends AbstractProduction {
-	constructor(e) {
-		super(e.definition), this.ignoreAmbiguities = !1, Object.assign(this, pickOnlyDefined(e));
-	}
-}, Option = class extends AbstractProduction {
-	constructor(e) {
-		super(e.definition), this.idx = 1, Object.assign(this, pickOnlyDefined(e));
-	}
-}, RepetitionMandatory = class extends AbstractProduction {
-	constructor(e) {
-		super(e.definition), this.idx = 1, Object.assign(this, pickOnlyDefined(e));
-	}
-}, RepetitionMandatoryWithSeparator = class extends AbstractProduction {
-	constructor(e) {
-		super(e.definition), this.idx = 1, Object.assign(this, pickOnlyDefined(e));
-	}
-}, Repetition = class extends AbstractProduction {
-	constructor(e) {
-		super(e.definition), this.idx = 1, Object.assign(this, pickOnlyDefined(e));
-	}
-}, RepetitionWithSeparator = class extends AbstractProduction {
-	constructor(e) {
-		super(e.definition), this.idx = 1, Object.assign(this, pickOnlyDefined(e));
-	}
-}, Alternation = class extends AbstractProduction {
-	get definition() {
-		return this._definition;
-	}
-	set definition(e) {
-		this._definition = e;
-	}
-	constructor(e) {
-		super(e.definition), this.idx = 1, this.ignoreAmbiguities = !1, this.hasPredicates = !1, Object.assign(this, pickOnlyDefined(e));
-	}
-}, Terminal = class {
-	constructor(e) {
-		this.idx = 1, Object.assign(this, pickOnlyDefined(e));
-	}
-	accept(e) {
-		e.visit(this);
-	}
-};
-function serializeGrammar(e) {
-	return e.map(serializeProduction);
-}
-function serializeProduction(p) {
-	function m(e) {
-		return e.map(serializeProduction);
-	}
-	/* istanbul ignore else */
-	if (p instanceof NonTerminal) {
-		let e = {
-			type: "NonTerminal",
-			name: p.nonTerminalName,
-			idx: p.idx
-		};
-		return typeof p.label == "string" && (e.label = p.label), e;
-	} else if (p instanceof Alternative) return {
-		type: "Alternative",
-		definition: m(p.definition)
-	};
-	else if (p instanceof Option) return {
-		type: "Option",
-		idx: p.idx,
-		definition: m(p.definition)
-	};
-	else if (p instanceof RepetitionMandatory) return {
-		type: "RepetitionMandatory",
-		idx: p.idx,
-		definition: m(p.definition)
-	};
-	else if (p instanceof RepetitionMandatoryWithSeparator) return {
-		type: "RepetitionMandatoryWithSeparator",
-		idx: p.idx,
-		separator: serializeProduction(new Terminal({ terminalType: p.separator })),
-		definition: m(p.definition)
-	};
-	else if (p instanceof RepetitionWithSeparator) return {
-		type: "RepetitionWithSeparator",
-		idx: p.idx,
-		separator: serializeProduction(new Terminal({ terminalType: p.separator })),
-		definition: m(p.definition)
-	};
-	else if (p instanceof Repetition) return {
-		type: "Repetition",
-		idx: p.idx,
-		definition: m(p.definition)
-	};
-	else if (p instanceof Alternation) return {
-		type: "Alternation",
-		idx: p.idx,
-		definition: m(p.definition)
-	};
-	else if (p instanceof Terminal) {
-		let m = {
-			type: "Terminal",
-			name: p.terminalType.name,
-			label: tokenLabel(p.terminalType),
-			idx: p.idx
-		};
-		typeof p.label == "string" && (m.terminalLabel = p.label);
-		let h = p.terminalType.PATTERN;
-		return p.terminalType.PATTERN && (m.pattern = h instanceof RegExp ? h.source : h), m;
-	} else if (p instanceof Rule) return {
-		type: "Rule",
-		name: p.name,
-		orgText: p.orgText,
-		definition: m(p.definition)
-	};
-	else throw Error("non exhaustive match");
-}
-function pickOnlyDefined(e) {
-	return Object.fromEntries(Object.entries(e).filter(([, e]) => e !== void 0));
-}
-export { AbstractProduction, Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal, serializeGrammar, serializeProduction };

package/dist/node_modules/@chevrotain/gast/lib/src/visitor.js

@@ -1,40 +0,0 @@
-import { Alternation, Alternative, NonTerminal, Option, Repetition, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Rule, Terminal } from "./model.js";
-var GAstVisitor = class {
-	visit(u) {
-		let d = u;
-		switch (d.constructor) {
-			case NonTerminal: return this.visitNonTerminal(d);
-			case Alternative: return this.visitAlternative(d);
-			case Option: return this.visitOption(d);
-			case RepetitionMandatory: return this.visitRepetitionMandatory(d);
-			case RepetitionMandatoryWithSeparator: return this.visitRepetitionMandatoryWithSeparator(d);
-			case RepetitionWithSeparator: return this.visitRepetitionWithSeparator(d);
-			case Repetition: return this.visitRepetition(d);
-			case Alternation: return this.visitAlternation(d);
-			case Terminal: return this.visitTerminal(d);
-			case Rule: return this.visitRule(d);
-			default: throw Error("non exhaustive match");
-		}
-	}
-	/* c8 ignore next */
-	visitNonTerminal(e) {}
-	/* c8 ignore next */
-	visitAlternative(e) {}
-	/* c8 ignore next */
-	visitOption(e) {}
-	/* c8 ignore next */
-	visitRepetition(e) {}
-	/* c8 ignore next */
-	visitRepetitionMandatory(e) {}
-	/* c8 ignore next 3 */
-	visitRepetitionMandatoryWithSeparator(e) {}
-	/* c8 ignore next */
-	visitRepetitionWithSeparator(e) {}
-	/* c8 ignore next */
-	visitAlternation(e) {}
-	/* c8 ignore next */
-	visitTerminal(e) {}
-	/* c8 ignore next */
-	visitRule(e) {}
-};
-export { GAstVisitor };

package/dist/node_modules/@chevrotain/regexp-to-ast/lib/src/api.js

@@ -1,2 +0,0 @@
-import { RegExpParser } from "./regexp-parser.js";
-import { BaseRegExpVisitor } from "./base-regexp-visitor.js";

package/dist/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js

@@ -1,85 +0,0 @@
-var BaseRegExpVisitor = class {
-	visitChildren(e) {
-		for (let t in e) {
-			let n = e[t];
-			/* istanbul ignore else */
-			e.hasOwnProperty(t) && (n.type === void 0 ? Array.isArray(n) && n.forEach((e) => {
-				this.visit(e);
-			}, this) : this.visit(n));
-		}
-	}
-	visit(e) {
-		switch (e.type) {
-			case "Pattern":
-				this.visitPattern(e);
-				break;
-			case "Flags":
-				this.visitFlags(e);
-				break;
-			case "Disjunction":
-				this.visitDisjunction(e);
-				break;
-			case "Alternative":
-				this.visitAlternative(e);
-				break;
-			case "StartAnchor":
-				this.visitStartAnchor(e);
-				break;
-			case "EndAnchor":
-				this.visitEndAnchor(e);
-				break;
-			case "WordBoundary":
-				this.visitWordBoundary(e);
-				break;
-			case "NonWordBoundary":
-				this.visitNonWordBoundary(e);
-				break;
-			case "Lookahead":
-				this.visitLookahead(e);
-				break;
-			case "NegativeLookahead":
-				this.visitNegativeLookahead(e);
-				break;
-			case "Lookbehind":
-				this.visitLookbehind(e);
-				break;
-			case "NegativeLookbehind":
-				this.visitNegativeLookbehind(e);
-				break;
-			case "Character":
-				this.visitCharacter(e);
-				break;
-			case "Set":
-				this.visitSet(e);
-				break;
-			case "Group":
-				this.visitGroup(e);
-				break;
-			case "GroupBackReference":
-				this.visitGroupBackReference(e);
-				break;
-			case "Quantifier":
-				this.visitQuantifier(e);
-				break;
-		}
-		this.visitChildren(e);
-	}
-	visitPattern(e) {}
-	visitFlags(e) {}
-	visitDisjunction(e) {}
-	visitAlternative(e) {}
-	visitStartAnchor(e) {}
-	visitEndAnchor(e) {}
-	visitWordBoundary(e) {}
-	visitNonWordBoundary(e) {}
-	visitLookahead(e) {}
-	visitNegativeLookahead(e) {}
-	visitLookbehind(e) {}
-	visitNegativeLookbehind(e) {}
-	visitCharacter(e) {}
-	visitSet(e) {}
-	visitGroup(e) {}
-	visitGroupBackReference(e) {}
-	visitQuantifier(e) {}
-};
-export { BaseRegExpVisitor };

package/dist/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js

@@ -1,35 +0,0 @@
-import { cc } from "./utils.js";
-const digitsCharCodes = [];
-for (let r = cc("0"); r <= cc("9"); r++) digitsCharCodes.push(r);
-const wordCharCodes = [cc("_")].concat(digitsCharCodes);
-for (let n = cc("a"); n <= cc("z"); n++) wordCharCodes.push(n);
-for (let n = cc("A"); n <= cc("Z"); n++) wordCharCodes.push(n);
-const whitespaceCodes = [
-	cc(" "),
-	cc("\f"),
-	cc("\n"),
-	cc("\r"),
-	cc("	"),
-	cc("\v"),
-	cc("	"),
-	cc("\xA0"),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc(" "),
-	cc("\u2028"),
-	cc("\u2029"),
-	cc(" "),
-	cc(" "),
-	cc("　"),
-	cc("")
-];
-export { digitsCharCodes, whitespaceCodes, wordCharCodes };