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

package/assets/PmooYGqWqoTxPExF.js

@@ -0,0 +1,449 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.14
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { i as t, n as e, r as n, t as r } from "./CMTDUipnLiOj5pbe.js";
+var s = 6e4, a = Math.PI / 180 / s, c = 108e5 / Math.PI, o = /^[+-]?\d+$/, u = (t) => o.test(t) ? Number(t) : t, i = /* @__PURE__ */ new WeakMap();
+function h(t) {
+	let e = i.get(t);
+	return e || (e = {
+		av: (t.av ?? []).map((t) => {
+			const e = t.split(" ");
+			if ("val" !== e[1] || 3 !== e.length) throw new Error(`adjust value "${t}" is not "name val N"`);
+			return {
+				name: e[0],
+				value: Number(e[2])
+			};
+		}),
+		gd: (t.gd ?? []).map((t) => {
+			const e = t.split(" ");
+			return {
+				name: e[0],
+				op: e[1],
+				args: e.slice(2).map(u)
+			};
+		})
+	}, i.set(t, e), e);
+}
+var l = class {
+	constructor(t, e) {
+		this._values = /* @__PURE__ */ new Map(), this.w = t, this.h = e;
+	}
+	get(t) {
+		if ("number" == typeof t) return t;
+		const e = this._values.get(t);
+		if (void 0 !== e) return e;
+		const n = function(t, e, n) {
+			switch (t) {
+				case "l":
+				case "t": return 0;
+				case "r":
+				case "w": return e;
+				case "b":
+				case "h": return n;
+				case "hc":
+				case "wd2": return e / 2;
+				case "vc":
+				case "hd2": return n / 2;
+				case "wd3": return e / 3;
+				case "wd4": return e / 4;
+				case "wd5": return e / 5;
+				case "wd6": return e / 6;
+				case "wd8": return e / 8;
+				case "wd10": return e / 10;
+				case "wd12": return e / 12;
+				case "wd32": return e / 32;
+				case "hd3": return n / 3;
+				case "hd4": return n / 4;
+				case "hd5": return n / 5;
+				case "hd6": return n / 6;
+				case "hd8": return n / 8;
+				case "hd10": return n / 10;
+				case "hd12": return n / 12;
+				case "ss": return Math.min(e, n);
+				case "ls": return Math.max(e, n);
+				case "ssd2": return Math.min(e, n) / 2;
+				case "ssd4": return Math.min(e, n) / 4;
+				case "ssd6": return Math.min(e, n) / 6;
+				case "ssd8": return Math.min(e, n) / 8;
+				case "ssd16": return Math.min(e, n) / 16;
+				case "ssd32": return Math.min(e, n) / 32;
+				case "cd2": return 108e5;
+				case "cd3": return 72e5;
+				case "cd4": return 54e5;
+				case "cd8": return 27e5;
+				case "3cd4": return 162e5;
+				case "3cd8": return 81e5;
+				case "5cd8": return 135e5;
+				case "7cd8": return 189e5;
+				default: return;
+			}
+		}(t, this.w, this.h);
+		if (void 0 === n) throw new Error(`undefined guide "${t}"`);
+		return n;
+	}
+	has(t) {
+		return this._values.has(t);
+	}
+	set(t, e) {
+		this._values.set(t, e);
+	}
+};
+function d(t, e, n, r) {
+	switch (t) {
+		case "*/": return 0 === r ? 0 : e * n / r;
+		case "+-": return e + n - r;
+		case "+/": return 0 === r ? 0 : (e + n) / r;
+		case "?:": return e > 0 ? n : r;
+		case "abs": return Math.abs(e);
+		case "at2": return Math.atan2(n, e) * c;
+		case "cat2": return e * Math.cos(Math.atan2(r, n));
+		case "sat2": return e * Math.sin(Math.atan2(r, n));
+		case "cos": return e * Math.cos(n * a);
+		case "sin": return e * Math.sin(n * a);
+		case "tan": return e * Math.tan(n * a);
+		case "max": return Math.max(e, n);
+		case "min": return Math.min(e, n);
+		case "mod": return Math.sqrt(e * e + n * n + r * r);
+		case "pin": return n < e ? e : n > r ? r : n;
+		case "sqrt": return Math.sqrt(Math.abs(e));
+		case "val": return e;
+		default: throw new Error(`unknown guide op "${t}"`);
+	}
+}
+function f(t, e, n, r) {
+	const { av: s, gd: a } = h(t), c = new l(e, n);
+	for (const t of s) {
+		const e = r?.[t.name];
+		c.set(t.name, void 0 !== e && Number.isFinite(e) ? e : t.value);
+	}
+	for (const t of a) {
+		const e = t.args;
+		c.set(t.name, d(t.op, e.length > 0 ? c.get(e[0]) : 0, e.length > 1 ? c.get(e[1]) : 0, e.length > 2 ? c.get(e[2]) : 0));
+	}
+	return c;
+}
+var m = {
+	M: 2,
+	L: 2,
+	Q: 4,
+	C: 6,
+	A: 4,
+	Z: 0
+}, g = /* @__PURE__ */ new WeakMap();
+function M(t) {
+	const e = 0 === t.d.length ? [] : t.d.split(" "), n = [];
+	let r = 0;
+	for (; r < e.length;) {
+		const s = e[r++], a = m[s];
+		if (void 0 === a) throw new Error(`unknown path command "${s}" in "${t.d}"`);
+		n.push({
+			c: s,
+			args: e.slice(r, r + a).map(u)
+		}), r += a;
+	}
+	const s = {
+		fill: t.f ?? "norm",
+		stroke: 0 !== t.s,
+		cmds: n
+	};
+	return void 0 !== t.w && (s.w = t.w), void 0 !== t.h && (s.h = t.h), s;
+}
+var p = Math.PI / 180 / s, x = 2 * Math.PI;
+function v(t, e, n, r) {
+	const s = [];
+	let a = 0, c = 0, o = 0, u = 0, i = null;
+	const h = (t) => {
+		const e = {
+			x: a * n,
+			y: c * r,
+			segments: [],
+			closed: !1
+		};
+		return t && (e.implicit = !0), s.push(e), i = e, e;
+	}, l = () => i ?? h(!0);
+	for (const s of t.cmds) {
+		const t = s.args;
+		switch (s.c) {
+			case "M":
+				a = o = e.get(t[0]), c = u = e.get(t[1]), h(!1);
+				break;
+			case "L": {
+				const s = e.get(t[0]), o = e.get(t[1]);
+				l().segments.push({
+					k: "L",
+					x0: a * n,
+					y0: c * r,
+					x1: s * n,
+					y1: o * r
+				}), a = s, c = o;
+				break;
+			}
+			case "Q": {
+				const s = e.get(t[2]), o = e.get(t[3]);
+				l().segments.push({
+					k: "Q",
+					x0: a * n,
+					y0: c * r,
+					cx: e.get(t[0]) * n,
+					cy: e.get(t[1]) * r,
+					x1: s * n,
+					y1: o * r
+				}), a = s, c = o;
+				break;
+			}
+			case "C": {
+				const s = e.get(t[4]), o = e.get(t[5]);
+				l().segments.push({
+					k: "C",
+					x0: a * n,
+					y0: c * r,
+					c1x: e.get(t[0]) * n,
+					c1y: e.get(t[1]) * r,
+					c2x: e.get(t[2]) * n,
+					c2y: e.get(t[3]) * r,
+					x1: s * n,
+					y1: o * r
+				}), a = s, c = o;
+				break;
+			}
+			case "Z":
+				l().closed = !0, i = null, a = o, c = u;
+				break;
+			case "A": {
+				const s = e.get(t[0]), o = e.get(t[1]), u = e.get(t[2]) * p, i = e.get(t[3]) * p;
+				if (0 === s || 0 === o || 0 === i) break;
+				const h = (t) => Math.atan2(s * Math.sin(t), o * Math.cos(t)), d = h(u), f = a - s * Math.cos(d), m = c - o * Math.sin(d), g = h(u + i), M = f + s * Math.cos(g), v = m + o * Math.sin(g);
+				let w;
+				Math.abs(i) >= x ? w = i > 0 ? x : -x : (w = g - d, (i > 0 ? w <= 0 : w >= 0) && (w += i > 0 ? x : -x)), l().segments.push({
+					k: "A",
+					cx: f * n,
+					cy: m * r,
+					rx: s * n,
+					ry: o * r,
+					phi: 0,
+					t0: d,
+					dt: w,
+					x0: a * n,
+					y0: c * r,
+					x1: M * n,
+					y1: v * r
+				}), a = M, c = v;
+				break;
+			}
+		}
+	}
+	return s;
+}
+var w = /* @__PURE__ */ new WeakMap(), y = (t) => "_" === t ? void 0 : t, b = (t) => void 0 === t || "_" === t ? void 0 : u(t);
+function k(t) {
+	let e = w.get(t);
+	return e || (e = {
+		handles: (t.ah ?? []).map((t) => {
+			const e = t.split(" "), n = {
+				type: e[0],
+				ref1: y(e[1]),
+				ref2: y(e[2]),
+				x: u(e[3]),
+				y: u(e[4])
+			};
+			return e.length > 5 && (n.bounds = [
+				b(e[5]),
+				b(e[6]),
+				b(e[7]),
+				b(e[8])
+			]), n;
+		}),
+		cxn: (t.cxn ?? []).map((t) => {
+			const e = t.split(" ");
+			return {
+				ang: u(e[0]),
+				x: u(e[1]),
+				y: u(e[2])
+			};
+		})
+	}, void 0 !== t.rect && (e.rect = t.rect.split(" ").map(u)), w.set(t, e), e);
+}
+function A(t, e) {
+	const n = (t) => e.get(t), r = (t) => void 0 === t ? void 0 : e.get(t), a = (t) => void 0 === t ? void 0 : e.get(t) / s;
+	return t.handles.map((t) => {
+		const e = t.bounds ?? [];
+		return "xy" === t.type ? Y({
+			type: "xy",
+			x: n(t.x),
+			y: n(t.y),
+			refX: t.ref1,
+			minX: r(e[0]),
+			maxX: r(e[1]),
+			refY: t.ref2,
+			minY: r(e[2]),
+			maxY: r(e[3])
+		}) : Y({
+			type: "polar",
+			x: n(t.x),
+			y: n(t.y),
+			refR: t.ref1,
+			minR: r(e[0]),
+			maxR: r(e[1]),
+			refAng: t.ref2,
+			minAng: a(e[2]),
+			maxAng: a(e[3])
+		});
+	});
+}
+function R(t, e, n, r) {
+	return A(k(t), f(t, e, n, r));
+}
+var $ = (t, e, n, r) => {
+	const s = e === n ? t.head : void 0, a = e === r ? t.tail : void 0;
+	if (!s && !a) return null;
+	const c = { ...t };
+	return s || delete c.head, a || delete c.tail, c;
+};
+function X(a, c, o, u, i) {
+	const l = i?.precision ?? 2, d = f(a, c, o, u), m = /* @__PURE__ */ new Map(), p = i?.line, x = [], w = t(), y = [];
+	for (const t of function(t) {
+		let e = g.get(t);
+		return e || (e = t.paths.map(M), g.set(t, e), e);
+	}(a)) {
+		let e = d, n = 1, r = 1;
+		if (void 0 !== t.w && void 0 !== t.h) {
+			const s = `${t.w}x${t.h}`;
+			let i = m.get(s);
+			i || (i = f(a, t.w, t.h, u), m.set(s, i)), e = i, n = c / t.w, r = o / t.h;
+		}
+		y.push({
+			fill: t.fill,
+			stroke: t.stroke,
+			subpaths: v(t, e, n, r)
+		});
+	}
+	let b = -1, R = -1;
+	p && y.forEach((t, e) => {
+		var n;
+		t.stroke && (n = t.subpaths).some((t) => t.segments.length > 0) && !n.some((t) => t.closed) && (b < 0 && (b = e), R = e);
+	});
+	for (let t = 0; t < y.length; t++) {
+		const s = y[t], a = s.subpaths, c = p && b >= 0 ? $(p, t, b, R) : null, o = c ? e(a, c) : null;
+		("none" !== s.fill || s.stroke) && n(w, a), o && n(w, o.ends), o ? ("none" !== s.fill && x.push({
+			d: r(a, l),
+			fill: s.fill,
+			stroke: !1
+		}), x.push({
+			d: r(o.stroke, l),
+			fill: "none",
+			stroke: !0
+		}), x.push({
+			d: r(o.ends, l),
+			fill: "line",
+			stroke: !1
+		})) : x.push({
+			d: r(a, l),
+			fill: s.fill,
+			stroke: s.stroke
+		});
+	}
+	const X = k(a), Y = (t) => d.get(t), I = X.rect ? {
+		l: Y(X.rect[0]),
+		t: Y(X.rect[1]),
+		r: Y(X.rect[2]),
+		b: Y(X.rect[3])
+	} : {
+		l: 0,
+		t: 0,
+		r: c,
+		b: o
+	}, N = A(X, d), P = X.cxn.map((t) => ({
+		x: Y(t.x),
+		y: Y(t.y),
+		ang: d.get(t.ang) / s
+	})), _ = {};
+	for (const t of h(a).av) _[t.name] = d.get(t.name);
+	return {
+		paths: x,
+		textRect: I,
+		pathBounds: w.l <= w.r ? w : {
+			l: 0,
+			t: 0,
+			r: c,
+			b: o
+		},
+		handles: N,
+		connections: P,
+		adjustments: _
+	};
+}
+function Y(t) {
+	for (const e of Object.keys(t)) void 0 === t[e] && delete t[e];
+	return t;
+}
+var I = 2147483647, N = .01;
+function P(t, e, n, r, s, a = (t, e) => t - e) {
+	const c = ((t, e) => (n) => Math.min(e, Math.max(t, n)))(r, s);
+	let o = c(n), u = a(t(o), e);
+	if (Math.abs(u) < N) return o;
+	const i = s - r, h = Number.isFinite(i) && i < I ? Math.max(i / 100, 1) : Math.max(Math.abs(o) / 10, 1e3);
+	let l = c(o + h);
+	if (l === o && (l = c(o - h)), l === o) return o;
+	let d = a(t(l), e);
+	for (let n = 0; n < 24; n++) {
+		if (Math.abs(d) < N) return l;
+		if (d === u) break;
+		const n = c(l - d * (l - o) / (d - u));
+		if (n === l) break;
+		o = l, u = d, l = n, d = a(t(l), e);
+	}
+	return Math.abs(d) <= Math.abs(u) ? l : o;
+}
+function _(t, e, n, r, a, c, o) {
+	const u = { ...r }, i = R(t, e, n, u)[a];
+	if (!i) return u;
+	const h = (r, s) => R(t, e, n, {
+		...u,
+		[r]: s
+	})[a], l = (e) => u[e] ?? function(t, e) {
+		for (const n of t.av ?? []) {
+			const t = n.split(" ");
+			if (t[0] === e && "val" === t[1]) return Number(t[2]);
+		}
+		return 0;
+	}(t, e);
+	if ("xy" === i.type) {
+		if (i.refX) {
+			const t = i.refX;
+			u[t] = P((e) => h(t, e).x, c, l(t), i.minX ?? -2147483647, i.maxX ?? I);
+		}
+		if (i.refY) {
+			const t = i.refY;
+			u[t] = P((e) => h(t, e).y, o, l(t), i.minY ?? -2147483647, i.maxY ?? I);
+		}
+		return u;
+	}
+	const d = e / 2, f = n / 2;
+	if (i.refAng) {
+		const t = i.refAng, e = 180 * Math.atan2(o - f, c - d) / Math.PI, n = (e) => {
+			const n = h(t, e);
+			return 180 * Math.atan2(n.y - f, n.x - d) / Math.PI;
+		}, r = void 0 === i.minAng ? -2147483647 : i.minAng * s, a = void 0 === i.maxAng ? I : i.maxAng * s;
+		u[t] = function(t, e, n, r, s) {
+			const a = (n) => ((t, e) => {
+				let n = (t - e) % 360;
+				return n <= -180 && (n += 360), n > 180 && (n -= 360), n;
+			})(t(n), e), c = 216e5, o = s - r, u = o <= 2 * c ? r : Math.max(r, n - c), i = o <= 2 * c ? s : Math.min(s, n + c);
+			let h = Math.min(s, Math.max(r, n)), l = Math.abs(a(h));
+			for (let t = 0; t <= 12 && l >= N; t++) {
+				const e = u + (i - u) * t / 12, n = Math.abs(a(e));
+				n < l && (h = e, l = n);
+			}
+			return l < N ? h : P(a, 0, h, r, s);
+		}(n, e, l(t), r, a);
+	}
+	if (i.refR) {
+		const t = i.refR, e = Math.hypot(c - d, o - f), n = (t) => Math.hypot(t.x - d, t.y - f);
+		u[t] = P((e) => n(h(t, e)), e, l(t), i.minR ?? -2147483647, i.maxR ?? I);
+	}
+	return u;
+}
+export { _ as adjustmentsFromHandle, X as evaluateGeometry };

