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

package/assets/BYtBi8vLoB41QkV8.js

@@ -0,0 +1,656 @@
+/**
+* @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 { ht as e } from "./DkFK1iu4vqjLZMja.js";
+import { c as t, p as n, r as a } from "./CBNNl8igIyeHY4St.js";
+import { c as r, s as i } from "./D94hlZEaHtGHdN_K.js";
+var o = /* @__PURE__ */ new Map([["IReferenceRange", "p"], ["IRange", "r"]]), s = new Set(Object.values(t).filter((e) => e !== t.Omitted)), l = /* @__PURE__ */ new Map([
+	["IWorkbook", "workbook"],
+	["IWorksheet", "sheet"],
+	["ICellRanges", "ranges"],
+	["ICellRange", "range"]
+]), d = Array.from(l.keys()), u = (e, t) => {
+	Array.from(t.keys()).forEach((n) => {
+		const a = t.get(n);
+		t.set(`${e}.${n}`, a);
+	});
+}, m = /* @__PURE__ */ new Map([
+	["Scalar", "*"],
+	["Lambda", "l"],
+	["FormulaError.Known", n.Error],
+	["Date", a.Date],
+	["IRichData", a.RichData]
+]), c = /* @__PURE__ */ new Map([["Repeating", "repeating"]]), p = /* @__PURE__ */ new Set(["Flatten", "SheetXL.Flatten"]), g = /* @__PURE__ */ new Set(["AcceptError"]), y = /* @__PURE__ */ new Set(["Omittable"]), f = /* @__PURE__ */ new Set(["NoLift"]), h = /* @__PURE__ */ new Set(["NoFilter"]), v = /* @__PURE__ */ new Set(["Lazy"]), $ = /* @__PURE__ */ new Set(["ReportType"]), b = /^[a-zA-Z_-￿][a-zA-Z0-9_.-￿]*$/, T = /^([a-z]{1,3})([0-9]+)$/i, w = /^r[0-9]*c[0-9]*$/i, x = "SheetXL", S = (e) => {
+	const t = e.typeName.getText();
+	return t.startsWith(`${x}.`) ? t.slice(8) : t;
+};
+u(x, o), u(x, l), u(x, c), g.add(x + ".AcceptError"), y.add(`${x}.Omittable`), f.add(`${x}.NoLift`), h.add(`${x}.NoFilter`), v.add(`${x}.Lazy`), $.add(`${x}.ReportType`);
+var k = /* @__PURE__ */ new Map([["Volatile", () => ({ volatile: !0 })], [`${x}.Volatile`, () => ({ volatile: !0 })]]), A = "__scriptContext__", R = "script", N = /* @__PURE__ */ new Set([
+	"IScript.ScriptContext",
+	`${x}.IScript.ScriptContext`,
+	"ScriptContext"
+]), K = (e, t) => {
+	const n = t.literal;
+	if (void 0 === n) return;
+	const a = e.SyntaxKind;
+	switch (n.kind) {
+		case a.StringLiteral: return n.text;
+		case a.NumericLiteral: return parseFloat(n.text);
+		case a.TrueKeyword: return !0;
+		case a.FalseKeyword: return !1;
+		case a.NullKeyword: return null;
+		case a.PrefixUnaryExpression: return n.operator === a.MinusToken && n.operand?.kind === a.NumericLiteral ? -parseFloat(n.operand.text) : void 0;
+		default: return;
+	}
+}, L = (e) => {
+	if (!e || 0 === e.length) return "";
+	let t = "";
+	for (let n = 0; n < e.length; n++) {
+		const a = e[n], r = a.kind;
+		if ("link" !== r) {
+			if ("linkName" === r) {
+				const r = e[n + 1];
+				if ("linkText" === r?.kind && r.text.trim()) continue;
+				t += a.text;
+				continue;
+			}
+			t += "linkText" !== r ? a.text : a.text.trim();
+		}
+	}
+	return t.replace(/\r\n?/g, "\n").split(/\n[^\S\n]*\n\s*/).map((e) => e.split("\n").map((e) => e.trim()).filter(Boolean).join(" ")).filter(Boolean).join("\n").trim();
+};
+function I(t, a, u, I) {
+	const E = I?.builtInNames?.length ? new Set(I.builtInNames.map((e) => e.toUpperCase())) : null, F = [], D = /* @__PURE__ */ new Map(), M = [];
+	let C = null;
+	const P = (e, t, n, a) => {
+		const { start: r, length: i } = ((e) => {
+			if (!e || "function" != typeof e.getStart) return {
+				start: 0,
+				length: 0
+			};
+			try {
+				return {
+					start: e.getStart(),
+					length: e.getWidth()
+				};
+			} catch {
+				return {
+					start: 0,
+					length: 0
+				};
+			}
+		})(e);
+		M.push({
+			start: r,
+			length: i,
+			severity: n,
+			code: t,
+			message: a
+		});
+	}, U = (e, t, n) => {
+		P(e, t, "error", n);
+	}, z = (e) => e?.parent?.name?.escapedText;
+	let O = null;
+	const j = (e, t, n, a, i = !1, o = !1, s = !1) => {
+		const l = { count: 0 }, d = Q(e, t, n, a, l, i, o, s);
+		l.count >= 2 && (t.range || (t.range = "m", l.count -= 2), !a && l.count >= 1 && (l.count -= 1, l.count > 0 && U(e, r.ArrayDepth, `Arrays of more than 2 dimensions are not supported: '${z(e)}'.`))), l.count > 0 && (t.arrayDepth = l.count);
+		const u = t.enum;
+		return u && (l.count > (s ? 1 : 0) || t.range) && !q.has(t) && (t.valueOrRange || (U(e, r.EnumPosition, `A list cannot hold the enum '${u.id}': '${t.name ?? z(e)}'. Its members reach the body as they are, so nothing checks them against the enum. Take one value per argument ('...x: ${u.id}[]'), or type the list by its scalar ('${u.type}').`), delete t.enum)), d;
+	}, V = (e, n, a, r, i) => {
+		if ("Lambda" !== n && n !== `${x}.Lambda`) return !1;
+		const o = e.typeArguments;
+		let s = "*";
+		if (o && 2 === o.length) if (i && o[0].kind === t.SyntaxKind.TupleType && (a.lambdaArity = o[0].elements.length), o[1].kind === t.SyntaxKind.AnyKeyword) s = "raw";
+		else {
+			const e = {};
+			Q(o[1], e, r, !1, { count: 0 }), s = e.scalar ?? "*";
+		}
+		else if (o && 1 === o.length && o[0].kind !== t.SyntaxKind.TupleType && o[0].kind !== t.SyntaxKind.ArrayType) if (i && (a.lambdaArity = 2), o[0].kind === t.SyntaxKind.AnyKeyword) s = "raw";
+		else {
+			const e = {};
+			Q(o[0], e, r, !1, { count: 0 }), s = e.scalar ?? "*";
+		}
+		return a.lambda = s, !0;
+	}, G = /* @__PURE__ */ new Map(), B = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map(), J = /* @__PURE__ */ new Set(), q = /* @__PURE__ */ new WeakSet(), W = (e) => void 0 !== e && e.getSourceFile() === a, X = (t, n = !1) => t.getJsDocTags(u).find((e) => "name" === e.name)?.text?.map((e) => e.text).join("").trim() || (n ? e.camelToPrettyCase(t.name) : t.name), Z = (e) => {
+		const t = e.getJsDocTags(u).find((e) => "deprecated" === e.name);
+		if (t) return t.text?.map((e) => e.text).join("").trim() || !0;
+	}, H = (e, i) => {
+		const o = t.isTypeReferenceNode(e) ? e.typeName : void 0, s = o ? u.getSymbolAtLocation(o) : void 0, l = s?.declarations?.length ? s : void 0;
+		if (o) {
+			if (l && l.flags & t.SymbolFlags.Alias) return void U(e, r.EnumNotLocal, `'${o.getText()}' is imported, so its declaration cannot be read: '${i}'. An enum must be declared in the module that uses it.`);
+			if (!(l && l.flags & t.SymbolFlags.Type)) {
+				const n = o.getText();
+				return (l ? 0 !== (l.flags & t.SymbolFlags.Variable) : a.statements.some((e) => t.isVariableStatement(e) && e.declarationList.declarations.some((e) => t.isIdentifier(e.name) && e.name.text === n))) ? void U(e, r.EnumMissingAlias, `'${n}' is a value, not a type: '${i}'. Pair the object with a same-name type — 'type ${n} = typeof ${n}[keyof typeof ${n}];' — or declare it as 'enum ${n} { … }'.`) : null;
+			}
+			const n = G.get(l);
+			if (void 0 !== n) return n;
+			if (J.has(l)) return;
+		}
+		const d = [];
+		let m = !1;
+		if (l && l.flags & t.SymbolFlags.Enum) {
+			if (!l.declarations?.some(W)) return void U(e, r.EnumNotLocal, `'${l.name}' is not declared in this module: '${i}'. An enum must be declared in the module that uses it.`);
+			m = !0;
+			let n = !1;
+			if (l.exports?.forEach((e) => {
+				const a = e.valueDeclaration;
+				if (!a || !t.isEnumMember(a)) return;
+				const i = u.getConstantValue(a);
+				if (void 0 === i) return U(a, r.EnumMemberNotConstant, `'${l.name}.${e.name}' is not a constant number or string. A formula passes the VALUE, so every member needs one that can be read at compile time.`), void (n = !0);
+				d.push([
+					X(e, !0),
+					i,
+					a,
+					L(e.getDocumentationComment(u)),
+					Z(e)
+				]);
+			}), n) return void J.add(l);
+		} else {
+			const n = u.getTypeFromTypeNode(e), a = t.TypeFlags.Null | t.TypeFlags.Undefined | t.TypeFlags.Void, r = (n.isUnion() ? n.types : [n]).filter((e) => !(e.flags & a)), i = [];
+			for (const e of r) {
+				if (!(e.flags & (t.TypeFlags.NumberLiteral | t.TypeFlags.StringLiteral))) return l && G.set(l, null), null;
+				i.push(e.value);
+			}
+			if (0 === i.length) return null;
+			const o = l?.declarations?.find((e) => t.isTypeAliasDeclaration(e)), s = t.isUnionTypeNode(e) ? e : o?.type;
+			if (s && t.isUnionTypeNode(s)) {
+				const e = s.types.map((e) => {
+					const t = u.getTypeFromTypeNode(e);
+					return t.isLiteral() ? t.value : void 0;
+				}), t = (t) => {
+					const n = e.indexOf(t);
+					return n < 0 ? e.length : n;
+				};
+				i.sort((e, n) => t(e) - t(n));
+			}
+			const c = l && l.flags & t.SymbolFlags.Variable ? l.valueDeclaration : void 0, p = new Set(i);
+			if (l && c && W(c)) for (const e of u.getTypeOfSymbolAtLocation(l, c).getProperties()) {
+				const n = e.valueDeclaration, a = u.getTypeOfSymbolAtLocation(e, n ?? c);
+				if (!(a.flags & (t.TypeFlags.NumberLiteral | t.TypeFlags.StringLiteral))) continue;
+				const r = a.value;
+				i.includes(r) && (m = !0, p.delete(r), d.push([
+					X(e, !0),
+					r,
+					n,
+					L(e.getDocumentationComment(u)),
+					Z(e)
+				]));
+			}
+			for (const e of i) p.has(e) && d.push([
+				String(e),
+				e,
+				void 0,
+				null
+			]);
+		}
+		if (0 === d.length) return null;
+		const c = "number" == typeof d[0][1];
+		if (d.some(([, e]) => "number" == typeof e !== c)) return void U(e, r.EnumMixed, `'${l?.name ?? e.getText()}' mixes number and string members: '${i}'. A parameter has one type, so an enum is all numbers or all strings.`);
+		const p = l ? X(l) : d.map(([, e]) => String(e)).join("|"), g = l ? void 0 : B.get(p);
+		if (g) return g;
+		if (m) {
+			const t = /* @__PURE__ */ new Map();
+			for (const [n, a, i, o] of d) {
+				const s = i?.name?.getText() ?? n, l = t.get(a);
+				void 0 !== l ? P(i ?? e, r.EnumDuplicateValue, "warning", `'${p}.${s}' has the same value as '${p}.${l}' (${JSON.stringify(a)}). A formula passes the value, so the two cannot be told apart.`) : t.set(a, s), "" === o && P(i ?? e, r.EnumMemberUndocumented, "warning", `'${p}.${s}' is missing a description. Add a doc comment above the member — it is what the argument dropdown shows.`);
+			}
+		}
+		const y = {
+			id: p,
+			type: c ? n.Number : n.String,
+			members: d.map(([e, t, , , n]) => n ? [
+				e,
+				t,
+				n
+			] : [e, t])
+		};
+		l ? G.set(l, y) : B.set(p, y);
+		const f = l ? L(l.getDocumentationComment(u)) : "", h = {};
+		for (const [e, , , t] of d) t && (h[e] = { description: t });
+		if (f || Object.keys(h).length > 0) {
+			const e = {};
+			f && (e.summary = f), Object.keys(h).length > 0 && (e.members = h), _.set(y, e);
+		}
+		return y;
+	}, Q = (e, a, i, s, u, b = !1, T = !1, w = !1) => {
+		if (e) {
+			if (e.kind === t.SyntaxKind.ParenthesizedType) return Q(e.type, a, i, s, u, b, T, w);
+			if (e.kind === t.SyntaxKind.UnionType) {
+				const n = (e) => e.kind === t.SyntaxKind.UndefinedKeyword || e.kind === t.SyntaxKind.VoidKeyword || e.kind === t.SyntaxKind.NullKeyword || e.kind === t.SyntaxKind.LiteralType && e.literal?.kind === t.SyntaxKind.NullKeyword, l = e.types.filter((e) => !n(e));
+				if (1 === l.length) return Q(l[0], a, i, s, u, b, T, w);
+				const d = H(e, a.name ?? z(e));
+				if (void 0 === d) return;
+				if (null !== d) return a.scalar = d.type, void (s && (a.enum = d));
+				if (!s) return void (a.scalar = "*");
+				if (2 === l.length) {
+					const e = (e) => e.kind === t.SyntaxKind.TypeReference && t.isTypeReferenceNode(e) && "Lambda" === S(e), n = l.findIndex(e);
+					if (n >= 0 && !e(l[1 - n])) return Q(l[1 - n], a, i, s, u, b, T, w), void V(l[n], S(l[n]), a, i, s);
+				}
+				if (s && 2 === l.length) {
+					const e = (e) => {
+						if (e.kind === t.SyntaxKind.TypeReference && !e.typeArguments?.length) return o.get(S(e));
+					}, n = l.findIndex((t) => void 0 !== e(t));
+					if (n >= 0 && void 0 === e(l[1 - n])) {
+						const t = {}, r = u.count;
+						if (Q(l[1 - n], t, i, s, u, b, !1), t.scalar && !t.range && null == t.lambda && u.count === r) {
+							a.range = e(l[n]), a.scalar = t.scalar, a.valueOrRange = !0;
+							const r = t.enum;
+							r && (a.enum = r);
+							return;
+						}
+					}
+				}
+				if (s && 2 === l.length) {
+					const n = (e) => e.kind === t.SyntaxKind.TypeReference && !e.typeArguments?.length && "Scalar" === S(e), r = l.findIndex(n);
+					if (r >= 0 && !n(l[1 - r])) {
+						const t = H(l[1 - r], a.name ?? z(e));
+						if (void 0 === t) return;
+						if (null !== t) return a.scalar = "*", void (a.enum = t);
+					}
+				}
+				U(e, r.InvalidParamType, `Union parameter types are not supported: '${z(e)}'. Use a single type, optionally with '| null' or '| undefined', 'T | Lambda<…>' for a value-or-lambda slot, 'IRange | Scalar' for a value-or-range slot, or 'E | Scalar' for an uncoerced slot whose values an enum documents.`);
+				return;
+			}
+			if (e.kind === t.SyntaxKind.NumberKeyword) a.scalar = n.Number;
+			else if (e.kind === t.SyntaxKind.StringKeyword) a.scalar = n.String;
+			else if (e.kind === t.SyntaxKind.BooleanKeyword) a.scalar = n.Boolean;
+			else if (e.kind === t.SyntaxKind.UndefinedKeyword || e.kind === t.SyntaxKind.NullKeyword || e.kind === t.SyntaxKind.VoidKeyword) {
+				if (s) return void U(e, r.UndefinedInput, `'undefined' is not a valid type for input: '${z(e)}'.`);
+				a.scalar = n.Null;
+			} else if (e.kind === t.SyntaxKind.BigIntKeyword) a.scalar = n.Number;
+			else if (e.kind === t.SyntaxKind.AnyKeyword) s && (a.range = "*");
+			else if (e.kind === t.SyntaxKind.ArrayType) {
+				const t = e.elementType;
+				if (!t) return void U(e, r.UntypedArray, `'Array' must be typed: '${z(e)}'.`);
+				if (s && T) {
+					const n = a, r = n.name ?? z(e) ?? "parameter", o = n.acceptError;
+					delete n.acceptError;
+					const s = { name: r };
+					j(t, s, i, !0), o && !s.acceptError && (s.acceptError = !0), n.repeating = [s];
+					return;
+				}
+				u.count++, Q(t, a, i, s, u);
+			} else if (e.kind !== t.SyntaxKind.TupleType) if (e.kind === t.SyntaxKind.TypeReference) {
+				const n = S(e);
+				if (g.has(n)) {
+					const t = z(e);
+					if (!s) return void U(e, r.InvalidReturnType, `'${n}' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					const o = a;
+					if (o.acceptError) return void U(e, r.InvalidParamType, `'${t}' declares 'AcceptError' more than once.`);
+					const l = e.typeArguments;
+					return l && 1 === l.length ? (o.acceptError = !0, Q(l[0], a, i, s, u, b, T, w)) : void U(e, r.GenericArity, `'${n}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if ($.has(n)) {
+					const t = a.name ?? z(e);
+					if (!s) return void U(e, r.InvalidReturnType, `'ReportType' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					const o = e.typeArguments;
+					return o && 1 === o.length ? (a.reportType = !0, Q(o[0], a, i, s, u, b, T, w)) : void U(e, r.GenericArity, `'${n}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if (f.has(n)) {
+					const t = a.name ?? z(e);
+					if (!s) return void U(e, r.InvalidReturnType, `'NoLift' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					const o = e.typeArguments;
+					if (!o || 1 !== o.length) return void U(e, r.GenericArity, `'${n}' must be typed with exactly 1 type: '${t}'.`);
+					const l = a;
+					l.noLift = !0;
+					const d = u.count;
+					Q(o[0], a, i, s, u, b, T, w), (l.range || null != l.lambda || l.repeating || u.count !== d) && U(e, r.InvalidParamType, `'${t}': 'NoLift' applies to a SCALAR parameter only - a range, list, repeating or lambda slot never lifts.`);
+					return;
+				}
+				if (h.has(n)) {
+					const t = a.name ?? z(e);
+					if (!s) return void U(e, r.InvalidReturnType, `'NoFilter' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					const o = e.typeArguments;
+					if (!o || 1 !== o.length) return void U(e, r.GenericArity, `'${n}' must be typed with exactly 1 type: '${t}'.`);
+					const l = a;
+					l.noFilter = !0;
+					const d = u.count;
+					if (Q(o[0], a, i, s, u, b, T, w), l.range || null != l.lambda || u.count !== d) return void U(e, r.InvalidParamType, `'${t}': 'NoFilter' applies to a SCALAR slot only - a range, list or lambda slot has no members to coerce.`);
+					const m = l.repeating;
+					if (m) {
+						if (delete l.noFilter, 1 !== m.length) return void U(e, r.InvalidParamType, `'${t}': 'NoFilter' over a repeating group applies to a period-1 group only - write it on the slot that takes the members.`);
+						m[0].noFilter = !0;
+					} else T && U(e, r.InvalidParamType, `'${t}': 'NoFilter' applies to a REPEATING slot only - a single scalar argument has no members to coerce.`);
+					return;
+				}
+				if (y.has(n)) {
+					const o = a.name ?? z(e);
+					if (!s) return void U(e, r.InvalidReturnType, `'Omittable' is not a valid return type: '${o}'. It describes how an ARGUMENT is received.`);
+					const l = e.typeArguments;
+					if (!l || l.length < 1 || l.length > 2) return void U(e, r.GenericArity, `'${n}' must be typed with 1 or 2 types: '${o}'.`);
+					const d = a;
+					if (d.omittable = !0, 2 === l.length) {
+						const a = K(t, l[1]);
+						if (void 0 === a) return void U(e, r.InvalidParamType, `'${o}' declares '${n}' with a second type that is not a literal value. Use a number, string, boolean or null - the engine substitutes it for an omitted argument.`);
+						d.omittedValue = a;
+					}
+					const m = Q(l[0], a, i, s, u, b, T, w), c = d.omittedValue;
+					return d.enum && null != c && !d.enum.members.some(([, e]) => e === c) && U(l[1], r.EnumOmittedValue, `'${o}': ${JSON.stringify(c)} is not a member of '${d.enum.id}'. An omitted argument must mean a member (${d.enum.members.map(([, e]) => JSON.stringify(e)).join(", ")}) or null.`), m;
+				}
+				if (v.has(n)) {
+					const o = a.name ?? z(e);
+					if (!s) return void U(e, r.InvalidReturnType, `'Lazy' is not a valid return type: '${o}'. It describes how an ARGUMENT is received.`);
+					const l = a;
+					if (l.lazy) return void U(e, r.InvalidParamType, `'${o}' declares 'Lazy' more than once.`);
+					const d = e.typeArguments;
+					if (!d || d.length < 1 || d.length > 2) return void U(e, r.GenericArity, `'${n}' must be typed with 1 or 2 types: '${o}'.`);
+					if (l.lazy = !0, 2 === d.length) {
+						const a = K(t, d[1]);
+						if (void 0 === a) return void U(e, r.InvalidParamType, `'${o}' declares '${n}' with a second type that is not a literal value. Use a number, string, boolean or null - the engine substitutes it for an absent argument.`);
+						l.optional = !0, l.defaultValue = a;
+					}
+					Q(d[0], a, i, s, u, b, T, w), l.enum ? (U(e, r.EnumPosition, `'${o}': 'Lazy' cannot hold the enum '${l.enum.id}'. The argument may never be evaluated, so there is no point at which it could be checked against the members.`), delete l.enum) : null != l.lambda ? U(e, r.InvalidParamType, `'${o}': 'Lazy' cannot be combined with a Lambda parameter - a callable slot is already the body's to call, or not.`) : l.repeating && U(e, r.InvalidParamType, `'${o}': 'Lazy' applies to a VALUE, not to a repeating group - mark the group's slots instead.`);
+					return;
+				}
+				if (p.has(n)) {
+					const t = a.name ?? z(e);
+					if (!s) return void U(e, r.InvalidReturnType, `'Flatten' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					const o = e.typeArguments;
+					return o && 1 === o.length ? (u.count++, Q(o[0], a, i, s, u, b)) : void U(e, r.GenericArity, `'${n}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if ("repeating" === c.get(n)) {
+					const o = a.name ?? z(e);
+					if (!s) return void U(e, r.RepeatingPosition, `'Repeating' is not a valid return type: '${o}'.`);
+					if (0 !== u.count) return void U(e, r.RepeatingPosition, `'Repeating' cannot be nested inside another type: '${o}'.`);
+					const l = a, d = e.typeArguments;
+					if (!d || d.length < 1 || d.length > 2) return void U(e, r.GenericArity, `'${n}' must be typed with 1 type, optionally followed by a maximum argument count: '${o}'.`);
+					let m;
+					if (2 === d.length) {
+						const e = d[1], a = e.kind === t.SyntaxKind.LiteralType ? e.literal : null, s = a && a.kind === t.SyntaxKind.NumericLiteral ? Number(a.text) : NaN;
+						if (!Number.isInteger(s) || s < 1 || s > 255) return void U(e, r.RepeatingMax, `'${o}': '${n}'’s maximum must be a whole number between 1 and 255.`);
+						m = s, i.maxArguments = s;
+					}
+					if (w) return void 0 === m ? void U(e, r.RepeatingPosition, `'${o}' is a rest parameter and a repeating group. A group already repeats — drop the '...', or give the group a maximum ('Repeating<T, 254>') if the ceiling is all you meant.`) : Q(d[0], a, i, s, u, b, T);
+					const c = l.acceptError;
+					delete l.acceptError;
+					const p = ((e, n, a, i) => {
+						const o = (e, t, n) => {
+							const r = { name: e };
+							return j(t, r, a, !0), n && (r.optional = !0), i && !r.acceptError && (r.acceptError = !0), r;
+						};
+						if (e.kind !== t.SyntaxKind.TupleType) return [o(n, e, !1)];
+						const s = e.elements;
+						if (s.length < 2) return U(e, r.RepeatingSlots, `'${n}': a repeating group of period ${s.length} must be spelled 'Repeating<T>' without the tuple.`), null;
+						const l = [];
+						for (let e = 0; e < s.length; e++) {
+							const a = s[e];
+							if (a.kind !== t.SyntaxKind.NamedTupleMember) return U(a, r.RepeatingSlots, `'${n}': every slot of a repeating group must be labelled, e.g. 'Repeating<[criteriaRange: IRange, criteria: Scalar]>'.`), null;
+							const i = !!a.questionToken;
+							if (i && e !== s.length - 1) return U(a, r.RepeatingOptional, `'${n}': only the LAST slot of a repeating group may be optional (slot '${a.name?.getText?.()}' is not).`), null;
+							l.push(o(a.name?.getText?.() ?? `${e}`, a.type, i));
+						}
+						return l;
+					})(d[0], o ?? "parameter", i, c);
+					p && (l.repeating = p);
+					return;
+				}
+				const R = o.get(n);
+				let L = !1;
+				R && (a.range = R, L = !0);
+				const I = m.get(n);
+				if (I && (a.scalar = I), void 0 !== I && (L = !0), V(e, n, a, i, s)) return;
+				if (s) {
+					if ("Volatile" === n || n === `${x}.Volatile`) return void U(e, r.InvalidParamType, `'Volatile' is not a valid parameter type: '${z(e)}'. It describes the function's RESULT, so it belongs on the return type.`);
+					if (N.has(n)) return A;
+					const t = l.get(n);
+					if (t) return t;
+				} else if ("Promise" === n) O = e, L = !0;
+				else {
+					const e = k.get(n);
+					e && (Object.assign(a, e()), L = !0);
+				}
+				if (!L) {
+					const t = H(e, a.name ?? z(e));
+					if (void 0 === t) return;
+					if (null !== t) return a.scalar = t.type, void (s && (a.enum = t));
+				}
+				if (!L) {
+					const t = "number, string, boolean, Scalar, Lambda, Date, FormulaError.Known, IRichData, IRange, IReferenceRange (and arrays of these; optionally wrapped in AcceptError<T>, or grouped with Repeating<T>)", a = "number, string, boolean, Scalar, Date, FormulaError.Known, IRichData, IRange, Volatile<T> (and arrays of these)";
+					let i;
+					i = s ? b ? `'${n}' is not a valid first parameter: '${z(e)}'. The first parameter is EITHER a macro target (making this a macro) OR a calculation input (making this a calculation function). Allowed: ${d.join(", ")} (macro target); ${t} (calculation input).` : `'${n}' is not a valid parameter type: '${z(e)}'. Allowed: ${t}.` : `'${n}' is not a valid return type: '${z(e)}'. Allowed: ${a}.`, U(e, s ? r.InvalidParamType : r.InvalidReturnType, i);
+					return;
+				}
+				const E = e.typeArguments;
+				if (E) {
+					if (1 !== E.length) return void U(e, r.GenericArity, `'${n}' must be typed with exactly 1 type: '${z(e)}'.`);
+					const o = E[0], l = s && t.isTypeReferenceNode(o) && $.has(S(o)), d = a.reportType;
+					l && q.add(a), j(o, a, i, s), l && void 0 === d && delete a.reportType;
+					const u = a.enum;
+					u && !l && (U(E[0], r.EnumPosition, `'${n}' cannot hold the enum '${u.id}': '${z(e)}'. The members of a range reach the body as they are, so nothing checks them against the enum. Take the enum as a value, or type the range by its scalar ('${n}<${u.type}>').`), delete a.enum);
+				}
+			} else e.kind === t.SyntaxKind.FunctionType && ((e, n, a, i) => {
+				if (!i) return void U(e, r.FunctionReturn, `Function type is not a valid return type: '${z(e)}'. Declare a 'Lambda' return instead.`);
+				const o = e.type, s = {};
+				let l = "*";
+				o && (o.kind === t.SyntaxKind.AnyKeyword ? l = "raw" : (Q(o, s, a, !1, { count: 0 }), l = s.scalar ?? "*"));
+				const d = e.parameters;
+				d && !d.some((e) => e.dotDotDotToken) && (n.lambdaArity = d.length), n.lambda = l;
+			})(e, a, i, s);
+		} else U(e, r.MissingType, `Type is not defined for '${a?.name ?? "return"}'.`);
+	};
+	try {
+		t.forEachChild(a, (e) => {
+			if (a = e, 0 !== (t.getCombinedModifierFlags(a) & t.ModifierFlags.Export) && t.isFunctionDeclaration(e)) {
+				const a = e?.name?.getText();
+				if (!e.body) return void U(e, r.NoBody, `'${a}': function has no body.`);
+				if (!a) return void U(e, r.Anonymous, "Anonymous exported functions are not allowed.");
+				const o = {}, l = { parameters: {} };
+				try {
+					o.name = a;
+					const d = L(u.getSymbolAtLocation(e.name)?.getDocumentationComment(u));
+					d && (l.summary = d);
+					const m = {};
+					O = null, j(e.type, m, o, !1), o.returnType = m;
+					const c = {};
+					n = e, 0 !== (t.getCombinedModifierFlags(n) & t.ModifierFlags.Default) && (c.default = !0, C = a), o.parameters = [];
+					const p = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Set();
+					let f = null, h = null, v = null, $ = 0, x = !1, S = 0;
+					for (let n = 0; n < e.parameters.length; n++) {
+						const a = e.parameters[n], i = {};
+						i.name = a.name?.getText();
+						const s = 0 === o.parameters.length;
+						if (I?.lenient && 0 === n && !a.type && c.default) {
+							o.context = R;
+							continue;
+						}
+						const d = j(a.type, i, o, !0, s, !a.dotDotDotToken, !!a.dotDotDotToken);
+						if (d === A) {
+							0 === n && void 0 === o.context && (o.context = R);
+							continue;
+						}
+						if (d) {
+							if (0 !== o.parameters.length) return void U(a, r.ContextNotFirst, `'${o.name}' contexts must be the first parameter: '${i.name}'.`);
+							o.context = d;
+							continue;
+						}
+						if (void 0 !== i.lambda) {
+							if (null !== f) return void U(a, r.MultipleLambda, `'${o.name}' has more than one Lambda parameter ('${f}' and '${i.name}'). Only one Lambda parameter is allowed.`);
+							f = i.name;
+						} else if (null !== f) return void U(a, r.LambdaNotLast, `'${o.name}' Lambda parameter ('${f}') must be the last parameter, but '${i.name}' follows it.`);
+						const m = !0 === i.optional || void 0 !== a.initializer && null !== a.initializer || void 0 !== a.questionToken && null !== a.questionToken;
+						let b;
+						if (m && (i.optional = !0, a.initializer)) try {
+							if (a.initializer.kind === t.SyntaxKind.StringLiteral) b = a.initializer.text;
+							else if (a.initializer.kind === t.SyntaxKind.NumericLiteral) b = parseFloat(a.initializer.text);
+							else if (a.initializer.kind === t.SyntaxKind.TrueKeyword || a.initializer.kind === t.SyntaxKind.FalseKeyword) b = a.initializer.kind === t.SyntaxKind.TrueKeyword;
+							else if (a.initializer.kind === t.SyntaxKind.NullKeyword) b = null;
+							else if (t.isPrefixUnaryExpression(a.initializer) && a.initializer.operator === t.SyntaxKind.MinusToken && a.initializer.operand.kind === t.SyntaxKind.NumericLiteral) b = -parseFloat(a.initializer.operand.text);
+							else if (t.isPropertyAccessExpression(a.initializer) || t.isElementAccessExpression(a.initializer)) {
+								const e = u.getTypeAtLocation(a.initializer);
+								e.flags & (t.TypeFlags.NumberLiteral | t.TypeFlags.StringLiteral) && (b = e.value);
+							}
+						} catch (e) {
+							console.warn(`Couldn't extract default value for parameter '${i.name}'`, e);
+						}
+						a.dotDotDotToken && (i.rest = !0);
+						const T = i.repeating;
+						if (T) {
+							if (i.rest) return void U(a, r.RepeatingPosition, `'${o.name}' parameter '${i.name}' is both a rest parameter and a repeating group. A group already repeats — drop the '...'.`);
+							if (m && 1 === T.length) return void U(a, r.RepeatingOptional, `'${o.name}' parameter '${i.name}' cannot be an optional repeating group. Use '...${i.name}: T[]' for zero-or-more, or drop the '?' for one-or-more.`);
+							if (null !== h) return void U(a, r.MultipleRepeating, `'${o.name}' has more than one repeating group ('${h}' and '${i.name}'). Only one is allowed — two would make the argument count ambiguous.`);
+							if (null !== v) return void U(a, r.RepeatingOptional, `'${o.name}' parameter '${v}' is optional and precedes the repeating group '${i.name}'. Every parameter outside a group must be required.`);
+							h = i.name, $ = T.length, x = !0 === T[T.length - 1].optional;
+						} else {
+							if (null !== h && i.rest) return void U(a, r.RepeatingOptional, `'${o.name}' parameter '${i.name}' is a rest parameter and follows the repeating group '${h}'. Two variadic tails would make the argument count ambiguous.`);
+							if (null !== h && m) {
+								if (S >= $ - 1) return void U(a, r.RepeatingOptional, 1 === $ ? `'${o.name}' parameter '${i.name}' is optional and follows the period-1 repeating group '${h}'. One more argument is indistinguishable from one more repetition — make it required, or give the group a period.` : `'${o.name}' has ${S + 1} optional parameters after the repeating group '${h}', which has period ${$}. At most ${$ - 1} may be optional, or the argument count no longer decides the parse.`);
+								if (x) return void U(a, r.RepeatingOptional, `'${o.name}' parameter '${i.name}' is optional and follows '${h}', whose own last slot is already optional. Both omissions reach the same argument count — drop one.`);
+								S++;
+							}
+						}
+						m && !T && (v = i.name);
+						const w = (i.range ? 2 : 0) + (i.arrayDepth ?? 0), k = "r" === i.range || "p" === i.range || "*" === i.range, N = i.rest || k ? 3 : 2;
+						if (w > N) return void U(a, r.ArrayDepth, `'${o.name}' parameter '${i.name}' has an array depth of ${w}; the maximum is ${N}${i.rest ? " for a rest parameter" : " (use a rest parameter for one more level, or an IRange)"}.`);
+						o.parameters.push(i);
+						const K = { description: "" };
+						l.parameters[i.name] = K, K.description = L(u.getSymbolAtLocation(a.name)?.getDocumentationComment(u)), void 0 !== b && (i.defaultValue = b);
+						for (const e of [i, ...i.repeating ?? []]) {
+							const t = e.enum ? _.get(e.enum) : void 0;
+							t && ((l.enums ??= {})[e.enum.id] = t);
+						}
+						if (p.set(i.name, i), g.set(i.name, a), T && T.length > 1) {
+							y.add(i.name);
+							for (const e of T) {
+								const t = `${i.name}.${e.name}`;
+								l.parameters[t] = { description: "" }, p.set(t, e), g.set(t, a);
+							}
+						}
+					}
+					const k = o.maxArguments;
+					if (void 0 !== k) {
+						const t = o.parameters ?? [];
+						if (!t.some((e) => !0 === e.rest || void 0 !== e.repeating)) return void U(e, r.RepeatingMax, `'${o.name}' declares a maximum of ${k} arguments but takes a fixed ${t.length}. A maximum only means something on a variadic tail.`);
+						let n = 0;
+						for (const e of t) !0 !== e.rest && !0 !== e.optional && (n += e.repeating ? e.repeating.length : 1);
+						if (k < n) return void U(e, r.RepeatingMax, `'${o.name}' declares a maximum of ${k} arguments but requires ${n}.`);
+					}
+					if (e.jsDoc && e.jsDoc.length > 0) {
+						const t = e.jsDoc, n = t.length;
+						for (let e = 0; e < n; e++) {
+							const n = t[e]?.tags;
+							if (!n) continue;
+							const d = n.length;
+							for (let e = 0; e < d; e++) {
+								const t = n[e];
+								let d = t?.tagName?.text;
+								if (!d) continue;
+								d = d.toLowerCase();
+								let u = t.comment;
+								const m = i(d);
+								if ("string" == typeof u || m) {
+									if ("string" == typeof u && (u = u.replace(/\r\n?/g, "\n").trim()), m || !u || (u = u.split("\n")[0].trim(), u && 0 !== u.length)) {
+										if (u && "string" == typeof u) {
+											const e = /\{@link(code|plain)?\s+([^}|]+)(?:\s*\|\s*([^}]+))?\}/g;
+											let t, n = u, a = [];
+											for (; null !== (t = e.exec(u));) {
+												const [e, n, a, r] = t, i = [a.trim()];
+												r && i.push(r.trim());
+											}
+											u = n, a.length > 0 && "see" === d && (l.links || (l.links = []), l.links.push(...a));
+										}
+										if ("name" === d) {
+											const e = u;
+											e !== a && (l.name = e);
+										} else if ("description" !== d) {
+											if ("param" === d) {
+												const e = t.name?.getText?.() ?? t.name?.text;
+												if (!p.get(e)) {
+													U(t, r.UnknownParam, `Parameter '${e}' not found in function '${a}'.`);
+													continue;
+												}
+												const n = l.parameters?.[e];
+												n && !n.description && "string" == typeof u && u && (n.description = u);
+											} else if ("returns" === d || "return" === d) o.returnType.description = u;
+											else if ("returnkind" === d) {
+												const e = (u ?? "").trim().toLowerCase();
+												s.has(e) ? o.returnType.kind = e : U(t, r.UnknownReturnKind, `'@returnKind ${e}' is not a known value kind. Known: ${[...s].map((e) => `'${e}'`).join(", ")}.`);
+											} else if ("category" === d) l.category = u;
+											else if ("deprecated" === d || "hidden" === d) {
+												let e = !0;
+												const t = u?.toLowerCase();
+												"false" === t ? e = !1 : "true" !== t && (e = u), !1 !== e && (l.deprecated = e ?? !0, o.hidden = !0);
+											}
+										}
+									}
+								} else "returnkind" === d && U(t, r.UnknownReturnKind, `'@returnKind' needs a value kind. Known: ${[...s].map((e) => `'${e}'`).join(", ")}.`);
+							}
+						}
+					}
+					if (!o.context && O) return void U(O, r.InvalidReturnType, `'${a}': Promise<T> is not a valid return type for a calculation function. Return the value the cell shows now, and call FormulaContext.defer(executor, payload) to deliver the result later.`);
+					0 === Object.keys(o.returnType).length && delete o.returnType, Object.keys(c).length > 0 && (o.behavior = c), l.summary || P(e.name ?? e, r.MissingSummary, "warning", `'${a}': missing a description. Add a JSDoc comment above the function.`);
+					const N = !o.context, K = N && l.name || a;
+					if (N && !b.test(K)) {
+						const t = l.name ? `'@name ${l.name}'` : `'${K}'`;
+						U(e.name ?? e, r.InvalidName, `'${a}': ${t} cannot be called from a formula. A function name starts with a letter or '_', and continues with letters, digits, '_' or '.'.` + (l.name ? "" : " Add an '@name' tag to register it under another name."));
+						return;
+					}
+					if (N && !I?.isBuiltIn && ((e) => {
+						if (w.test(e)) return !0;
+						const t = T.exec(e);
+						if (!t) return !1;
+						let n = 0;
+						for (const e of t[1].toUpperCase()) n = 26 * n + (e.charCodeAt(0) - 64);
+						const a = Number(t[2]);
+						return n <= 16384 && a >= 1 && a <= 1048576;
+					})(K)) {
+						const t = l.name ? `'@name ${l.name}'` : `'${K}'`;
+						U(e.name ?? e, r.InvalidName, `'${a}': ${t} cannot be called from a formula. It reads as a cell address.` + (l.name ? "" : " Add an '@name' tag to register it under another name."));
+						return;
+					}
+					const M = D.get(K.toUpperCase());
+					if (void 0 !== M) return void U(e.name ?? e, r.DuplicateName, `'${a}': '${K}' is already the name of '${M}' in this module.`);
+					if (D.set(K.toUpperCase(), a), N && E?.has(K.toUpperCase())) return void U(e.name ?? e, r.BuiltInName, `'${K}' is a built-in function. Choose a different name - a calculation function cannot replace a built-in.`);
+					if (N) {
+						const e = l.parameters ?? {};
+						for (const [t, n] of Object.entries(e)) if (!y.has(t) && !n.description) {
+							const e = g.get(t);
+							P(e, r.MissingParamDescription, "warning", `'${a}': parameter '${t}' is missing a description. Add an '@param ${t}' tag.`);
+						}
+					}
+					F.push([o, l]);
+				} catch (t) {
+					U(e, r.ParseError, `'${a}': ${t.message}`);
+				}
+			}
+			var n, a;
+		});
+	} catch (e) {
+		U(void 0, r.ParseError, `Unable to analyze module: ${e?.message ?? e}`);
+	}
+	return {
+		functions: F,
+		autoRun: C,
+		diagnostics: M
+	};
+}
+function E(e, t, n) {
+	const a = "script.ts", r = "lib.d.ts", i = {
+		[a]: t ?? "",
+		[r]: ""
+	}, o = e.createProgram([a], {
+		allowJs: !0,
+		noResolve: !0,
+		noLib: !0,
+		isolatedModules: !0,
+		module: 99,
+		target: e.ScriptTarget.ES2020
+	}, {
+		getSourceFile: (t) => {
+			const n = i[t];
+			if (void 0 !== n) return e.createSourceFile(t, n, e.ScriptTarget.Latest, !0);
+		},
+		fileExists: (e) => void 0 !== i[e],
+		readFile: (e) => i[e],
+		writeFile: () => {},
+		getCurrentDirectory: () => "./",
+		getCanonicalFileName: (e) => e,
+		useCaseSensitiveFileNames: () => !0,
+		getDefaultLibFileName: () => r,
+		getNewLine: () => "\n"
+	}), s = o.getTypeChecker(), l = o.getSourceFile(a);
+	return l ? I(e, l, s, n).diagnostics : [];
+}
+export { I as n, E as t };