@sheetxl/formulas 0.7.21 → 0.7.23-beta.1

package/node/esm/Crca5jE3Yf7IZSH-.mjs

@@ -0,0 +1,316 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	ADDRESS: {
+		s: "Creates a cell reference as text, given specified row and column numbers.",
+		p: {
+			rowNum: { d: "is the row number to use in the cell reference: Row_number = 1 for row 1." },
+			columnNum: { d: "is the column number to use in the cell reference. For example, Column_number = 4 for column D." },
+			absNum: { d: "specifies the reference type: absolute = 1; absolute row/relative column = 2; relative row/absolute column = 3; relative = 4." },
+			a1: { d: "is a logical value that specifies the reference style: A1 style = 1 or TRUE; R1C1 style = 0 or FALSE." },
+			sheetText: { d: "is text specifying the name of the worksheet to be used as the external reference." }
+		}
+	},
+	AREAS: {
+		s: "Returns the number of areas in a reference. An area is a range of contiguous cells or a single cell.",
+		p: { references: { d: "is a reference to a cell or range of cells and can refer to multiple areas." } }
+	},
+	ARRAY_CONSTRAIN: {
+		s: "Constrains an array result to a specified size.",
+		c: "Sheets",
+		p: {
+			inputRange: { d: "The range to constrain." },
+			numRows: { d: "The number of rows the result should contain." },
+			numCols: { d: "The number of columns the result should contain." }
+		}
+	},
+	ARRAYFORMULA: {
+		s: "Enables the display of values returned from an array formula into multiple rows and/or columns.",
+		c: "Sheets",
+		p: { arrayFormula: { d: "A range, a mathematical expression over ranges of the same size, or a function that returns a result of more than one cell." } }
+	},
+	CHOOSE: {
+		s: "Chooses a value or action to perform from a list of values, based on an index number.",
+		p: {
+			indexNum: { d: "specifies which value argument is selected. Index_num must be between 1 and 254, or a formula or a reference to a number between 1 and 254." },
+			value: { d: "are 1 to 254 numbers, cell references, defined names, formulas, functions, or text arguments from which CHOOSE selects." }
+		}
+	},
+	CHOOSECOLS: {
+		s: "Returns columns from an array or reference.",
+		p: {
+			array: { d: "The array or reference from which to choose columns." },
+			colNum: { d: "The number of the column to be returned." }
+		}
+	},
+	CHOOSEROWS: {
+		s: "Returns rows from an array or reference.",
+		p: {
+			array: { d: "The array or reference from which to choose rows." },
+			rowNum: { d: "The number of the row to be returned." }
+		}
+	},
+	COLUMN: {
+		s: "Returns the column number of a reference.",
+		p: { reference: { d: "is the cell or range of contiguous cells for which you want the column number. If omitted, the cell containing the COLUMN function is used." } }
+	},
+	COLUMNS: {
+		s: "Returns the number of columns in an array or reference.",
+		p: { array: { d: "is an array or array formula, or a reference to a range of cells for which you want the number of columns." } }
+	},
+	DROP: {
+		s: "Drops rows or columns from array start or end.",
+		p: {
+			array: { d: "The array from which to drop rows or columns." },
+			row: { d: "The number of rows to drop. A negative value drops from the end of the array." },
+			columns: { d: "The number of columns to drop. A negative value drops from the end of the array." }
+		}
+	},
+	EXPAND: {
+		s: "Expands an array to the specified dimensions.",
+		p: {
+			array: { d: "The array to expand." },
+			row: { d: "The number of rows in the expanded array. If missing, rows will not be expanded." },
+			columns: { d: "The number of columns in the expanded array. If missing, columns will not be expanded." },
+			padWidth: { d: "The value with which to pad. The default is #N/A." }
+		}
+	},
+	FIELDVALUE: {
+		s: "Extracts a value from a field of a given record.",
+		p: {
+			value: { d: "The record from which you want to extract the field." },
+			fieldName: { d: "The names of the field or fields that you want to extract." }
+		},
+		h: "Unimplemented RichData"
+	},
+	FILTER: {
+		s: "Filter a range or array.",
+		p: {
+			array: { d: "the range or array to filter." },
+			include: { d: "an array of booleans where TRUE represents a row or column to retain." },
+			ifEmpty: { d: "return if no items are retained." }
+		}
+	},
+	FORMULATEXT: {
+		s: "Returns a formula as a string.",
+		p: { reference: { d: "is a reference to a formula." } }
+	},
+	GETPIVOTDATA: {
+		s: "Extracts data stored in a PivotTable.",
+		p: {
+			dataField: { d: "is the name of the data field to extract data from." },
+			pivotTable: { d: "is a reference to a cell or range of cells in the PivotTable that contains the data you want to retrieve." },
+			fieldItem: { d: "the field/item pairs to refer to." },
+			"fieldItem.field": { d: "field to refer to." },
+			"fieldItem.item": { d: "field item to refer to." }
+		},
+		h: "Unimplemented Pivot"
+	},
+	HLOOKUP: {
+		s: "Looks for a value in the top row of a table or array of values and returns the value in the same column from a row you specify.",
+		p: {
+			lookupValue: { d: "is the value to be found in the first row of the table and can be a value, a reference, or a text string." },
+			tableArray: { d: "is a table of text, numbers, or logical values in which data is looked up. tableArray can be a reference to a range or a range name." },
+			rowIndexNum: { d: "is the row number in tableArray from which the matching value should be returned. The first row of values in the table is row 1." },
+			rangeLookup: { d: "is a logical value: to find the closest match in the top row (sorted in ascending order) = TRUE; find an exact match = FALSE." }
+		}
+	},
+	HSTACK: {
+		s: "Horizontally stacks arrays into one array.",
+		p: { array: { d: "An array or reference to be stacked." } }
+	},
+	HYPERLINK: {
+		s: "Creates a shortcut or jump that opens a document stored on your hard drive, a network server, or on the Internet.",
+		p: {
+			linkLocation: { d: "is the text giving the path and file name to the document to be opened, a hard drive location, UNC address, or URL path." },
+			friendlyName: { d: "is text or a number that is displayed in the cell. If omitted, the cell displays the linkLocation text." }
+		},
+		h: "Unimplemented RichData"
+	},
+	IMAGE: {
+		s: "Returns an image from a given source.",
+		p: {
+			source: { d: "The path of the source that points to the image." },
+			alternateText: { d: "The alternative text that describes the image for accessibility." },
+			sizing: { d: "The setting that determines the dimensions in which the image will be rendered in the cell." },
+			height: { d: "The custom height of the image in pixels." },
+			width: { d: "The custom width of the image in pixels." }
+		},
+		h: "Unimplemented RichData"
+	},
+	INDEX: {
+		s: "Returns a value or reference of the cell at the intersection of a particular row and column, in a given range.",
+		p: {
+			array: { d: "is a range of cells or an array constant." },
+			rowNum: { d: "selects the row in Array or Reference from which to return a value. If omitted, colNum is required." },
+			colNum: { d: "selects the column in Array or Reference from which to return a value. If omitted, rowNum is required." },
+			areaNum: { d: "selects the area in Array or Reference from which to return a value. If omitted, the first area is used." }
+		}
+	},
+	INDIRECT: {
+		s: "Returns the reference specified by a text string.",
+		p: {
+			refText: { d: "is a reference to a cell that contains an A1- or R1C1-style reference, a name defined as a reference, or a reference to a cell as a text string." },
+			a1: { d: "is a logical value that specifies the type of reference in refText: R1C1-style = FALSE; A1-style = TRUE." }
+		}
+	},
+	LOOKUP: {
+		s: "Looks up a value either from a one-row or one-column range or from an array. Provided for backward compatibility.",
+		p: {
+			lookupValue: { d: "is a value that LOOKUP searches for in lookupVector and can be a number, text, a logical value, or a name or reference to a value." },
+			lookupVector: { d: "is a range that contains only one row or one column of text, numbers, or logical values, placed in ascending order." },
+			resultVector: { d: "is a range that contains only one row or column, the same size as lookupVector." }
+		}
+	},
+	MATCH: {
+		s: "Returns the relative position of an item in an array that matches a specified value in a specified order.",
+		p: {
+			lookupValue: { d: "is the value you use to find the value you want in the array, a number, text, or logical value, or a reference to one of these." },
+			lookupArray: { d: "is a contiguous range of cells containing possible lookup values, an array of values, or a reference to an array." },
+			matchType: { d: "is a number 1, 0, or -1 indicating which value to return." }
+		}
+	},
+	OFFSET: {
+		s: "Returns a reference to a range that is a given number of rows and columns from a given reference.",
+		p: {
+			reference: { d: "is the reference from which you want to base the offset, a reference to a cell or range of adjacent cells." },
+			rows: { d: "is the number of rows, up or down, that you want the upper-left cell of the result to refer to." },
+			cols: { d: "is the number of columns, to the left or right, that you want the upper-left cell of the result to refer to." },
+			height: { d: "is the height, in number of rows, that you want the result to be, the same height as Reference if omitted." },
+			width: { d: "is the width, in number of columns, that you want the result to be, the same width as Reference if omitted." }
+		}
+	},
+	ROW: {
+		s: "Returns the row number of a reference.",
+		p: { reference: { d: "is the cell or a single range of cells for which you want the row number; if omitted, returns the cell containing the ROW function." } }
+	},
+	ROWS: {
+		s: "Returns the number of rows in a reference or array.",
+		p: { array: { d: "is an array, an array formula, or a reference to a range of cells for which you want the number of rows." } }
+	},
+	RTD: {
+		s: "Retrieves the real-time data (RTD) from a program that supports COM automation.",
+		p: {
+			progId: { d: "is the programmatic identifier (ProgID) of a registered COM automation add-in. Enclose the id in quotation marks." },
+			server: { d: "is the name of the server that provides the real-time data. If running locally us an empty string." },
+			topic: { d: "are 1 to 38 parameters that specify a piece of data." }
+		},
+		h: "Unimplemented Connectivity"
+	},
+	SORT: {
+		s: "Sorts a range or array.",
+		p: {
+			array: { d: "the range or array to sort." },
+			sortIndex: { d: "a number indicating the row or column to sort by." },
+			sortOrder: { d: "a number indicating the desired sort order; 1 for ascending order (default), -1 for descending order." },
+			byCol: { d: "a logical value indicating the desired sort direction: FALSE to sort by row (default), TRUE to sort by column." }
+		}
+	},
+	SORTBY: {
+		s: "Sorts a range or array based on the values in a corresponding range or array.",
+		p: {
+			array: { d: "the range or array to sort." },
+			by: { d: "the ranges to sort on and the direction for each." },
+			"by.byArray": { d: "the range or array to sort on." },
+			"by.sortOrder": { d: "a number indicating the desired sort order; 1 for ascending order (default), -1 for descending order." }
+		}
+	},
+	TAKE: {
+		s: "Returns rows or columns from array start or end.",
+		p: {
+			array: { d: "The array from which to take rows or columns." },
+			rows: { d: "The number of rows to take. A negative value takes from the end of the array." },
+			columns: { d: "The number of columns to take. A negative value takes from the end of the array." }
+		}
+	},
+	TOCOL: {
+		s: "Returns the array as one column.",
+		p: {
+			array: { d: "The array or reference to return as a column." },
+			ignore: { d: "Whether to ignore certain types of values. By default, no values are ignored." },
+			scanByColumn: { d: "Scan the array by column. By default, the array is scanned by row." }
+		}
+	},
+	TOROW: {
+		s: "Returns the array as one row.",
+		p: {
+			array: { d: "The array or reference to return as a row." },
+			ignore: { d: "Whether to ignore certain types of values. By default, no values are ignored." },
+			scanByColumn: { d: "Scan the array by column. By default, the array is scanned by row." }
+		}
+	},
+	TRANSPOSE: {
+		s: "Converts a vertical range of cells to a horizontal range, or vice versa.",
+		p: { array: { d: "is a range of cells on a worksheet or an array of values that you want to transpose." } }
+	},
+	TRIMRANGE: {
+		s: "Trims a range to the last used cell in any direction.",
+		p: {
+			range: { d: "The range to be trimmed." },
+			rowTrimMode: { d: "Row trim direction. 0 - none, 1 - leading, 2 - trailing, 3 - both." },
+			colTrimMode: { d: "Column trim direction. 0 - none. 1 - leading, 2 - trailing, 3 - both." }
+		}
+	},
+	UNIQUE: {
+		s: "Returns the unique values from a range or array.",
+		p: {
+			array: { d: "the range or array from which to return unique rows or columns." },
+			byCol: { d: "is a logical value: compare rows against each other and return the unique rows = FALSE; compare columns against each other and return the unique columns = TRUE." },
+			exactlyOnce: { d: "is a logical value: return rows or columns that occur exactly once from the array = TRUE; return all distinct rows or columns from the array = FALSE." }
+		}
+	},
+	VLOOKUP: {
+		s: "Looks for a value in the leftmost column of a table, and then returns a value in the same row from a column you specify. By default, the table must be sorted in an ascending order.",
+		p: {
+			lookupValue: { d: "is the value to be found in the first column of the table, and can be a value, a reference, or a text string." },
+			tableArray: { d: "is a table of text, numbers, or logical values, in which data is retrieved. tableArray can be a reference to a range or a range name." },
+			colIndexNum: { d: "is the column number in tableArray from which the matching value should be returned. The first column of values in the table is column 1." },
+			rangeLookup: { d: "is a logical value: to find the closest match in the first column (sorted in ascending order) = TRUE; find an exact match = FALSE." }
+		}
+	},
+	VSTACK: {
+		s: "Vertically stacks arrays into one array.",
+		p: { array: { d: "An array or reference to be stacked." } }
+	},
+	WRAPCOLS: {
+		s: "Wraps a row or column vector after a specified number of values.",
+		p: {
+			vector: { d: "The vector or reference to wrap." },
+			wrapCount: { d: "The maximum number of values per column." },
+			padWith: { d: "The value with which to pad. The default is #N/A." }
+		}
+	},
+	WRAPROWS: {
+		s: "Wraps a row or column vector after a specified number of values.",
+		p: {
+			vector: { d: "The vector or reference to wrap." },
+			wrapCount: { d: "The maximum number of values per row." },
+			padWith: { d: "The value with which to pad. The default is #N/A." }
+		}
+	},
+	XLOOKUP: {
+		s: "Searches a range or an array for a match and returns the corresponding item from a second range or array. By default, an exact match is used.",
+		p: {
+			lookupValue: { d: "is the value to search for." },
+			lookupArray: { d: "is the array or range to search." },
+			returnArray: { d: "is the array or range to return." },
+			ifNotFound: { d: "returned if no match is found." },
+			matchMode: { d: "0=exact (default), -1=exact/next-smaller, 1=exact/next-larger, 2=wildcard" },
+			searchMode: { d: "1=first→last (default), -1=last→first, 2=binary asc, -2=binary desc" }
+		}
+	},
+	XMATCH: {
+		s: "Returns the relative position of an item in an array. By default, an exact match is required.",
+		p: {
+			lookupValue: { d: "is the value to search for." },
+			lookupArray: { d: "is the array or range to search." },
+			matchMode: { d: "0=exact (default), -1=exact/next-smaller, 1=exact/next-larger, 2=wildcard" },
+			searchMode: { d: "1=first→last (default), -1=last→first, 2=binary asc, -2=binary desc" }
+		}
+	}
+};
+export { e as default };

