@sheetxl/studio-vanilla 0.7.28-beta.4 → 0.8.0-beta.1

package/cdn/assets/BWlMK76Aj2d4ygsH.js

@@ -0,0 +1,538 @@
+/**
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { a as e, f as t, l as n, r, t as i } from "./D_t53-8k73CNpV-p2.js";
+var a = 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",
+	NoExports: "SXL3001",
+	UnknownParam: "SXL3002",
+	BuiltInName: "SXL3003",
+	UnknownCompat: "SXL3004",
+	MissingSummary: "SXL9001",
+	MissingParamDescription: "SXL9002",
+	MissingReturns: "SXL9003"
+}), o = [
+	{
+		name: "summary",
+		group: "sheetxl",
+		description: "Short description shown in function tooltips and autocomplete."
+	},
+	{
+		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: "Override the displayed function name.",
+		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: "compat",
+		group: "sheetxl",
+		description: "Opt into a named engine compatibility behavior (`noReferenceLift`, `noMemberFilter`) or a family alias (`atp` = both).",
+		snippet: "compat ${1:atp}"
+	},
+	{
+		name: "example",
+		group: "jsdoc",
+		description: "Provide a usage example."
+	},
+	{
+		name: "see",
+		group: "jsdoc",
+		description: "Reference a related function or link."
+	}
+], s = (() => {
+	let e = /* @__PURE__ */ new Map();
+	for (let t of o) if (e.set(t.name, t), t.aliases) for (let n of t.aliases) e.set(n, t);
+	return e;
+})();
+function c(e) {
+	return !0 === function(e) {
+		if (!e) return;
+		let t = (e.startsWith("@") ? e.slice(1) : e).toLowerCase();
+		return s.get(t);
+	}(e)?.standalone;
+}
+var l = /* @__PURE__ */ new Map([["IReferenceRange", "p"], ["IRange", "r"]]), 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", i.Error],
+	["Date", n.Date],
+	["IRichData", n.RichData]
+]), m = /* @__PURE__ */ new Map([["Repeating", "repeating"]]), h = /* @__PURE__ */ new Set(["Flatten", "SheetXL.Flatten"]), g = /* @__PURE__ */ new Map([["AcceptError", "accept"], ["AcceptRefError", "accept-ref"]]), _ = /* @__PURE__ */ new Set(["Omittable"]), v = "SheetXL";
+f(v, l), f(v, u), f(v, m), f(v, g), _.add(`${v}.Omittable`);
+var y = /* @__PURE__ */ new Map([["Promise", () => ({ async: !0 })], ["Observable", () => ({ stream: !0 })]]), b = "__scriptContext__", x = /* @__PURE__ */ new Set([
+	"IScript.ScriptContext",
+	`${v}.IScript.ScriptContext`,
+	"ScriptContext"
+]), S = (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();
+}, C = () => [...Object.keys(t), ...Object.keys(r)].map((e) => `'${e}'`).join(", ");
+function w(t, n, r, o) {
+	let s = o?.builtInNames?.length ? new Set(o.builtInNames.map((e) => e.toUpperCase())) : null, f = [], w = [], T = null, E = (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);
+		w.push({
+			start: i,
+			length: a,
+			severity: n,
+			code: t,
+			message: r
+		});
+	}, D = (e, t, n) => {
+		E(e, t, "error", n);
+	}, O = (e) => e?.parent?.name?.escapedText, k = (e, t, n, r, i = !1, o = !1) => {
+		let s = { count: 0 }, c = j(e, t, n, r, s, i, o);
+		return s.count >= 2 && (t.range || (t.range = "m", s.count -= 2), !r && s.count >= 1 && (--s.count, s.count > 0 && D(e, a.ArrayDepth, `Arrays of more than 2 dimensions are not supported: '${O(e)}'.`))), s.count > 0 && (t.arrayDepth = s.count), c;
+	}, A = (e, n, r, i, a) => {
+		if (n !== "Lambda" && n !== `${v}.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 = {};
+			j(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 = {};
+			j(o[0], e, i, !1, { count: 0 }), s = e.scalar ?? "*";
+		}
+		return r.lambda = s, !0;
+	}, j = (e, n, r, o, s, c = !1, f = !1) => {
+		if (e) {
+			if (e.kind === t.SyntaxKind.ParenthesizedType) return j(e.type, n, r, o, s, c, f);
+			if (e.kind === t.SyntaxKind.UnionType) {
+				let l = (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) => !l(e));
+				if (u.length === 1) return j(u[0], n, r, o, s, c, f);
+				let d = (e) => {
+					if (e.kind !== t.SyntaxKind.LiteralType) return;
+					let n = e.literal;
+					return n?.kind === t.SyntaxKind.NumericLiteral || n?.kind === t.SyntaxKind.PrefixUnaryExpression && n.operand?.kind === t.SyntaxKind.NumericLiteral ? t.SyntaxKind.NumericLiteral : n?.kind === t.SyntaxKind.StringLiteral ? t.SyntaxKind.StringLiteral : void 0;
+				}, p = d(u[0]);
+				if (p !== void 0 && u.every((e) => d(e) === p)) return void (n.scalar = p === t.SyntaxKind.NumericLiteral ? i.Number : i.String);
+				if (!o) return void (n.scalar = "*");
+				if (u.length === 2) {
+					let e = (e) => {
+						if (e.kind !== t.SyntaxKind.TypeReference) return !1;
+						let n = t.isTypeReferenceNode(e) ? e.typeName.getText() : "";
+						return n === "Lambda" || n === `${v}.Lambda`;
+					}, i = u.findIndex(e);
+					if (i >= 0 && !e(u[1 - i])) return j(u[1 - i], n, r, o, s, c, f), void A(u[i], u[i].typeName.getText(), n, r, o);
+				}
+				D(e, a.InvalidParamType, `Union parameter types are not supported: '${O(e)}'. Use a single type, optionally with '| null' or '| undefined', or 'T | Lambda<…>' for a value-or-lambda slot.`);
+				return;
+			}
+			if (e.kind === t.SyntaxKind.NumberKeyword) n.scalar = i.Number;
+			else if (e.kind === t.SyntaxKind.StringKeyword) n.scalar = i.String;
+			else if (e.kind === t.SyntaxKind.BooleanKeyword) n.scalar = i.Boolean;
+			else if (e.kind === t.SyntaxKind.UndefinedKeyword || e.kind === t.SyntaxKind.NullKeyword || e.kind === t.SyntaxKind.VoidKeyword) {
+				if (o) return void D(e, a.UndefinedInput, `'undefined' is not a valid type for input: '${O(e)}'.`);
+				n.scalar = i.Null;
+			} else if (e.kind === t.SyntaxKind.BigIntKeyword) n.scalar = i.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 D(e, a.UntypedArray, `'Array' must be typed: '${O(e)}'.`);
+				if (o && f) {
+					let i = n, a = i.name ?? O(e) ?? "parameter", o = i.errors;
+					delete i.errors;
+					let s = { name: a };
+					k(t, s, r, !0), o && !s.errors && (s.errors = o), i.repeating = [s];
+					return;
+				}
+				s.count++, j(t, n, r, o, s);
+			} else if (e.kind !== t.SyntaxKind.TupleType) if (e.kind === t.SyntaxKind.TypeReference) {
+				let i = e.typeName?.getText?.() ?? null, v = g.get(i);
+				if (v) {
+					let t = O(e);
+					if (!o) return void D(e, a.InvalidReturnType, `'${i}' is not a valid return type: '${t}'. Error-policy markers apply to parameters only.`);
+					let l = n;
+					if (l.errors) return void D(e, a.InvalidParamType, `'${t}' declares more than one error-policy marker ('${l.errors}' and '${v}'). Only one is allowed.`);
+					let u = e.typeArguments;
+					return u && u.length === 1 ? (l.errors = v, j(u[0], n, r, o, s, c, f)) : void D(e, a.GenericArity, `'${i}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if (_.has(i)) {
+					let l = n.name ?? O(e);
+					if (!o) return void D(e, a.InvalidReturnType, `'Omittable' is not a valid return type: '${l}'. It describes how an ARGUMENT is received.`);
+					let u = e.typeArguments;
+					if (!u || u.length < 1 || u.length > 2) return void D(e, a.GenericArity, `'${i}' must be typed with 1 or 2 types: '${l}'.`);
+					let d = n;
+					if (d.omittable = !0, u.length === 2) {
+						let n = ((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;
+							}
+						})(t, u[1]);
+						if (n === void 0) return void D(e, a.InvalidParamType, `'${l}' declares '${i}' 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;
+					}
+					return j(u[0], n, r, o, s, c, f);
+				}
+				if (h.has(i)) {
+					let t = n.name ?? O(e);
+					if (!o) return void D(e, a.InvalidReturnType, `'Flatten' is not a valid return type: '${t}'. It describes how an ARGUMENT is received.`);
+					let l = e.typeArguments;
+					return l && l.length === 1 ? (s.count++, j(l[0], n, r, o, s, c)) : void D(e, a.GenericArity, `'${i}' must be typed with exactly 1 type: '${t}'.`);
+				}
+				if (m.get(i) === "repeating") {
+					let c = n.name ?? O(e);
+					if (!o) return void D(e, a.RepeatingPosition, `'Repeating' is not a valid return type: '${c}'.`);
+					if (s.count !== 0) return void D(e, a.RepeatingPosition, `'Repeating' cannot be nested inside another type: '${c}'.`);
+					let l = n, u = e.typeArguments;
+					if (!u || u.length !== 1) return void D(e, a.GenericArity, `'${i}' must be typed with exactly 1 type: '${c}'.`);
+					let d = l.errors;
+					delete l.errors;
+					let f = ((e, n, r, i) => {
+						let o = (e, t, n) => {
+							let a = { name: e };
+							return k(t, a, r, !0), n && (a.optional = !0), i && !a.errors && (a.errors = i), a;
+						};
+						if (e.kind !== t.SyntaxKind.TupleType) return [o(n, e, !1)];
+						let s = e.elements;
+						if (s.length < 2) return D(e, a.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 D(r, a.RepeatingSlots, `'${n}': every slot of a repeating group must be labelled, e.g. 'Repeating<[criteriaRange: IRange, criteria: Scalar]>'.`), null;
+							let i = !!r.questionToken;
+							if (i && e !== s.length - 1) return D(r, a.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, i));
+						}
+						return c;
+					})(u[0], c ?? "parameter", r, d);
+					f && (l.repeating = f);
+					return;
+				}
+				let S = l.get(i), C = !1;
+				S && (n.range = S, C = !0);
+				let w = p.get(i);
+				if (w && (n.scalar = w), w !== void 0 && (C = !0), A(e, i, n, r, o)) return;
+				if (o) {
+					if (x.has(i)) return b;
+					let e = u.get(i);
+					if (e) return e;
+				} else {
+					let t = y.get(i);
+					if (t) {
+						let r = Object.assign(n, t()), o = 0;
+						if (r.async && o++, r.stream && o++, o > 1) return void D(e, a.MultipleModifiers, `'${i}' cannot have multiple modifiers: '${O(e)}'.`);
+						C = !0;
+					}
+				}
+				if (!C) {
+					let t, n = "number, string, boolean, Scalar, Lambda, Date, FormulaError.Known, IRichData, IRange, IReferenceRange (and arrays of these; optionally wrapped in AcceptError<T>/AcceptRefError<T>, or grouped with Repeating<T>)";
+					t = o ? c ? `'${i}' is not a valid first parameter: '${O(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); ${n} (calculation input).` : `'${i}' is not a valid parameter type: '${O(e)}'. Allowed: ${n}.` : `'${i}' is not a valid return type: '${O(e)}'. Allowed: number, string, boolean, Scalar, Date, FormulaError.Known, IRichData, IRange, Promise<T>, Observable<T> (and arrays of these).`, D(e, o ? a.InvalidParamType : a.InvalidReturnType, t);
+					return;
+				}
+				let T = e.typeArguments;
+				if (T) {
+					if (T.length !== 1) return void D(e, a.GenericArity, `'${i}' must be typed with exactly 1 type: '${O(e)}'.`);
+					k(T[0], n, r, o);
+				}
+			} else e.kind === t.SyntaxKind.FunctionType && ((e, n, r, i) => {
+				if (!i) return void D(e, a.FunctionReturn, `Function type is not a valid return type: '${O(e)}'. Declare a 'Lambda' return instead.`);
+				let o = e.type, s = {}, c = "*";
+				o && (o.kind === t.SyntaxKind.AnyKeyword ? c = "raw" : (j(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, r, o);
+		} else D(e, a.MissingType, `Type is not defined for '${n?.name ?? "return"}'.`);
+	};
+	try {
+		t.forEachChild(n, (n) => {
+			if (((e) => (t.getCombinedModifierFlags(e) & t.ModifierFlags.Export) !== 0)(n) && t.isFunctionDeclaration(n)) {
+				let i = n?.name?.getText();
+				if (!n.body) return void D(n, a.NoBody, `'${i}': function has no body.`);
+				if (!i) return void D(n, a.Anonymous, "Anonymous exported functions are not allowed.");
+				let o = {}, l = { parameters: {} };
+				try {
+					o.name = i;
+					let u = S(r.getSymbolAtLocation(n.name)?.getDocumentationComment(r));
+					u && (l.summary = u);
+					let d = {};
+					k(n.type, d, o, !1), o.returnType = d;
+					let p = {}, m = /* @__PURE__ */ new Set();
+					((e) => (t.getCombinedModifierFlags(e) & t.ModifierFlags.Default) !== 0)(n) && (p.default = !0, T = i), o.parameters = [];
+					let h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Set(), v = null, y = null, x = null, w = 0, O = !1, A = 0;
+					for (let e = 0; e < n.parameters.length; e++) {
+						let i = n.parameters[e], s = {};
+						s.name = i.name?.getText();
+						let c = o.parameters.length === 0, u = k(i.type, s, o, !0, c, !i.dotDotDotToken);
+						if (u === b) {
+							e === 0 && o.context === void 0 && (o.context = "script");
+							continue;
+						}
+						if (u) {
+							if (o.parameters.length !== 0) return void D(i, a.ContextNotFirst, `'${o.name}' contexts must be the first parameter: '${s.name}'.`);
+							o.context = u;
+							continue;
+						}
+						if (s.lambda !== void 0) {
+							if (v !== null) return void D(i, a.MultipleLambda, `'${o.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 D(i, a.LambdaNotLast, `'${o.name}' Lambda parameter ('${v}') must be the last parameter, but '${s.name}' follows it.`);
+						let d, f = i.initializer !== void 0 && i.initializer !== null || i.questionToken !== void 0 && i.questionToken !== null;
+						if (f && (s.optional = !0, i.initializer)) try {
+							i.initializer.kind === t.SyntaxKind.StringLiteral ? d = i.initializer.text : i.initializer.kind === t.SyntaxKind.NumericLiteral ? d = parseFloat(i.initializer.text) : i.initializer.kind === t.SyntaxKind.TrueKeyword || i.initializer.kind === t.SyntaxKind.FalseKeyword ? d = i.initializer.kind === t.SyntaxKind.TrueKeyword : i.initializer.kind === t.SyntaxKind.NullKeyword && (d = null);
+						} catch (e) {
+							console.warn(`Couldn't extract default value for parameter '${s.name}'`, e);
+						}
+						i.dotDotDotToken && (s.rest = !0);
+						let p = s.repeating;
+						if (p) {
+							if (s.rest) return void D(i, a.RepeatingPosition, `'${o.name}' parameter '${s.name}' is both a rest parameter and a repeating group. A group already repeats — drop the '...'.`);
+							if (f && p.length === 1) return void D(i, a.RepeatingOptional, `'${o.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 D(i, a.MultipleRepeating, `'${o.name}' has more than one repeating group ('${y}' and '${s.name}'). Only one is allowed — two would make the argument count ambiguous.`);
+							if (x !== null) return void D(i, a.RepeatingOptional, `'${o.name}' parameter '${x}' is optional and precedes the repeating group '${s.name}'. Every parameter outside a group must be required.`);
+							y = s.name, w = p.length, O = !0 === p[p.length - 1].optional;
+						} else {
+							if (y !== null && s.rest) return void D(i, a.RepeatingOptional, `'${o.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 (A >= w - 1) return void D(i, a.RepeatingOptional, w === 1 ? `'${o.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.` : `'${o.name}' has ${A + 1} optional parameters after the repeating group '${y}', which has period ${w}. At most ${w - 1} may be optional, or the argument count no longer decides the parse.`);
+								if (O) return void D(i, a.RepeatingOptional, `'${o.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.`);
+								A++;
+							}
+						}
+						f && !p && (x = s.name);
+						let m = (s.range ? 2 : 0) + (s.arrayDepth ?? 0), C = s.range === "r" || s.range === "p" || s.range === "*", T = s.rest || C ? 3 : 2;
+						if (m > T) return void D(i, a.ArrayDepth, `'${o.name}' parameter '${s.name}' has an array depth of ${m}; the maximum is ${T}${s.rest ? " for a rest parameter" : " (use a rest parameter for one more level, or an IRange)"}.`);
+						o.parameters.push(s);
+						let E = { description: "" };
+						if (l.parameters[s.name] = E, E.description = S(r.getSymbolAtLocation(i.name)?.getDocumentationComment(r)), d !== void 0 && (s.defaultValue = d), h.set(s.name, s), g.set(s.name, i), p && p.length > 1) {
+							_.add(s.name);
+							for (let e of p) {
+								let t = `${s.name}.${e.name}`;
+								l.parameters[t] = { description: "" }, h.set(t, e), g.set(t, i);
+							}
+						}
+					}
+					if (n.jsDoc && n.jsDoc.length > 0) {
+						let r = n.jsDoc, s = r.length;
+						for (let n = 0; n < s; n++) {
+							let s = r[n]?.tags;
+							if (!s) continue;
+							let u = s.length;
+							for (let n = 0; n < u; n++) {
+								let r = s[n], u = r?.tagName?.text;
+								if (!u) continue;
+								u = u.toLowerCase();
+								let d = r.comment, f = c(u);
+								if (typeof d == "string" || f) {
+									if (typeof d == "string" && (d = d.replace(/\r\n?/g, "\n").trim()), f || !d || (d = d.split("\n")[0].trim(), d && d.length !== 0)) {
+										if (d && typeof d == "string") {
+											let e, t = /\{@link(code|plain)?\s+([^}|]+)(?:\s*\|\s*([^}]+))?\}/g, n = d, r = [];
+											for (; (e = t.exec(d)) !== null;) {
+												let [t, n, r, i] = e, a = [r.trim()];
+												i && a.push(i.trim());
+											}
+											d = n, r.length > 0 && u === "see" && (l.links ||= [], l.links.push(...r));
+										}
+										if (u === "name") {
+											let e = d;
+											e !== i && (l.name = e);
+										} else if (u !== "description") {
+											if (u === "summary") {
+												let e = d;
+												e && (l.summary = e);
+											} else if (u === "param") {
+												let e = r.name?.getText?.() ?? r.name?.text, n = h.get(e);
+												if (!n) {
+													D(r, a.UnknownParam, `Parameter '${e}' not found in function '${i}'.`);
+													continue;
+												}
+												let o = l.parameters?.[e];
+												if (o && !o.description && typeof d == "string" && d && (o.description = d), r.typeExpression && r.typeExpression.type) try {
+													let e = r.typeExpression.type;
+													if (e.kind === t.SyntaxKind.UnionType) {
+														let r = [];
+														n.enums = r, e.types.forEach((e) => {
+															if (e.kind === t.SyntaxKind.LiteralType) {
+																let t = e.literal.text;
+																t && r.push(t);
+															}
+														});
+													}
+												} catch (e) {
+													console.warn("Error parsing JSDoc type expression:", e);
+												}
+											} else if (u === "returns" || u === "return") o.returnType.description = d;
+											else if (u === "compat") {
+												let t = (d ?? "").split(/[\s,]+/).filter((e) => e.length > 0);
+												if (t.length === 0) {
+													D(r, a.UnknownCompat, `'@compat' needs at least one feature name. Known: ${C()}.`);
+													continue;
+												}
+												for (let n of t) {
+													let t = e(n);
+													if (t) for (let e of t) m.add(e);
+													else D(r, a.UnknownCompat, `'@compat ${n}' is not a known feature. Known: ${C()}.`);
+												}
+											} else if (u === "category") l.category = d;
+											else if (u === "deprecated" || u === "hidden") {
+												let e = !0, t = d?.toLowerCase();
+												t === "false" ? e = !1 : t !== "true" && (e = d), !1 !== e && (l.deprecated = e ?? !0);
+											}
+										}
+									}
+								} else u === "compat" && D(r, a.UnknownCompat, `'@compat' needs at least one feature name. Known: ${C()}.`);
+							}
+						}
+					}
+					Object.keys(o.returnType).length === 0 && delete o.returnType, m.size > 0 && (o.context ? D(n.name ?? n, a.UnknownCompat, `'${i}': '@compat' applies to calculation functions; this one takes a '${o.context}' context.`) : p.compat = [...m]), Object.keys(p).length > 0 && (o.behavior = p), l.summary || E(n.name ?? n, a.MissingSummary, "warning", `'${i}': missing a description. Add a JSDoc summary or '@summary'.`);
+					let j = !o.context;
+					if (j && s?.has(i.toUpperCase())) return void D(n.name ?? n, a.BuiltInName, `'${i}' is a built-in function. Choose a different name - a calculation function cannot replace a built-in.`);
+					if (j) {
+						let e = l.parameters ?? {};
+						for (let [t, n] of Object.entries(e)) if (!_.has(t) && !n.description) {
+							let e = g.get(t);
+							E(e, a.MissingParamDescription, "warning", `'${i}': parameter '${t}' is missing a description. Add an '@param ${t}' tag.`);
+						}
+					}
+					f.push([o, l]);
+				} catch (e) {
+					D(n, a.ParseError, `'${i}': ${e.message}`);
+				}
+			}
+		});
+	} catch (e) {
+		D(void 0, a.ParseError, `Unable to analyze module: ${e?.message ?? e}`);
+	}
+	return {
+		functions: f,
+		autoRun: T,
+		diagnostics: w
+	};
+}
+function T(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 ? w(e, c, s, n).diagnostics : [];
+}
+export { w as analyzeModule, T as lintScript };

package/cdn/assets/{HFqcMD9nTL0jdLxT2.js → BZsx0QHg1RZlM9ZN2.js}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.7.28-beta.4
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.1
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.

package/cdn/assets/{B3tC7wY_kUGXf5sb.js → Be4QC65cR8N84rTn2.js}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.7.28-beta.4
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.1
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.

package/cdn/assets/{DP9sLYfGGWMDI7hL2.js → BhDLR-jtbOOG-tl12.js}

@@ -1,21 +1,21 @@
 /**
-* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.7.28-beta.4
+* @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.8.0-beta.1
 *
 * (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 "./B_U_UpQXdbjNRthb.js";
-import { t } from "./BynqRVXFRplO7XgC.js";
-import { t as n } from "./B0N6rTGGJN2DZPaf.js";
-import { v as r } from "./BetL7yI63lEdQ0gM2.js";
-import { n as i } from "./C7xBBqvPqat9oEft2.js";
-import { Xt as a, t as o } from "./DW2yQm-sEcHogX7E.js";
-import { N as s, i as c } from "./Bj8bWbLg1IY965tK.js";
+import { r as e } from "./D9-wpGVbTS9rRpxx.js";
+import { t } from "./DnzDlqizzNkbhJP7.js";
+import { t as n } from "./CBuvbUg67ah_3BOZ.js";
+import { t as r } from "./D_t53-8k73CNpV-p2.js";
+import { v as i } from "./CEN8dYSpN2oew8HH2.js";
+import { Xt as a, t as o } from "./BNybEGR813e3aNIv.js";
+import { N as s, i as c } from "./iXWgTu3qpYZHcx1J.js";
 var l = e(t(), 1), u = n(), d = ["Ok"], f = [
-	i.Number,
-	i.String,
-	i.Boolean,
-	i.Error
+	r.Number,
+	r.String,
+	r.Boolean,
+	r.Error
 ], p = (0, l.memo)((e) => {
 	let { context: t, onDone: n, options: p = d, defaultOption: m = p?.[0], sx: h, ...g } = e, _ = a(), v = (0, l.useMemo)(() => {
 		let e = t?.().getWorkbook();
@@ -24,24 +24,24 @@ var l = e(t(), 1), u = n(), d = ["Ok"], f = [
 			let t = e.getTypedCounts(f);
 			return [
 				{
-					labelKey: r("workbookStatistics.cellsWithData"),
+					labelKey: i("workbookStatistics.cellsWithData"),
 					value: e.getCount().toLocaleString()
 				},
 				{
-					labelKey: r("workbookStatistics.numbers"),
-					value: (t[i.Number] ?? 0).toLocaleString()
+					labelKey: i("workbookStatistics.numbers"),
+					value: (t[r.Number] ?? 0).toLocaleString()
 				},
 				{
-					labelKey: r("workbookStatistics.text"),
-					value: (t[i.String] ?? 0).toLocaleString()
+					labelKey: i("workbookStatistics.text"),
+					value: (t[r.String] ?? 0).toLocaleString()
 				},
 				{
-					labelKey: r("workbookStatistics.booleans"),
-					value: (t[i.Boolean] ?? 0).toLocaleString()
+					labelKey: i("workbookStatistics.booleans"),
+					value: (t[r.Boolean] ?? 0).toLocaleString()
 				},
 				{
-					labelKey: r("workbookStatistics.errors"),
-					value: (t[i.Error] ?? 0).toLocaleString()
+					labelKey: i("workbookStatistics.errors"),
+					value: (t[r.Error] ?? 0).toLocaleString()
 				}
 			];
 		}, a = e.getSelectedSheet(), o = a.getUsedRange()?.getCoords(), s = o ? a.getRange({
@@ -51,17 +51,17 @@ var l = e(t(), 1), u = n(), d = ["Ok"], f = [
 			colEnd: o.colEnd
 		}).getAddress() : "–";
 		return [{
-			titleKey: r("workbookStatistics.currentSheet"),
+			titleKey: i("workbookStatistics.currentSheet"),
 			subTitle: a.getName(),
 			rows: [{
-				labelKey: r("workbookStatistics.endOfSheet"),
+				labelKey: i("workbookStatistics.endOfSheet"),
 				value: s
 			}, ...n(a.getStats({ onError: "ignore" }))]
 		}, {
-			titleKey: r("workbookStatistics.workbook"),
+			titleKey: i("workbookStatistics.workbook"),
 			subTitle: null,
 			rows: [{
-				labelKey: r("workbookStatistics.sheets"),
+				labelKey: i("workbookStatistics.sheets"),
 				value: e.getSheets().getCount().toLocaleString()
 			}, ...n(e.getStats({ onError: "ignore" }))]
 		}];