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

package/dist/node_modules/stringify-entities/lib/constant/dangerous.js

@@ -0,0 +1,11 @@
+const dangerous = [
+	"cent",
+	"copy",
+	"divide",
+	"gt",
+	"lt",
+	"not",
+	"para",
+	"times"
+];
+export { dangerous };

package/dist/node_modules/stringify-entities/lib/core.js

@@ -0,0 +1,21 @@
+var defaultSubsetRegex = /["&'<>`]/g, surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g, controlCharactersRegex = /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g, regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g, subsetToRegexCache = /* @__PURE__ */ new WeakMap();
+function core(i, a) {
+	if (i = i.replace(a.subset ? charactersToExpressionCached(a.subset) : defaultSubsetRegex, s), a.subset || a.escapeOnly) return i;
+	return i.replace(surrogatePairsRegex, o).replace(controlCharactersRegex, s);
+	function o(e, n, r) {
+		return a.format((e.charCodeAt(0) - 55296) * 1024 + e.charCodeAt(1) - 56320 + 65536, r.charCodeAt(n + 2), a);
+	}
+	function s(e, n, r) {
+		return a.format(e.charCodeAt(0), r.charCodeAt(n + 1), a);
+	}
+}
+function charactersToExpressionCached(e) {
+	let n = subsetToRegexCache.get(e);
+	return n || (n = charactersToExpression(e), subsetToRegexCache.set(e, n)), n;
+}
+function charactersToExpression(e) {
+	let n = [], r = -1;
+	for (; ++r < e.length;) n.push(e[r].replace(regexEscapeRegex, "\\$&"));
+	return RegExp("(?:" + n.join("|") + ")", "g");
+}
+export { core };

package/dist/node_modules/stringify-entities/lib/index.js

@@ -0,0 +1,6 @@
+import { core } from "./core.js";
+import { formatSmart } from "./util/format-smart.js";
+function stringifyEntities(n, r) {
+	return core(n, Object.assign({ format: formatSmart }, r));
+}
+export { stringifyEntities };

package/dist/node_modules/stringify-entities/lib/util/format-smart.js

@@ -0,0 +1,12 @@
+import { toHexadecimal } from "./to-hexadecimal.js";
+import { toDecimal } from "./to-decimal.js";
+import { toNamed } from "./to-named.js";
+function formatSmart(r, i, a) {
+	let o = toHexadecimal(r, i, a.omitOptionalSemicolons), s;
+	if ((a.useNamedReferences || a.useShortestReferences) && (s = toNamed(r, i, a.omitOptionalSemicolons, a.attribute)), (a.useShortestReferences || !s) && a.useShortestReferences) {
+		let e = toDecimal(r, i, a.omitOptionalSemicolons);
+		e.length < o.length && (o = e);
+	}
+	return s && (!a.useShortestReferences || s.length < o.length) ? s : o;
+}
+export { formatSmart };

package/dist/node_modules/stringify-entities/lib/util/to-decimal.js

@@ -0,0 +1,6 @@
+var decimalRegex = /\d/;
+function toDecimal(t, n, r) {
+	let i = "&#" + String(t);
+	return r && n && !decimalRegex.test(String.fromCharCode(n)) ? i : i + ";";
+}
+export { toDecimal };

package/dist/node_modules/stringify-entities/lib/util/to-hexadecimal.js

@@ -0,0 +1,6 @@
+var hexadecimalRegex = /[\dA-Fa-f]/;
+function toHexadecimal(t, n, r) {
+	let i = "&#x" + t.toString(16).toUpperCase();
+	return r && n && !hexadecimalRegex.test(String.fromCharCode(n)) ? i : i + ";";
+}
+export { toHexadecimal };

package/dist/node_modules/stringify-entities/lib/util/to-named.js

@@ -0,0 +1,15 @@
+import { characterEntitiesLegacy } from "../../../character-entities-legacy/index.js";
+import { characterEntitiesHtml4 } from "../../../character-entities-html4/index.js";
+import { dangerous } from "../constant/dangerous.js";
+var own = {}.hasOwnProperty, characters = {}, key;
+for (key in characterEntitiesHtml4) own.call(characterEntitiesHtml4, key) && (characters[characterEntitiesHtml4[key]] = key);
+var notAlphanumericRegex = /[^\dA-Za-z]/;
+function toNamed(i, o, s, c) {
+	let l = String.fromCharCode(i);
+	if (own.call(characters, l)) {
+		let i = characters[l], a = "&" + i;
+		return s && characterEntitiesLegacy.includes(i) && !dangerous.includes(i) && (!c || o && o !== 61 && notAlphanumericRegex.test(String.fromCharCode(o))) ? a : a + ";";
+	}
+	return "";
+}
+export { toNamed };

package/dist/node_modules/style-to-js/cjs/index.js

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../../_virtual/rolldown_runtime.js";
+import { require_cjs as require_cjs$1 } from "../../style-to-object/cjs/index.js";
+import { require_utilities } from "./utilities.js";
+var require_cjs = /* @__PURE__ */ __commonJSMin(((e, r) => {
+	var i = (e && e.__importDefault || function(e) {
+		return e && e.__esModule ? e : { default: e };
+	})(require_cjs$1()), a = require_utilities();
+	function o(e, t) {
+		var n = {};
+		return !e || typeof e != "string" || (0, i.default)(e, function(e, r) {
+			e && r && (n[(0, a.camelCase)(e, t)] = r);
+		}), n;
+	}
+	o.default = o, r.exports = o;
+}));
+export default require_cjs();
+export { require_cjs };

package/dist/node_modules/style-to-js/cjs/utilities.js

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../_virtual/rolldown_runtime.js";
+var require_utilities = /* @__PURE__ */ __commonJSMin(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.camelCase = void 0;
+	var t = /^--[a-zA-Z0-9_-]+$/, n = /-([a-z])/g, r = /^[^-]+$/, i = /^-(webkit|moz|ms|o|khtml)-/, a = /^-(ms)-/, o = function(e) {
+		return !e || r.test(e) || t.test(e);
+	}, s = function(e, t) {
+		return t.toUpperCase();
+	}, c = function(e, t) {
+		return `${t}-`;
+	};
+	e.camelCase = function(e, t) {
+		return t === void 0 && (t = {}), o(e) ? e : (e = e.toLowerCase(), e = t.reactCompat ? e.replace(a, c) : e.replace(i, c), e.replace(n, s));
+	};
+}));
+export default require_utilities();
+export { require_utilities };