package/node/esm/CtrldQ03taJCXRon.mjs

@@ -0,0 +1,96 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	ACOS: {
+		s: "Returns the arccosine of a number, in radians in the range 0 to Pi. The arccosine is the angle whose cosine is Number.",
+		p: { number: { d: "is the cosine of the angle you want and must be from -1 to 1." } }
+	},
+	ACOSH: {
+		s: "Returns the inverse hyperbolic cosine of a number.",
+		p: { number: { d: "is any real number equal to or greater than 1." } }
+	},
+	ACOT: {
+		s: "Returns the arccotangent of a number, in radians in the range 0 to Pi.",
+		p: { number: { d: "is the cotangent of the angle you want." } }
+	},
+	ACOTH: {
+		s: "Returns the inverse hyperbolic cotangent of a number.",
+		p: { number: { d: "is the hyperbolic cotangent of the angle that you want." } }
+	},
+	ASIN: {
+		s: "Returns the arcsine of a number in radians, in the range -Pi/2 to Pi/2.",
+		p: { number: { d: "is the sine of the angle you want and must be from -1 to 1." } }
+	},
+	ASINH: {
+		s: "Returns the inverse hyperbolic sine of a number.",
+		p: { number: { d: "is any real number equal to or greater than 1." } }
+	},
+	ATAN: {
+		s: "Returns the arctangent of a number in radians, in the range -Pi/2 to Pi/2.",
+		p: { number: { d: "is the tangent of the angle you want." } }
+	},
+	ATAN2: {
+		s: "Returns the arctangent of the specified x- and y- coordinates, in radians between -Pi and Pi, excluding -Pi.",
+		p: {
+			x: { d: "is the x-coordinate of the point." },
+			y: { d: "is the y-coordinate of the point." }
+		}
+	},
+	ATANH: {
+		s: "Returns the inverse hyperbolic tangent of a number.",
+		p: { number: { d: "is any real number between -1 and 1 excluding -1 and 1." } }
+	},
+	COS: {
+		s: "Returns the cosine of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the cosine." } }
+	},
+	COSH: {
+		s: "Returns the hyperbolic cosine of a number.",
+		p: { number: { d: "is any real number." } }
+	},
+	COT: {
+		s: "Returns the cotangent of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the cotangent." } }
+	},
+	COTH: {
+		s: "Returns the hyperbolic cotangent of a number.",
+		p: { number: { d: "is the angle in radians for which you want the hyperbolic cotangent." } }
+	},
+	CSC: {
+		s: "Returns the cosecant of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the cosecant." } }
+	},
+	CSCH: {
+		s: "Returns the hyperbolic cosecant of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the hyperbolic cosecant." } }
+	},
+	SEC: {
+		s: "Returns the secant of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the secant." } }
+	},
+	SECH: {
+		s: "Returns the hyperbolic secant of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the hyperbolic secant." } }
+	},
+	SIN: {
+		s: "Returns the sine of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the sine. Degrees * PI()/180 = radians." } }
+	},
+	SINH: {
+		s: "Returns the hyperbolic sine of a number.",
+		p: { number: { d: "is any real number." } }
+	},
+	TAN: {
+		s: "Returns the tangent of an angle.",
+		p: { number: { d: "is the angle in radians for which you want the tangent. Degrees * PI()/180 = radians." } }
+	},
+	TANH: {
+		s: "Returns the hyperbolic tangent of a number.",
+		p: { number: { d: "is any real number." } }
+	}
+};
+export { e as default };

