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

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

@@ -0,0 +1,570 @@
+import { ASSERT_EXISTS, ASSERT_NEVER_REACH_HERE, addFlag, cc, insertToSet, isCharacter } from "./utils.js";
+import { digitsCharCodes, whitespaceCodes, wordCharCodes } from "./character-classes.js";
+var hexDigitPattern = /[0-9a-fA-F]/, decimalPattern = /[0-9]/, decimalPatternNoZero = /[1-9]/, RegExpParser = class {
+	constructor() {
+		this.idx = 0, this.input = "", this.groupIdx = 0;
+	}
+	saveState() {
+		return {
+			idx: this.idx,
+			input: this.input,
+			groupIdx: this.groupIdx
+		};
+	}
+	restoreState(e) {
+		this.idx = e.idx, this.input = e.input, this.groupIdx = e.groupIdx;
+	}
+	pattern(e) {
+		this.idx = 0, this.input = e, this.groupIdx = 0, this.consumeChar("/");
+		let u = this.disjunction();
+		this.consumeChar("/");
+		let f = {
+			type: "Flags",
+			loc: {
+				begin: this.idx,
+				end: e.length
+			},
+			global: !1,
+			ignoreCase: !1,
+			multiLine: !1,
+			unicode: !1,
+			sticky: !1
+		};
+		for (; this.isRegExpFlag();) switch (this.popChar()) {
+			case "g":
+				addFlag(f, "global");
+				break;
+			case "i":
+				addFlag(f, "ignoreCase");
+				break;
+			case "m":
+				addFlag(f, "multiLine");
+				break;
+			case "u":
+				addFlag(f, "unicode");
+				break;
+			case "y":
+				addFlag(f, "sticky");
+				break;
+		}
+		if (this.idx !== this.input.length) throw Error("Redundant input: " + this.input.substring(this.idx));
+		return {
+			type: "Pattern",
+			flags: f,
+			value: u,
+			loc: this.loc(0)
+		};
+	}
+	disjunction() {
+		let e = [], u = this.idx;
+		for (e.push(this.alternative()); this.peekChar() === "|";) this.consumeChar("|"), e.push(this.alternative());
+		return {
+			type: "Disjunction",
+			value: e,
+			loc: this.loc(u)
+		};
+	}
+	alternative() {
+		let e = [], u = this.idx;
+		for (; this.isTerm();) e.push(this.term());
+		return {
+			type: "Alternative",
+			value: e,
+			loc: this.loc(u)
+		};
+	}
+	term() {
+		return this.isAssertion() ? this.assertion() : this.atom();
+	}
+	assertion() {
+		let d = this.idx;
+		switch (this.popChar()) {
+			case "^": return {
+				type: "StartAnchor",
+				loc: this.loc(d)
+			};
+			case "$": return {
+				type: "EndAnchor",
+				loc: this.loc(d)
+			};
+			case "\\":
+				switch (this.popChar()) {
+					case "b": return {
+						type: "WordBoundary",
+						loc: this.loc(d)
+					};
+					case "B": return {
+						type: "NonWordBoundary",
+						loc: this.loc(d)
+					};
+				}
+				/* c8 ignore next */
+				throw Error("Invalid Assertion Escape");
+			case "(":
+				this.consumeChar("?");
+				let u;
+				switch (this.popChar()) {
+					case "=":
+						u = "Lookahead";
+						break;
+					case "!":
+						u = "NegativeLookahead";
+						break;
+					case "<":
+						switch (this.popChar()) {
+							case "=":
+								u = "Lookbehind";
+								break;
+							case "!": u = "NegativeLookbehind";
+						}
+						break;
+				}
+				ASSERT_EXISTS(u);
+				let f = this.disjunction();
+				return this.consumeChar(")"), {
+					type: u,
+					value: f,
+					loc: this.loc(d)
+				};
+		}
+		// istanbul ignore next
+		return ASSERT_NEVER_REACH_HERE();
+	}
+	quantifier(u = !1) {
+		let d, f = this.idx;
+		switch (this.popChar()) {
+			case "*":
+				d = {
+					atLeast: 0,
+					atMost: Infinity
+				};
+				break;
+			case "+":
+				d = {
+					atLeast: 1,
+					atMost: Infinity
+				};
+				break;
+			case "?":
+				d = {
+					atLeast: 0,
+					atMost: 1
+				};
+				break;
+			case "{":
+				let f = this.integerIncludingZero();
+				switch (this.popChar()) {
+					case "}":
+						d = {
+							atLeast: f,
+							atMost: f
+						};
+						break;
+					case ",":
+						let e;
+						this.isDigit() ? (e = this.integerIncludingZero(), d = {
+							atLeast: f,
+							atMost: e
+						}) : d = {
+							atLeast: f,
+							atMost: Infinity
+						}, this.consumeChar("}");
+						break;
+				}
+				if (u === !0 && d === void 0) return;
+				ASSERT_EXISTS(d);
+				break;
+		}
+		if (!(u === !0 && d === void 0) && ASSERT_EXISTS(d)) return this.peekChar(0) === "?" ? (this.consumeChar("?"), d.greedy = !1) : d.greedy = !0, d.type = "Quantifier", d.loc = this.loc(f), d;
+	}
+	atom() {
+		let d, f = this.idx;
+		switch (this.peekChar()) {
+			case ".":
+				d = this.dotAll();
+				break;
+			case "\\":
+				d = this.atomEscape();
+				break;
+			case "[":
+				d = this.characterClass();
+				break;
+			case "(":
+				d = this.group();
+				break;
+		}
+		// istanbul ignore next
+		return d === void 0 && this.isPatternCharacter() && (d = this.patternCharacter()), ASSERT_EXISTS(d) ? (d.loc = this.loc(f), this.isQuantifier() && (d.quantifier = this.quantifier()), d) : ASSERT_NEVER_REACH_HERE();
+	}
+	dotAll() {
+		return this.consumeChar("."), {
+			type: "Set",
+			complement: !0,
+			value: [
+				cc("\n"),
+				cc("\r"),
+				cc("\u2028"),
+				cc("\u2029")
+			]
+		};
+	}
+	atomEscape() {
+		switch (this.consumeChar("\\"), this.peekChar()) {
+			case "1":
+			case "2":
+			case "3":
+			case "4":
+			case "5":
+			case "6":
+			case "7":
+			case "8":
+			case "9": return this.decimalEscapeAtom();
+			case "d":
+			case "D":
+			case "s":
+			case "S":
+			case "w":
+			case "W": return this.characterClassEscape();
+			case "f":
+			case "n":
+			case "r":
+			case "t":
+			case "v": return this.controlEscapeAtom();
+			case "c": return this.controlLetterEscapeAtom();
+			case "0": return this.nulCharacterAtom();
+			case "x": return this.hexEscapeSequenceAtom();
+			case "u": return this.regExpUnicodeEscapeSequenceAtom();
+			default: return this.identityEscapeAtom();
+		}
+	}
+	decimalEscapeAtom() {
+		return {
+			type: "GroupBackReference",
+			value: this.positiveInteger()
+		};
+	}
+	characterClassEscape() {
+		let d, f = !1;
+		switch (this.popChar()) {
+			case "d":
+				d = digitsCharCodes;
+				break;
+			case "D":
+				d = digitsCharCodes, f = !0;
+				break;
+			case "s":
+				d = whitespaceCodes;
+				break;
+			case "S":
+				d = whitespaceCodes, f = !0;
+				break;
+			case "w":
+				d = wordCharCodes;
+				break;
+			case "W":
+				d = wordCharCodes, f = !0;
+				break;
+		}
+		// istanbul ignore next
+		return ASSERT_EXISTS(d) ? {
+			type: "Set",
+			value: d,
+			complement: f
+		} : ASSERT_NEVER_REACH_HERE();
+	}
+	controlEscapeAtom() {
+		let d;
+		switch (this.popChar()) {
+			case "f":
+				d = cc("\f");
+				break;
+			case "n":
+				d = cc("\n");
+				break;
+			case "r":
+				d = cc("\r");
+				break;
+			case "t":
+				d = cc("	");
+				break;
+			case "v":
+				d = cc("\v");
+				break;
+		}
+		// istanbul ignore next
+		return ASSERT_EXISTS(d) ? {
+			type: "Character",
+			value: d
+		} : ASSERT_NEVER_REACH_HERE();
+	}
+	controlLetterEscapeAtom() {
+		this.consumeChar("c");
+		let e = this.popChar();
+		if (/[a-zA-Z]/.test(e) === !1) throw Error("Invalid ");
+		return {
+			type: "Character",
+			value: e.toUpperCase().charCodeAt(0) - 64
+		};
+	}
+	nulCharacterAtom() {
+		return this.consumeChar("0"), {
+			type: "Character",
+			value: cc("\0")
+		};
+	}
+	hexEscapeSequenceAtom() {
+		return this.consumeChar("x"), this.parseHexDigits(2);
+	}
+	regExpUnicodeEscapeSequenceAtom() {
+		return this.consumeChar("u"), this.parseHexDigits(4);
+	}
+	identityEscapeAtom() {
+		return {
+			type: "Character",
+			value: cc(this.popChar())
+		};
+	}
+	classPatternCharacterAtom() {
+		switch (this.peekChar()) {
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029":
+			case "\\":
+			case "]": throw Error("TBD");
+			default: return {
+				type: "Character",
+				value: cc(this.popChar())
+			};
+		}
+	}
+	characterClass() {
+		let e = [], u = !1;
+		for (this.consumeChar("["), this.peekChar(0) === "^" && (this.consumeChar("^"), u = !0); this.isClassAtom();) {
+			let u = this.classAtom();
+			if (u.type, isCharacter(u) && this.isRangeDash()) {
+				this.consumeChar("-");
+				let d = this.classAtom();
+				if (d.type, isCharacter(d)) {
+					if (d.value < u.value) throw Error("Range out of order in character class");
+					e.push({
+						from: u.value,
+						to: d.value
+					});
+				} else insertToSet(u.value, e), e.push(cc("-")), insertToSet(d.value, e);
+			} else insertToSet(u.value, e);
+		}
+		return this.consumeChar("]"), {
+			type: "Set",
+			complement: u,
+			value: e
+		};
+	}
+	classAtom() {
+		switch (this.peekChar()) {
+			case "]":
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029": throw Error("TBD");
+			case "\\": return this.classEscape();
+			default: return this.classPatternCharacterAtom();
+		}
+	}
+	classEscape() {
+		switch (this.consumeChar("\\"), this.peekChar()) {
+			case "b": return this.consumeChar("b"), {
+				type: "Character",
+				value: cc("\b")
+			};
+			case "d":
+			case "D":
+			case "s":
+			case "S":
+			case "w":
+			case "W": return this.characterClassEscape();
+			case "f":
+			case "n":
+			case "r":
+			case "t":
+			case "v": return this.controlEscapeAtom();
+			case "c": return this.controlLetterEscapeAtom();
+			case "0": return this.nulCharacterAtom();
+			case "x": return this.hexEscapeSequenceAtom();
+			case "u": return this.regExpUnicodeEscapeSequenceAtom();
+			default: return this.identityEscapeAtom();
+		}
+	}
+	group() {
+		let e = !0;
+		switch (this.consumeChar("("), this.peekChar(0)) {
+			case "?":
+				this.consumeChar("?"), this.consumeChar(":"), e = !1;
+				break;
+			default:
+				this.groupIdx++;
+				break;
+		}
+		let u = this.disjunction();
+		this.consumeChar(")");
+		let d = {
+			type: "Group",
+			capturing: e,
+			value: u
+		};
+		return e && (d.idx = this.groupIdx), d;
+	}
+	positiveInteger() {
+		let e = this.popChar();
+		// istanbul ignore next - can't ever get here due to previous lookahead checks
+		if (decimalPatternNoZero.test(e) === !1) throw Error("Expecting a positive integer");
+		for (; decimalPattern.test(this.peekChar(0));) e += this.popChar();
+		return parseInt(e, 10);
+	}
+	integerIncludingZero() {
+		let e = this.popChar();
+		if (decimalPattern.test(e) === !1) throw Error("Expecting an integer");
+		for (; decimalPattern.test(this.peekChar(0));) e += this.popChar();
+		return parseInt(e, 10);
+	}
+	patternCharacter() {
+		let e = this.popChar();
+		switch (e) {
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029":
+			case "^":
+			case "$":
+			case "\\":
+			case ".":
+			case "*":
+			case "+":
+			case "?":
+			case "(":
+			case ")":
+			case "[":
+			case "|":
+ // istanbul ignore next
+			throw Error("TBD");
+			default: return {
+				type: "Character",
+				value: cc(e)
+			};
+		}
+	}
+	isRegExpFlag() {
+		switch (this.peekChar(0)) {
+			case "g":
+			case "i":
+			case "m":
+			case "u":
+			case "y": return !0;
+			default: return !1;
+		}
+	}
+	isRangeDash() {
+		return this.peekChar() === "-" && this.isClassAtom(1);
+	}
+	isDigit() {
+		return decimalPattern.test(this.peekChar(0));
+	}
+	isClassAtom(e = 0) {
+		switch (this.peekChar(e)) {
+			case "]":
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029": return !1;
+			default: return !0;
+		}
+	}
+	isTerm() {
+		return this.isAtom() || this.isAssertion();
+	}
+	isAtom() {
+		if (this.isPatternCharacter()) return !0;
+		switch (this.peekChar(0)) {
+			case ".":
+			case "\\":
+			case "[":
+			case "(": return !0;
+			default: return !1;
+		}
+	}
+	isAssertion() {
+		switch (this.peekChar(0)) {
+			case "^":
+			case "$": return !0;
+			case "\\": switch (this.peekChar(1)) {
+				case "b":
+				case "B": return !0;
+				default: return !1;
+			}
+			case "(": return this.peekChar(1) === "?" && (this.peekChar(2) === "=" || this.peekChar(2) === "!" || this.peekChar(2) === "<" && (this.peekChar(3) === "=" || this.peekChar(3) === "!"));
+			default: return !1;
+		}
+	}
+	isQuantifier() {
+		let e = this.saveState();
+		try {
+			return this.quantifier(!0) !== void 0;
+		} catch {
+			return !1;
+		} finally {
+			this.restoreState(e);
+		}
+	}
+	isPatternCharacter() {
+		switch (this.peekChar()) {
+			case "^":
+			case "$":
+			case "\\":
+			case ".":
+			case "*":
+			case "+":
+			case "?":
+			case "(":
+			case ")":
+			case "[":
+			case "|":
+			case "/":
+			case "\n":
+			case "\r":
+			case "\u2028":
+			case "\u2029": return !1;
+			default: return !0;
+		}
+	}
+	parseHexDigits(e) {
+		let u = "";
+		for (let d = 0; d < e; d++) {
+			let e = this.popChar();
+			if (hexDigitPattern.test(e) === !1) throw Error("Expecting a HexDecimal digits");
+			u += e;
+		}
+		return {
+			type: "Character",
+			value: parseInt(u, 16)
+		};
+	}
+	peekChar(e = 0) {
+		return this.input[this.idx + e];
+	}
+	popChar() {
+		let e = this.peekChar(0);
+		return this.consumeChar(void 0), e;
+	}
+	consumeChar(e) {
+		if (e !== void 0 && this.input[this.idx] !== e) throw Error("Expected: '" + e + "' but found: '" + this.input[this.idx] + "' at offset: " + this.idx);
+		if (this.idx >= this.input.length) throw Error("Unexpected end of input");
+		this.idx++;
+	}
+	loc(e) {
+		return {
+			begin: e,
+			end: this.idx
+		};
+	}
+};
+export { RegExpParser };

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