package/dist/node_modules/style-to-object/cjs/index.js

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../../_virtual/rolldown_runtime.js";
+import { require_cjs as require_cjs$1 } from "../../inline-style-parser/cjs/index.js";
+var require_cjs = /* @__PURE__ */ __commonJSMin(((e) => {
+	var n = e && e.__importDefault || function(e) {
+		return e && e.__esModule ? e : { default: e };
+	};
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.default = i;
+	var r = n(require_cjs$1());
+	function i(e, t) {
+		let n = null;
+		if (!e || typeof e != "string") return n;
+		let i = (0, r.default)(e), a = typeof t == "function";
+		return i.forEach((e) => {
+			if (e.type !== "declaration") return;
+			let { property: r, value: i } = e;
+			a ? t(r, i, e) : i && (n ||= {}, n[r] = i);
+		}), n;
+	}
+}));
+export default require_cjs();
+export { require_cjs };

package/dist/node_modules/trim-lines/index.js

@@ -0,0 +1,19 @@
+var tab = 9, space = 32;
+function trimLines(e) {
+	let t = String(e), n = /\r?\n|\r/g, i = n.exec(t), a = 0, o = [];
+	for (; i;) o.push(trimLine(t.slice(a, i.index), a > 0, !0), i[0]), a = i.index + i[0].length, i = n.exec(t);
+	return o.push(trimLine(t.slice(a), a > 0, !1)), o.join("");
+}
+function trimLine(n, r, i) {
+	let a = 0, o = n.length;
+	if (r) {
+		let r = n.codePointAt(a);
+		for (; r === tab || r === space;) a++, r = n.codePointAt(a);
+	}
+	if (i) {
+		let r = n.codePointAt(o - 1);
+		for (; r === tab || r === space;) o--, r = n.codePointAt(o - 1);
+	}
+	return o > a ? n.slice(a, o) : "";
+}
+export { trimLines };

package/dist/node_modules/trough/lib/index.js

@@ -0,0 +1,48 @@
+function trough() {
+	let e = [], n = {
+		run: r,
+		use: i
+	};
+	return n;
+	function r(...n) {
+		let r = -1, i = n.pop();
+		if (typeof i != "function") throw TypeError("Expected function as last argument, not " + i);
+		a(null, ...n);
+		function a(o, ...s) {
+			let c = e[++r], l = -1;
+			if (o) {
+				i(o);
+				return;
+			}
+			for (; ++l < n.length;) (s[l] === null || s[l] === void 0) && (s[l] = n[l]);
+			n = s, c ? wrap(c, a)(...s) : i(null, ...s);
+		}
+	}
+	function i(t) {
+		if (typeof t != "function") throw TypeError("Expected `middelware` to be a function, not " + t);
+		return e.push(t), n;
+	}
+}
+function wrap(e, t) {
+	let n;
+	return r;
+	function r(...t) {
+		let r = e.length > t.length, o;
+		r && t.push(i);
+		try {
+			o = e.apply(this, t);
+		} catch (e) {
+			let t = e;
+			if (r && n) throw t;
+			return i(t);
+		}
+		r || (o && o.then && typeof o.then == "function" ? o.then(a, i) : o instanceof Error ? i(o) : a(o));
+	}
+	function i(e, ...r) {
+		n || (n = !0, t(e, ...r));
+	}
+	function a(e) {
+		i(null, e);
+	}
+}
+export { trough };