package/node/esm/D-ZOXtNuCTDM93kQ.mjs

@@ -0,0 +1,13 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.1
+*
+* (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/node/esm/DCSVv5SQ5HKw36ZJ.mjs

@@ -0,0 +1,21 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = { GROUPBY: {
+	s: "Aggregate values by row fields.",
+	p: {
+		rowFields: { d: "The range or array containing the row fields." },
+		values: { d: "The range or array containing the values to aggregate." },
+		fn: { d: "The function used to do the aggregations." },
+		fieldHeaders: { d: "A number between 0 and 3 that specifies whether the field data has headers and whether field headers should be returned in the results." },
+		totalDepth: { d: "Show totals for the row fields. 0 for none, 1 for grand totals, 2 for grand total and first level subtotals, etc." },
+		sortOrder: { d: "The column index to sort the row fields on. A negative index will sort in reverse order." },
+		filterArray: { d: "param-534 paramName-535." },
+		fieldRelationship: { d: "The relationship of fields when multiple columns are supplied to the rowFields argument." }
+	},
+	h: "Unimplemented TODO"
+} };
+export { e as default };

package/node/esm/DMSc03XuAxrkQNc6.mjs

@@ -0,0 +1,146 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.1
+*
+* (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/node/esm/DOmYwMQ5JE_iPKuc.mjs

@@ -0,0 +1,37 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	BESSELI: {
+		s: "Returns the modified Bessel function In(x).",
+		p: {
+			x: { d: "is the value at which to evaluate the function." },
+			n: { d: "is the order of the Bessel function." }
+		}
+	},
+	BESSELJ: {
+		s: "Returns the Bessel function Jn(x).",
+		p: {
+			x: { d: "is the value at which to evaluate the function." },
+			n: { d: "is the order of the Bessel function." }
+		}
+	},
+	BESSELK: {
+		s: "Returns the modified Bessel function Kn(x).",
+		p: {
+			x: { d: "is the value at which to evaluate the function." },
+			n: { d: "is the order of the function." }
+		}
+	},
+	BESSELY: {
+		s: "Returns the Bessel function Yn(x).",
+		p: {
+			x: { d: "is the value at which to evaluate the function." },
+			n: { d: "is the order of the function." }
+		}
+	}
+};
+export { e as default };