@loopstack/loopstack-studio 0.25.1 → 0.26.0

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

@@ -1,7 +1,6 @@
-import { ASSERT_EXISTS as e, ASSERT_NEVER_REACH_HERE as t, addFlag as n, cc as r, insertToSet as i, isCharacter as a } from "./utils.js";
-import { digitsCharCodes as o, whitespaceCodes as s, wordCharCodes as c } from "./character-classes.js";
-//#region ../../node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js
-var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
+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;
 	}
@@ -17,9 +16,9 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 	}
 	pattern(e) {
 		this.idx = 0, this.input = e, this.groupIdx = 0, this.consumeChar("/");
-		let t = this.disjunction();
+		let u = this.disjunction();
 		this.consumeChar("/");
-		let r = {
+		let f = {
 			type: "Flags",
 			loc: {
 				begin: this.idx,
@@ -33,179 +32,179 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 		};
 		for (; this.isRegExpFlag();) switch (this.popChar()) {
 			case "g":
-				n(r, "global");
+				addFlag(f, "global");
 				break;
 			case "i":
-				n(r, "ignoreCase");
+				addFlag(f, "ignoreCase");
 				break;
 			case "m":
-				n(r, "multiLine");
+				addFlag(f, "multiLine");
 				break;
 			case "u":
-				n(r, "unicode");
+				addFlag(f, "unicode");
 				break;
 			case "y":
-				n(r, "sticky");
+				addFlag(f, "sticky");
 				break;
 		}
 		if (this.idx !== this.input.length) throw Error("Redundant input: " + this.input.substring(this.idx));
 		return {
 			type: "Pattern",
-			flags: r,
-			value: t,
+			flags: f,
+			value: u,
 			loc: this.loc(0)
 		};
 	}
 	disjunction() {
-		let e = [], t = this.idx;
+		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(t)
+			loc: this.loc(u)
 		};
 	}
 	alternative() {
-		let e = [], t = this.idx;
+		let e = [], u = this.idx;
 		for (; this.isTerm();) e.push(this.term());
 		return {
 			type: "Alternative",
 			value: e,
-			loc: this.loc(t)
+			loc: this.loc(u)
 		};
 	}
 	term() {
 		return this.isAssertion() ? this.assertion() : this.atom();
 	}
 	assertion() {
-		let n = this.idx;
+		let d = this.idx;
 		switch (this.popChar()) {
 			case "^": return {
 				type: "StartAnchor",
-				loc: this.loc(n)
+				loc: this.loc(d)
 			};
 			case "$": return {
 				type: "EndAnchor",
-				loc: this.loc(n)
+				loc: this.loc(d)
 			};
 			case "\\":
 				switch (this.popChar()) {
 					case "b": return {
 						type: "WordBoundary",
-						loc: this.loc(n)
+						loc: this.loc(d)
 					};
 					case "B": return {
 						type: "NonWordBoundary",
-						loc: this.loc(n)
+						loc: this.loc(d)
 					};
 				}
 				/* c8 ignore next */
 				throw Error("Invalid Assertion Escape");
 			case "(":
 				this.consumeChar("?");
-				let t;
+				let u;
 				switch (this.popChar()) {
 					case "=":
-						t = "Lookahead";
+						u = "Lookahead";
 						break;
 					case "!":
-						t = "NegativeLookahead";
+						u = "NegativeLookahead";
 						break;
 					case "<":
 						switch (this.popChar()) {
 							case "=":
-								t = "Lookbehind";
+								u = "Lookbehind";
 								break;
-							case "!": t = "NegativeLookbehind";
+							case "!": u = "NegativeLookbehind";
 						}
 						break;
 				}
-				e(t);
-				let r = this.disjunction();
+				ASSERT_EXISTS(u);
+				let f = this.disjunction();
 				return this.consumeChar(")"), {
-					type: t,
-					value: r,
-					loc: this.loc(n)
+					type: u,
+					value: f,
+					loc: this.loc(d)
 				};
 		}
 		// istanbul ignore next
-		return t();
+		return ASSERT_NEVER_REACH_HERE();
 	}
-	quantifier(t = !1) {
-		let n, r = this.idx;
+	quantifier(u = !1) {
+		let d, f = this.idx;
 		switch (this.popChar()) {
 			case "*":
-				n = {
+				d = {
 					atLeast: 0,
 					atMost: Infinity
 				};
 				break;
 			case "+":
-				n = {
+				d = {
 					atLeast: 1,
 					atMost: Infinity
 				};
 				break;
 			case "?":
-				n = {
+				d = {
 					atLeast: 0,
 					atMost: 1
 				};
 				break;
 			case "{":
-				let r = this.integerIncludingZero();
+				let f = this.integerIncludingZero();
 				switch (this.popChar()) {
 					case "}":
-						n = {
-							atLeast: r,
-							atMost: r
+						d = {
+							atLeast: f,
+							atMost: f
 						};
 						break;
 					case ",":
 						let e;
-						this.isDigit() ? (e = this.integerIncludingZero(), n = {
-							atLeast: r,
+						this.isDigit() ? (e = this.integerIncludingZero(), d = {
+							atLeast: f,
 							atMost: e
-						}) : n = {
-							atLeast: r,
+						}) : d = {
+							atLeast: f,
 							atMost: Infinity
 						}, this.consumeChar("}");
 						break;
 				}
-				if (t === !0 && n === void 0) return;
-				e(n);
+				if (u === !0 && d === void 0) return;
+				ASSERT_EXISTS(d);
 				break;
 		}
-		if (!(t === !0 && n === void 0) && e(n)) return this.peekChar(0) === "?" ? (this.consumeChar("?"), n.greedy = !1) : n.greedy = !0, n.type = "Quantifier", n.loc = this.loc(r), n;
+		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 n, r = this.idx;
+		let d, f = this.idx;
 		switch (this.peekChar()) {
 			case ".":
-				n = this.dotAll();
+				d = this.dotAll();
 				break;
 			case "\\":
-				n = this.atomEscape();
+				d = this.atomEscape();
 				break;
 			case "[":
-				n = this.characterClass();
+				d = this.characterClass();
 				break;
 			case "(":
-				n = this.group();
+				d = this.group();
 				break;
 		}
 		// istanbul ignore next
-		return n === void 0 && this.isPatternCharacter() && (n = this.patternCharacter()), e(n) ? (n.loc = this.loc(r), this.isQuantifier() && (n.quantifier = this.quantifier()), n) : t();
+		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: [
-				r("\n"),
-				r("\r"),
-				r("\u2028"),
-				r("\u2029")
+				cc("\n"),
+				cc("\r"),
+				cc("\u2028"),
+				cc("\u2029")
 			]
 		};
 	}
@@ -245,58 +244,58 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 		};
 	}
 	characterClassEscape() {
-		let n, r = !1;
+		let d, f = !1;
 		switch (this.popChar()) {
 			case "d":
-				n = o;
+				d = digitsCharCodes;
 				break;
 			case "D":
-				n = o, r = !0;
+				d = digitsCharCodes, f = !0;
 				break;
 			case "s":
-				n = s;
+				d = whitespaceCodes;
 				break;
 			case "S":
-				n = s, r = !0;
+				d = whitespaceCodes, f = !0;
 				break;
 			case "w":
-				n = c;
+				d = wordCharCodes;
 				break;
 			case "W":
-				n = c, r = !0;
+				d = wordCharCodes, f = !0;
 				break;
 		}
 		// istanbul ignore next
-		return e(n) ? {
+		return ASSERT_EXISTS(d) ? {
 			type: "Set",
-			value: n,
-			complement: r
-		} : t();
+			value: d,
+			complement: f
+		} : ASSERT_NEVER_REACH_HERE();
 	}
 	controlEscapeAtom() {
-		let n;
+		let d;
 		switch (this.popChar()) {
 			case "f":
-				n = r("\f");
+				d = cc("\f");
 				break;
 			case "n":
-				n = r("\n");
+				d = cc("\n");
 				break;
 			case "r":
-				n = r("\r");
+				d = cc("\r");
 				break;
 			case "t":
-				n = r("	");
+				d = cc("	");
 				break;
 			case "v":
-				n = r("\v");
+				d = cc("\v");
 				break;
 		}
 		// istanbul ignore next
-		return e(n) ? {
+		return ASSERT_EXISTS(d) ? {
 			type: "Character",
-			value: n
-		} : t();
+			value: d
+		} : ASSERT_NEVER_REACH_HERE();
 	}
 	controlLetterEscapeAtom() {
 		this.consumeChar("c");
@@ -310,7 +309,7 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 	nulCharacterAtom() {
 		return this.consumeChar("0"), {
 			type: "Character",
-			value: r("\0")
+			value: cc("\0")
 		};
 	}
 	hexEscapeSequenceAtom() {
@@ -322,62 +321,51 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 	identityEscapeAtom() {
 		return {
 			type: "Character",
-			value: r(this.popChar())
+			value: cc(this.popChar())
 		};
 	}
 	classPatternCharacterAtom() {
 		switch (this.peekChar()) {
-			// istanbul ignore next
 			case "\n":
-			// istanbul ignore next
 			case "\r":
-			// istanbul ignore next
 			case "\u2028":
-			// istanbul ignore next
 			case "\u2029":
-			// istanbul ignore next
 			case "\\":
-			// istanbul ignore next
 			case "]": throw Error("TBD");
 			default: return {
 				type: "Character",
-				value: r(this.popChar())
+				value: cc(this.popChar())
 			};
 		}
 	}
 	characterClass() {
-		let e = [], t = !1;
-		for (this.consumeChar("["), this.peekChar(0) === "^" && (this.consumeChar("^"), t = !0); this.isClassAtom();) {
-			let t = this.classAtom();
-			if (t.type, a(t) && this.isRangeDash()) {
+		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 n = this.classAtom();
-				if (n.type, a(n)) {
-					if (n.value < t.value) throw Error("Range out of order in character class");
+				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: t.value,
-						to: n.value
+						from: u.value,
+						to: d.value
 					});
-				} else i(t.value, e), e.push(r("-")), i(n.value, e);
-			} else i(t.value, e);
+				} else insertToSet(u.value, e), e.push(cc("-")), insertToSet(d.value, e);
+			} else insertToSet(u.value, e);
 		}
 		return this.consumeChar("]"), {
 			type: "Set",
-			complement: t,
+			complement: u,
 			value: e
 		};
 	}
 	classAtom() {
 		switch (this.peekChar()) {
-			// istanbul ignore next
 			case "]":
-			// istanbul ignore next
 			case "\n":
-			// istanbul ignore next
 			case "\r":
-			// istanbul ignore next
 			case "\u2028":
-			// istanbul ignore next
 			case "\u2029": throw Error("TBD");
 			case "\\": return this.classEscape();
 			default: return this.classPatternCharacterAtom();
@@ -387,7 +375,7 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 		switch (this.consumeChar("\\"), this.peekChar()) {
 			case "b": return this.consumeChar("b"), {
 				type: "Character",
-				value: r("\b")
+				value: cc("\b")
 			};
 			case "d":
 			case "D":
@@ -417,66 +405,51 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 				this.groupIdx++;
 				break;
 		}
-		let t = this.disjunction();
+		let u = this.disjunction();
 		this.consumeChar(")");
-		let n = {
+		let d = {
 			type: "Group",
 			capturing: e,
-			value: t
+			value: u
 		};
-		return e && (n.idx = this.groupIdx), n;
+		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 (d.test(e) === !1) throw Error("Expecting a positive integer");
-		for (; u.test(this.peekChar(0));) e += this.popChar();
+		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 (u.test(e) === !1) throw Error("Expecting an integer");
-		for (; u.test(this.peekChar(0));) 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) {
-			// istanbul ignore next
 			case "\n":
-			// istanbul ignore next
 			case "\r":
-			// istanbul ignore next
 			case "\u2028":
-			// istanbul ignore next
 			case "\u2029":
-			// istanbul ignore next
 			case "^":
-			// istanbul ignore next
 			case "$":
-			// istanbul ignore next
 			case "\\":
-			// istanbul ignore next
 			case ".":
-			// istanbul ignore next
 			case "*":
-			// istanbul ignore next
 			case "+":
-			// istanbul ignore next
 			case "?":
-			// istanbul ignore next
 			case "(":
-			// istanbul ignore next
 			case ")":
-			// istanbul ignore next
 			case "[":
-			// istanbul ignore next
 			case "|":
  // istanbul ignore next
 			throw Error("TBD");
 			default: return {
 				type: "Character",
-				value: r(e)
+				value: cc(e)
 			};
 		}
 	}
@@ -494,7 +467,7 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 		return this.peekChar() === "-" && this.isClassAtom(1);
 	}
 	isDigit() {
-		return u.test(this.peekChar(0));
+		return decimalPattern.test(this.peekChar(0));
 	}
 	isClassAtom(e = 0) {
 		switch (this.peekChar(e)) {
@@ -564,15 +537,15 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 		}
 	}
 	parseHexDigits(e) {
-		let t = "";
-		for (let n = 0; n < e; n++) {
+		let u = "";
+		for (let d = 0; d < e; d++) {
 			let e = this.popChar();
-			if (l.test(e) === !1) throw Error("Expecting a HexDecimal digits");
-			t += e;
+			if (hexDigitPattern.test(e) === !1) throw Error("Expecting a HexDecimal digits");
+			u += e;
 		}
 		return {
 			type: "Character",
-			value: parseInt(t, 16)
+			value: parseInt(u, 16)
 		};
 	}
 	peekChar(e = 0) {
@@ -594,5 +567,4 @@ var l = /[0-9a-fA-F]/, u = /[0-9]/, d = /[1-9]/, f = class {
 		};
 	}
 };
-//#endregion
-export { f as RegExpParser };
+export { RegExpParser };

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

@@ -1,27 +1,25 @@
-//#region ../../node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js
-function e(e) {
+function cc(e) {
 	return e.charCodeAt(0);
 }
-function t(e, t) {
+function insertToSet(e, a) {
 	Array.isArray(e) ? e.forEach(function(e) {
-		t.push(e);
-	}) : t.push(e);
+		a.push(e);
+	}) : a.push(e);
 }
-function n(e, t) {
-	if (e[t] === !0) throw "duplicate flag " + t;
-	e[t], e[t] = !0;
+function addFlag(e, a) {
+	if (e[a] === !0) throw "duplicate flag " + a;
+	e[a], e[a] = !0;
 }
-function r(e) {
+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 i() {
+function ASSERT_NEVER_REACH_HERE() {
 	throw Error("Internal Error - Should never get here!");
 }
-function a(e) {
+function isCharacter(e) {
 	return e.type === "Character";
 }
-//#endregion
-export { r as ASSERT_EXISTS, i as ASSERT_NEVER_REACH_HERE, n as addFlag, e as cc, t as insertToSet, a as isCharacter };
+export { ASSERT_EXISTS, ASSERT_NEVER_REACH_HERE, addFlag, cc, insertToSet, isCharacter };

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

@@ -1,11 +1,9 @@
-//#region ../../node_modules/@chevrotain/utils/lib/src/print.js
-function e(e) {
+function PRINT_ERROR(e) {
 	/* istanbul ignore else - can't override global.console in node.js */
 	console && console.error && console.error(`Error: ${e}`);
 }
-function t(e) {
+function PRINT_WARNING(e) {
 	/* istanbul ignore else - can't override global.console in node.js*/
 	console && console.warn && console.warn(`Warning: ${e}`);
 }
-//#endregion
-export { e as PRINT_ERROR, t as PRINT_WARNING };
+export { PRINT_ERROR, PRINT_WARNING };

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

@@ -1,10 +1,8 @@
-//#region ../../node_modules/@chevrotain/utils/lib/src/timer.js
-function e(e) {
+function timer(e) {
 	let t = (/* @__PURE__ */ new Date()).getTime(), n = e();
 	return {
 		time: (/* @__PURE__ */ new Date()).getTime() - t,
 		value: n
 	};
 }
-//#endregion
-export { e as timer };
+export { timer };

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

@@ -1,5 +1,4 @@
-//#region ../../node_modules/@chevrotain/utils/lib/src/to-fast-properties.js
-function e(e) {
+function toFastProperties(e) {
 	function t() {}
 	t.prototype = e;
 	let n = new t();
@@ -8,5 +7,4 @@ function e(e) {
 	}
 	return r(), r(), e;
 }
-//#endregion
-export { e as toFastProperties };
+export { toFastProperties };

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

@@ -1,11 +1,9 @@
-import { defaultIconTransformations as e } from "../icon/defaults.js";
-//#region ../../node_modules/@iconify/utils/lib/customisations/defaults.js
-var t = Object.freeze({
+import { defaultIconTransformations } from "../icon/defaults.js";
+var defaultIconSizeCustomisations = Object.freeze({
 	width: null,
 	height: null
-}), n = Object.freeze({
-	...t,
-	...e
+}), defaultIconCustomisations = Object.freeze({
+	...defaultIconSizeCustomisations,
+	...defaultIconTransformations
 });
-//#endregion
-export { n as defaultIconCustomisations };
+export { defaultIconCustomisations };

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

@@ -1,20 +1,18 @@
-//#region ../../node_modules/@iconify/utils/lib/icon/defaults.js
-var e = Object.freeze({
+var defaultIconDimensions = Object.freeze({
 	left: 0,
 	top: 0,
 	width: 16,
 	height: 16
-}), t = Object.freeze({
+}), defaultIconTransformations = Object.freeze({
 	rotate: 0,
 	vFlip: !1,
 	hFlip: !1
-}), n = Object.freeze({
-	...e,
-	...t
-}), r = Object.freeze({
-	...n,
+}), defaultIconProps = Object.freeze({
+	...defaultIconDimensions,
+	...defaultIconTransformations
+}), defaultExtendedIconProps = Object.freeze({
+	...defaultIconProps,
 	body: "",
 	hidden: !1
 });
-//#endregion
-export { r as defaultExtendedIconProps, n as defaultIconProps, t as defaultIconTransformations };
+export { defaultExtendedIconProps, defaultIconProps, defaultIconTransformations };