package/dist/node_modules/unified/lib/callable-instance.js

@@ -0,0 +1,7 @@
+const CallableInstance = (function(e) {
+	let t = this.constructor.prototype, n = t[e], r = function() {
+		return n.apply(r, arguments);
+	};
+	return Object.setPrototypeOf(r, t), r;
+});
+export { CallableInstance };

package/dist/node_modules/unified/lib/index.js

@@ -0,0 +1,160 @@
+import { __toESM } from "../../../_virtual/rolldown_runtime.js";
+import { ok } from "../../devlop/lib/default.js";
+import { bail } from "../../bail/index.js";
+import { require_extend } from "../../extend/index.js";
+import isPlainObject from "../node_modules/is-plain-obj/index.js";
+import { trough } from "../../trough/lib/index.js";
+import { VFile } from "../../vfile/lib/index.js";
+import { CallableInstance } from "./callable-instance.js";
+var import_extend = /* @__PURE__ */ __toESM(require_extend(), 1), own = {}.hasOwnProperty;
+const unified = new class e extends CallableInstance {
+	constructor() {
+		super("copy"), this.Compiler = void 0, this.Parser = void 0, this.attachers = [], this.compiler = void 0, this.freezeIndex = -1, this.frozen = void 0, this.namespace = {}, this.parser = void 0, this.transformers = trough();
+	}
+	copy() {
+		let f = new e(), p = -1;
+		for (; ++p < this.attachers.length;) {
+			let e = this.attachers[p];
+			f.use(...e);
+		}
+		return f.data((0, import_extend.default)(!0, {}, this.namespace)), f;
+	}
+	data(e, f) {
+		return typeof e == "string" ? arguments.length === 2 ? (assertUnfrozen("data", this.frozen), this.namespace[e] = f, this) : own.call(this.namespace, e) && this.namespace[e] || void 0 : e ? (assertUnfrozen("data", this.frozen), this.namespace = e, this) : this.namespace;
+	}
+	freeze() {
+		if (this.frozen) return this;
+		let e = this;
+		for (; ++this.freezeIndex < this.attachers.length;) {
+			let [f, ...p] = this.attachers[this.freezeIndex];
+			if (p[0] === !1) continue;
+			p[0] === !0 && (p[0] = void 0);
+			let m = f.call(e, ...p);
+			typeof m == "function" && this.transformers.use(m);
+		}
+		return this.frozen = !0, this.freezeIndex = Infinity, this;
+	}
+	parse(e) {
+		this.freeze();
+		let f = vfile(e), p = this.parser || this.Parser;
+		return assertParser("parse", p), p(String(f), f);
+	}
+	process(e, f) {
+		let p = this;
+		return this.freeze(), assertParser("process", this.parser || this.Parser), assertCompiler("process", this.compiler || this.Compiler), f ? m(void 0, f) : new Promise(m);
+		function m(m, h) {
+			let g = vfile(e), _ = p.parse(g);
+			p.run(_, g, function(e, f, m) {
+				if (e || !f || !m) return v(e);
+				let h = f, g = p.stringify(h, m);
+				looksLikeAValue(g) ? m.value = g : m.result = g, v(e, m);
+			});
+			function v(e, p) {
+				e || !p ? h(e) : m ? m(p) : f(void 0, p);
+			}
+		}
+	}
+	processSync(e) {
+		let f = !1, m;
+		return this.freeze(), assertParser("processSync", this.parser || this.Parser), assertCompiler("processSync", this.compiler || this.Compiler), this.process(e, h), assertDone("processSync", "process", f), m;
+		function h(e, h) {
+			f = !0, bail(e), m = h;
+		}
+	}
+	run(e, f, p) {
+		assertNode(e), this.freeze();
+		let m = this.transformers;
+		return !p && typeof f == "function" && (p = f, f = void 0), p ? h(void 0, p) : new Promise(h);
+		function h(h, g) {
+			let _ = vfile(f);
+			m.run(e, _, v);
+			function v(f, m, _) {
+				let v = m || e;
+				f ? g(f) : h ? h(v) : p(void 0, v, _);
+			}
+		}
+	}
+	runSync(e, f) {
+		let m = !1, h;
+		return this.run(e, f, g), assertDone("runSync", "run", m), h;
+		function g(e, f) {
+			bail(e), h = f, m = !0;
+		}
+	}
+	stringify(e, f) {
+		this.freeze();
+		let p = vfile(f), m = this.compiler || this.Compiler;
+		return assertCompiler("stringify", m), assertNode(e), m(e, p);
+	}
+	use(e, ...f) {
+		let p = this.attachers, m = this.namespace;
+		if (assertUnfrozen("use", this.frozen), e != null) if (typeof e == "function") y(e, f);
+		else if (typeof e == "object") Array.isArray(e) ? v(e) : _(e);
+		else throw TypeError("Expected usable value, not `" + e + "`");
+		return this;
+		function g(e) {
+			if (typeof e == "function") y(e, []);
+			else if (typeof e == "object") if (Array.isArray(e)) {
+				let [f, ...p] = e;
+				y(f, p);
+			} else _(e);
+			else throw TypeError("Expected usable value, not `" + e + "`");
+		}
+		function _(e) {
+			if (!("plugins" in e) && !("settings" in e)) throw Error("Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither");
+			v(e.plugins), e.settings && (m.settings = (0, import_extend.default)(!0, m.settings, e.settings));
+		}
+		function v(e) {
+			let f = -1;
+			if (e != null) if (Array.isArray(e)) for (; ++f < e.length;) {
+				let p = e[f];
+				g(p);
+			}
+			else throw TypeError("Expected a list of plugins, not `" + e + "`");
+		}
+		function y(e, f) {
+			let m = -1, g = -1;
+			for (; ++m < p.length;) if (p[m][0] === e) {
+				g = m;
+				break;
+			}
+			if (g === -1) p.push([e, ...f]);
+			else if (f.length > 0) {
+				let [m, ..._] = f, v = p[g][1];
+				isPlainObject(v) && isPlainObject(m) && (m = (0, import_extend.default)(!0, v, m)), p[g] = [
+					e,
+					m,
+					..._
+				];
+			}
+		}
+	}
+}().freeze();
+function assertParser(e, f) {
+	if (typeof f != "function") throw TypeError("Cannot `" + e + "` without `parser`");
+}
+function assertCompiler(e, f) {
+	if (typeof f != "function") throw TypeError("Cannot `" + e + "` without `compiler`");
+}
+function assertUnfrozen(e, f) {
+	if (f) throw Error("Cannot call `" + e + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.");
+}
+function assertNode(e) {
+	if (!isPlainObject(e) || typeof e.type != "string") throw TypeError("Expected node, got `" + e + "`");
+}
+function assertDone(e, f, p) {
+	if (!p) throw Error("`" + e + "` finished async. Use `" + f + "` instead");
+}
+function vfile(e) {
+	return looksLikeAVFile(e) ? e : new VFile(e);
+}
+function looksLikeAVFile(e) {
+	return !!(e && typeof e == "object" && "message" in e && "messages" in e);
+}
+function looksLikeAValue(e) {
+	return typeof e == "string" || isUint8Array(e);
+}
+function isUint8Array(e) {
+	return !!(e && typeof e == "object" && "byteLength" in e && "byteOffset" in e);
+}
+export { unified };

package/dist/node_modules/unified/node_modules/is-plain-obj/index.js

@@ -0,0 +1,6 @@
+function isPlainObject(e) {
+	if (typeof e != "object" || !e) return !1;
+	let t = Object.getPrototypeOf(e);
+	return (t === null || t === Object.prototype || Object.getPrototypeOf(t) === null) && !(Symbol.toStringTag in e) && !(Symbol.iterator in e);
+}
+export { isPlainObject as default };

package/dist/node_modules/unist-util-position/lib/index.js

@@ -0,0 +1,20 @@
+const pointEnd = point("end"), pointStart = point("start");
+function point(e) {
+	return t;
+	function t(t) {
+		let n = t && t.position && t.position[e] || {};
+		if (typeof n.line == "number" && n.line > 0 && typeof n.column == "number" && n.column > 0) return {
+			line: n.line,
+			column: n.column,
+			offset: typeof n.offset == "number" && n.offset > -1 ? n.offset : void 0
+		};
+	}
+}
+function position(n) {
+	let r = pointStart(n), i = pointEnd(n);
+	if (r && i) return {
+		start: r,
+		end: i
+	};
+}
+export { pointEnd, pointStart, position };

package/dist/node_modules/unist-util-stringify-position/lib/index.js

@@ -0,0 +1,13 @@
+function stringifyPosition(e) {
+	return !e || typeof e != "object" ? "" : "position" in e || "type" in e ? position(e.position) : "start" in e || "end" in e ? position(e) : "line" in e || "column" in e ? point(e) : "";
+}
+function point(e) {
+	return index(e && e.line) + ":" + index(e && e.column);
+}
+function position(e) {
+	return point(e && e.start) + "-" + point(e && e.end);
+}
+function index(e) {
+	return e && typeof e == "number" ? e : 1;
+}
+export { stringifyPosition };