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

package/assets/a7BoASyT8yQZY9hJ.js

@@ -0,0 +1,22 @@
+/**
+* @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 { dirname as t, join as o, parse as r } from "node:path";
+import { readFile as n } from "node:fs/promises";
+import { fileURLToPath as s } from "node:url";
+async function e() {
+	let e = t(s(import.meta.url));
+	const i = r(e).root;
+	for (;;) {
+		for (const t of ["types/scripting-enums.json", "build/types/scripting-enums.json"]) try {
+			return JSON.parse(await n(o(e, t), "utf8"));
+		} catch {}
+		if (e === i) break;
+		e = t(e);
+	}
+	throw new Error("Unable to locate scripting-enums.json. Run `pnpm --filter @sheetxl/sdk build:types-scripting`.");
+}
+export { e as loadEnumManifest };

package/assets/aqguaobnu61szXWM.js

@@ -0,0 +1,22 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.14
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	DATESTRING: {
+		s: "Converts a standard date code into a localized text string.",
+		p: { number: { d: "A numeric value representing a date code." } },
+		h: "Unimplemented Japanese."
+	},
+	NUMBERSTRING: {
+		s: "Converts a number into Japanese Kanji words.",
+		p: {
+			number: { d: "A numeric value representing a date code." },
+			number2: { d: "A numeric value representing a date code." }
+		},
+		h: "Unimplemented Japanese."
+	}
+};
+export { e as default };

package/assets/cdIvC9t9tYtVn4nc.js

@@ -0,0 +1,405 @@
+/**
+* @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 { d as t } from "./CBNNl8igIyeHY4St.js";
+import { J as n, ea as r, ra as s } from "./DTlvhtB9hvPdbdxu.js";
+import { D as a, O as o, S as l, a as i, g as c, j as u, k as p, n as d, o as f, p as h, r as g, s as m, t as x, u as y, w as v, y as I } from "./C-CNmTrzNS-ZlQ8j.js";
+import { n as _, r as b, t as T } from "./DuZ6DXQGttY3Lrhd.js";
+var P = class {
+	constructor(e) {
+		e = { ...e }, this._editing = "editing" === e.profile, this._parser = new b(e);
+	}
+	compile(e, r, s, i, b, P, k, E, F) {
+		if (0 === i.length) {
+			const n = new t.Parse(T);
+			return this._compileUnparsed(e, b, i, {
+				input: i,
+				cause: n,
+				causes: [n]
+			});
+		}
+		if (i.length > n.MAX_EXPRESSION_LENGTH) {
+			const r = new t.Parse(_(i.length, n.MAX_EXPRESSION_LENGTH));
+			return this._compileUnparsed(e, b, i, {
+				input: i,
+				cause: r,
+				causes: [r]
+			});
+		}
+		let w, C, U = [];
+		try {
+			const e = this._parser.parse(r, s, i);
+			w = e.root, U = e.errors, E && w && 0 === U.length && (w.legacyIntersect = !0);
+		} catch (e) {
+			C = t.isError(e, t.Code.Parse) ? e : new t.Parse(e.message, e);
+		}
+		const R = [];
+		for (const e of U) R.push(y(e));
+		if (w) {
+			const e = p(w, P ?? null);
+			"string" == typeof e ? R.push(new t.Parse(e)) : w = e, l(w, P ?? null) && R.push(new t.Parse("The implicit intersection operator ' ' requires a cell or range on both sides")), v(w, P ?? null) && R.push(new t.Parse("The spill anchor operator '#' requires a cell or range")), c(w, P ?? null) && R.push(new t.Parse("Expected a reference; a value cannot be converted to one."));
+			const n = a(w, P ?? null);
+			n && R.push(new t.Parse(n));
+			const r = x(w, P ?? null);
+			r && R.push(new t.Parse(r));
+			const s = I(w, P ?? null);
+			s && R.push(new t.Parse(s));
+			const o = h(w);
+			o && R.push(new t.Parse(o));
+		}
+		R.length > 0 && !C && (C = R[0]);
+		let S = null;
+		if (C && (S = {
+			input: i,
+			cause: C,
+			causes: R.length > 0 ? R : [C]
+		}), !w) {
+			if (this._editing) {
+				const t = this._recoverCompiled(e, r, s, i, b, S, k);
+				if (t) return t;
+			}
+			return this._compileUnparsed(e, b, i, S, this._editing, () => A(b, k, r, s));
+		}
+		if (w = u(w, P ?? null), w = d(w, P ?? null), b) {
+			const e = this._editing ? F : {
+				mint: !F?.book,
+				...F
+			};
+			w = f(w, b, k, e, {
+				rowIndex: r,
+				colIndex: s
+			});
+			const n = m(w, b);
+			if (n) {
+				const e = new t.Parse(n);
+				R.push(e), S = {
+					input: i,
+					cause: S?.cause ?? e,
+					causes: S ? [...S.causes, e] : [e]
+				};
+			}
+		}
+		const z = g(e, b, w, this._editing, S, P ?? null);
+		return this._editing && S && o(z.getTokens(), b) !== i ? this._recoverCompiled(e, r, s, i, b, S, k) || this._compileUnparsed(e, b, i, S, !0) : z;
+	}
+	autoCorrect(e) {
+		const t = function(e) {
+			let t = 0, n = null;
+			for (let r = 0; r < e.length; r++) {
+				const s = e[r];
+				n ? s === n && (n = null) : t > 0 ? "'" === s ? r++ : "[" === s ? t++ : "]" === s && t-- : "\"" === s || "'" === s ? n = s : "[" === s && t++;
+			}
+			return n ? 0 : t;
+		}(e), n = e + "]".repeat(t);
+		let r;
+		try {
+			const e = this._parser.getLexer().tokenize(n, !1);
+			if (e.errors.length > 0) return null;
+			r = e.tokens;
+		} catch {
+			return null;
+		}
+		const s = [];
+		for (const e of r) {
+			const t = e.tokenType?.name;
+			if ("OpenParen" === t) s.push(")");
+			else if ("OpenCurlyParen" === t) s.push("}");
+			else if (("CloseParen" === t || "CloseCurlyParen" === t) && s.pop() !== ("CloseParen" === t ? ")" : "}")) return null;
+		}
+		return 0 === s.length && 0 === t ? null : n + s.reverse().join("");
+	}
+	_compileUnparsed(t, n, r, a, o = !1, l) {
+		const i = {
+			runtime: t,
+			symbols: n,
+			getFunction: null,
+			ast: null,
+			evaluations: e.EmptyArray,
+			executions: e.EmptyArray,
+			bindings: e.EmptyArray,
+			referencesAbsolute: e.EmptyArray,
+			referencesExecute: e.EmptyArray,
+			referencesRelative: e.EmptyArray,
+			referencesRoot: e.EmptyArray,
+			referenceIndices: e.EmptyArray,
+			formatReferenceIndices: e.EmptyArray,
+			getTokens: () => {
+				const e = [];
+				return o && w(e, r, void 0, l) ? e : [{
+					type: s.Unparsed,
+					value: r,
+					text: r
+				}];
+			},
+			namedIds: e.EmptyArray,
+			symbolIds: e.EmptyArray,
+			hasTotals: !1,
+			hasDataTable: !1,
+			hasVolatile: !1,
+			isBlankCacheable: !1,
+			isBlankCacheableArray: !1,
+			isReferenceOnly: !1,
+			error: a,
+			transform: () => i
+		};
+		return i;
+	}
+	_recoverCompiled(e, t, n, r, a, l, i) {
+		let c, u = r.length;
+		try {
+			const e = this._parser.getLexer().tokenize(r, !1);
+			c = e.tokens, e.errors.length > 0 && (u = Math.min(u, e.errors[0].offset));
+		} catch {
+			return null;
+		}
+		const p = [];
+		for (let e = c.length - 1; e >= 0 && p.length < 24; e--) {
+			const t = (c[e].endOffset ?? -1) + 1;
+			t > 0 && t < r.length && t <= u && p.push(t);
+		}
+		for (const c of p) {
+			const u = r.slice(0, c);
+			let p, h;
+			try {
+				p = this._parser.parse(t, n, u).root;
+			} catch {
+				continue;
+			}
+			if (!p || p.type === s.Unparsed) continue;
+			try {
+				const r = d(p, null), s = a ? f(r, a, i, void 0, {
+					rowIndex: t,
+					colIndex: n
+				}) : r;
+				h = g(e, a, s, !0, l);
+			} catch {
+				continue;
+			}
+			if (o(h.getTokens(), a) !== u) continue;
+			const m = r.slice(c);
+			if (0 === m.length) return h;
+			let x;
+			const y = {
+				...h,
+				getTokens: () => (x || (x = [...h.getTokens()], this._appendUnparsedTail(x, m, () => A(a, i, t, n))), x),
+				transform: () => y
+			};
+			return y;
+		}
+		return null;
+	}
+	_appendUnparsedTail(e, t, n) {
+		const r = [];
+		for (const t of e) {
+			if (t.type === s.Whitespace) continue;
+			const e = t.type === s.Paren || t.type === s.Type ? t.text : void 0, n = r.length > 0 ? r[r.length - 1] : void 0;
+			if (t.type === s.Separator && n) {
+				const e = n.declared[n.declared.length - 1];
+				"let" === n.ctx?.type && -1 === n.ctx.argIndex && n.lambda?.argTokens === n.argTokens && e?.argIndex === n.argIndex - 1 && (e.params = n.lambda.params), n.argIndex++, n.argTokens = 0, n.lambda = void 0;
+				continue;
+			}
+			if (n && n.argTokens++, "(" === e || "[" === e || "{" === e) r.push({
+				ctx: t.context,
+				argIndex: 0,
+				declared: [],
+				argTokens: 0,
+				leadsArg: 2 === n?.argTokens
+			});
+			else if (")" === e || "]" === e || "}" === e) {
+				const e = r.pop(), t = r.length > 0 ? r[r.length - 1] : void 0;
+				t && e?.leadsArg && "lambda" === e.ctx?.type && -1 === e.ctx.argIndex && (t.lambda = {
+					params: e.declared.map(({ name: e, optional: t }) => t ? {
+						name: e,
+						optional: t
+					} : { name: e }),
+					argTokens: t.argTokens
+				});
+			} else if (t.type === s.Parameter && n && t.value?.declaration) {
+				const e = t.value;
+				n.declared.push(e.optional ? {
+					name: e.name,
+					argIndex: n.argIndex,
+					optional: !0
+				} : {
+					name: e.name,
+					argIndex: n.argIndex
+				});
+			}
+		}
+		const a = r.length > 0 ? r[r.length - 1] : void 0, o = a?.ctx ? {
+			...a.ctx,
+			argIndex: -1 === a.ctx.argIndex ? a.argIndex : a.ctx.argIndex
+		} : void 0;
+		if (o && -1 === a.ctx.argIndex && ("let" === o.type || "lambda" === o.type)) {
+			const e = "let" === o.type ? 2 : 1;
+			let t = o.bound;
+			for (const n of a.declared) {
+				if (o.argIndex < n.argIndex + e) continue;
+				const { name: r, params: s } = n;
+				t = i(t, s ? {
+					name: r,
+					params: s
+				} : { name: r });
+			}
+			t && (o.bound = t);
+		}
+		const l = (t, n) => {
+			const r = n ? {
+				type: s.Named,
+				value: { name: t },
+				text: t
+			} : {
+				type: s.Unparsed,
+				value: t,
+				text: t
+			};
+			o && (r.context = o), e.push(r);
+		};
+		if (w(e, t, o, n)) return;
+		const c = /[A-Za-z_][A-Za-z0-9_]*$/.exec(t), u = c ? c.index : -1;
+		let p = u > 0 ? t[u - 1] : "";
+		for (let t = e.length - 1; 0 === u && t >= 0 && !p; t--) p = e[t].text?.at(-1) ?? "";
+		u >= 0 && !/[A-Za-z0-9_.]/.test(p) ? (u > 0 && l(t.slice(0, u)), l(t.slice(u), !0)) : l(t);
+	}
+};
+function A(e, t, n, s) {
+	if (!e || !t) return;
+	const a = e.bind(r.Table, "", { at: {
+		scope: t,
+		rowIndex: n,
+		colIndex: s
+	} });
+	return a ? e.resolve(r.Table, a)?.toString() : void 0;
+}
+var k = /[A-Za-z_\\\u007F-\uFFFF][A-Za-z0-9_.\u007F-\uFFFF]*$/, E = /[A-Za-z0-9_.)\]}"'!#\u007F-\uFFFF]/;
+function F(e, t) {
+	for (let n = t + 1; n < e.length; n++) {
+		const t = e[n];
+		if ("'" !== t) {
+			if ("]" === t) return n + 1;
+			if ("[" === t) return null;
+		} else n++;
+	}
+	return -1;
+}
+function w(e, t, n, r) {
+	let a = 0, o = -1;
+	for (let e = 0; e < t.length; e++) {
+		const n = t[e];
+		a > 0 && "'" === n ? e++ : "[" === n ? (0 === a && (o = e), a++) : "]" === n && a > 0 && a--;
+	}
+	if (0 === a) return !1;
+	let l = t.slice(0, o);
+	if ((l.split("\"").length - 1) % 2 == 1) return !1;
+	const i = e.length > 0 ? e[e.length - 1] : void 0;
+	let c = "", u = !1;
+	const p = k.exec(l);
+	if (p) {
+		const e = p.index > 0 ? l[p.index - 1] : i?.text?.at(-1) ?? "";
+		if (/[A-Za-z0-9_.]/.test(e)) return !1;
+		c = p[0], l = l.slice(0, p.index);
+	} else 0 === l.length && i?.text && 0 === k.exec(i.text)?.index && (i.type === s.Named && !i.value?.scope || i.type === s.TableReference) && (c = i.text, u = !0);
+	if (!u) {
+		const e = l.length > 0 ? l[l.length - 1] : i?.text?.at(-1) ?? "";
+		if (e && E.test(e)) return !1;
+	}
+	const d = c || (r?.() ?? ""), f = [], h = (e, t, n) => {
+		f.push({
+			type: e,
+			value: t,
+			text: t,
+			context: {
+				name: d,
+				argIndex: n,
+				type: "table"
+			}
+		});
+	}, g = (e, t, n, r) => {
+		const a = e.startsWith("#"), o = n ? r ? "column" : a ? "specifier" : e ? "column" : "any" : void 0, l = o ? {
+			table: d,
+			name: e,
+			partial: o
+		} : {
+			table: d,
+			name: e
+		};
+		f.push({
+			type: a ? s.TableSpecifier : s.TableColumn,
+			value: l,
+			text: e,
+			context: {
+				name: d,
+				argIndex: t,
+				type: "table"
+			}
+		});
+	}, m = (e, t, n, r) => {
+		h(s.Paren, "[", n), g(e.slice(1, t ? -1 : void 0), n, !t, r), t && h(s.Paren, "]", n);
+	};
+	h(s.Paren, "[", -1);
+	const x = t.slice(o + 1);
+	if (x.startsWith("[")) {
+		let e = 0, t = !1, n = 0;
+		for (; n < x.length;) {
+			const r = x[n];
+			if ("[" === r) {
+				const r = F(x, n);
+				if (null === r) return !1;
+				const s = -1 !== r;
+				if (m(x.slice(n, s ? r : x.length), s, e, t), t = !1, !s) break;
+				n = r;
+			} else if ("," === r) h(s.Separator, ",", e++), n++;
+			else if (":" === r) h(s.Infix, ":", e), n++;
+			else if ("@" === r) h(s.Prefix, "@", e), t = !0, n++;
+			else {
+				if (" " !== r) return !1;
+				{
+					let t = n;
+					for (; " " === x[t];) t++;
+					h(s.Whitespace, x.slice(n, t), e), n = t;
+				}
+			}
+		}
+	} else {
+		let e = x;
+		const t = e.startsWith("@");
+		if (t && (h(s.Prefix, "@", 0), e = e.slice(1)), e.startsWith("[")) {
+			if (-1 !== F(e, 0)) return !1;
+			m(e, !1, 0, t);
+		} else {
+			if (/(^|[^'])[[\]]/.test(e) || e.startsWith("#") && e.includes(",")) return !1;
+			g(e, 0, !0, t);
+		}
+	}
+	if (l) {
+		const t = {
+			type: s.Unparsed,
+			value: l,
+			text: l
+		};
+		n && (t.context = n), e.push(t);
+	}
+	if (u) {
+		const t = {
+			...i,
+			type: s.TableReference,
+			value: c,
+			text: c
+		};
+		delete t.referenceIndex, e[e.length - 1] = t;
+	} else if (c) {
+		const t = {
+			type: s.TableReference,
+			value: c,
+			text: c
+		};
+		n && (t.context = n), e.push(t);
+	}
+	for (const t of f) e.push(t);
+	return !0;
+}
+export { P as FormulaCompiler, w as appendPartialStructuredReference };

package/assets/cv7k-VAIJtYeL9k4.js

@@ -0,0 +1,23 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.14
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	DELTA: {
+		s: "Tests whether two numbers are equal.",
+		p: {
+			number1: { d: "is the first number." },
+			number2: { d: "is the second number." }
+		}
+	},
+	GESTEP: {
+		s: "Tests whether a number is greater than a threshold value.",
+		p: {
+			number: { d: "is the value to test against step." },
+			step: { d: "is the threshold value." }
+		}
+	}
+};
+export { e as default };

package/assets/ddJqSu7gXUkXjGxZ.js

@@ -0,0 +1,13 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.14
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var t = { BAHTTEXT: {
+	s: "Converts a number to baht (Thai) text.",
+	c: "Baht",
+	p: { number: { d: "is the number to convert." } },
+	h: "Thai"
+} };
+export { t as default };

package/assets/eHAVGCUcMAfNjEGt.js

@@ -0,0 +1,7 @@
+/**
+* @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.
+*/
+export { F as ZipReader, I as getEntryDataDescriptorLength } from "./BFwNQZVRnbNt-gRJ.js";