@@ -0,0 +1,25 @@
+function cc(e) {
+	return e.charCodeAt(0);
+}
+function insertToSet(e, a) {
+	Array.isArray(e) ? e.forEach(function(e) {
+		a.push(e);
+	}) : a.push(e);
+}
+function addFlag(e, a) {
+	if (e[a] === !0) throw "duplicate flag " + a;
+	e[a], e[a] = !0;
+}
+function ASSERT_EXISTS(e) {
+	// istanbul ignore next
+	if (e === void 0) throw Error("Internal Error - Should never get here!");
+	return !0;
+}
+// istanbul ignore next
+function ASSERT_NEVER_REACH_HERE() {
+	throw Error("Internal Error - Should never get here!");
+}
+function isCharacter(e) {
+	return e.type === "Character";
+}
+export { ASSERT_EXISTS, ASSERT_NEVER_REACH_HERE, addFlag, cc, insertToSet, isCharacter };

package/dist/node_modules/@chevrotain/utils/lib/src/print.js

@@ -0,0 +1,9 @@
+function PRINT_ERROR(e) {
+	/* istanbul ignore else - can't override global.console in node.js */
+	console && console.error && console.error(`Error: ${e}`);
+}
+function PRINT_WARNING(e) {
+	/* istanbul ignore else - can't override global.console in node.js*/
+	console && console.warn && console.warn(`Warning: ${e}`);
+}
+export { PRINT_ERROR, PRINT_WARNING };

