@sheetxl/formulas 0.7.26 → 0.7.28-beta.1

package/browser/esm/CzY0HOXVgv9HM917.mjs

@@ -0,0 +1,13 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.28-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = { BAHTTEXT: {
+	s: "Converts a number to baht (Thai) text.",
+	c: "Baht",
+	p: { number: { d: "is the number to convert." } },
+	h: "Thai"
+} };
+export { e as default };

package/browser/esm/D--3bRsKlG0pbw1W.mjs

@@ -0,0 +1,111 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.28-beta.1
+*
+* (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: {}
+		}
+	},
+	"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." } }
+	}
+};
+export { e as default };

package/browser/esm/D85giwE9k8tjVhRt.mjs

@@ -0,0 +1,319 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.28-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	ASC: {
+		s: "Converts a string to full-width characters to half-width. Uses the double-byte character set (DBCS).",
+		p: { text: { d: "is a text or a reference to a cell containing text." } },
+		h: "DBCS"
+	},
+	ARRAYTOTEXT: {
+		s: "Returns a text representation of an array.",
+		p: {
+			array: { d: "the array to represent as text." },
+			format: { d: "0 for relaxed format, 1 for strict format." }
+		}
+	},
+	CHAR: {
+		s: "Returns the character specified by the code number from the character set for your computer.",
+		p: { number: { d: "is a number between 1 and 255 specifying which character you want." } }
+	},
+	CLEAN: {
+		s: "Removes all nonprintable characters from text.",
+		p: { text: { d: "is the text you want to clean." } }
+	},
+	CODE: {
+		s: "Returns the Unicode value of the first character in a text string.",
+		p: { text: { d: "is the text string whose Unicode value you want." } }
+	},
+	CONCAT: {
+		s: "Concatenates a list or range of text strings.",
+		p: { text: { d: "are 1 to 252 text strings or ranges to be joined." } }
+	},
+	CONCATENATE: {
+		s: "Joins several text strings into one text string.",
+		c: "Compatibility",
+		p: { text: { d: "is the first text string or range to be joined." } }
+	},
+	DETECTLANGUAGE: {
+		s: "Detects the language of a given text.",
+		p: { text: { d: "is the text to detect the language for." } },
+		h: "Unimplemented Connectivity"
+	},
+	DBCS: {
+		s: "Changes half-width characters to full-width characters. Uses the double-byte character set (DBCS).",
+		p: { text: { d: "is a text or a reference to a cell containing text." } },
+		h: "DBCS"
+	},
+	DOLLAR: {
+		s: "Converts a number to text in currency format.",
+		p: {
+			number: { d: "is the number to convert." },
+			decimals: { d: "is the number of digits to the right of the decimal point." }
+		}
+	},
+	EXACT: {
+		s: "Checks whether two text strings are exactly the same, and returns TRUE or FALSE. EXACT is case-sensitive.",
+		p: {
+			text1: { d: "is the first text string." },
+			text2: { d: "is the second text string." }
+		}
+	},
+	FIND: {
+		s: "Returns the starting position of one text string within another text string. FIND is case-sensitive.",
+		p: {
+			findText: { d: "Returns the starting position of one text string within another text string. FIND is case-sensitive." },
+			withinText: { d: "is the text you want to search." },
+			startNum: { d: "specifies the character at which to start the search. The first character in withinText is character number 1." }
+		}
+	},
+	FINDB: {
+		s: "Finds the starting position of one text string with another text string. FINDB is case-sensitive. Use with double-byte characters.",
+		p: {
+			findText: { d: "is the text you want to find." },
+			withinText: { d: "is the text you want to search." },
+			startNum: { d: "is the position in withinText to start searching." }
+		},
+		h: "DBCS"
+	},
+	FIXED: {
+		s: "Rounds a number to the specified number of decimals and returns the result as text with or without commas",
+		p: {
+			number: { d: "is the number you want to round and convert to text." },
+			decimals: { d: "is the number of digits to the right of the decimal point." },
+			noCommas: { d: "is a logical value: do not display commas in the returned text = TRUE; do display commas in the returned text = FALSE." }
+		}
+	},
+	JOIN: {
+		s: "Concatenates elements of an array or range with a delimiter.",
+		c: "Sheets",
+		p: {
+			delimiter: { d: "The delimiter to place between values." },
+			value: { d: "The array or range to join." }
+		}
+	},
+	LEFT: {
+		s: "Returns the specified number of characters from the start of a text string.",
+		p: {
+			text: { d: "is the text string from which you want to extract characters." },
+			numChars: { d: "specifies how many characters you want LEFT to extract." }
+		}
+	},
+	LEFTB: {
+		s: "Returns the leftmost numBytes characters from text. Uses double-byte characters.",
+		p: {
+			text: { d: "is the text string from which you want to extract characters." },
+			numBytes: { d: "is the number of bytes to extract." }
+		},
+		h: "DBCS"
+	},
+	LEN: {
+		s: "Returns the number of characters in a text string.",
+		p: { text: { d: "is the text whose length you want to find. Spaces count as characters." } }
+	},
+	LENB: {
+		s: "Returns the number of bytes in a text string. Uses double-byte characters.",
+		p: { text: { d: "is the text string from which you want to extract characters." } }
+	},
+	LOWER: {
+		s: "Converts all letters in a text string to lowercase.",
+		p: { text: { d: "is the text you want to convert to lowercase. Characters in Text that are not letters are not changed." } }
+	},
+	MID: {
+		s: "Returns the characters from the middle of a text string, given a starting position and length.",
+		p: {
+			text: { d: "is the text string from which you want to extract characters." },
+			startNum: { d: "is the position of the first character you want to extract." },
+			numChars: { d: "specifies how many characters to return from Text." }
+		}
+	},
+	MIDB: {
+		s: "Returns characters from the middle of a text string. Uses double-byte characters.",
+		p: {
+			text: { d: "is the text string from which you want to extract characters." },
+			startNum: { d: "is the position of the first character you want to extract." },
+			numBytes: { d: "is the number of bytes to extract." }
+		},
+		h: "DBCS"
+	},
+	NUMBERVALUE: {
+		s: "Converts text to number in a locale-independent manner.",
+		p: {
+			text: { d: "is the text string you want to convert." },
+			decimalSeparator: { d: "is the character that separates the integer part from the decimal part of the number." },
+			groupSeparator: { d: "is the character that separates groups of thousands." }
+		}
+	},
+	PROPER: {
+		s: "Converts the first letter of each word in a text string to uppercase.",
+		p: { text: { d: "is the text string you want to convert." } }
+	},
+	REPLACE: {
+		s: "Replaces part of a text string with a different text string.",
+		p: {
+			oldText: { d: "is the text string to be changed." },
+			startNum: { d: "is the position of the first character you want to replace." },
+			numChars: { d: "is the number of characters to replace." },
+			newText: { d: "is the text string that will replace oldText." }
+		}
+	},
+	REPLACEB: {
+		s: "Replaces part of a text string with a different text string using the number of bytes. Uses the double-byte character set (DBCS).",
+		p: {
+			oldText: { d: "is the text string to be changed." },
+			startNum: { d: "is the position of the first character you want to replace." },
+			numBytes: { d: "is the number of bytes to replace." },
+			newText: { d: "is the text string that will replace oldText." }
+		},
+		h: "DBCS"
+	},
+	REPT: {
+		s: "Repeats text a given number of times.",
+		p: {
+			text: { d: "is the text you want to repeat." },
+			numberTimes: { d: "is the number of times you want to repeat text." }
+		}
+	},
+	RIGHT: {
+		s: "Returns the specified number of characters from the end of a text string.",
+		p: {
+			text: { d: "is the text string that contains the characters you want to extract." },
+			numChars: { d: "specifies how many characters you want to extract." }
+		}
+	},
+	RIGHTB: {
+		s: "Returns the rightmost numBytes characters from text. Uses double-byte characters.",
+		p: {
+			text: { d: "is the text string from which you want to extract characters." },
+			numBytes: { d: "is the number of bytes to extract." }
+		}
+	},
+	SEARCH: {
+		s: "Returns the number of the character at which a specific character or text string is first found, reading left to right (not case-sensitive).",
+		p: {
+			findText: { d: "is the text you want to find." },
+			withinText: { d: "is the text in which you want to search for findText." },
+			startNum: { d: "is the character number in withinText, counting from the left, at which you want to start searching." }
+		}
+	},
+	SEARCHB: {
+		s: "Returns the number of the character at which a specific character or text string is first found, reading left to right (not case-sensitive). Uses the double-byte character set (DBCS).",
+		p: {
+			findText: { d: "is the text you want to find." },
+			withinText: { d: "is the text in which you want to search for findText." },
+			startBytes: { d: "is the character number in withinText, counting from the left, at which you want to start searching." }
+		},
+		h: "DBCS"
+	},
+	SPLIT: {
+		s: "Splits text around a specified delimiter.",
+		c: "Sheets",
+		p: {
+			text: { d: "The text to split." },
+			delimiter: { d: "The character or string to split around." },
+			splitByEach: { d: "Whether to split around each character in delimiter individually. Default TRUE." },
+			removeEmptyText: { d: "Whether to remove empty strings from results. Default TRUE." }
+		}
+	},
+	SUBSTITUTE: {
+		s: "Replaces existing text with new text in a text string.",
+		p: {
+			text: { d: "is the text or the reference to a cell containing text in which you want to substitute characters." },
+			oldText: { d: "is the existing text you want to replace. If the case of oldText does not match the case of text, SUBSTITUTE will not replace the text." },
+			newText: { d: "is the text you want to replace oldText with." },
+			instanceNum: { d: "specifies which occurrence of oldText you want to replace. If omitted, every instance of oldText is replaced." }
+		}
+	},
+	T: {
+		s: "Checks whether a value is text, and returns the text if it is, or returns double quotes (empty text) if it is not.",
+		p: { value: { d: "is the value to test." } }
+	},
+	TEXT: {
+		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." },
+			formatText: { d: "is a text string that defines the number format to use." }
+		}
+	},
+	TEXTAFTER: {
+		s: "Returns text that's after delimiting characters.",
+		p: {
+			text: { d: "The text you want to search for the delimiter." },
+			delimiter: { d: "The character or string to use as a delimiter." },
+			instanceNum: { d: "The desired occurrence of delimiter. The default is 1. A negative number searches from the end." },
+			matchMode: { d: "Searches the text for a delimiter match. By default, a case-sensitive match is done." },
+			matchEnd: { d: "Whether to match the delimiter against the end of text. By default, they're not matched." },
+			ifNotFound: { d: "Returned if no match is found. By default, #N/A is returned." }
+		}
+	},
+	TEXTBEFORE: {
+		s: "Returns text that's before delimiting characters.",
+		p: {
+			text: { d: "The text you want to search for the delimiter." },
+			delimiter: { d: "The character or string to use as a delimiter." },
+			instanceNum: { d: "The desired occurrence of delimiter. The default is 1. A negative number searches from the end." },
+			matchMode: { d: "Whether to use case-sensitive (0) or case-insensitive (1) match (defaults to `0`)." },
+			matchEnd: { d: "Whether to match the delimiter against the end of text. By default, they're not matched." },
+			ifNotFound: { d: "Returned if no match is found. By default, #N/A is returned." }
+		}
+	},
+	TEXTJOIN: {
+		s: "Concatenates a list or range of text strings using a delimiter.",
+		p: {
+			delimiter: { d: "Character or string to insert between each text item." },
+			ignoreEmpty: { d: "if TRUE(default), ignores empty cells." },
+			text: { d: "are 1 to 252 text strings or ranges to be joined." }
+		}
+	},
+	TEXTSPLIT: {
+		s: "Splits text into rows or columns using delimiters.",
+		p: {
+			text: { d: "The text to split." },
+			colDelimiter: { d: "The column delimiter(s) - can be string or array of strings." },
+			rowDelimiter: { d: "The row delimiter(s), null/undefined means no row splitting." },
+			ignoreEmpty: { d: "Whether to ignore empty values (defaults to `false`)." },
+			matchMode: { d: "Whether to use case-sensitive (0) or case-insensitive (1) match (defaults to `0`)." },
+			padWith: { d: "Value to use for padding if matrix is uneven (defaults to `#N/A`)." }
+		}
+	},
+	TRANSLATE: {
+		s: "Translate a text string from one language to another using the Microsoft Translator service.",
+		p: {
+			text: { d: "The text to translate." },
+			sourceLanguage: { d: "Specifiy the source language your text is currently in. Expressed as a two-letter language code." },
+			targetLanguage: { d: "Specifiy the source language you want your text to be translated to. Expressed as a two-letter language code." }
+		},
+		h: "Unsupported Connectivity"
+	},
+	TRIM: {
+		s: "Removes all spaces from text except for single spaces between words.",
+		p: { text: { d: "The text from which you want to remove extra spaces." } }
+	},
+	UNICHAR: {
+		s: "Returns the Unicode character referenced by the given numeric value.",
+		p: { number: { d: "is the Unicode number representing a character." } }
+	},
+	UNICODE: {
+		s: "Returns the number (code point) corresponding to the first character of the text.",
+		p: { text: { d: "is the character that you want the Unicode value of." } }
+	},
+	UPPER: {
+		s: "Converts a text string to all uppercase letters.",
+		p: { text: { d: "is the text you want converted to uppercase, a reference or a text string." } }
+	},
+	VALUE: {
+		s: "Converts a text string that represents a number to a number.",
+		p: { text: { d: "is the text enclosed in quotation marks or a reference to a cell containing the text you want to convert." } }
+	},
+	VALUETOTEXT: {
+		s: "Returns a text representation of a value.",
+		p: {
+			value: { d: "the value to represent as text." },
+			format: { d: "the format of the text." }
+		}
+	}
+};
+export { e as default };

package/browser/esm/DCo9qXQklIlMDf1F.mjs

@@ -0,0 +1,12 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.28-beta.1
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = { PHONETIC: {
+	s: "Returns the phonetic spelling of a text string.",
+	p: { reference: { d: "Text string or a reference to a single cell or a range of cells that contain a furigana text string." } },
+	h: "Unimplemented Japanese."
+} };
+export { e as default };

package/browser/esm/DXCZWZ7sM3_YT_1j.mjs

@@ -0,0 +1,146 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.28-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 };