@sheetxl/sdk 0.7.28-beta.4 → 0.8.0-beta.10

package/node/esm/CImNvdz1iP-lUlro.mjs

@@ -0,0 +1,610 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - 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 t } from "./BH1v-E4Ro3bR7Znw.mjs";
+var n = 2 * Math.PI;
+function c(t, n) {
+	const c = Math.cos(n), e = Math.sin(n), s = Math.cos(t.phi), y = Math.sin(t.phi);
+	return {
+		x: t.cx + t.rx * c * s - t.ry * e * y,
+		y: t.cy + t.rx * c * y + t.ry * e * s
+	};
+}
+function e(t, n) {
+	switch (t.k) {
+		case "L": return {
+			x: t.x0 + (t.x1 - t.x0) * n,
+			y: t.y0 + (t.y1 - t.y0) * n
+		};
+		case "Q": {
+			const c = 1 - n;
+			return {
+				x: c * c * t.x0 + 2 * c * n * t.cx + n * n * t.x1,
+				y: c * c * t.y0 + 2 * c * n * t.cy + n * n * t.y1
+			};
+		}
+		case "C": {
+			const c = 1 - n, e = c * c * c, s = 3 * c * c * n, y = 3 * c * n * n, x = n * n * n;
+			return {
+				x: e * t.x0 + s * t.c1x + y * t.c2x + x * t.x1,
+				y: e * t.y0 + s * t.c1y + y * t.c2y + x * t.y1
+			};
+		}
+		case "A": return c(t, t.t0 + t.dt * n);
+	}
+}
+function s(t, n) {
+	switch (t.k) {
+		case "L": return {
+			x: t.x1 - t.x0,
+			y: t.y1 - t.y0
+		};
+		case "Q": {
+			const c = 1 - n;
+			return {
+				x: 2 * c * (t.cx - t.x0) + 2 * n * (t.x1 - t.cx),
+				y: 2 * c * (t.cy - t.y0) + 2 * n * (t.y1 - t.cy)
+			};
+		}
+		case "C": {
+			const c = 1 - n;
+			return {
+				x: 3 * c * c * (t.c1x - t.x0) + 6 * c * n * (t.c2x - t.c1x) + 3 * n * n * (t.x1 - t.c2x),
+				y: 3 * c * c * (t.c1y - t.y0) + 6 * c * n * (t.c2y - t.c1y) + 3 * n * n * (t.y1 - t.c2y)
+			};
+		}
+		case "A": {
+			const c = t.t0 + t.dt * n, e = Math.cos(c), s = Math.sin(c), y = Math.cos(t.phi), x = Math.sin(t.phi), r = t.dt < 0 ? -1 : 1;
+			return {
+				x: r * (-t.rx * s * y - t.ry * e * x),
+				y: r * (-t.rx * s * x + t.ry * e * y)
+			};
+		}
+	}
+}
+var y = /* @__PURE__ */ new WeakMap();
+function x(t) {
+	let n = y.get(t);
+	if (n) return n;
+	if ("L" === t.k) {
+		const c = Math.hypot(t.x1 - t.x0, t.y1 - t.y0);
+		n = {
+			cum: new Float64Array([0, c]),
+			total: c
+		};
+	} else {
+		const c = function(t) {
+			let n;
+			switch (t.k) {
+				case "Q":
+					n = Math.hypot(t.cx - t.x0, t.cy - t.y0) + Math.hypot(t.x1 - t.cx, t.y1 - t.cy);
+					break;
+				case "C":
+					n = Math.hypot(t.c1x - t.x0, t.c1y - t.y0) + Math.hypot(t.c2x - t.c1x, t.c2y - t.c1y) + Math.hypot(t.x1 - t.c2x, t.y1 - t.c2y);
+					break;
+				case "A":
+					n = Math.abs(t.dt) * Math.max(t.rx, t.ry);
+					break;
+				default: n = 0;
+			}
+			return Math.min(256, Math.max(32, Math.ceil(n)));
+		}(t), s = new Float64Array(c + 1);
+		let y = e(t, 0);
+		for (let n = 1; n <= c; n++) {
+			const x = e(t, n / c);
+			s[n] = s[n - 1] + Math.hypot(x.x - y.x, x.y - y.y), y = x;
+		}
+		n = {
+			cum: s,
+			total: s[c]
+		};
+	}
+	return y.set(t, n), n;
+}
+function r(t) {
+	return x(t).total;
+}
+function o(t, n) {
+	const { cum: c, total: e } = x(t);
+	if (!(e > 0)) return 0;
+	if (n <= 0) return 0;
+	if (n >= e) return 1;
+	const s = c.length - 1;
+	let y = 0, r = s;
+	for (; r - y > 1;) {
+		const t = y + r >> 1;
+		c[t] <= n ? y = t : r = t;
+	}
+	const o = c[r] - c[y];
+	return (y + (o > 0 ? (n - c[y]) / o : 0)) / s;
+}
+var a = (t, n, c) => t + (n - t) * c;
+function i(t, n) {
+	switch (t.k) {
+		case "L": {
+			const c = e(t, n);
+			return [{
+				k: "L",
+				x0: t.x0,
+				y0: t.y0,
+				x1: c.x,
+				y1: c.y
+			}, {
+				k: "L",
+				x0: c.x,
+				y0: c.y,
+				x1: t.x1,
+				y1: t.y1
+			}];
+		}
+		case "Q": {
+			const c = a(t.x0, t.cx, n), e = a(t.y0, t.cy, n), s = a(t.cx, t.x1, n), y = a(t.cy, t.y1, n), x = a(c, s, n), r = a(e, y, n);
+			return [{
+				k: "Q",
+				x0: t.x0,
+				y0: t.y0,
+				cx: c,
+				cy: e,
+				x1: x,
+				y1: r
+			}, {
+				k: "Q",
+				x0: x,
+				y0: r,
+				cx: s,
+				cy: y,
+				x1: t.x1,
+				y1: t.y1
+			}];
+		}
+		case "C": {
+			const c = a(t.x0, t.c1x, n), e = a(t.y0, t.c1y, n), s = a(t.c1x, t.c2x, n), y = a(t.c1y, t.c2y, n), x = a(t.c2x, t.x1, n), r = a(t.c2y, t.y1, n), o = a(c, s, n), i = a(e, y, n), h = a(s, x, n), u = a(y, r, n), l = a(o, h, n), p = a(i, u, n);
+			return [{
+				k: "C",
+				x0: t.x0,
+				y0: t.y0,
+				c1x: c,
+				c1y: e,
+				c2x: o,
+				c2y: i,
+				x1: l,
+				y1: p
+			}, {
+				k: "C",
+				x0: l,
+				y0: p,
+				c1x: h,
+				c1y: u,
+				c2x: x,
+				c2y: r,
+				x1: t.x1,
+				y1: t.y1
+			}];
+		}
+		case "A": {
+			const e = c(t, t.t0 + t.dt * n);
+			return [{
+				...t,
+				dt: t.dt * n,
+				x1: e.x,
+				y1: e.y
+			}, {
+				...t,
+				t0: t.t0 + t.dt * n,
+				dt: t.dt * (1 - n),
+				x0: e.x,
+				y0: e.y
+			}];
+		}
+	}
+}
+var h = (t) => ({
+	x: t.x1,
+	y: t.y1
+});
+function u(t) {
+	let n = 0;
+	for (const c of t.segments) n += r(c);
+	return n;
+}
+function l(t, n) {
+	const c = t.segments;
+	if (0 === c.length) return {
+		point: {
+			x: t.x,
+			y: t.y
+		},
+		tangent: {
+			x: 0,
+			y: 0
+		}
+	};
+	let y = Math.max(0, n);
+	for (let t = 0; t < c.length; t++) {
+		const n = c[t], x = r(n);
+		if (y <= x || t === c.length - 1) {
+			const t = o(n, Math.min(y, x));
+			return {
+				point: e(n, t),
+				tangent: s(n, t)
+			};
+		}
+		y -= x;
+	}
+	const x = c[c.length - 1];
+	return {
+		point: h(x),
+		tangent: s(x, 1)
+	};
+}
+var p = () => ({
+	l: 1 / 0,
+	t: 1 / 0,
+	r: -1 / 0,
+	b: -1 / 0
+}), f = (t, n, c) => {
+	n < t.l && (t.l = n), n > t.r && (t.r = n), c < t.t && (t.t = c), c > t.b && (t.b = c);
+}, M = (t, n, c) => {
+	const e = [], s = (t) => {
+		t > 0 && t < 1 && e.push(t);
+	};
+	if (Math.abs(t) < 1e-12) return Math.abs(n) > 1e-12 && s(-c / n), e;
+	const y = n * n - 4 * t * c;
+	if (y < 0) return e;
+	const x = Math.sqrt(y);
+	return s((-n + x) / (2 * t)), s((-n - x) / (2 * t)), e;
+}, m = (t, c) => {
+	const e = Math.abs(t.dt);
+	return e >= n || ((t.dt >= 0 ? c - t.t0 : t.t0 - c) % n + n) % n <= e;
+};
+function d(t, n) {
+	switch (f(t, n.x0, n.y0), f(t, n.x1, n.y1), n.k) {
+		case "L": return;
+		case "Q":
+			for (const c of M(0, 2 * (n.x0 - 2 * n.cx + n.x1), 2 * (n.cx - n.x0))) {
+				const s = e(n, c);
+				f(t, s.x, s.y);
+			}
+			for (const c of M(0, 2 * (n.y0 - 2 * n.cy + n.y1), 2 * (n.cy - n.y0))) {
+				const s = e(n, c);
+				f(t, s.x, s.y);
+			}
+			return;
+		case "C": {
+			const c = (t, n, c, e) => M(3 * n - t - 3 * c + e, 2 * (t - 2 * n + c), n - t);
+			for (const s of [...c(n.x0, n.c1x, n.c2x, n.x1), ...c(n.y0, n.c1y, n.c2y, n.y1)]) {
+				const c = e(n, s);
+				f(t, c.x, c.y);
+			}
+			return;
+		}
+		case "A": {
+			const e = Math.cos(n.phi), s = Math.sin(n.phi), y = [Math.atan2(-n.ry * s, n.rx * e), Math.atan2(n.ry * e, n.rx * s)];
+			for (const e of y) for (const s of [e, e + Math.PI]) if (m(n, s)) {
+				const e = c(n, s);
+				f(t, e.x, e.y);
+			}
+			return;
+		}
+	}
+}
+function g(t, n) {
+	for (const c of n) {
+		f(t, c.x, c.y);
+		for (const n of c.segments) d(t, n);
+	}
+	return t;
+}
+function $(e, s) {
+	const y = [], x = (n) => t(n, s);
+	for (const t of e) {
+		t.implicit || y.push(`M${x(t.x)} ${x(t.y)}`);
+		for (const e of t.segments) switch (e.k) {
+			case "L":
+				y.push(`L${x(e.x1)} ${x(e.y1)}`);
+				break;
+			case "Q":
+				y.push(`Q${x(e.cx)} ${x(e.cy)} ${x(e.x1)} ${x(e.y1)}`);
+				break;
+			case "C":
+				y.push(`C${x(e.c1x)} ${x(e.c1y)} ${x(e.c2x)} ${x(e.c2y)} ${x(e.x1)} ${x(e.y1)}`);
+				break;
+			case "A": {
+				const t = x(e.rx), s = x(e.ry), r = x(180 * e.phi / Math.PI), o = e.dt > 0 ? 1 : 0;
+				if (Math.abs(e.dt) >= n) {
+					const n = c(e, e.t0 + e.dt / 2);
+					y.push(`A${t} ${s} ${r} 0 ${o} ${x(n.x)} ${x(n.y)}`), y.push(`A${t} ${s} ${r} 0 ${o} ${x(e.x1)} ${x(e.y1)}`);
+				} else {
+					const n = Math.abs(e.dt) > Math.PI + 1e-9 ? 1 : 0;
+					y.push(`A${t} ${s} ${r} ${n} ${o} ${x(e.x1)} ${x(e.y1)}`);
+				}
+				break;
+			}
+		}
+		t.closed && y.push("Z");
+	}
+	return y.join(" ");
+}
+var k = 192 / 72, b = {
+	sm: 1,
+	med: 1.5,
+	lg: 2.5
+}, w = {
+	sm: 2,
+	med: 3,
+	lg: 4.5
+}, A = {
+	sm: 1.25,
+	med: 1.75,
+	lg: 2.5
+}, L = (t) => {
+	const n = [];
+	for (let c = 1; c < t.length; c++) {
+		const [e, s] = t[c - 1], [y, x] = t[c];
+		n.push({
+			k: "L",
+			x0: e,
+			y0: s,
+			x1: y,
+			y1: x
+		});
+	}
+	return {
+		x: t[0][0],
+		y: t[0][1],
+		segments: n,
+		closed: !0
+	};
+};
+function v(t, n) {
+	const c = t?.type;
+	if (!c || "none" === c) return null;
+	const e = t?.length ?? "med", s = t?.width ?? "med";
+	if ("arrow" === c) return function(t, n, c) {
+		const e = Math.max(t, k), s = w[n] * e, y = A[c] * e, x = Math.atan(y / s), r = Math.hypot(s, y), o = t / (2 * Math.sin(x / 2)), a = t / 2, i = Math.cos(x), h = Math.sin(x), u = o / 2, l = (t, n) => ({
+			x: t + u,
+			y: n
+		}), p = l(-o / 2, 0), f = l(r * i - a * h, -r * h - a * i), M = l(r * i, -r * h), m = l(r * i + a * h, -r * h + a * i), d = l(o / 2, 0), g = l(r * i + a * h, r * h - a * i), $ = l(r * i, r * h), b = l(r * i - a * h, r * h + a * i), L = (t, n) => ({
+			k: "L",
+			x0: t.x,
+			y0: t.y,
+			x1: n.x,
+			y1: n.y
+		}), v = (t, n, c) => ({
+			k: "A",
+			cx: t.x,
+			cy: t.y,
+			rx: a,
+			ry: a,
+			phi: 0,
+			t0: Math.atan2(n.y - t.y, n.x - t.x),
+			dt: Math.PI,
+			x0: n.x,
+			y0: n.y,
+			x1: c.x,
+			y1: c.y
+		});
+		return {
+			outline: [{
+				x: p.x,
+				y: p.y,
+				closed: !0,
+				segments: [
+					L(p, f),
+					v(M, f, m),
+					L(m, d),
+					L(d, g),
+					v($, g, b),
+					L(b, p)
+				]
+			}],
+			clip: o / 2,
+			sample: o / 2
+		};
+	}(n, e, s);
+	const y = Math.max(n, k), x = b[e] * y, r = b[s] * y;
+	switch (c) {
+		case "triangle": return {
+			outline: [L([
+				[0, 0],
+				[2 * x, -r],
+				[2 * x, r]
+			])],
+			clip: 2 * x - y / 2,
+			sample: 2 * x
+		};
+		case "stealth": return {
+			outline: [L([
+				[1.2 * x, 0],
+				[2 * x, r],
+				[0, 0],
+				[2 * x, -r]
+			])],
+			clip: 1.2 * x,
+			sample: 1.2 * x
+		};
+		case "diamond": return {
+			outline: [L([
+				[0, -r],
+				[x, 0],
+				[0, r],
+				[-x, 0]
+			])],
+			clip: -1,
+			sample: 0
+		};
+		case "oval": return {
+			outline: [(o = x, a = r, {
+				x: -o,
+				y: 0,
+				closed: !0,
+				segments: [{
+					k: "A",
+					cx: 0,
+					cy: 0,
+					rx: o,
+					ry: a,
+					phi: 0,
+					t0: Math.PI,
+					dt: Math.PI,
+					x0: -o,
+					y0: 0,
+					x1: o,
+					y1: 0
+				}, {
+					k: "A",
+					cx: 0,
+					cy: 0,
+					rx: o,
+					ry: a,
+					phi: 0,
+					t0: 0,
+					dt: Math.PI,
+					x0: o,
+					y0: 0,
+					x1: -o,
+					y1: 0
+				}]
+			})],
+			clip: -1,
+			sample: 0
+		};
+	}
+	var o, a;
+}
+function C(t, n, c, e) {
+	if (!(n.clip > 0)) return t;
+	const s = u(t);
+	let y = s - n.clip > 0 ? n.clip : s;
+	return y += e, y >= s && (y = s - .26), function(t, n, c) {
+		if (!(n > .26) || 0 === t.segments.length) return t;
+		const e = c ? t.segments : [...t.segments].reverse(), s = [];
+		let y = n;
+		for (const t of e) {
+			if (y > .26) {
+				const n = r(t);
+				if (n <= y) {
+					y -= n;
+					continue;
+				}
+				const [e, x] = i(t, o(t, c ? y : n - y));
+				s.push(c ? x : e), y = 0;
+				continue;
+			}
+			s.push(t);
+		}
+		const x = c ? s : s.reverse(), a = x.length > 0 ? {
+			x: (h = x[0]).x0,
+			y: h.y0
+		} : {
+			x: t.x,
+			y: t.y
+		};
+		var h;
+		const u = {
+			x: a.x,
+			y: a.y,
+			segments: x,
+			closed: t.closed
+		};
+		return t.implicit && (u.implicit = !0), u;
+	}(t, y, c);
+}
+function Q(t, n, c) {
+	const e = u(t), s = l(t, c ? 0 : e);
+	let y;
+	if (n.sample > 0) {
+		const x = l(t, c ? Math.min(n.sample, e) : n.sample < e ? e - n.sample : 0).point;
+		y = Math.atan2(x.y - s.point.y, x.x - s.point.x);
+	} else y = Math.atan2(s.tangent.y, s.tangent.x);
+	return n.outline.map((t) => function(t, n, c, e, s = !1) {
+		const y = Math.cos(e), x = Math.sin(e), r = s ? -1 : 1, o = (t, e) => ({
+			x: n + t * y - e * r * x,
+			y: c + t * x + e * r * y
+		}), a = t.segments.map((t) => {
+			const n = o(t.x0, t.y0), c = o(t.x1, t.y1);
+			switch (t.k) {
+				case "L": return {
+					k: "L",
+					x0: n.x,
+					y0: n.y,
+					x1: c.x,
+					y1: c.y
+				};
+				case "Q": {
+					const e = o(t.cx, t.cy);
+					return {
+						k: "Q",
+						x0: n.x,
+						y0: n.y,
+						cx: e.x,
+						cy: e.y,
+						x1: c.x,
+						y1: c.y
+					};
+				}
+				case "C": {
+					const e = o(t.c1x, t.c1y), s = o(t.c2x, t.c2y);
+					return {
+						k: "C",
+						x0: n.x,
+						y0: n.y,
+						c1x: e.x,
+						c1y: e.y,
+						c2x: s.x,
+						c2y: s.y,
+						x1: c.x,
+						y1: c.y
+					};
+				}
+				case "A": {
+					const y = o(t.cx, t.cy);
+					return {
+						k: "A",
+						cx: y.x,
+						cy: y.y,
+						rx: t.rx,
+						ry: t.ry,
+						phi: s ? e - t.phi : e + t.phi,
+						t0: s ? -t.t0 : t.t0,
+						dt: s ? -t.dt : t.dt,
+						x0: n.x,
+						y0: n.y,
+						x1: c.x,
+						y1: c.y
+					};
+				}
+			}
+		}), i = o(t.x, t.y);
+		return {
+			x: i.x,
+			y: i.y,
+			segments: a,
+			closed: t.closed
+		};
+	}(t, s.point.x, s.point.y, y, !c));
+}
+function I(t, n) {
+	const c = v(n.head, n.width), e = v(n.tail, n.width);
+	if (!c && !e) return null;
+	const s = "square" === n.cap ? n.width / 2 : 0, y = [];
+	let x = !1;
+	const r = t.map((t) => {
+		if (!function(t) {
+			if (t.closed || 0 === t.segments.length) return !1;
+			const n = h(t.segments[t.segments.length - 1]);
+			return Math.abs(n.x - t.x) > 1e-6 || Math.abs(n.y - t.y) > 1e-6;
+		}(t)) return t;
+		x = !0;
+		let n = t;
+		return c && (y.push(...Q(n, c, !0)), n = C(n, c, !0, s)), e && (y.push(...Q(n, e, !1)), n = C(n, e, !1, s)), n;
+	});
+	return x ? {
+		stroke: r,
+		ends: y
+	} : null;
+}
+export { $ as i, g as n, p as r, I as t };