package/dist/node_modules/@chevrotain/utils/lib/src/timer.js

@@ -0,0 +1,8 @@
+function timer(e) {
+	let t = (/* @__PURE__ */ new Date()).getTime(), n = e();
+	return {
+		time: (/* @__PURE__ */ new Date()).getTime() - t,
+		value: n
+	};
+}
+export { timer };

package/dist/node_modules/@chevrotain/utils/lib/src/to-fast-properties.js

@@ -0,0 +1,10 @@
+function toFastProperties(e) {
+	function t() {}
+	t.prototype = e;
+	let n = new t();
+	function r() {
+		return typeof n.bar;
+	}
+	return r(), r(), e;
+}
+export { toFastProperties };

package/dist/node_modules/@iconify/utils/lib/customisations/defaults.js

@@ -0,0 +1,9 @@
+import { defaultIconTransformations } from "../icon/defaults.js";
+var defaultIconSizeCustomisations = Object.freeze({
+	width: null,
+	height: null
+}), defaultIconCustomisations = Object.freeze({
+	...defaultIconSizeCustomisations,
+	...defaultIconTransformations
+});
+export { defaultIconCustomisations };

package/dist/node_modules/@iconify/utils/lib/icon/defaults.js

@@ -0,0 +1,18 @@
+var defaultIconDimensions = Object.freeze({
+	left: 0,
+	top: 0,
+	width: 16,
+	height: 16
+}), defaultIconTransformations = Object.freeze({
+	rotate: 0,
+	vFlip: !1,
+	hFlip: !1
+}), defaultIconProps = Object.freeze({
+	...defaultIconDimensions,
+	...defaultIconTransformations
+}), defaultExtendedIconProps = Object.freeze({
+	...defaultIconProps,
+	body: "",
+	hidden: !1
+});
+export { defaultExtendedIconProps, defaultIconProps, defaultIconTransformations };

