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

package/browser/esm/DZLyXICwEHYRnCuO.mjs

@@ -0,0 +1,758 @@
+/**
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.2
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { R as e } from "./DuijhgjRhgWB9sCY.mjs";
+import { c as t, o as n, t as r } from "./B50P0gSziuG68Umu.mjs";
+var i = Object.freeze({
+	NoBody: "SXL1001",
+	Anonymous: "SXL1002",
+	ParseError: "SXL1003",
+	InvalidParamType: "SXL2001",
+	InvalidReturnType: "SXL2002",
+	UndefinedInput: "SXL2003",
+	MissingType: "SXL2004",
+	UntypedArray: "SXL2005",
+	GenericArity: "SXL2006",
+	MultipleModifiers: "SXL2007",
+	ContextNotFirst: "SXL2010",
+	MultipleLambda: "SXL2020",
+	LambdaNotLast: "SXL2021",
+	LambdaScalarMismatch: "SXL2022",
+	LambdaReturn: "SXL2023",
+	FunctionReturn: "SXL2024",
+	LambdaArity: "SXL2025",
+	ArrayDepth: "SXL2030",
+	RepeatingPosition: "SXL2040",
+	MultipleRepeating: "SXL2041",
+	RepeatingSlots: "SXL2042",
+	RepeatingOptional: "SXL2043",
+	RepeatingMax: "SXL2044",
+	EnumMixed: "SXL2050",
+	EnumMemberNotConstant: "SXL2051",
+	EnumNotLocal: "SXL2052",
+	EnumMissingAlias: "SXL2053",
+	EnumPosition: "SXL2054",
+	EnumOmittedValue: "SXL2055",
+	NoExports: "SXL3001",
+	UnknownParam: "SXL3002",
+	BuiltInName: "SXL3003",
+	UnknownReturnKind: "SXL3005",
+	InvalidName: "SXL3006",
+	DuplicateName: "SXL3007",
+	MissingSummary: "SXL9001",
+	MissingParamDescription: "SXL9002",
+	MissingReturns: "SXL9003",
+	EnumDuplicateValue: "SXL9004",
+	EnumMemberUndocumented: "SXL9005"
+}), a = [
+	{
+		name: "param",
+		group: "jsdoc",
+		description: "Document a parameter. A string union type becomes a dropdown of allowed options.",
+		snippet: "param ${1:name} ${2:description}"
+	},
+	{
+		name: "returns",
+		aliases: ["return"],
+		group: "jsdoc",
+		description: "Describe the return value."
+	},
+	{
+		name: "category",
+		group: "sheetxl",
+		description: "Group the function under a category in the function list.",
+		snippet: "category ${1:name}"
+	},
+	{
+		name: "name",
+		group: "sheetxl",
+		description: "A name an identifier cannot spell: the name formulas call a function by (MY.FUNC), or an enum member's label.",
+		snippet: "name ${1:NAME}"
+	},
+	{
+		name: "description",
+		group: "sheetxl",
+		description: "A longer description of the function."
+	},
+	{
+		name: "deprecated",
+		group: "sheetxl",
+		standalone: !0,
+		description: "Mark the function as deprecated (optionally with a reason)."
+	},
+	{
+		name: "hidden",
+		group: "sheetxl",
+		standalone: !0,
+		description: "Hide the function from the function list."
+	},
+	{
+		name: "returnkind",
+		group: "sheetxl",
+		description: "Declare the value kind of the return (a ValueKind word, e.g. `number`, `array`, `reference`) where the type spelling cannot say it (a union return collapses to any).",
+		snippet: "returnKind ${1:number}"
+	},
+	{
+		name: "example",
+		group: "jsdoc",
+		description: "Provide a usage example."
+	},
+	{
+		name: "see",
+		group: "jsdoc",
+		description: "Reference a related function or link."
+	}
+], o = (() => {
+	let e = /* @__PURE__ */ new Map();
+	for (let t of a) if (e.set(t.name, t), t.aliases) for (let n of t.aliases) e.set(n, t);
+	return e;
+})();
+function s(e) {
+	return !0 === function(e) {
+		if (!e) return;
+		let t = (e.startsWith("@") ? e.slice(1) : e).toLowerCase();
+		return o.get(t);
+	}(e)?.standalone;
+}
+var c = /* @__PURE__ */ new Map([["IReferenceRange", "p"], ["IRange", "r"]]), l = new Set(Object.values(t).filter((e) => e !== t.Omitted)), u = /* @__PURE__ */ new Map([
+	["IWorkbook", "workbook"],
+	["ISheet", "sheet"],
+	["ICellRanges", "ranges"],
+	["ICellRange", "range"]
+]), d = Array.from(u.keys()), f = (e, t) => {
+	Array.from(t.keys()).forEach((n) => {
+		let r = t.get(n);
+		t.set(`${e}.${n}`, r);
+	});
+}, p = /* @__PURE__ */ new Map([
+	["Scalar", "*"],
+	["Lambda", "l"],
+	["FormulaError.Known", r.Error],
+	["Date", n.Date],
+	["IRichData", n.RichData]
+]), m = /* @__PURE__ */ new Map([["Repeating", "repeating"]]), h = /* @__PURE__ */ new Set(["Flatten", "SheetXL.Flatten"]), g = /* @__PURE__ */ new Set(["AcceptError"]), _ = /* @__PURE__ */ new Set(["Omittable"]), v = /* @__PURE__ */ new Set(["NoLift"]), y = /* @__PURE__ */ new Set(["NoFilter"]), b = /* @__PURE__ */ new Set(["Lazy"]), x = /* @__PURE__ */ new Set(["ReportType"]), S = /^[a-zA-Z_-￿][a-zA-Z0-9_.-￿]*$/, C = /^([a-z]{1,3})([0-9]+)$/i, w = /^r[0-9]*c[0-9]*$/i, T = "SheetXL", E = (e) => {
+	let t = e.typeName.getText();
+	return t.startsWith(`${T}.`) ? t.slice(8) : t;
+};
+f(T, c), f(T, u), f(T, m), g.add(T + ".AcceptError"), _.add(`${T}.Omittable`), v.add(`${T}.NoLift`), y.add(`${T}.NoFilter`), b.add(`${T}.Lazy`), x.add(`${T}.ReportType`);
+var D = /* @__PURE__ */ new Map([
+	["Promise", () => ({ async: !0 })],
+	["Observable", () => ({ stream: !0 })],
+	["Volatile", () => ({ volatile: !0 })],
+	[`${T}.Volatile`, () => ({ volatile: !0 })]
+]), O = "__scriptContext__", k = "script", A = /* @__PURE__ */ new Set([
+	"IScript.ScriptContext",
+	`${T}.IScript.ScriptContext`,
+	"ScriptContext"
+]), j = (e, t) => {
+	let n = t.literal;
+	if (n === void 0) return;
+	let r = e.SyntaxKind;
+	switch (n.kind) {
+		case r.StringLiteral: return n.text;
+		case r.NumericLiteral: return parseFloat(n.text);
+		case r.TrueKeyword: return !0;
+		case r.FalseKeyword: return !1;
+		case r.NullKeyword: return null;
+		case r.PrefixUnaryExpression: return n.operator === r.MinusToken && n.operand?.kind === r.NumericLiteral ? -parseFloat(n.operand.text) : void 0;
+		default: return;
+	}
+}, M = (e) => {
+	if (!e || e.length === 0) return "";
+	let t = "";
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n], i = r.kind;
+		if (i !== "link") {
+			if (i === "linkName") {
+				let i = e[n + 1];
+				if (i?.kind === "linkText" && i.text.trim()) continue;
+				t += r.text;
+				continue;
+			}
+			t += i === "linkText" ? r.text.trim() : r.text;
+		}
+	}
+	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 N(t, n, a, o) {
+	let f = o?.builtInNames?.length ? new Set(o.builtInNames.map((e) => e.toUpperCase())) : null, N = [], P = /* @__PURE__ */ new Map(), F = [], I = null, L = (e, t, n, r) => {
+		let { start: i, length: a } = ((e) => {
+			if (!e || typeof e.getStart != "function") return {
+				start: 0,
+				length: 0
+			};
+			try {
+				return {
+					start: e.getStart(),
+					length: e.getWidth()
+				};
+			} catch {
+				return {
+					start: 0,
+					length: 0
+				};
+			}
+		})(e);
+		F.push({
+			start: i,
+			length: a,
+			severity: n,
+			code: t,
+			message: r
+		});
+	}, R = (e, t, n) => {
+		L(e, t, "error", n);
+	}, z = (e) => e?.parent?.name?.escapedText, B = (e, t, n, r, a = !1, o = !1, s = !1) => {
+		let c = { count: 0 }, l = Z(e, t, n, r, c, a, o, s);
+		c.count >= 2 && (t.range || (t.range = "m", c.count -= 2), !r && c.count >= 1 && (--c.count, c.count > 0 && R(e, i.ArrayDepth, `Arrays of more than 2 dimensions are not supported: '${z(e)}'.`))), c.count > 0 && (t.arrayDepth = c.count);
+		let u = t.enum;
+		return u && (c.count > +!!s || t.range) && !K.has(t) && (t.valueOrRange || (R(e, i.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)), l;
+	}, V = (e, n, r, i, a) => {
+		if (n !== "Lambda" && n !== `${T}.Lambda`) return !1;
+		let o = e.typeArguments, s = "*";
+		if (o && o.length === 2) if (a && o[0].kind === t.SyntaxKind.TupleType && (r.lambdaArity = o[0].elements.length), o[1].kind === t.SyntaxKind.AnyKeyword) s = "raw";
+		else {
+			let e = {};
+			Z(o[1], e, i, !1, { count: 0 }), s = e.scalar ?? "*";
+		}
+		else if (o && o.length === 1 && o[0].kind !== t.SyntaxKind.TupleType && o[0].kind !== t.SyntaxKind.ArrayType) if (a && (r.lambdaArity = 2), o[0].kind === t.SyntaxKind.AnyKeyword) s = "raw";
+		else {
+			let e = {};
+			Z(o[0], e, i, !1, { count: 0 }), s = e.scalar ?? "*";
+		}
+		return r.lambda = s, !0;
+	}, H = /* @__PURE__ */ new Map(), U = /* @__PURE__ */ new Map(), W = /* @__PURE__ */ new Map(), G = /* @__PURE__ */ new Set(), K = /* @__PURE__ */ new WeakSet(), q = (e) => e !== void 0 && e.getSourceFile() === n, J = (t, n = !1) => t.getJsDocTags(a).find((e) => e.name === "name")?.text?.map((e) => e.text).join("").trim() || (n ? e.camelToPrettyCase(t.name) : t.name), Y = (e) => {
+		let t = e.getJsDocTags(a).find((e) => e.name === "deprecated");
+		if (t) return t.text?.map((e) => e.text).join("").trim() || !0;
+	}, X = (e, o) => {
+		let s = t.isTypeReferenceNode(e) ? e.typeName : void 0, c = s ? a.getSymbolAtLocation(s) : void 0, l = c?.declarations?.length ? c : void 0;
+		if (s) {
+			if (l && l.flags & t.SymbolFlags.Alias) return void R(e, i.EnumNotLocal, `'${s.getText()}' is imported, so its declaration cannot be read: '${o}'. An enum must be declared in the module that uses it.`);
+			if (!(l && l.flags & t.SymbolFlags.Type)) {
+				let r = s.getText();
+				return (l ? (l.flags & t.SymbolFlags.Variable) !== 0 : n.statements.some((e) => t.isVariableStatement(e) && e.declarationList.declarations.some((e) => t.isIdentifier(e.name) && e.name.text === r))) ? void R(e, i.EnumMissingAlias, `'${r}' is a value, not a type: '${o}'. Pair the object with a same-name type — 'type ${r} = typeof ${r}[keyof typeof ${r}];' — or declare it as 'enum ${r} { … }'.`) : null;
+			}
+			let r = H.get(l);
+			if (r !== void 0) return r;
+			if (G.has(l)) return;
+		}
+		let u = [], d = !1;
+		if (l && l.flags & t.SymbolFlags.Enum) {
+			if (!l.declarations?.some(q)) return void R(e, i.EnumNotLocal, `'${l.name}' is not declared in this module: '${o}'. An enum must be declared in the module that uses it.`);
+			d = !0;
+			let n = !1;
+			if (l.exports?.forEach((e) => {
+				let r = e.valueDeclaration;
+				if (!r || !t.isEnumMember(r)) return;
+				let o = a.getConstantValue(r);
+				if (o === void 0) return R(r, i.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);
+				u.push([
+					J(e, !0),
+					o,
+					r,
+					M(e.getDocumentationComment(a)),
+					Y(e)
+				]);
+			}), n) return void G.add(l);
+		} else {
+			let n = a.getTypeFromTypeNode(e), r = t.TypeFlags.Null | t.TypeFlags.Undefined | t.TypeFlags.Void, i = (n.isUnion() ? n.types : [n]).filter((e) => !(e.flags & r)), o = [];
+			for (let e of i) {
+				if (!(e.flags & (t.TypeFlags.NumberLiteral | t.TypeFlags.StringLiteral))) return l && H.set(l, null), null;
+				o.push(e.value);
+			}
+			if (o.length === 0) return null;
+			let s = l?.declarations?.find((e) => t.isTypeAliasDeclaration(e)), c = t.isUnionTypeNode(e) ? e : s?.type;
+			if (c && t.isUnionTypeNode(c)) {
+				let e = c.types.map((e) => {
+					let t = a.getTypeFromTypeNode(e);
+					return t.isLiteral() ? t.value : void 0;
+				}), t = (t) => {
+					let n = e.indexOf(t);
+					return n < 0 ? e.length : n;
+				};
+				o.sort((e, n) => t(e) - t(n));
+			}
+			let f = l && l.flags & t.SymbolFlags.Variable ? l.valueDeclaration : void 0, p = new Set(o);
+			if (l && f && q(f)) for (let e of a.getTypeOfSymbolAtLocation(l, f).getProperties()) {
+				let n = e.valueDeclaration, r = a.getTypeOfSymbolAtLocation(e, n ?? f);
+				if (!(r.flags & (t.TypeFlags.NumberLiteral | t.TypeFlags.StringLiteral))) continue;
+				let i = r.value;
+				o.includes(i) && (d = !0, p.delete(i), u.push([
+					J(e, !0),
+					i,
+					n,
+					M(e.getDocumentationComment(a)),
+					Y(e)
+				]));
+			}
+			for (let e of o) p.has(e) && u.push([
+				String(e),
+				e,
+				void 0,
+				null
+			]);
+		}
+		if (u.length === 0) return null;
+		let f = typeof u[0][1] == "number";
+		if (u.some(([, e]) => typeof e == "number" !== f)) return void R(e, i.EnumMixed, `'${l?.name ?? e.getText()}' mixes number and string members: '${o}'. A parameter has one type, so an enum is all numbers or all strings.`);
+		let p = l ? J(l) : u.map(([, e]) => String(e)).join("|"), m = l ? void 0 : U.get(p);
+		if (m) return m;
+		if (d) {
+			let t = /* @__PURE__ */ new Map();
+			for (let [n, r, a, o] of u) {
+				let s = a?.name?.getText() ?? n, c = t.get(r);
+				c === void 0 ? t.set(r, s) : L(a ?? e, i.EnumDuplicateValue, "warning", `'${p}.${s}' has the same value as '${p}.${c}' (${JSON.stringify(r)}). A formula passes the value, so the two cannot be told apart.`), o === "" && L(a ?? e, i.EnumMemberUndocumented, "warning", `'${p}.${s}' is missing a description. Add a doc comment above the member — it is what the argument dropdown shows.`);
+			}
+		}
+		let h = {
+			id: p,
+			type: f ? r.Number : r.String,
+			members: u.map(([e, t, , , n]) => n ? [
+				e,
+				t,
+				n
+			] : [e, t])
+		};
+		l ? H.set(l, h) : U.set(p, h);
+		let g = l ? M(l.getDocumentationComment(a)) : "", _ = {};
+		for (let [e, , , t] of u) t && (_[e] = { description: t });
+		if (g || Object.keys(_).length > 0) {
+			let e = {};
+			g && (e.summary = g), Object.keys(_).length > 0 && (e.members = _), W.set(h, e);
+		}
+		return h;
+	}, Z = (e, n, a, o, s, l = !1, f = !1, S = !1) => {
+		if (e) {
+			if (e.kind === t.SyntaxKind.ParenthesizedType) return Z(e.type, n, a, o, s, l, f, S);
+			if (e.kind === t.SyntaxKind.UnionType) {
+				let r = (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, u = e.types.filter((e) => !r(e));
+				if (u.length === 1) return Z(u[0], n, a, o, s, l, f, S);
+				let d = X(e, n.name ?? z(e));
+				if (d === void 0) return;
+				if (d !== null) return n.scalar = d.type, void (o && (n.enum = d));
+				if (!o) return void (n.scalar = "*");
+				if (u.length === 2) {
+					let e = (e) => e.kind === t.SyntaxKind.TypeReference && t.isTypeReferenceNode(e) && E(e) === "Lambda", r = u.findIndex(e);
+					if (r >= 0 && !e(u[1 - r])) return Z(u[1 - r], n, a, o, s, l, f, S), void V(u[r], E(u[r]), n, a, o);
+				}
+				if (o && u.length === 2) {
+					let e = (e) => {
+						if (e.kind === t.SyntaxKind.TypeReference && !e.typeArguments?.length) return c.get(E(e));
+					}, r = u.findIndex((t) => e(t) !== void 0);
+					if (r >= 0 && e(u[1 - r]) === void 0) {
+						let t = {}, i = s.count;
+						if (Z(u[1 - r], t, a, o, s, l, !1), t.scalar && !t.range && t.lambda == null && s.count === i) {
+							n.range = e(u[r]), n.scalar = t.scalar, n.valueOrRange = !0;
+							let i = t.enum;
+							i && (n.enum = i);
+							return;
+						}
+					}
+				}
+				if (o && u.length === 2) {
+					let r = (e) => e.kind === t.SyntaxKind.TypeReference && !e.typeArguments?.length && E(e) === "Scalar", i = u.findIndex(r);
+					if (i >= 0 && !r(u[1 - i])) {
+						let t = X(u[1 - i], n.name ?? z(e));
+						if (t === void 0) return;
+						if (t !== null) return n.scalar = "*", void (n.enum = t);
+					}
+				}
+				R(e, i.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) n.scalar = r.Number;
+			else if (e.kind === t.SyntaxKind.StringKeyword) n.scalar = r.String;
+			else if (e.kind === t.SyntaxKind.BooleanKeyword) n.scalar = r.Boolean;
+			else if (e.kind === t.SyntaxKind.UndefinedKeyword || e.kind === t.SyntaxKind.NullKeyword || e.kind === t.SyntaxKind.VoidKeyword) {
+				if (o) return void R(e, i.UndefinedInput, `'undefined' is not a valid type for input: '${z(e)}'.`);
+				n.scalar = r.Null;
+			} else if (e.kind === t.SyntaxKind.BigIntKeyword) n.scalar = r.Number;
+			else if (e.kind === t.SyntaxKind.AnyKeyword) o && (n.range = "*");
+			else if (e.kind === t.SyntaxKind.ArrayType) {
+				let t = e.elementType;
+				if (!t) return void R(e, i.UntypedArray, `'Array' must be typed: '${z(e)}'.`);
+				if (o && f) {
+					let r = n, i = r.name ?? z(e) ?? "parameter", o = r.acceptError;
+					delete r.acceptError;
+					let s = { name: i };
+					B(t, s, a, !0), o && !s.acceptError && (s.acceptError = !0), r.repeating = [s];
+					return;
+				}
+				s.count++, Z(t, n, a, o, s);
+			} else if (e.kind !== t.SyntaxKind.TupleType) if (e.kind === t.SyntaxKind.TypeReference) {
+				let r = E(e);
+				if (g.has(r)) {
+					let t = z(e);
+					if (!o) return void R(e, i.InvalidReturnType, `'${r}' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					let c = n;
+					if (c.acceptError) return void R(e, i.InvalidParamType, `'${t}' declares 'AcceptError' more than once.`);
+					let u = e.typeArguments;
+					return u && u.length === 1 ? (c.acceptError = !0, Z(u[0], n, a, o, s, l, f, S)) : void R(e, i.GenericArity, `'${r}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if (x.has(r)) {
+					let t = n.name ?? z(e);
+					if (!o) return void R(e, i.InvalidReturnType, `'ReportType' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					let c = e.typeArguments;
+					return c && c.length === 1 ? (n.reportType = !0, Z(c[0], n, a, o, s, l, f, S)) : void R(e, i.GenericArity, `'${r}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if (v.has(r)) {
+					let t = n.name ?? z(e);
+					if (!o) return void R(e, i.InvalidReturnType, `'NoLift' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					let c = e.typeArguments;
+					if (!c || c.length !== 1) return void R(e, i.GenericArity, `'${r}' must be typed with exactly 1 type: '${t}'.`);
+					let u = n;
+					u.noLift = !0;
+					let d = s.count;
+					Z(c[0], n, a, o, s, l, f, S), (u.range || u.lambda != null || u.repeating || s.count !== d) && R(e, i.InvalidParamType, `'${t}': 'NoLift' applies to a SCALAR parameter only - a range, list, repeating or lambda slot never lifts.`);
+					return;
+				}
+				if (y.has(r)) {
+					let t = n.name ?? z(e);
+					if (!o) return void R(e, i.InvalidReturnType, `'NoFilter' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					let c = e.typeArguments;
+					if (!c || c.length !== 1) return void R(e, i.GenericArity, `'${r}' must be typed with exactly 1 type: '${t}'.`);
+					let u = n;
+					u.noFilter = !0;
+					let d = s.count;
+					if (Z(c[0], n, a, o, s, l, f, S), u.range || u.lambda != null || s.count !== d) return void R(e, i.InvalidParamType, `'${t}': 'NoFilter' applies to a SCALAR slot only - a range, list or lambda slot has no members to coerce.`);
+					let p = u.repeating;
+					if (p) {
+						if (delete u.noFilter, p.length !== 1) return void R(e, i.InvalidParamType, `'${t}': 'NoFilter' over a repeating group applies to a period-1 group only - write it on the slot that takes the members.`);
+						p[0].noFilter = !0;
+					} else f && R(e, i.InvalidParamType, `'${t}': 'NoFilter' applies to a REPEATING slot only - a single scalar argument has no members to coerce.`);
+					return;
+				}
+				if (_.has(r)) {
+					let c = n.name ?? z(e);
+					if (!o) return void R(e, i.InvalidReturnType, `'Omittable' is not a valid return type: '${c}'. It describes how an ARGUMENT is received.`);
+					let u = e.typeArguments;
+					if (!u || u.length < 1 || u.length > 2) return void R(e, i.GenericArity, `'${r}' must be typed with 1 or 2 types: '${c}'.`);
+					let d = n;
+					if (d.omittable = !0, u.length === 2) {
+						let n = j(t, u[1]);
+						if (n === void 0) return void R(e, i.InvalidParamType, `'${c}' declares '${r}' 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 = n;
+					}
+					let p = Z(u[0], n, a, o, s, l, f, S), m = d.omittedValue;
+					return d.enum && m != null && !d.enum.members.some(([, e]) => e === m) && R(u[1], i.EnumOmittedValue, `'${c}': ${JSON.stringify(m)} 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.`), p;
+				}
+				if (b.has(r)) {
+					let c = n.name ?? z(e);
+					if (!o) return void R(e, i.InvalidReturnType, `'Lazy' is not a valid return type: '${c}'. It describes how an ARGUMENT is received.`);
+					let u = n;
+					if (u.lazy) return void R(e, i.InvalidParamType, `'${c}' declares 'Lazy' more than once.`);
+					let d = e.typeArguments;
+					if (!d || d.length < 1 || d.length > 2) return void R(e, i.GenericArity, `'${r}' must be typed with 1 or 2 types: '${c}'.`);
+					if (u.lazy = !0, d.length === 2) {
+						let n = j(t, d[1]);
+						if (n === void 0) return void R(e, i.InvalidParamType, `'${c}' declares '${r}' 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.`);
+						u.optional = !0, u.defaultValue = n;
+					}
+					Z(d[0], n, a, o, s, l, f, S), u.enum ? (R(e, i.EnumPosition, `'${c}': 'Lazy' cannot hold the enum '${u.enum.id}'. The argument may never be evaluated, so there is no point at which it could be checked against the members.`), delete u.enum) : u.lambda == null ? u.repeating && R(e, i.InvalidParamType, `'${c}': 'Lazy' applies to a VALUE, not to a repeating group - mark the group's slots instead.`) : R(e, i.InvalidParamType, `'${c}': 'Lazy' cannot be combined with a Lambda parameter - a callable slot is already the body's to call, or not.`);
+					return;
+				}
+				if (h.has(r)) {
+					let t = n.name ?? z(e);
+					if (!o) return void R(e, i.InvalidReturnType, `'Flatten' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					let c = e.typeArguments;
+					return c && c.length === 1 ? (s.count++, Z(c[0], n, a, o, s, l)) : void R(e, i.GenericArity, `'${r}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if (m.get(r) === "repeating") {
+					let c = n.name ?? z(e);
+					if (!o) return void R(e, i.RepeatingPosition, `'Repeating' is not a valid return type: '${c}'.`);
+					if (s.count !== 0) return void R(e, i.RepeatingPosition, `'Repeating' cannot be nested inside another type: '${c}'.`);
+					let u = n, d = e.typeArguments;
+					if (!d || d.length < 1 || d.length > 2) return void R(e, i.GenericArity, `'${r}' must be typed with 1 type, optionally followed by a maximum argument count: '${c}'.`);
+					let p;
+					if (d.length === 2) {
+						let e = d[1], n = e.kind === t.SyntaxKind.LiteralType ? e.literal : null, o = n && n.kind === t.SyntaxKind.NumericLiteral ? Number(n.text) : NaN;
+						if (!Number.isInteger(o) || o < 1 || o > 255) return void R(e, i.RepeatingMax, `'${c}': '${r}'’s maximum must be a whole number between 1 and 255.`);
+						p = o, a.maxArguments = o;
+					}
+					if (S) return p === void 0 ? void R(e, i.RepeatingPosition, `'${c}' 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.`) : Z(d[0], n, a, o, s, l, f);
+					let m = u.acceptError;
+					delete u.acceptError;
+					let h = ((e, n, r, a) => {
+						let o = (e, t, n) => {
+							let i = { name: e };
+							return B(t, i, r, !0), n && (i.optional = !0), a && !i.acceptError && (i.acceptError = !0), i;
+						};
+						if (e.kind !== t.SyntaxKind.TupleType) return [o(n, e, !1)];
+						let s = e.elements;
+						if (s.length < 2) return R(e, i.RepeatingSlots, `'${n}': a repeating group of period ${s.length} must be spelled 'Repeating<T>' without the tuple.`), null;
+						let c = [];
+						for (let e = 0; e < s.length; e++) {
+							let r = s[e];
+							if (r.kind !== t.SyntaxKind.NamedTupleMember) return R(r, i.RepeatingSlots, `'${n}': every slot of a repeating group must be labelled, e.g. 'Repeating<[criteriaRange: IRange, criteria: Scalar]>'.`), null;
+							let a = !!r.questionToken;
+							if (a && e !== s.length - 1) return R(r, i.RepeatingOptional, `'${n}': only the LAST slot of a repeating group may be optional (slot '${r.name?.getText?.()}' is not).`), null;
+							c.push(o(r.name?.getText?.() ?? `${e}`, r.type, a));
+						}
+						return c;
+					})(d[0], c ?? "parameter", a, m);
+					h && (u.repeating = h);
+					return;
+				}
+				let C = c.get(r), w = !1;
+				C && (n.range = C, w = !0);
+				let k = p.get(r);
+				if (k && (n.scalar = k), k !== void 0 && (w = !0), V(e, r, n, a, o)) return;
+				if (o) {
+					if (r === "Volatile" || r === `${T}.Volatile`) return void R(e, i.InvalidParamType, `'Volatile' is not a valid parameter type: '${z(e)}'. It describes the function's RESULT, so it belongs on the return type.`);
+					if (A.has(r)) return O;
+					let t = u.get(r);
+					if (t) return t;
+				} else {
+					let t = D.get(r);
+					if (t) {
+						let a = Object.assign(n, t()), o = 0;
+						if (a.async && o++, a.stream && o++, o > 1) return void R(e, i.MultipleModifiers, `'${r}' cannot have multiple modifiers: '${z(e)}'.`);
+						w = !0;
+					}
+				}
+				if (!w) {
+					let t = X(e, n.name ?? z(e));
+					if (t === void 0) return;
+					if (t !== null) return n.scalar = t.type, void (o && (n.enum = t));
+				}
+				if (!w) {
+					let 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>)", n;
+					n = o ? l ? `'${r}' 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).` : `'${r}' is not a valid parameter type: '${z(e)}'. Allowed: ${t}.` : `'${r}' is not a valid return type: '${z(e)}'. Allowed: number, string, boolean, Scalar, Date, FormulaError.Known, IRichData, IRange, Promise<T>, Observable<T>, Volatile<T> (and arrays of these).`, R(e, o ? i.InvalidParamType : i.InvalidReturnType, n);
+					return;
+				}
+				let M = e.typeArguments;
+				if (M) {
+					if (M.length !== 1) return void R(e, i.GenericArity, `'${r}' must be typed with exactly 1 type: '${z(e)}'.`);
+					let s = M[0], c = o && t.isTypeReferenceNode(s) && x.has(E(s)), l = n.reportType;
+					c && K.add(n), B(s, n, a, o), c && l === void 0 && delete n.reportType;
+					let u = n.enum;
+					u && !c && (R(M[0], i.EnumPosition, `'${r}' 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 ('${r}<${u.type}>').`), delete n.enum);
+				}
+			} else e.kind === t.SyntaxKind.FunctionType && ((e, n, r, a) => {
+				if (!a) return void R(e, i.FunctionReturn, `Function type is not a valid return type: '${z(e)}'. Declare a 'Lambda' return instead.`);
+				let o = e.type, s = {}, c = "*";
+				o && (o.kind === t.SyntaxKind.AnyKeyword ? c = "raw" : (Z(o, s, r, !1, { count: 0 }), c = s.scalar ?? "*"));
+				let l = e.parameters;
+				l && !l.some((e) => e.dotDotDotToken) && (n.lambdaArity = l.length), n.lambda = c;
+			})(e, n, a, o);
+		} else R(e, i.MissingType, `Type is not defined for '${n?.name ?? "return"}'.`);
+	};
+	try {
+		t.forEachChild(n, (e) => {
+			if (r = e, (t.getCombinedModifierFlags(r) & t.ModifierFlags.Export) !== 0 && t.isFunctionDeclaration(e)) {
+				let r = e?.name?.getText();
+				if (!e.body) return void R(e, i.NoBody, `'${r}': function has no body.`);
+				if (!r) return void R(e, i.Anonymous, "Anonymous exported functions are not allowed.");
+				let c = {}, u = { parameters: {} };
+				try {
+					c.name = r;
+					let d = M(a.getSymbolAtLocation(e.name)?.getDocumentationComment(a));
+					d && (u.summary = d);
+					let p = {};
+					B(e.type, p, c, !1), c.returnType = p;
+					let m = {};
+					n = e, (t.getCombinedModifierFlags(n) & t.ModifierFlags.Default) !== 0 && (m.default = !0, I = r), c.parameters = [];
+					let h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Set(), v = null, y = null, b = null, x = 0, T = !1, E = 0;
+					for (let n = 0; n < e.parameters.length; n++) {
+						let r = e.parameters[n], s = {};
+						s.name = r.name?.getText();
+						let l = c.parameters.length === 0;
+						if (o?.lenient && n === 0 && !r.type && m.default) {
+							c.context = k;
+							continue;
+						}
+						let d = B(r.type, s, c, !0, l, !r.dotDotDotToken, !!r.dotDotDotToken);
+						if (d === O) {
+							n === 0 && c.context === void 0 && (c.context = k);
+							continue;
+						}
+						if (d) {
+							if (c.parameters.length !== 0) return void R(r, i.ContextNotFirst, `'${c.name}' contexts must be the first parameter: '${s.name}'.`);
+							c.context = d;
+							continue;
+						}
+						if (s.lambda !== void 0) {
+							if (v !== null) return void R(r, i.MultipleLambda, `'${c.name}' has more than one Lambda parameter ('${v}' and '${s.name}'). Only one Lambda parameter is allowed.`);
+							v = s.name;
+						} else if (v !== null) return void R(r, i.LambdaNotLast, `'${c.name}' Lambda parameter ('${v}') must be the last parameter, but '${s.name}' follows it.`);
+						let f = !0 === s.optional || r.initializer !== void 0 && r.initializer !== null || r.questionToken !== void 0 && r.questionToken !== null, p;
+						if (f && (s.optional = !0, r.initializer)) try {
+							if (r.initializer.kind === t.SyntaxKind.StringLiteral) p = r.initializer.text;
+							else if (r.initializer.kind === t.SyntaxKind.NumericLiteral) p = parseFloat(r.initializer.text);
+							else if (r.initializer.kind === t.SyntaxKind.TrueKeyword || r.initializer.kind === t.SyntaxKind.FalseKeyword) p = r.initializer.kind === t.SyntaxKind.TrueKeyword;
+							else if (r.initializer.kind === t.SyntaxKind.NullKeyword) p = null;
+							else if (t.isPrefixUnaryExpression(r.initializer) && r.initializer.operator === t.SyntaxKind.MinusToken && r.initializer.operand.kind === t.SyntaxKind.NumericLiteral) p = -parseFloat(r.initializer.operand.text);
+							else if (t.isPropertyAccessExpression(r.initializer) || t.isElementAccessExpression(r.initializer)) {
+								let e = a.getTypeAtLocation(r.initializer);
+								e.flags & (t.TypeFlags.NumberLiteral | t.TypeFlags.StringLiteral) && (p = e.value);
+							}
+						} catch (e) {
+							console.warn(`Couldn't extract default value for parameter '${s.name}'`, e);
+						}
+						r.dotDotDotToken && (s.rest = !0);
+						let S = s.repeating;
+						if (S) {
+							if (s.rest) return void R(r, i.RepeatingPosition, `'${c.name}' parameter '${s.name}' is both a rest parameter and a repeating group. A group already repeats — drop the '...'.`);
+							if (f && S.length === 1) return void R(r, i.RepeatingOptional, `'${c.name}' parameter '${s.name}' cannot be an optional repeating group. Use '...${s.name}: T[]' for zero-or-more, or drop the '?' for one-or-more.`);
+							if (y !== null) return void R(r, i.MultipleRepeating, `'${c.name}' has more than one repeating group ('${y}' and '${s.name}'). Only one is allowed — two would make the argument count ambiguous.`);
+							if (b !== null) return void R(r, i.RepeatingOptional, `'${c.name}' parameter '${b}' is optional and precedes the repeating group '${s.name}'. Every parameter outside a group must be required.`);
+							y = s.name, x = S.length, T = !0 === S[S.length - 1].optional;
+						} else {
+							if (y !== null && s.rest) return void R(r, i.RepeatingOptional, `'${c.name}' parameter '${s.name}' is a rest parameter and follows the repeating group '${y}'. Two variadic tails would make the argument count ambiguous.`);
+							if (y !== null && f) {
+								if (E >= x - 1) return void R(r, i.RepeatingOptional, x === 1 ? `'${c.name}' parameter '${s.name}' is optional and follows the period-1 repeating group '${y}'. One more argument is indistinguishable from one more repetition — make it required, or give the group a period.` : `'${c.name}' has ${E + 1} optional parameters after the repeating group '${y}', which has period ${x}. At most ${x - 1} may be optional, or the argument count no longer decides the parse.`);
+								if (T) return void R(r, i.RepeatingOptional, `'${c.name}' parameter '${s.name}' is optional and follows '${y}', whose own last slot is already optional. Both omissions reach the same argument count — drop one.`);
+								E++;
+							}
+						}
+						f && !S && (b = s.name);
+						let C = (s.range ? 2 : 0) + (s.arrayDepth ?? 0), w = s.range === "r" || s.range === "p" || s.range === "*", D = s.rest || w ? 3 : 2;
+						if (C > D) return void R(r, i.ArrayDepth, `'${c.name}' parameter '${s.name}' has an array depth of ${C}; the maximum is ${D}${s.rest ? " for a rest parameter" : " (use a rest parameter for one more level, or an IRange)"}.`);
+						c.parameters.push(s);
+						let A = { description: "" };
+						u.parameters[s.name] = A, A.description = M(a.getSymbolAtLocation(r.name)?.getDocumentationComment(a)), p !== void 0 && (s.defaultValue = p);
+						for (let e of [s, ...s.repeating ?? []]) {
+							let t = e.enum ? W.get(e.enum) : void 0;
+							t && ((u.enums ??= {})[e.enum.id] = t);
+						}
+						if (h.set(s.name, s), g.set(s.name, r), S && S.length > 1) {
+							_.add(s.name);
+							for (let e of S) {
+								let t = `${s.name}.${e.name}`;
+								u.parameters[t] = { description: "" }, h.set(t, e), g.set(t, r);
+							}
+						}
+					}
+					let D = c.maxArguments;
+					if (D !== void 0) {
+						let t = c.parameters ?? [];
+						if (!t.some((e) => !0 === e.rest || e.repeating !== void 0)) return void R(e, i.RepeatingMax, `'${c.name}' declares a maximum of ${D} arguments but takes a fixed ${t.length}. A maximum only means something on a variadic tail.`);
+						let n = 0;
+						for (let e of t) !0 !== e.rest && !0 !== e.optional && (n += e.repeating ? e.repeating.length : 1);
+						if (D < n) return void R(e, i.RepeatingMax, `'${c.name}' declares a maximum of ${D} arguments but requires ${n}.`);
+					}
+					if (e.jsDoc && e.jsDoc.length > 0) {
+						let t = e.jsDoc, n = t.length;
+						for (let e = 0; e < n; e++) {
+							let n = t[e]?.tags;
+							if (!n) continue;
+							let a = n.length;
+							for (let e = 0; e < a; e++) {
+								let t = n[e], a = t?.tagName?.text;
+								if (!a) continue;
+								a = a.toLowerCase();
+								let o = t.comment, d = s(a);
+								if (typeof o == "string" || d) {
+									if (typeof o == "string" && (o = o.replace(/\r\n?/g, "\n").trim()), d || !o || (o = o.split("\n")[0].trim(), o && o.length !== 0)) {
+										if (o && typeof o == "string") {
+											let e = /\{@link(code|plain)?\s+([^}|]+)(?:\s*\|\s*([^}]+))?\}/g, t, n = o, r = [];
+											for (; (t = e.exec(o)) !== null;) {
+												let [e, n, r, i] = t, a = [r.trim()];
+												i && a.push(i.trim());
+											}
+											o = n, r.length > 0 && a === "see" && (u.links ||= [], u.links.push(...r));
+										}
+										if (a === "name") {
+											let e = o;
+											e !== r && (u.name = e);
+										} else if (a !== "description") {
+											if (a === "param") {
+												let e = t.name?.getText?.() ?? t.name?.text;
+												if (!h.get(e)) {
+													R(t, i.UnknownParam, `Parameter '${e}' not found in function '${r}'.`);
+													continue;
+												}
+												let n = u.parameters?.[e];
+												n && !n.description && typeof o == "string" && o && (n.description = o);
+											} else if (a === "returns" || a === "return") c.returnType.description = o;
+											else if (a === "returnkind") {
+												let e = (o ?? "").trim().toLowerCase();
+												l.has(e) ? c.returnType.kind = e : R(t, i.UnknownReturnKind, `'@returnKind ${e}' is not a known value kind. Known: ${[...l].map((e) => `'${e}'`).join(", ")}.`);
+											} else if (a === "category") u.category = o;
+											else if (a === "deprecated" || a === "hidden") {
+												let e = !0, t = o?.toLowerCase();
+												t === "false" ? e = !1 : t !== "true" && (e = o), !1 !== e && (u.deprecated = e ?? !0);
+											}
+										}
+									}
+								} else a === "returnkind" && R(t, i.UnknownReturnKind, `'@returnKind' needs a value kind. Known: ${[...l].map((e) => `'${e}'`).join(", ")}.`);
+							}
+						}
+					}
+					Object.keys(c.returnType).length === 0 && delete c.returnType, Object.keys(m).length > 0 && (c.behavior = m), u.summary || L(e.name ?? e, i.MissingSummary, "warning", `'${r}': missing a description. Add a JSDoc comment above the function.`);
+					let A = !c.context, j = A && u.name || r;
+					if (A && !S.test(j)) {
+						let t = u.name ? `'@name ${u.name}'` : `'${j}'`;
+						R(e.name ?? e, i.InvalidName, `'${r}': ${t} cannot be called from a formula. A function name starts with a letter or '_', and continues with letters, digits, '_' or '.'.` + (u.name ? "" : " Add an '@name' tag to register it under another name."));
+						return;
+					}
+					if (A && !o?.isBuiltIn && ((e) => {
+						if (w.test(e)) return !0;
+						let t = C.exec(e);
+						if (!t) return !1;
+						let n = 0;
+						for (let e of t[1].toUpperCase()) n = 26 * n + (e.charCodeAt(0) - 64);
+						let r = Number(t[2]);
+						return n <= 16384 && r >= 1 && r <= 1048576;
+					})(j)) {
+						let t = u.name ? `'@name ${u.name}'` : `'${j}'`;
+						R(e.name ?? e, i.InvalidName, `'${r}': ${t} cannot be called from a formula. It reads as a cell address.` + (u.name ? "" : " Add an '@name' tag to register it under another name."));
+						return;
+					}
+					let F = P.get(j.toUpperCase());
+					if (F !== void 0) return void R(e.name ?? e, i.DuplicateName, `'${r}': '${j}' is already the name of '${F}' in this module.`);
+					if (P.set(j.toUpperCase(), r), A && f?.has(j.toUpperCase())) return void R(e.name ?? e, i.BuiltInName, `'${j}' is a built-in function. Choose a different name - a calculation function cannot replace a built-in.`);
+					if (A) {
+						let e = u.parameters ?? {};
+						for (let [t, n] of Object.entries(e)) if (!_.has(t) && !n.description) {
+							let e = g.get(t);
+							L(e, i.MissingParamDescription, "warning", `'${r}': parameter '${t}' is missing a description. Add an '@param ${t}' tag.`);
+						}
+					}
+					N.push([c, u]);
+				} catch (t) {
+					R(e, i.ParseError, `'${r}': ${t.message}`);
+				}
+			}
+			var n, r;
+		});
+	} catch (e) {
+		R(void 0, i.ParseError, `Unable to analyze module: ${e?.message ?? e}`);
+	}
+	return {
+		functions: N,
+		autoRun: I,
+		diagnostics: F
+	};
+}
+function P(e, t, n) {
+	let r = "script.ts", i = "lib.d.ts", a = {
+		[r]: t ?? "",
+		[i]: ""
+	}, o = e.createProgram([r], {
+		allowJs: !0,
+		noResolve: !0,
+		noLib: !0,
+		isolatedModules: !0,
+		module: 99,
+		target: e.ScriptTarget.ES2020
+	}, {
+		getSourceFile: (t) => {
+			let n = a[t];
+			if (n !== void 0) return e.createSourceFile(t, n, e.ScriptTarget.Latest, !0);
+		},
+		fileExists: (e) => a[e] !== void 0,
+		readFile: (e) => a[e],
+		writeFile: () => {},
+		getCurrentDirectory: () => "./",
+		getCanonicalFileName: (e) => e,
+		useCaseSensitiveFileNames: () => !0,
+		getDefaultLibFileName: () => i,
+		getNewLine: () => "\n"
+	}), s = o.getTypeChecker(), c = o.getSourceFile(r);
+	return c ? N(e, c, s, n).diagnostics : [];
+}
+export { N as analyzeModule, P as lintScript, i as t };