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

package/assets/CPDkdp0yI4DwUHGZ.js

@@ -0,0 +1,119 @@
+/**
+* @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 = {
+	FV: {
+		s: "Returns the future value of an investment based on periodic, constant payments and a constant interest rate.",
+		p: {
+			rate: { d: "is the interest rate." },
+			nper: { d: "is the total number of payment periods." },
+			pmt: { d: "is the payment made each period; it cannot change over the life of the investment." },
+			pv: { d: "is the present value of the investment." },
+			type: { d: "Indicates when payments are due: at the end of the period = 0, at the beginning of the period = 1." }
+		}
+	},
+	PV: {
+		s: "Returns the present value of an investment: the total amount that a series of future payments is worth now.",
+		p: {
+			rate: { d: "is the interest rate." },
+			nper: { d: "is the total number of payment periods in an investment." },
+			pmt: { d: "is the payment made each period and cannot change over the life of the investment." },
+			fv: { d: "is the future value, or a cash balance you want to attain after the last payment is made." },
+			type: { d: "is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0." }
+		}
+	},
+	PMT: {
+		s: "Calculates the payment for a loan based on constant payments and a constant interest rate.",
+		p: {
+			rate: { d: "is the interest rate." },
+			nper: { d: "is the total number of payment periods." },
+			pv: { d: "is the present value of the investment." },
+			fv: { d: "is the future value, or a cash balance you want to attain after the last payment is made." },
+			type: { d: "is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0." }
+		}
+	},
+	NPER: {
+		s: "Returns the number of periods for an investment based on periodic, constant payments and a constant interest rate.",
+		p: {
+			rate: { d: "is the interest rate per period. For example, use 6%/4 for quarterly payments at 6% APR." },
+			pmt: { d: "is the payment made each period; it cannot change over the life of the investment." },
+			pv: { d: "is the present value, or the lump-sum amount that a series of future payments is worth now." },
+			fv: { d: "is the future value, or a cash balance you want to attain after the last payment is made." },
+			type: { d: "is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0." }
+		}
+	},
+	RATE: {
+		s: "Returns the interest rate per period of a loan or an investment. For example, use 6%/4 for quarterly payments at 6% APR.",
+		p: {
+			nper: { d: "is the total number of payment periods." },
+			pmt: { d: "is the payment made each period and cannot change over the life of the loan or investment." },
+			pv: { d: "is the present value: the total amount that a series of future payments is worth now." },
+			fv: { d: "is the future value, or a cash balance you want to attain after the last payment is made." },
+			type: { d: "is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0." },
+			guess: { d: "is your guess for what the rate will be." }
+		}
+	},
+	IPMT: {
+		s: "Returns the interest payment for a given period for an investment, based on periodic, constant payments and a constant interest rate.",
+		p: {
+			rate: { d: "is the interest rate." },
+			per: { d: "is the period for which you want to find the interest and must be in the range 1 to Nper." },
+			nper: { d: "is the total number of payment periods." },
+			pv: { d: "is the present value of the investment." },
+			fv: { d: "is the future value, or a cash balance you want to attain after the last payment is made." },
+			type: { d: "is a logical value representing the timing of payment: at the end of the period = 0, at the beginning of the period = 1." }
+		}
+	},
+	PPMT: {
+		s: "Returns the payment on the principal for a given investment based on periodic, constant payments and a constant payments and a constant interest rate.",
+		p: {
+			rate: { d: "is the interest rate per period." },
+			per: { d: "is the period for which you want to find the principal payment and must be in the range 1 to Nper." },
+			nper: { d: "is the total number of payment periods in the investment." },
+			pv: { d: "is the present value of the investment." },
+			fv: { d: "is the future value, or a cash balance you want to attain after the last payment is made." },
+			type: { d: "is a logical value: payment at the beginning of the period = 1; payment at the end of the period = 0." }
+		}
+	},
+	CUMIPMT: {
+		s: "Returns the cumulative interest paid between two periods.",
+		p: {
+			rate: { d: "is the interest rate." },
+			nper: { d: "is the total number of payment periods." },
+			pv: { d: "is the present value of the investment." },
+			startPeriod: { d: "is the first period in the calculation." },
+			endPeriod: { d: "is the last period in the calculation." },
+			type: { d: "is the timing of the payment." }
+		}
+	},
+	CUMPRINC: {
+		s: "Returns the cumulative principal paid on a loan between two periods.",
+		p: {
+			rate: { d: "is the interest rate." },
+			nper: { d: "is the total number of payment periods." },
+			pv: { d: "is the present value of the investment." },
+			startPeriod: { d: "is the first period in the calculation." },
+			endPeriod: { d: "is the last period in the calculation." },
+			type: { d: "is the timing of the payment." }
+		}
+	},
+	ISPMT: {
+		s: "Returns the interest paid during a specific period of an investment.",
+		p: {
+			rate: { d: "is the interest rate." },
+			per: { d: "period for which you want to find the interest." },
+			nper: { d: "number of payment periods in an investment." },
+			pv: { d: "lump sum amount that a series of future payments is right now." }
+		}
+	}
+}, t = { PaymentType: {
+	s: "When payments are due in each period.",
+	m: {
+		"At the end of the period": { d: "Payments are due at the end of each period." },
+		"At the beginning of the period": { d: "Payments are due at the beginning of each period." }
+	}
+} };
+export { e as default, t as enums };

package/assets/CULV-2mwmqYYpAjM.js

@@ -0,0 +1,119 @@
+/**
+* @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 = {
+	BIN2DEC: {
+		s: "Converts a binary number to decimal.",
+		p: { number: { d: "is the binary number you want to convert." } }
+	},
+	BIN2HEX: {
+		s: "Converts a binary number to hexadecimal.",
+		p: {
+			number: { d: "is the binary number you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	BIN2OCT: {
+		s: "Converts a binary number to octal.",
+		p: {
+			number: { d: "is the binary number you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	BITAND: {
+		s: "Returns a bitwise 'And' of two numbers.",
+		p: {
+			number1: { d: "is the decimal representation of the binary number you want to evaluate." },
+			number2: { d: "is the decimal representation of the binary number you want to evaluate." }
+		}
+	},
+	BITLSHIFT: {
+		s: "Returns a number shifted left by shiftAmount bits.",
+		p: {
+			number: { d: "is the decimal representation of the binary number you want to evaluate." },
+			shiftAmount: { d: "is the number of bits that you want to shift Number left by." }
+		}
+	},
+	BITOR: {
+		s: "Returns a bitwise 'Or' of two numbers.",
+		p: {
+			number1: { d: "is the decimal representation of the binary number you want to evaluate." },
+			number2: { d: "is the decimal representation of the binary number you want to evaluate." }
+		}
+	},
+	BITRSHIFT: {
+		s: "Returns a number shifted right by shiftAmount bits.",
+		p: {
+			number: { d: "is the decimal representation of the binary number you want to evaluate." },
+			shiftAmount: { d: "is the number of bits that you want to shift Number left by." }
+		}
+	},
+	BITXOR: {
+		s: "Returns a bitwise 'Exclusive Or' of two numbers.",
+		p: {
+			number1: { d: "is the decimal representation of the binary number you want to evaluate." },
+			number2: { d: "is the decimal representation of the binary number you want to evaluate." }
+		}
+	},
+	DEC2BIN: {
+		s: "Converts a decimal number to binary.",
+		p: {
+			number: { d: "is the decimal integer you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	DEC2HEX: {
+		s: "Converts a decimal number to hexadecimal.",
+		p: {
+			number: { d: "is the decimal integer you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	DEC2OCT: {
+		s: "Converts a decimal number to octal.",
+		p: {
+			number: { d: "is the decimal integer you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	HEX2BIN: {
+		s: "Converts a Hexadecimal number to binary.",
+		p: {
+			number: { d: "is the hexadecimal number you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	HEX2DEC: {
+		s: "Converts a hexadecimal number to decimal.",
+		p: { number: { d: "is the hexadecimal number you want to convert." } }
+	},
+	HEX2OCT: {
+		s: "Converts a hexadecimal number to octal.",
+		p: {
+			number: { d: "is the hexadecimal number you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	OCT2BIN: {
+		s: "Converts an octal number to binary.",
+		p: {
+			number: { d: "is the octal number you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	},
+	OCT2DEC: {
+		s: "Converts an octal number to decimal.",
+		p: { number: { d: "is the octal number you want to convert." } }
+	},
+	OCT2HEX: {
+		s: "Converts an octal number to hexadecimal.",
+		p: {
+			number: { d: "is the octal number you want to convert." },
+			places: { d: "is the number of characters to use." }
+		}
+	}
+};
+export { e as default };

package/assets/CVFTQ0OwsUt03r4o.js

@@ -0,0 +1,146 @@
+/**
+* @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 = {
+	AND: {
+		s: "Checks whether all arguments are TRUE, and returns TRUE if all arguments are TRUE.",
+		p: { logical: { d: "are 1 to 255 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references." } }
+	},
+	BYCOL: {
+		s: "Applies a LAMBDA function to each column and returns an array of the results.",
+		p: {
+			array: { d: "is an array to be separated by column." },
+			fn: { d: "is a LAMBDA that takes a column as its single parameter and returns one result for it." }
+		}
+	},
+	BYROW: {
+		s: "Applies a LAMBDA function to each row and returns an array of the results.",
+		p: {
+			array: { d: "is an array to be separated by row." },
+			fn: { d: "is a LAMBDA that takes a row as its single parameter and returns one result for it." }
+		}
+	},
+	FALSE: {
+		s: "Returns the logical value FALSE.",
+		p: {}
+	},
+	FLATTEN: {
+		s: "Flattens all the values from one or more ranges into a single column.",
+		c: "Sheets",
+		p: { ranges: { d: "One or more ranges or scalar values to flatten." } }
+	},
+	IF: {
+		s: "Checks whether a condition is met, and returns one value if TRUE, and another value if FALSE.",
+		p: {
+			logicalTest: { d: "is any value or expression that can be evaluated to TRUE or FALSE." },
+			valueIfTrue: { d: "is the value that is returned if logicalTest is TRUE. If omitted, TRUE is returned. You can nest up to seven IF functions." },
+			valueIfFalse: { d: "is the value that is returned if logicalTest is FALSE. If omitted, FALSE is returned." }
+		}
+	},
+	IFERROR: {
+		s: "Returns valueIfError if expression is an error and the value of the expression itself otherwise.",
+		p: {
+			value: { d: "is any value or expression or reference." },
+			valueIfError: { d: "is any value or expression or reference." }
+		}
+	},
+	IFNA: {
+		s: "Returns the value you specify if the expression resolves to #N/A, otherwise returns the result of the expression.",
+		p: {
+			value: { d: "is any value or expression or reference." },
+			valueIfNA: { d: "is any value or expression or reference." }
+		}
+	},
+	IFS: {
+		s: "Checks whether one or more conditions are met and returns a value corresponding to the first TRUE condition.",
+		p: {
+			condition: { d: "the conditions to test and the values to return for them." },
+			"condition.logicalTest": { d: "is any value or expression that can be evaluated to TRUE or FALSE." },
+			"condition.logicalTrue": { d: "is the value returned if logicalTest is TRUE." }
+		}
+	},
+	LAMBDA: {
+		s: "Creates a function value which can be called within formulas.",
+		p: { parameterOrCalculation: { d: "a parameter or a calculation that returns a value. If a parameter, it must be the last argument." } }
+	},
+	LET: {
+		s: "Assigns calculation results to names. Useful for storing intermediate calculations and values by defining names inside a formula. These names only apply within the scope of the LET function.",
+		p: {
+			name: { d: "the name, or a calculation which can make use of all names within the LET. Names must start with a letter, cannot be the output of a formula, or conflict with range syntax." },
+			nameOrValue: { d: "the value associated with the name." },
+			calculationOrName: {},
+			rest: {}
+		}
+	},
+	MAKEARRAY: {
+		s: "Returns a calculated array of a specified row and column size, by applying a LAMBDA function.",
+		p: {
+			rows: { d: "is the number of rows in the array. Must be greater than zero." },
+			columns: { d: "is the number of columns in the array. Must be greater than zero." },
+			fn: { d: "is a LAMBDA that is called to create the array. The LAMBDA takes two parameters, row index and column index." }
+		}
+	},
+	MAP: {
+		s: "Returns an array formed by 'mapping' each value in the array(s) to a new value by applying a lambda to create a new value.",
+		p: {
+			array: { d: "is an array to be mapped." },
+			lambdaOrArray: { d: "is a LAMBDA which must be the last argument and must have a parameter for each array passed, or another array to be mapped." }
+		}
+	},
+	NOT: {
+		s: "Changes FALSE to TRUE, or TRUE to FALSE.",
+		p: { logical: { d: "is a value or expression that can be evaluated to TRUE or FALSE." } }
+	},
+	OR: {
+		s: "Checks whether any of the arguments are TRUE, and returns TRUE or FALSE. Returns FALSE only if all arguments are FALSE.",
+		p: { logical: { d: "are 1 to 255 conditions that you want to test that can be either TRUE or FALSE." } }
+	},
+	REDUCE: {
+		s: "Reduces an array to an accumulated value by applying a LAMBDA function to each value and returning the total value in the accumulator.",
+		p: {
+			initialValue: { d: "is the starting value for the accumulator." },
+			array: { d: "is an array to be reduced." },
+			fn: { d: "is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value." }
+		}
+	},
+	REDUCEIF: {
+		s: "Reduces the cells specified by a given condition or criteria.",
+		c: "SheetXL",
+		p: {
+			range: { d: "is the range of cells you want evaluated." },
+			criteria: { d: "is the condition or criteria in the form of a number, expression, or text that defines which cells will be reduced." },
+			reduceRange: { d: "are the actual cells to reduce. If omitted, the cells in range are used. This can be blank." },
+			fn: { d: "is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value." }
+		}
+	},
+	SCAN: {
+		s: "Scans an array by applying a LAMBDA function to each value and returns an array that has each intermediate value.",
+		p: {
+			initialValue: { d: "is the starting value for the accumulator." },
+			array: { d: "is an array to be reduced." },
+			fn: { d: "is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value." }
+		}
+	},
+	SWITCH: {
+		s: "Evaluates an expression against a list of values and returns the result corresponding to the first matching value. If there is no match, an optional default value is returned.",
+		p: {
+			expression: { d: "is an expression to be evaluated." },
+			match: { d: "the values to compare against expression and the results to return for them." },
+			"match.value": { d: "is a value to compare against expression." },
+			"match.result": { d: "is a result to be returned if the corresponding value matches expression." },
+			defaultResult: { d: "is the result to be returned when no value matches expression." }
+		}
+	},
+	TRUE: {
+		s: "Returns the logical value TRUE.",
+		p: {}
+	},
+	XOR: {
+		s: "Returns a logical 'Exclusive Or' of all arguments.",
+		p: { logical: { d: "are 1 to 254 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references." } }
+	}
+};
+export { e as default };

package/assets/CXM1IYmE-TDInPwr.js

@@ -0,0 +1,118 @@
+/**
+* @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 = class t {
+	static {
+		this.SIGNATURE = 3759263696;
+	}
+	static {
+		this.ENDOFCHAIN = 4294967294;
+	}
+	static {
+		this.FREESECT = 4294967295;
+	}
+	constructor(e) {
+		this.buf = e, this.dv = new DataView(e.buffer, e.byteOffset, e.byteLength);
+		const i = this.dv;
+		if (i.getUint32(0, !0) !== t.SIGNATURE) throw new Error("Not an OLE Compound File (bad signature).");
+		const n = i.getUint16(30, !0), r = i.getUint16(32, !0);
+		this.sectorSize = 1 << n, this.miniSectorSize = 1 << r, this.miniStreamCutoff = i.getUint32(56, !0) || 4096;
+		const s = i.getUint32(48, !0), a = i.getUint32(60, !0), o = i.getUint32(64, !0), h = i.getUint32(68, !0), c = i.getUint32(72, !0), f = [];
+		for (let e = 0; e < 109; e++) {
+			const n = i.getUint32(76 + 4 * e, !0);
+			if (n === t.FREESECT || n === t.ENDOFCHAIN) break;
+			f.push(n);
+		}
+		let S = h;
+		const g = this.sectorSize / 4;
+		let u = 0;
+		for (; S !== t.ENDOFCHAIN && S !== t.FREESECT && u++ < c + 1;) {
+			const e = this.sectorOffset(S);
+			for (let n = 0; n < g - 1; n++) {
+				const r = i.getUint32(e + 4 * n, !0);
+				r !== t.FREESECT && r !== t.ENDOFCHAIN && f.push(r);
+			}
+			S = i.getUint32(e + 4 * (g - 1), !0);
+		}
+		const E = new Uint32Array(f.length * g);
+		let l = 0;
+		for (const t of f) {
+			const e = this.sectorOffset(t);
+			for (let t = 0; t < g; t++) E[l++] = i.getUint32(e + 4 * t, !0);
+		}
+		this.fat = E;
+		const m = this.readChain(s), U = new DataView(m.buffer, m.byteOffset, m.byteLength), y = [], C = Math.floor(m.length / 128);
+		for (let t = 0; t < C; t++) {
+			const e = 128 * t, i = m[e + 66];
+			if (0 === i) continue;
+			const n = U.getUint16(e + 64, !0);
+			let r = "";
+			for (let t = 0; t < n / 2 - 1 && t < 31; t++) r += String.fromCharCode(U.getUint16(e + 2 * t, !0));
+			y.push({
+				name: r,
+				type: i,
+				startSector: U.getUint32(e + 116, !0),
+				size: U.getUint32(e + 120, !0)
+			});
+		}
+		this.entries = y, this.byName = new Map(y.map((t) => [t.name, t]));
+		const d = o ? this.readChain(a) : /* @__PURE__ */ new Uint8Array(0), b = new DataView(d.buffer, d.byteOffset, d.byteLength);
+		this.miniFat = new Uint32Array(Math.floor(d.length / 4));
+		for (let t = 0; t < this.miniFat.length; t++) this.miniFat[t] = b.getUint32(4 * t, !0);
+		const N = y.find((t) => 5 === t.type);
+		this.miniStream = N ? this.readChainSized(N.startSector, N.size) : /* @__PURE__ */ new Uint8Array(0);
+	}
+	static read(e) {
+		const i = e instanceof Uint8Array ? e : new Uint8Array(e);
+		return new t(i);
+	}
+	sectorOffset(t) {
+		return (t + 1) * this.sectorSize;
+	}
+	readChain(e) {
+		const i = [];
+		let n = e, r = 0;
+		for (; n !== t.ENDOFCHAIN && n !== t.FREESECT && r++ < 1e6;) {
+			const t = this.sectorOffset(n);
+			i.push(this.buf.subarray(t, t + this.sectorSize)), n = this.fat[n];
+		}
+		return t.concat(i);
+	}
+	readChainSized(t, e) {
+		return this.readChain(t).subarray(0, e);
+	}
+	readMiniChain(e, i) {
+		const n = [];
+		let r = e, s = 0;
+		for (; r !== t.ENDOFCHAIN && r !== t.FREESECT && s++ < 1e6;) {
+			const t = r * this.miniSectorSize;
+			n.push(this.miniStream.subarray(t, t + this.miniSectorSize)), r = this.miniFat[r];
+		}
+		return t.concat(n).subarray(0, i);
+	}
+	static concat(t) {
+		let e = 0;
+		for (const i of t) e += i.length;
+		const i = new Uint8Array(e);
+		let n = 0;
+		for (const e of t) i.set(e, n), n += e.length;
+		return i;
+	}
+	getStreamEntries() {
+		return this.entries.filter((t) => 2 === t.type);
+	}
+	has(t) {
+		return this.byName.has(t);
+	}
+	readStream(t) {
+		const e = this.byName.get(t);
+		return e && 2 === e.type ? this.readStreamEntry(e) : null;
+	}
+	readStreamEntry(t) {
+		return t.size < this.miniStreamCutoff ? this.readMiniChain(t.startSector, t.size) : this.readChainSized(t.startSector, t.size);
+	}
+};
+export { t };