@sheetxl/mcp 0.0.0-stage → 0.8.0-beta.15

package/assets/Crt2kLdGIlBHANgg.js

@@ -0,0 +1,28 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.15
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	DELAY: {
+		s: "Returns the input value after a delay.",
+		c: "SheetXL",
+		p: {
+			time: { d: "the delay time in milliseconds. Default is 1000ms (1 second)." },
+			input: { d: "returns the input." },
+			label: { d: "optional label for the delay function." }
+		},
+		h: "Testing"
+	},
+	WAIT: {
+		s: "Starts waiting for event",
+		c: "SheetXL",
+		p: {
+			type: { d: "the type of message." },
+			input: { d: "an optional dependency." }
+		},
+		h: "Testing"
+	}
+};
+export { e as default };

package/assets/CudNpUD78SrtJIiy.js

@@ -0,0 +1,610 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.15
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { t } from "./DvUUArnZwoYOKOuk.js";
+var c = 2 * Math.PI;
+function n(t, c) {
+	const n = Math.cos(c), e = Math.sin(c), s = Math.cos(t.phi), y = Math.sin(t.phi);
+	return {
+		x: t.cx + t.rx * n * s - t.ry * e * y,
+		y: t.cy + t.rx * n * y + t.ry * e * s
+	};
+}
+function e(t, c) {
+	switch (t.k) {
+		case "L": return {
+			x: t.x0 + (t.x1 - t.x0) * c,
+			y: t.y0 + (t.y1 - t.y0) * c
+		};
+		case "Q": {
+			const n = 1 - c;
+			return {
+				x: n * n * t.x0 + 2 * n * c * t.cx + c * c * t.x1,
+				y: n * n * t.y0 + 2 * n * c * t.cy + c * c * t.y1
+			};
+		}
+		case "C": {
+			const n = 1 - c, e = n * n * n, s = 3 * n * n * c, y = 3 * n * c * c, x = c * c * c;
+			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 n(t, t.t0 + t.dt * c);
+	}
+}
+function s(t, c) {
+	switch (t.k) {
+		case "L": return {
+			x: t.x1 - t.x0,
+			y: t.y1 - t.y0
+		};
+		case "Q": {
+			const n = 1 - c;
+			return {
+				x: 2 * n * (t.cx - t.x0) + 2 * c * (t.x1 - t.cx),
+				y: 2 * n * (t.cy - t.y0) + 2 * c * (t.y1 - t.cy)
+			};
+		}
+		case "C": {
+			const n = 1 - c;
+			return {
+				x: 3 * n * n * (t.c1x - t.x0) + 6 * n * c * (t.c2x - t.c1x) + 3 * c * c * (t.x1 - t.c2x),
+				y: 3 * n * n * (t.c1y - t.y0) + 6 * n * c * (t.c2y - t.c1y) + 3 * c * c * (t.y1 - t.c2y)
+			};
+		}
+		case "A": {
+			const n = t.t0 + t.dt * c, e = Math.cos(n), s = Math.sin(n), 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 c = y.get(t);
+	if (c) return c;
+	if ("L" === t.k) {
+		const n = Math.hypot(t.x1 - t.x0, t.y1 - t.y0);
+		c = {
+			cum: new Float64Array([0, n]),
+			total: n
+		};
+	} else {
+		const n = function(t) {
+			let c;
+			switch (t.k) {
+				case "Q":
+					c = Math.hypot(t.cx - t.x0, t.cy - t.y0) + Math.hypot(t.x1 - t.cx, t.y1 - t.cy);
+					break;
+				case "C":
+					c = 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":
+					c = Math.abs(t.dt) * Math.max(t.rx, t.ry);
+					break;
+				default: c = 0;
+			}
+			return Math.min(256, Math.max(32, Math.ceil(c)));
+		}(t), s = new Float64Array(n + 1);
+		let y = e(t, 0);
+		for (let c = 1; c <= n; c++) {
+			const x = e(t, c / n);
+			s[c] = s[c - 1] + Math.hypot(x.x - y.x, x.y - y.y), y = x;
+		}
+		c = {
+			cum: s,
+			total: s[n]
+		};
+	}
+	return y.set(t, c), c;
+}
+function r(t) {
+	return x(t).total;
+}
+function o(t, c) {
+	const { cum: n, total: e } = x(t);
+	if (!(e > 0)) return 0;
+	if (c <= 0) return 0;
+	if (c >= e) return 1;
+	const s = n.length - 1;
+	let y = 0, r = s;
+	for (; r - y > 1;) {
+		const t = y + r >> 1;
+		n[t] <= c ? y = t : r = t;
+	}
+	const o = n[r] - n[y];
+	return (y + (o > 0 ? (c - n[y]) / o : 0)) / s;
+}
+var a = (t, c, n) => t + (c - t) * n;
+function i(t, c) {
+	switch (t.k) {
+		case "L": {
+			const n = e(t, c);
+			return [{
+				k: "L",
+				x0: t.x0,
+				y0: t.y0,
+				x1: n.x,
+				y1: n.y
+			}, {
+				k: "L",
+				x0: n.x,
+				y0: n.y,
+				x1: t.x1,
+				y1: t.y1
+			}];
+		}
+		case "Q": {
+			const n = a(t.x0, t.cx, c), e = a(t.y0, t.cy, c), s = a(t.cx, t.x1, c), y = a(t.cy, t.y1, c), x = a(n, s, c), r = a(e, y, c);
+			return [{
+				k: "Q",
+				x0: t.x0,
+				y0: t.y0,
+				cx: n,
+				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 n = a(t.x0, t.c1x, c), e = a(t.y0, t.c1y, c), s = a(t.c1x, t.c2x, c), y = a(t.c1y, t.c2y, c), x = a(t.c2x, t.x1, c), r = a(t.c2y, t.y1, c), o = a(n, s, c), i = a(e, y, c), h = a(s, x, c), u = a(y, r, c), l = a(o, h, c), p = a(i, u, c);
+			return [{
+				k: "C",
+				x0: t.x0,
+				y0: t.y0,
+				c1x: n,
+				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 = n(t, t.t0 + t.dt * c);
+			return [{
+				...t,
+				dt: t.dt * c,
+				x1: e.x,
+				y1: e.y
+			}, {
+				...t,
+				t0: t.t0 + t.dt * c,
+				dt: t.dt * (1 - c),
+				x0: e.x,
+				y0: e.y
+			}];
+		}
+	}
+}
+var h = (t) => ({
+	x: t.x1,
+	y: t.y1
+});
+function u(t) {
+	let c = 0;
+	for (const n of t.segments) c += r(n);
+	return c;
+}
+function l(t, c) {
+	const n = t.segments;
+	if (0 === n.length) return {
+		point: {
+			x: t.x,
+			y: t.y
+		},
+		tangent: {
+			x: 0,
+			y: 0
+		}
+	};
+	let y = Math.max(0, c);
+	for (let t = 0; t < n.length; t++) {
+		const c = n[t], x = r(c);
+		if (y <= x || t === n.length - 1) {
+			const t = o(c, Math.min(y, x));
+			return {
+				point: e(c, t),
+				tangent: s(c, t)
+			};
+		}
+		y -= x;
+	}
+	const x = n[n.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, c, n) => {
+	c < t.l && (t.l = c), c > t.r && (t.r = c), n < t.t && (t.t = n), n > t.b && (t.b = n);
+}, M = (t, c, n) => {
+	const e = [], s = (t) => {
+		t > 0 && t < 1 && e.push(t);
+	};
+	if (Math.abs(t) < 1e-12) return Math.abs(c) > 1e-12 && s(-n / c), e;
+	const y = c * c - 4 * t * n;
+	if (y < 0) return e;
+	const x = Math.sqrt(y);
+	return s((-c + x) / (2 * t)), s((-c - x) / (2 * t)), e;
+}, m = (t, n) => {
+	const e = Math.abs(t.dt);
+	return e >= c || ((t.dt >= 0 ? n - t.t0 : t.t0 - n) % c + c) % c <= e;
+};
+function d(t, c) {
+	switch (f(t, c.x0, c.y0), f(t, c.x1, c.y1), c.k) {
+		case "L": return;
+		case "Q":
+			for (const n of M(0, 2 * (c.x0 - 2 * c.cx + c.x1), 2 * (c.cx - c.x0))) {
+				const s = e(c, n);
+				f(t, s.x, s.y);
+			}
+			for (const n of M(0, 2 * (c.y0 - 2 * c.cy + c.y1), 2 * (c.cy - c.y0))) {
+				const s = e(c, n);
+				f(t, s.x, s.y);
+			}
+			return;
+		case "C": {
+			const n = (t, c, n, e) => M(3 * c - t - 3 * n + e, 2 * (t - 2 * c + n), c - t);
+			for (const s of [...n(c.x0, c.c1x, c.c2x, c.x1), ...n(c.y0, c.c1y, c.c2y, c.y1)]) {
+				const n = e(c, s);
+				f(t, n.x, n.y);
+			}
+			return;
+		}
+		case "A": {
+			const e = Math.cos(c.phi), s = Math.sin(c.phi), y = [Math.atan2(-c.ry * s, c.rx * e), Math.atan2(c.ry * e, c.rx * s)];
+			for (const e of y) for (const s of [e, e + Math.PI]) if (m(c, s)) {
+				const e = n(c, s);
+				f(t, e.x, e.y);
+			}
+			return;
+		}
+	}
+}
+function g(t, c) {
+	for (const n of c) {
+		f(t, n.x, n.y);
+		for (const c of n.segments) d(t, c);
+	}
+	return t;
+}
+function $(e, s) {
+	const y = [], x = (c) => t(c, 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) >= c) {
+					const c = n(e, e.t0 + e.dt / 2);
+					y.push(`A${t} ${s} ${r} 0 ${o} ${x(c.x)} ${x(c.y)}`), y.push(`A${t} ${s} ${r} 0 ${o} ${x(e.x1)} ${x(e.y1)}`);
+				} else {
+					const c = Math.abs(e.dt) > Math.PI + 1e-9 ? 1 : 0;
+					y.push(`A${t} ${s} ${r} ${c} ${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 c = [];
+	for (let n = 1; n < t.length; n++) {
+		const [e, s] = t[n - 1], [y, x] = t[n];
+		c.push({
+			k: "L",
+			x0: e,
+			y0: s,
+			x1: y,
+			y1: x
+		});
+	}
+	return {
+		x: t[0][0],
+		y: t[0][1],
+		segments: c,
+		closed: !0
+	};
+};
+function v(t, c) {
+	const n = t?.type;
+	if (!n || "none" === n) return null;
+	const e = t?.length ?? "med", s = t?.width ?? "med";
+	if ("arrow" === n) return function(t, c, n) {
+		const e = Math.max(t, k), s = w[c] * e, y = A[n] * 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, c) => ({
+			x: t + u,
+			y: c
+		}), 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, c) => ({
+			k: "L",
+			x0: t.x,
+			y0: t.y,
+			x1: c.x,
+			y1: c.y
+		}), v = (t, c, n) => ({
+			k: "A",
+			cx: t.x,
+			cy: t.y,
+			rx: a,
+			ry: a,
+			phi: 0,
+			t0: Math.atan2(c.y - t.y, c.x - t.x),
+			dt: Math.PI,
+			x0: c.x,
+			y0: c.y,
+			x1: n.x,
+			y1: n.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
+		};
+	}(c, e, s);
+	const y = Math.max(c, k), x = b[e] * y, r = b[s] * y;
+	switch (n) {
+		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, c, n, e) {
+	if (!(c.clip > 0)) return t;
+	const s = u(t);
+	let y = s - c.clip > 0 ? c.clip : s;
+	return y += e, y >= s && (y = s - .26), function(t, c, n) {
+		if (!(c > .26) || 0 === t.segments.length) return t;
+		const e = n ? t.segments : [...t.segments].reverse(), s = [];
+		let y = c;
+		for (const t of e) {
+			if (y > .26) {
+				const c = r(t);
+				if (c <= y) {
+					y -= c;
+					continue;
+				}
+				const [e, x] = i(t, o(t, n ? y : c - y));
+				s.push(n ? x : e), y = 0;
+				continue;
+			}
+			s.push(t);
+		}
+		const x = n ? 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, n);
+}
+function Q(t, c, n) {
+	const e = u(t), s = l(t, n ? 0 : e);
+	let y;
+	if (c.sample > 0) {
+		const x = l(t, n ? Math.min(c.sample, e) : c.sample < e ? e - c.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 c.outline.map((t) => function(t, c, n, e, s = !1) {
+		const y = Math.cos(e), x = Math.sin(e), r = s ? -1 : 1, o = (t, e) => ({
+			x: c + t * y - e * r * x,
+			y: n + t * x + e * r * y
+		}), a = t.segments.map((t) => {
+			const c = o(t.x0, t.y0), n = o(t.x1, t.y1);
+			switch (t.k) {
+				case "L": return {
+					k: "L",
+					x0: c.x,
+					y0: c.y,
+					x1: n.x,
+					y1: n.y
+				};
+				case "Q": {
+					const e = o(t.cx, t.cy);
+					return {
+						k: "Q",
+						x0: c.x,
+						y0: c.y,
+						cx: e.x,
+						cy: e.y,
+						x1: n.x,
+						y1: n.y
+					};
+				}
+				case "C": {
+					const e = o(t.c1x, t.c1y), s = o(t.c2x, t.c2y);
+					return {
+						k: "C",
+						x0: c.x,
+						y0: c.y,
+						c1x: e.x,
+						c1y: e.y,
+						c2x: s.x,
+						c2y: s.y,
+						x1: n.x,
+						y1: n.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: c.x,
+						y0: c.y,
+						x1: n.x,
+						y1: n.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, !n));
+}
+function I(t, c) {
+	const n = v(c.head, c.width), e = v(c.tail, c.width);
+	if (!n && !e) return null;
+	const s = "square" === c.cap ? c.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 c = h(t.segments[t.segments.length - 1]);
+			return Math.abs(c.x - t.x) > 1e-6 || Math.abs(c.y - t.y) > 1e-6;
+		}(t)) return t;
+		x = !0;
+		let c = t;
+		return n && (y.push(...Q(c, n, !0)), c = C(c, n, !0, s)), e && (y.push(...Q(c, e, !1)), c = C(c, e, !1, s)), c;
+	});
+	return x ? {
+		stroke: r,
+		ends: y
+	} : null;
+}
+export { p as i, I as n, g as r, $ as t };