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

package/dist/node_modules/@ungap/structured-clone/esm/deserialize.js

@@ -0,0 +1,51 @@
+import { ARRAY, BIGINT, DATE, ERROR, MAP, OBJECT, PRIMITIVE, REGEXP, SET, VOID } from "./types.js";
+var env = typeof self == "object" ? self : globalThis, deserializer = (e, s) => {
+	let c = (s, c) => (e.set(c, s), s), l = (u) => {
+		if (e.has(u)) return e.get(u);
+		let [d, f] = s[u];
+		switch (d) {
+			case 0:
+			case -1: return c(f, u);
+			case 1: {
+				let e = c([], u);
+				for (let s of f) e.push(l(s));
+				return e;
+			}
+			case 2: {
+				let e = c({}, u);
+				for (let [s, c] of f) e[l(s)] = l(c);
+				return e;
+			}
+			case 3: return c(new Date(f), u);
+			case 4: {
+				let { source: e, flags: s } = f;
+				return c(new RegExp(e, s), u);
+			}
+			case 5: {
+				let e = c(/* @__PURE__ */ new Map(), u);
+				for (let [s, c] of f) e.set(l(s), l(c));
+				return e;
+			}
+			case 6: {
+				let e = c(/* @__PURE__ */ new Set(), u);
+				for (let s of f) e.add(l(s));
+				return e;
+			}
+			case 7: {
+				let { name: e, message: s } = f;
+				return c(new env[e](s), u);
+			}
+			case 8: return c(BigInt(f), u);
+			case "BigInt": return c(Object(BigInt(f)), u);
+			case "ArrayBuffer": return c(new Uint8Array(f).buffer, f);
+			case "DataView": {
+				let { buffer: e } = new Uint8Array(f);
+				return c(new DataView(e), f);
+			}
+		}
+		return c(new env[d](f), u);
+	};
+	return l;
+};
+const deserialize = (e) => deserializer(/* @__PURE__ */ new Map(), e)(0);
+export { deserialize };

package/dist/node_modules/@ungap/structured-clone/esm/index.js

@@ -0,0 +1,4 @@
+import { deserialize } from "./deserialize.js";
+import { serialize } from "./serialize.js";
+var esm_default = typeof structuredClone == "function" ? (n, r) => r && ("json" in r || "lossy" in r) ? deserialize(serialize(n, r)) : structuredClone(n) : (n, r) => deserialize(serialize(n, r));
+export { esm_default as default };

package/dist/node_modules/@ungap/structured-clone/esm/serialize.js

@@ -0,0 +1,91 @@
+import { ARRAY, BIGINT, DATE, ERROR, MAP, OBJECT, PRIMITIVE, REGEXP, SET, VOID } from "./types.js";
+var EMPTY = "", { toString } = {}, { keys } = Object, typeOf = (e) => {
+	let l = typeof e;
+	if (l !== "object" || !e) return [0, l];
+	let u = toString.call(e).slice(8, -1);
+	switch (u) {
+		case "Array": return [1, EMPTY];
+		case "Object": return [2, EMPTY];
+		case "Date": return [3, EMPTY];
+		case "RegExp": return [4, EMPTY];
+		case "Map": return [5, EMPTY];
+		case "Set": return [6, EMPTY];
+		case "DataView": return [1, u];
+	}
+	return u.includes("Array") ? [1, u] : u.includes("Error") ? [7, u] : [2, u];
+}, shouldSkip = ([e, l]) => e === 0 && (l === "function" || l === "symbol"), serializer = (e, l, u, d) => {
+	let f = (e, l) => {
+		let f = d.push(e) - 1;
+		return u.set(l, f), f;
+	}, p = (d) => {
+		if (u.has(d)) return u.get(d);
+		let [m, h] = typeOf(d);
+		switch (m) {
+			case 0: {
+				let l = d;
+				switch (h) {
+					case "bigint":
+						m = 8, l = d.toString();
+						break;
+					case "function":
+					case "symbol":
+						if (e) throw TypeError("unable to serialize " + h);
+						l = null;
+						break;
+					case "undefined": return f([-1], d);
+				}
+				return f([m, l], d);
+			}
+			case 1: {
+				if (h) {
+					let e = d;
+					return h === "DataView" ? e = new Uint8Array(d.buffer) : h === "ArrayBuffer" && (e = new Uint8Array(d)), f([h, [...e]], d);
+				}
+				let e = [], l = f([m, e], d);
+				for (let l of d) e.push(p(l));
+				return l;
+			}
+			case 2: {
+				if (h) switch (h) {
+					case "BigInt": return f([h, d.toString()], d);
+					case "Boolean":
+					case "Number":
+					case "String": return f([h, d.valueOf()], d);
+				}
+				if (l && "toJSON" in d) return p(d.toJSON());
+				let u = [], g = f([m, u], d);
+				for (let l of keys(d)) (e || !shouldSkip(typeOf(d[l]))) && u.push([p(l), p(d[l])]);
+				return g;
+			}
+			case 3: return f([m, d.toISOString()], d);
+			case 4: {
+				let { source: e, flags: l } = d;
+				return f([m, {
+					source: e,
+					flags: l
+				}], d);
+			}
+			case 5: {
+				let l = [], u = f([m, l], d);
+				for (let [u, f] of d) (e || !(shouldSkip(typeOf(u)) || shouldSkip(typeOf(f)))) && l.push([p(u), p(f)]);
+				return u;
+			}
+			case 6: {
+				let l = [], u = f([m, l], d);
+				for (let u of d) (e || !shouldSkip(typeOf(u))) && l.push(p(u));
+				return u;
+			}
+		}
+		let { message: g } = d;
+		return f([m, {
+			name: h,
+			message: g
+		}], d);
+	};
+	return p;
+};
+const serialize = (e, { json: l, lossy: u } = {}) => {
+	let d = [];
+	return serializer(!(l || u), !!l, /* @__PURE__ */ new Map(), d)(e), d;
+};
+export { serialize };

package/dist/node_modules/@ungap/structured-clone/esm/types.js

@@ -0,0 +1,2 @@
+const VOID = -1, PRIMITIVE = 0, ARRAY = 1, OBJECT = 2, DATE = 3, REGEXP = 4, MAP = 5, SET = 6, ERROR = 7, BIGINT = 8;
+export { ARRAY, BIGINT, DATE, ERROR, MAP, OBJECT, PRIMITIVE, REGEXP, SET, VOID };