package/assets/hRLLK6I6m0uGKWo8.js

@@ -0,0 +1,32 @@
+/**
+* @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 { r as e } from "./33QTHR3r6ZujxFx8.js";
+import { m as r } from "./CBNNl8igIyeHY4St.js";
+import { P as t } from "./BDZ1FGc1zFqO1nK7.js";
+var o = async (o, s) => {
+	const { papaParseConfig: a, setValuesOptions: n, createWorkbookOptions: i } = s ?? {}, d = s?.progress, m = d?.onProgress ? d.onProgress.bind(d) : void 0, p = await import("./9MRZ5Yc2RBgcqZSp.js").then((r) => e(r.default, 1)), g = p.default ?? p, c = new TextDecoder().decode(o);
+	let f = -1;
+	const l = new t(i), u = l.getWorksheetAt(0), h = u.getEntireRange().getCoords(), w = h.colEnd, x = h.rowEnd, P = u.getEntireRange().createSparseBuilder({ axis: r.Axis.Row });
+	let j = 0, E = 0;
+	const k = {
+		...a,
+		transform: (e, r) => {
+			a?.transform && (e = a.transform(e, r));
+			const t = r;
+			0 === t && f++;
+			let o = e ?? "";
+			if (!(f > x || t > w)) return P.pushAt(f, t, o), j++, j % 1e5 == 0 && m?.(j), e;
+			0 === t && E++;
+		}
+	};
+	return g.parse(c, k).data, P.apply({
+		textParser: !0,
+		autoFormat: !0,
+		...n
+	}), E > 0 && d?.onWarning?.(`Ignored ${E} ${1 === E ? "row" : "rows"} that exceeded the maximum range of the sheet`), l;
+};
+export { o as readCSV };

package/assets/mcFLzsOH35mvmd3C.js

@@ -0,0 +1,145 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.14
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	CELL: {
+		s: "Returns information about the cell.",
+		p: {
+			infoType: { d: "The type of information to return." },
+			reference: { d: "The cell to report on. Defaults to the cell holding the formula." }
+		}
+	},
+	"ERROR.TYPE": {
+		s: "Returns a number matching an error value.",
+		p: { errorVal: { d: "is the error value for which you want the identifying number, and can be an actual error value or a reference to a cell containing an error value." } }
+	},
+	INFO: {
+		s: "Returns information about the current operating system.",
+		p: { typeText: { d: "The type of information to return." } }
+	},
+	ISBLANK: {
+		s: "Checks whether a reference is to an empty cell, and returns TRUE or FALSE.",
+		p: { value: { d: "is the cell or a name that refers to the cell you want to test." } }
+	},
+	ISDATE: {
+		s: "Returns TRUE if the value is a date.",
+		c: "Sheets",
+		p: { value: { d: "The value to check." } }
+	},
+	ISEMAIL: {
+		s: "Returns TRUE if the value is a valid email address.",
+		c: "Sheets",
+		p: { value: { d: "The value to check." } }
+	},
+	ISERR: {
+		s: "Checks whether a value is an error other than #N/A, and returns TRUE or FALSE.",
+		p: { value: { d: "is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value." } }
+	},
+	ISERROR: {
+		s: "Checks whether a value is an error, and returns TRUE or FALSE",
+		p: { value: { d: "is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value" } }
+	},
+	ISEVEN: {
+		s: "Returns TRUE if the number is even.",
+		p: { number: { d: "is the value to test." } }
+	},
+	ISFORMULA: {
+		s: "Checks whether a reference is to a cell containing a formula, and returns TRUE or FALSE.",
+		p: { reference: { d: "is a reference to the cell you want to test.  Reference can be a cell reference, a formula, or name that refers to a cell." } }
+	},
+	ISLOGICAL: {
+		s: "Checks whether a value is a logical value (TRUE or FALSE), and returns TRUE or FALSE.",
+		p: { value: { d: "is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value." } }
+	},
+	ISNA: {
+		s: "Checks whether a value is #N/A, and returns TRUE or FALSE.",
+		p: { value: { d: "is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value." } }
+	},
+	ISNONTEXT: {
+		s: "Checks whether a value is not text (blank cells are not text), and returns TRUE or FALSE.",
+		p: { value: { d: "is the value you want tested: a cell; a formula; or a name referring to a cell, formula, or value." } }
+	},
+	ISNUMBER: {
+		s: "Checks whether a value is not text (blank cells are not text), and returns TRUE or FALSE.",
+		p: { value: { d: "is the value you want tested: a cell; a formula; or a name referring to a cell, formula, or value." } }
+	},
+	ISODD: {
+		s: "Returns TRUE if the number is odd.",
+		p: { number: { d: "is the value to test." } }
+	},
+	ISOMITTED: {
+		s: "Checks whether the value is omitted, and returns TRUE or FALSE.",
+		p: { argument: { d: "is the value you want to test, such as a LAMBDA parameter." } }
+	},
+	ISURL: {
+		s: "Returns TRUE if the value is a valid HTTP or HTTPS URL.",
+		c: "Sheets",
+		p: { value: { d: "The value to check." } }
+	},
+	ISREF: {
+		s: "Checks whether a value is a reference, and returns TRUE or FALSE.",
+		p: { value: { d: "is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value." } }
+	},
+	ISTEXT: {
+		s: "Converts a value to text in a specific number format.",
+		p: { value: { d: "is a number, a formula that evaluates to a numeric value, or a reference to a cell containing a numeric value." } }
+	},
+	N: {
+		s: "Converts non-number value to a number, dates to serial numbers, TRUE to 1, anything else to 0 (zero).",
+		p: { value: { d: "is the value to convert." } }
+	},
+	NA: {
+		s: "Returns the #N/A error value",
+		p: {}
+	},
+	SHEET: {
+		s: "Returns the sheet number of the referenced sheet.",
+		p: { value: { d: "is the name of a sheet or a reference that you want the sheet number of. If omitted the number of the sheet containing the function is returned." } }
+	},
+	SHEETS: {
+		s: "Returns the number of sheets in a reference.",
+		p: { reference: { d: "is a reference for which you want to know the number of sheets it contains. If omitted the number of sheets in the workbook containing the function is returned." } }
+	},
+	TYPE: {
+		s: "Returns an integer representing the data type of a value: number = 1; text = 2; logical value = 4; error value = 16; array = 64; compound data = 128.",
+		p: { value: { d: "is the value to check." } }
+	}
+}, t = {
+	CellInfoType: {
+		s: "The information to return about the cell.",
+		m: {
+			Address: { d: "Reference of the first cell in the reference, as text." },
+			Col: { d: "Column number of the cell in the reference." },
+			Color: { d: "1 if the cell is formatted in color for negative values; otherwise 0." },
+			Contents: { d: "Value of the upper-left cell in the reference; not a formula." },
+			Filename: { d: "Full path of the file that contains the reference, as text." },
+			Format: { d: "Text value corresponding to the number format of the cell." },
+			Parentheses: { d: "1 if the cell is formatted with parentheses for positive or all values; otherwise 0." },
+			Prefix: { d: "Text value corresponding to the label prefix of the cell." },
+			Protect: { d: "0 if the cell is not locked; otherwise 1." },
+			Row: { d: "Row number of the cell in the reference." },
+			Type: { d: "\"b\" for a blank cell, \"l\" for a text constant, \"v\" for anything else." },
+			Width: { d: "Column width of the cell, rounded to an integer." }
+		}
+	},
+	InfoType: {
+		s: "The information to return about the operating environment.",
+		m: {
+			Directory: { d: "Path of the current directory or folder." },
+			"Mem Avail": { d: "Amount of memory available. Legacy: answers #N/A." },
+			"Mem Used": { d: "Amount of memory being used for data. Legacy: answers #N/A." },
+			"Num File": { d: "Number of active worksheets in the open workbooks." },
+			Origin: { d: "Absolute reference of the top and leftmost visible cell." },
+			"OS Version": { d: "Current operating system version, as text." },
+			Recalc: { d: "Current recalculation mode; \"Automatic\" or \"Manual\"." },
+			Release: { d: "Version of the application, as text." },
+			System: { d: "Name of the operating environment; \"pcdos\" or \"mac\"." },
+			"Tot Mem": { d: "Total memory available. Legacy: answers #N/A." },
+			User: { d: "The licensed user. Not part of Excel." }
+		}
+	}
+};
+export { e as default, t as enums };