@sheetxl/studio-vanilla 0.8.0-beta.1 → 0.8.0-beta.10

package/cdn/assets/BvlfKrfrDhE9Jw4d.js

@@ -0,0 +1,598 @@
+/**
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.10
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { n as e } from "./CSIZpJClc66_20kP.js";
+var t = 2 * Math.PI;
+function n(e, t) {
+	let n = Math.cos(t), r = Math.sin(t), i = Math.cos(e.phi), a = Math.sin(e.phi);
+	return {
+		x: e.cx + e.rx * n * i - e.ry * r * a,
+		y: e.cy + e.rx * n * a + e.ry * r * i
+	};
+}
+function r(e, t) {
+	switch (e.k) {
+		case "L": return {
+			x: e.x0 + (e.x1 - e.x0) * t,
+			y: e.y0 + (e.y1 - e.y0) * t
+		};
+		case "Q": {
+			let n = 1 - t;
+			return {
+				x: n * n * e.x0 + 2 * n * t * e.cx + t * t * e.x1,
+				y: n * n * e.y0 + 2 * n * t * e.cy + t * t * e.y1
+			};
+		}
+		case "C": {
+			let n = 1 - t, r = n * n * n, i = 3 * n * n * t, a = 3 * n * t * t, o = t * t * t;
+			return {
+				x: r * e.x0 + i * e.c1x + a * e.c2x + o * e.x1,
+				y: r * e.y0 + i * e.c1y + a * e.c2y + o * e.y1
+			};
+		}
+		case "A": return n(e, e.t0 + e.dt * t);
+	}
+}
+function i(e, t) {
+	switch (e.k) {
+		case "L": return {
+			x: e.x1 - e.x0,
+			y: e.y1 - e.y0
+		};
+		case "Q": {
+			let n = 1 - t;
+			return {
+				x: 2 * n * (e.cx - e.x0) + 2 * t * (e.x1 - e.cx),
+				y: 2 * n * (e.cy - e.y0) + 2 * t * (e.y1 - e.cy)
+			};
+		}
+		case "C": {
+			let n = 1 - t;
+			return {
+				x: 3 * n * n * (e.c1x - e.x0) + 6 * n * t * (e.c2x - e.c1x) + 3 * t * t * (e.x1 - e.c2x),
+				y: 3 * n * n * (e.c1y - e.y0) + 6 * n * t * (e.c2y - e.c1y) + 3 * t * t * (e.y1 - e.c2y)
+			};
+		}
+		case "A": {
+			let n = e.t0 + e.dt * t, r = Math.cos(n), i = Math.sin(n), a = Math.cos(e.phi), o = Math.sin(e.phi), s = e.dt < 0 ? -1 : 1;
+			return {
+				x: s * (-e.rx * i * a - e.ry * r * o),
+				y: s * (-e.rx * i * o + e.ry * r * a)
+			};
+		}
+	}
+}
+var a = /* @__PURE__ */ new WeakMap();
+function o(e) {
+	let t = a.get(e);
+	if (t) return t;
+	if (e.k === "L") {
+		let n = Math.hypot(e.x1 - e.x0, e.y1 - e.y0);
+		t = {
+			cum: new Float64Array([0, n]),
+			total: n
+		};
+	} else {
+		let n = function(e) {
+			let t;
+			switch (e.k) {
+				case "Q":
+					t = Math.hypot(e.cx - e.x0, e.cy - e.y0) + Math.hypot(e.x1 - e.cx, e.y1 - e.cy);
+					break;
+				case "C":
+					t = Math.hypot(e.c1x - e.x0, e.c1y - e.y0) + Math.hypot(e.c2x - e.c1x, e.c2y - e.c1y) + Math.hypot(e.x1 - e.c2x, e.y1 - e.c2y);
+					break;
+				case "A":
+					t = Math.abs(e.dt) * Math.max(e.rx, e.ry);
+					break;
+				default: t = 0;
+			}
+			return Math.min(256, Math.max(32, Math.ceil(t)));
+		}(e), i = new Float64Array(n + 1), a = r(e, 0);
+		for (let t = 1; t <= n; t++) {
+			let o = r(e, t / n);
+			i[t] = i[t - 1] + Math.hypot(o.x - a.x, o.y - a.y), a = o;
+		}
+		t = {
+			cum: i,
+			total: i[n]
+		};
+	}
+	return a.set(e, t), t;
+}
+function s(e) {
+	return o(e).total;
+}
+function c(e, t) {
+	let { cum: n, total: r } = o(e);
+	if (!(r > 0) || t <= 0) return 0;
+	if (t >= r) return 1;
+	let i = n.length - 1, a = 0, s = i;
+	for (; s - a > 1;) {
+		let e = a + s >> 1;
+		n[e] <= t ? a = e : s = e;
+	}
+	let c = n[s] - n[a];
+	return (a + (c > 0 ? (t - n[a]) / c : 0)) / i;
+}
+var l = (e, t, n) => e + (t - e) * n;
+function u(e, t) {
+	switch (e.k) {
+		case "L": {
+			let n = r(e, t);
+			return [{
+				k: "L",
+				x0: e.x0,
+				y0: e.y0,
+				x1: n.x,
+				y1: n.y
+			}, {
+				k: "L",
+				x0: n.x,
+				y0: n.y,
+				x1: e.x1,
+				y1: e.y1
+			}];
+		}
+		case "Q": {
+			let n = l(e.x0, e.cx, t), r = l(e.y0, e.cy, t), i = l(e.cx, e.x1, t), a = l(e.cy, e.y1, t), o = l(n, i, t), s = l(r, a, t);
+			return [{
+				k: "Q",
+				x0: e.x0,
+				y0: e.y0,
+				cx: n,
+				cy: r,
+				x1: o,
+				y1: s
+			}, {
+				k: "Q",
+				x0: o,
+				y0: s,
+				cx: i,
+				cy: a,
+				x1: e.x1,
+				y1: e.y1
+			}];
+		}
+		case "C": {
+			let n = l(e.x0, e.c1x, t), r = l(e.y0, e.c1y, t), i = l(e.c1x, e.c2x, t), a = l(e.c1y, e.c2y, t), o = l(e.c2x, e.x1, t), s = l(e.c2y, e.y1, t), c = l(n, i, t), u = l(r, a, t), d = l(i, o, t), f = l(a, s, t), p = l(c, d, t), m = l(u, f, t);
+			return [{
+				k: "C",
+				x0: e.x0,
+				y0: e.y0,
+				c1x: n,
+				c1y: r,
+				c2x: c,
+				c2y: u,
+				x1: p,
+				y1: m
+			}, {
+				k: "C",
+				x0: p,
+				y0: m,
+				c1x: d,
+				c1y: f,
+				c2x: o,
+				c2y: s,
+				x1: e.x1,
+				y1: e.y1
+			}];
+		}
+		case "A": {
+			let r = n(e, e.t0 + e.dt * t);
+			return [{
+				...e,
+				dt: e.dt * t,
+				x1: r.x,
+				y1: r.y
+			}, {
+				...e,
+				t0: e.t0 + e.dt * t,
+				dt: e.dt * (1 - t),
+				x0: r.x,
+				y0: r.y
+			}];
+		}
+	}
+}
+var d = (e) => ({
+	x: e.x1,
+	y: e.y1
+});
+function f(e) {
+	let t = 0;
+	for (let n of e.segments) t += s(n);
+	return t;
+}
+function p(e, t) {
+	let n = e.segments;
+	if (n.length === 0) return {
+		point: {
+			x: e.x,
+			y: e.y
+		},
+		tangent: {
+			x: 0,
+			y: 0
+		}
+	};
+	let a = Math.max(0, t);
+	for (let e = 0; e < n.length; e++) {
+		let t = n[e], o = s(t);
+		if (a <= o || e === n.length - 1) {
+			let e = c(t, Math.min(a, o));
+			return {
+				point: r(t, e),
+				tangent: i(t, e)
+			};
+		}
+		a -= o;
+	}
+	let o = n[n.length - 1];
+	return {
+		point: d(o),
+		tangent: i(o, 1)
+	};
+}
+var m = () => ({
+	l: 1 / 0,
+	t: 1 / 0,
+	r: -1 / 0,
+	b: -1 / 0
+}), h = (e, t, n) => {
+	t < e.l && (e.l = t), t > e.r && (e.r = t), n < e.t && (e.t = n), n > e.b && (e.b = n);
+}, g = (e, t, n) => {
+	let r = [], i = (e) => {
+		e > 0 && e < 1 && r.push(e);
+	};
+	if (Math.abs(e) < 1e-12) return Math.abs(t) > 1e-12 && i(-n / t), r;
+	let a = t * t - 4 * e * n;
+	if (a < 0) return r;
+	let o = Math.sqrt(a);
+	return i((-t + o) / (2 * e)), i((-t - o) / (2 * e)), r;
+}, _ = (e, n) => {
+	let r = Math.abs(e.dt);
+	return r >= t || ((e.dt >= 0 ? n - e.t0 : e.t0 - n) % t + t) % t <= r;
+};
+function v(e, t) {
+	switch (h(e, t.x0, t.y0), h(e, t.x1, t.y1), t.k) {
+		case "L": return;
+		case "Q":
+			for (let n of g(0, 2 * (t.x0 - 2 * t.cx + t.x1), 2 * (t.cx - t.x0))) {
+				let i = r(t, n);
+				h(e, i.x, i.y);
+			}
+			for (let n of g(0, 2 * (t.y0 - 2 * t.cy + t.y1), 2 * (t.cy - t.y0))) {
+				let i = r(t, n);
+				h(e, i.x, i.y);
+			}
+			return;
+		case "C": {
+			let n = (e, t, n, r) => g(3 * t - e - 3 * n + r, 2 * (e - 2 * t + n), t - e);
+			for (let i of [...n(t.x0, t.c1x, t.c2x, t.x1), ...n(t.y0, t.c1y, t.c2y, t.y1)]) {
+				let n = r(t, i);
+				h(e, n.x, n.y);
+			}
+			return;
+		}
+		case "A": {
+			let r = Math.cos(t.phi), i = Math.sin(t.phi), a = [Math.atan2(-t.ry * i, t.rx * r), Math.atan2(t.ry * r, t.rx * i)];
+			for (let r of a) for (let i of [r, r + Math.PI]) if (_(t, i)) {
+				let r = n(t, i);
+				h(e, r.x, r.y);
+			}
+			return;
+		}
+	}
+}
+function y(e, t) {
+	for (let n of t) {
+		h(e, n.x, n.y);
+		for (let t of n.segments) v(e, t);
+	}
+	return e;
+}
+function b(r, i) {
+	let a = [], o = (t) => e(t, i);
+	for (let e of r) {
+		e.implicit || a.push(`M${o(e.x)} ${o(e.y)}`);
+		for (let r of e.segments) switch (r.k) {
+			case "L":
+				a.push(`L${o(r.x1)} ${o(r.y1)}`);
+				break;
+			case "Q":
+				a.push(`Q${o(r.cx)} ${o(r.cy)} ${o(r.x1)} ${o(r.y1)}`);
+				break;
+			case "C":
+				a.push(`C${o(r.c1x)} ${o(r.c1y)} ${o(r.c2x)} ${o(r.c2y)} ${o(r.x1)} ${o(r.y1)}`);
+				break;
+			case "A": {
+				let e = o(r.rx), i = o(r.ry), s = o(180 * r.phi / Math.PI), c = +(r.dt > 0);
+				if (Math.abs(r.dt) >= t) {
+					let t = n(r, r.t0 + r.dt / 2);
+					a.push(`A${e} ${i} ${s} 0 ${c} ${o(t.x)} ${o(t.y)}`), a.push(`A${e} ${i} ${s} 0 ${c} ${o(r.x1)} ${o(r.y1)}`);
+				} else {
+					let t = +(Math.abs(r.dt) > Math.PI + 1e-9);
+					a.push(`A${e} ${i} ${s} ${t} ${c} ${o(r.x1)} ${o(r.y1)}`);
+				}
+				break;
+			}
+		}
+		e.closed && a.push("Z");
+	}
+	return a.join(" ");
+}
+var x = 192 / 72, S = {
+	sm: 1,
+	med: 1.5,
+	lg: 2.5
+}, C = {
+	sm: 2,
+	med: 3,
+	lg: 4.5
+}, w = {
+	sm: 1.25,
+	med: 1.75,
+	lg: 2.5
+}, T = (e) => {
+	let t = [];
+	for (let n = 1; n < e.length; n++) {
+		let [r, i] = e[n - 1], [a, o] = e[n];
+		t.push({
+			k: "L",
+			x0: r,
+			y0: i,
+			x1: a,
+			y1: o
+		});
+	}
+	return {
+		x: e[0][0],
+		y: e[0][1],
+		segments: t,
+		closed: !0
+	};
+};
+function E(e, t) {
+	let n = e?.type;
+	if (!n || n === "none") return null;
+	let r = e?.length ?? "med", i = e?.width ?? "med";
+	if (n === "arrow") return function(e, t, n) {
+		let r = Math.max(e, x), i = C[t] * r, a = w[n] * r, o = Math.atan(a / i), s = Math.hypot(i, a), c = e / (2 * Math.sin(o / 2)), l = e / 2, u = Math.cos(o), d = Math.sin(o), f = c / 2, p = (e, t) => ({
+			x: e + f,
+			y: t
+		}), m = p(-c / 2, 0), h = p(s * u - l * d, -s * d - l * u), g = p(s * u, -s * d), _ = p(s * u + l * d, -s * d + l * u), v = p(c / 2, 0), y = p(s * u + l * d, s * d - l * u), b = p(s * u, s * d), S = p(s * u - l * d, s * d + l * u), T = (e, t) => ({
+			k: "L",
+			x0: e.x,
+			y0: e.y,
+			x1: t.x,
+			y1: t.y
+		}), E = (e, t, n) => ({
+			k: "A",
+			cx: e.x,
+			cy: e.y,
+			rx: l,
+			ry: l,
+			phi: 0,
+			t0: Math.atan2(t.y - e.y, t.x - e.x),
+			dt: Math.PI,
+			x0: t.x,
+			y0: t.y,
+			x1: n.x,
+			y1: n.y
+		});
+		return {
+			outline: [{
+				x: m.x,
+				y: m.y,
+				closed: !0,
+				segments: [
+					T(m, h),
+					E(g, h, _),
+					T(_, v),
+					T(v, y),
+					E(b, y, S),
+					T(S, m)
+				]
+			}],
+			clip: c / 2,
+			sample: c / 2
+		};
+	}(t, r, i);
+	let a = Math.max(t, x), o = S[r] * a, s = S[i] * a;
+	switch (n) {
+		case "triangle": return {
+			outline: [T([
+				[0, 0],
+				[2 * o, -s],
+				[2 * o, s]
+			])],
+			clip: 2 * o - a / 2,
+			sample: 2 * o
+		};
+		case "stealth": return {
+			outline: [T([
+				[1.2 * o, 0],
+				[2 * o, s],
+				[0, 0],
+				[2 * o, -s]
+			])],
+			clip: 1.2 * o,
+			sample: 1.2 * o
+		};
+		case "diamond": return {
+			outline: [T([
+				[0, -s],
+				[o, 0],
+				[0, s],
+				[-o, 0]
+			])],
+			clip: -1,
+			sample: 0
+		};
+		case "oval": return {
+			outline: [(c = o, l = s, {
+				x: -c,
+				y: 0,
+				closed: !0,
+				segments: [{
+					k: "A",
+					cx: 0,
+					cy: 0,
+					rx: c,
+					ry: l,
+					phi: 0,
+					t0: Math.PI,
+					dt: Math.PI,
+					x0: -c,
+					y0: 0,
+					x1: c,
+					y1: 0
+				}, {
+					k: "A",
+					cx: 0,
+					cy: 0,
+					rx: c,
+					ry: l,
+					phi: 0,
+					t0: 0,
+					dt: Math.PI,
+					x0: c,
+					y0: 0,
+					x1: -c,
+					y1: 0
+				}]
+			})],
+			clip: -1,
+			sample: 0
+		};
+	}
+	var c, l;
+}
+function D(e, t, n, r) {
+	if (!(t.clip > 0)) return e;
+	let i = f(e), a = i - t.clip > 0 ? t.clip : i;
+	return a += r, a >= i && (a = i - .26), function(e, t, n) {
+		if (!(t > .26) || e.segments.length === 0) return e;
+		let r = n ? e.segments : [...e.segments].reverse(), i = [], a = t;
+		for (let e of r) if (a > .26) {
+			let t = s(e);
+			if (t <= a) {
+				a -= t;
+				continue;
+			}
+			let [r, o] = u(e, c(e, n ? a : t - a));
+			i.push(n ? o : r), a = 0;
+		} else i.push(e);
+		let o = n ? i : i.reverse(), l = o.length > 0 ? {
+			x: (d = o[0]).x0,
+			y: d.y0
+		} : {
+			x: e.x,
+			y: e.y
+		};
+		var d;
+		let f = {
+			x: l.x,
+			y: l.y,
+			segments: o,
+			closed: e.closed
+		};
+		return e.implicit && (f.implicit = !0), f;
+	}(e, a, n);
+}
+function O(e, t, n) {
+	let r, i = f(e), a = p(e, n ? 0 : i);
+	if (t.sample > 0) {
+		let o = p(e, n ? Math.min(t.sample, i) : t.sample < i ? i - t.sample : 0).point;
+		r = Math.atan2(o.y - a.point.y, o.x - a.point.x);
+	} else r = Math.atan2(a.tangent.y, a.tangent.x);
+	return t.outline.map((e) => function(e, t, n, r, i = !1) {
+		let a = Math.cos(r), o = Math.sin(r), s = i ? -1 : 1, c = (e, r) => ({
+			x: t + e * a - r * s * o,
+			y: n + e * o + r * s * a
+		}), l = e.segments.map((e) => {
+			let t = c(e.x0, e.y0), n = c(e.x1, e.y1);
+			switch (e.k) {
+				case "L": return {
+					k: "L",
+					x0: t.x,
+					y0: t.y,
+					x1: n.x,
+					y1: n.y
+				};
+				case "Q": {
+					let r = c(e.cx, e.cy);
+					return {
+						k: "Q",
+						x0: t.x,
+						y0: t.y,
+						cx: r.x,
+						cy: r.y,
+						x1: n.x,
+						y1: n.y
+					};
+				}
+				case "C": {
+					let r = c(e.c1x, e.c1y), i = c(e.c2x, e.c2y);
+					return {
+						k: "C",
+						x0: t.x,
+						y0: t.y,
+						c1x: r.x,
+						c1y: r.y,
+						c2x: i.x,
+						c2y: i.y,
+						x1: n.x,
+						y1: n.y
+					};
+				}
+				case "A": {
+					let a = c(e.cx, e.cy);
+					return {
+						k: "A",
+						cx: a.x,
+						cy: a.y,
+						rx: e.rx,
+						ry: e.ry,
+						phi: i ? r - e.phi : r + e.phi,
+						t0: i ? -e.t0 : e.t0,
+						dt: i ? -e.dt : e.dt,
+						x0: t.x,
+						y0: t.y,
+						x1: n.x,
+						y1: n.y
+					};
+				}
+			}
+		}), u = c(e.x, e.y);
+		return {
+			x: u.x,
+			y: u.y,
+			segments: l,
+			closed: e.closed
+		};
+	}(e, a.point.x, a.point.y, r, !n));
+}
+function k(e, t) {
+	let n = E(t.head, t.width), r = E(t.tail, t.width);
+	if (!n && !r) return null;
+	let i = t.cap === "square" ? t.width / 2 : 0, a = [], o = !1, s = e.map((e) => {
+		if (!function(e) {
+			if (e.closed || e.segments.length === 0) return !1;
+			let t = d(e.segments[e.segments.length - 1]);
+			return Math.abs(t.x - e.x) > 1e-6 || Math.abs(t.y - e.y) > 1e-6;
+		}(e)) return e;
+		o = !0;
+		let t = e;
+		return n && (a.push(...O(t, n, !0)), t = D(t, n, !0, i)), r && (a.push(...O(t, r, !1)), t = D(t, r, !1, i)), t;
+	});
+	return o ? {
+		stroke: s,
+		ends: a
+	} : null;
+}
+export { y as i, k as n, m as r, b as t };