package/dist/node_modules/@iconify/utils/lib/icon/merge.js

@@ -0,0 +1,8 @@
+import { defaultExtendedIconProps, defaultIconTransformations } from "./defaults.js";
+import { mergeIconTransformations } from "./transformations.js";
+function mergeIconData(r, i) {
+	let a = mergeIconTransformations(r, i);
+	for (let n in defaultExtendedIconProps) n in defaultIconTransformations ? n in r && !(n in a) && (a[n] = defaultIconTransformations[n]) : n in i ? a[n] = i[n] : n in r && (a[n] = r[n]);
+	return a;
+}
+export { mergeIconData };

package/dist/node_modules/@iconify/utils/lib/icon/name.js

@@ -0,0 +1,35 @@
+var stringToIcon = (e, n, r, i = "") => {
+	let a = e.split(":");
+	if (e.slice(0, 1) === "@") {
+		if (a.length < 2 || a.length > 3) return null;
+		i = a.shift().slice(1);
+	}
+	if (a.length > 3 || !a.length) return null;
+	if (a.length > 1) {
+		let e = a.pop(), r = a.pop(), o = {
+			provider: a.length > 0 ? a[0] : i,
+			prefix: r,
+			name: e
+		};
+		return n && !validateIconName(o) ? null : o;
+	}
+	let o = a[0], s = o.split("-");
+	if (s.length > 1) {
+		let e = {
+			provider: i,
+			prefix: s.shift(),
+			name: s.join("-")
+		};
+		return n && !validateIconName(e) ? null : e;
+	}
+	if (r && i === "") {
+		let e = {
+			provider: i,
+			prefix: "",
+			name: o
+		};
+		return n && !validateIconName(e, r) ? null : e;
+	}
+	return null;
+}, validateIconName = (e, t) => e ? !!((t && e.prefix === "" || e.prefix) && e.name) : !1;
+export { stringToIcon };

package/dist/node_modules/@iconify/utils/lib/icon/transformations.js

@@ -0,0 +1,7 @@
+function mergeIconTransformations(e, t) {
+	let n = {};
+	!e.hFlip != !t.hFlip && (n.hFlip = !0), !e.vFlip != !t.vFlip && (n.vFlip = !0);
+	let r = ((e.rotate || 0) + (t.rotate || 0)) % 4;
+	return r && (n.rotate = r), n;
+}
+export { mergeIconTransformations };