package/assets/QXKcNTuZqOauSidr.js

@@ -0,0 +1,58 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.14
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	SLN: {
+		s: "Returns the straight-line depreciation of an asset for one period.",
+		p: {
+			cost: { d: "is the initial cost of the asset." },
+			salvage: { d: "is the salvage value at the end of the life of the asset." },
+			life: { d: "is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)." }
+		}
+	},
+	SYD: {
+		s: "Returns the sum-of-years' digits depreciation of an asset for a specified period.",
+		p: {
+			cost: { d: "is the initial cost of the asset." },
+			salvage: { d: "is the salvage value at the end of the life of the asset." },
+			life: { d: "is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)." },
+			per: { d: "is the period and must use the same units as Life." }
+		}
+	},
+	DB: {
+		s: "Returns the depreciation of an asset for a specified period using the fixed-declining balance method.",
+		p: {
+			cost: { d: "is the initial cost of the asset." },
+			salvage: { d: "is the salvage value at the end of the life of the asset." },
+			life: { d: "is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)." },
+			period: { d: "is the period for which you want to calculate the depreciation. Period must use the same units as Life." },
+			month: { d: "is the number of months in the first year." }
+		}
+	},
+	DDB: {
+		s: "Returns the depreciation of an asset for a specified period using the double-declining balance method or some other method you specify.",
+		p: {
+			cost: { d: "is the initial cost of the asset." },
+			salvage: { d: "is the salvage value at the end of the life of the asset." },
+			life: { d: "is the number of periods over which the asset is being depreciated (sometimes called the useful life of the asset)." },
+			period: { d: "is the period for which you want to calculate the depreciation. Period must use the same units as Life." },
+			factor: { d: "is the rate at which the balance declines." }
+		}
+	},
+	AMORLINC: {
+		s: "Returns the prorated linear depreciation of an asset for each accounting period.",
+		p: {
+			cost: { d: "is the cost of the asset." },
+			datePurchased: { d: "is the date the asset is purchased." },
+			firstPeriod: { d: "is the date of the end of the first period." },
+			salvage: { d: "is the salvage value at the end of life of the asset." },
+			period: { d: "is the period." },
+			rate: { d: "is the rate of depreciation." },
+			basis: { d: "year basis : 0 for year of 360 days, 1 for actual, 3 for year of 365 days." }
+		}
+	}
+};
+export { e as default };