@sheetxl/formulas 0.7.22 → 0.7.23-beta.2

package/node/esm/CdQB285WaqVnEtwI.mjs

@@ -0,0 +1,319 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.2
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var t = {
+	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 { t as default };

package/node/esm/CiKHpC0L1ehZx-pr.mjs

@@ -0,0 +1,123 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.2
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	ADD: {
+		s: "Returns the sum of two numbers. Equal to the '+' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first number to add." },
+			value2: { d: "The second number to add." }
+		}
+	},
+	DIVIDE: {
+		s: "Returns the result of dividing one number by another. Equal to the '/' operator.",
+		c: "Sheets",
+		p: {
+			dividend: { d: "The number to be divided." },
+			divisor: { d: "The number to divide by." }
+		}
+	},
+	EQ: {
+		s: "Returns TRUE if the two specified values are equal. Equal to the '=' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first value to compare." },
+			value2: { d: "The second value to compare." }
+		}
+	},
+	GT: {
+		s: "Returns TRUE if the first value is greater than the second. Equal to the '>' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first value to compare." },
+			value2: { d: "The second value to compare." }
+		}
+	},
+	GTE: {
+		s: "Returns TRUE if the first value is greater than or equal to the second. Equal to the '>=' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first value to compare." },
+			value2: { d: "The second value to compare." }
+		}
+	},
+	LT: {
+		s: "Returns TRUE if the first value is less than the second. Equal to the '<' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first value to compare." },
+			value2: { d: "The second value to compare." }
+		}
+	},
+	LTE: {
+		s: "Returns TRUE if the first value is less than or equal to the second. Equal to the '<=' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first value to compare." },
+			value2: { d: "The second value to compare." }
+		}
+	},
+	MINUS: {
+		s: "Returns the difference of two numbers. Equal to the '-' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The number from which to subtract." },
+			value2: { d: "The number to subtract." }
+		}
+	},
+	MULTIPLY: {
+		s: "Returns the product of two numbers. Equal to the '*' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first number to multiply." },
+			value2: { d: "The second number to multiply." }
+		}
+	},
+	NE: {
+		s: "Returns TRUE if the two specified values are not equal. Equal to the '<>' operator.",
+		c: "Sheets",
+		p: {
+			value1: { d: "The first value to compare." },
+			value2: { d: "The second value to compare." }
+		}
+	},
+	POW: {
+		s: "Returns a number raised to a power. Equal to the '^' operator.",
+		c: "Sheets",
+		p: {
+			base: { d: "The number to raise to a power." },
+			exponent: { d: "The power to raise the base to." }
+		}
+	},
+	UMINUS: {
+		s: "Returns the negation of a number. Equal to the unary '-' operator.",
+		c: "Sheets",
+		p: { value: { d: "The number to negate." } }
+	},
+	UNARY_PERCENT: {
+		s: "Converts a number to a percentage. Equal to the '%' operator.",
+		c: "Sheets",
+		p: { value: { d: "The number to convert to a percentage." } }
+	},
+	UPLUS: {
+		s: "Returns a number unchanged. Equal to the unary '+' operator.",
+		c: "Sheets",
+		p: { value: { d: "The number to return." } }
+	},
+	ISBETWEEN: {
+		s: "Checks whether a number is between two numbers, inclusive by default.",
+		c: "Sheets",
+		p: {
+			value: { d: "The value to test." },
+			lower: { d: "The lower bound." },
+			upper: { d: "The upper bound." },
+			lowerInclusive: { d: "Whether the lower bound is inclusive. Default TRUE." },
+			upperInclusive: { d: "Whether the upper bound is inclusive. Default TRUE." }
+		}
+	}
+};
+export { e as default };

package/node/esm/Cim2e4ufVhd_hd70.mjs

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

package/node/esm/CvDvremNlW-E3lOp.mjs

@@ -0,0 +1,173 @@
+/**
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.7.23-beta.2
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = {
+	AVEDEV: {
+		s: "Returns the average of the absolute deviations of data points from their mean. Arguments can be numbers or names, arrays, or references that contain numbers.",
+		p: { number: { d: "are 1 to 255 arguments for which you want the average of the absolute deviations." } }
+	},
+	AVERAGE: {
+		s: "Returns the average (arithmetic mean) of its arguments, which can be numbers or names, arrays, or references that contain numbers.",
+		p: { number: { d: "are 1 to 255 numeric arguments for which you want the average." } }
+	},
+	AVERAGEA: {
+		s: "Returns the average (arithmetic mean) of its arguments, evaluating text and FALSE in arguments as 0; TRUE evaluates as 1. Arguments can be numbers, names, arrays, or references.",
+		p: { value: { d: "are 1 to 255 arguments for which you want the average." } }
+	},
+	AVERAGEIF: {
+		s: "Finds average(arithmetic mean) for the cells specified by a given condition or criteria.",
+		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 used to find the average." },
+			averageRange: { d: "are the actual cells to be used to find the average. If omitted, the cells in range are used." }
+		}
+	},
+	AVERAGEIFS: {
+		s: "Finds average(arithmetic mean) for the cells specified by a given set of conditions or criteria.",
+		p: {
+			averageRange: { d: "are the actual cells to be used to find the average." },
+			criteria: { d: "the ranges to evaluate and the conditions to evaluate them against." },
+			"criteria.criteriaRange": { d: "is the range of cells you want evaluated for the particular condition." },
+			"criteria.criteria": { d: "is the condition or criteria in the form of a number, expression, or text that defines which cells will be used to find the average." }
+		}
+	},
+	"AVERAGE.WEIGHTED": {
+		s: "Finds the weighted average of a set of values, given the values and the corresponding weights.",
+		c: "Sheets",
+		p: {
+			values: { d: "the values to average and the weights to apply to them." },
+			"values.values": { d: "are the values to be averaged." },
+			"values.weights": { d: "are the corresponding weights to apply. A weight may be zero but not negative." }
+		}
+	},
+	COUNT: {
+		s: "Counts the number of cells in a range that contain numbers.",
+		p: { number: { d: "are 1 to 255 arguments that can contain or refer to a variety of different types of data, but only numbers are counted." } }
+	},
+	COUNTA: {
+		s: "Counts the number of cells in a range that are not empty.",
+		p: { value: { d: "are 1 to 255 arguments representing the values and cells you want to count. Values can be any type of information." } }
+	},
+	COUNTBLANK: {
+		s: "Counts the number of empty cells in a specified range of cells.",
+		p: { range: { d: "is the range from which you want to count the empty cells." } }
+	},
+	COUNTIF: {
+		s: "Counts the number of cells within a range that meet the given condition.",
+		p: {
+			range: { d: "is the range of cells from which you want to count nonblank cells." },
+			criteria: { d: "is the condition in the form of a number, expression, or text that defines which cells will be counted." }
+		}
+	},
+	COUNTIFS: {
+		s: "Counts the number of cells specified by a given set of conditions or criteria.",
+		p: {
+			criteria: { d: "the ranges to evaluate and the conditions to evaluate them against." },
+			"criteria.criteriaRange": { d: "is the range of cells you want evaluated for the particular condition." },
+			"criteria.criteria": { d: "is the condition in the form of a number, expression, or text that defines which cells will be counted." }
+		}
+	},
+	COUNTUNIQUE: {
+		s: "Counts the number of unique values in a list of specified values and ranges.",
+		c: "Sheets",
+		p: { value: { d: "are the values or ranges to consider for uniqueness." } }
+	},
+	COUNTUNIQUEIFS: {
+		s: "Counts the number of unique values in a range of cells, filtered by a set of criteria.",
+		c: "Sheets",
+		p: {
+			countUniqueRange: { d: "is the range from which the unique values will be counted." },
+			criteria: { d: "the ranges to evaluate and the conditions to evaluate them against." },
+			"criteria.criteriaRange": { d: "is the range of cells you want evaluated for the particular condition." },
+			"criteria.criteria": { d: "is the condition in the form of a number, expression, or text that defines which cells will be counted." }
+		}
+	},
+	LARGE: {
+		s: "Returns the k-th largest value in a data set. For example, the fifth largest number.",
+		p: {
+			array: { d: "is the array or range of data for which you want to determine the k-th largest value." },
+			k: { d: "is the position (from the largest) in the array or cell range of the value to return." }
+		}
+	},
+	MAX: {
+		s: "Returns the largest value in a set of values. Ignores logical values and text.",
+		p: { number: { d: "are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the maximum." } }
+	},
+	MAXA: {
+		s: "Returns the largest value in a set of values. Does not ignore logical values and text.",
+		p: { value: { d: "are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the maximum." } }
+	},
+	MAXIF: {
+		s: "Returns the maximum value for the cells within a range that meet the given condition.",
+		c: "SheetXL",
+		p: {
+			range: { d: "is the range of cells from which you want to find the maximum nonblank cells." },
+			criteria: { d: "is the condition in the form of a number, expression, or text that defines which cells will be counted." },
+			maxRange: { d: "are the actual cells to be used to find the maximum. If omitted, the cells in range are used." }
+		}
+	},
+	MAXIFS: {
+		s: "Returns the maximum value among cells specified by a given set of conditions or criteria.",
+		p: {
+			maxRange: { d: "the cells in which to determine the maximum value." },
+			criteria: { d: "the ranges to evaluate and the conditions to evaluate them against." },
+			"criteria.criteriaRange": { d: "is the range of cells you want to evaluate for the particular condition." },
+			"criteria.criteria": { d: "is the condition or criteria in the form of a number, expression, or text that defines which cells will be included when determining the maximum value." }
+		}
+	},
+	MEDIAN: {
+		s: "Returns the median, or the number in the middle of the set of given numbers.",
+		p: { number: { d: "are 1 to 255 numbers or names, arrays, or references that contain numbers for which you want the median." } }
+	},
+	MIN: {
+		s: "Returns the smallest number in a set of values. Ignores logical values and text.",
+		p: { number: { d: "are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the minimum." } }
+	},
+	MINA: {
+		s: "Returns the smallest value in a set of values. Does not ignore logical values and text.",
+		p: { value: { d: "are 1 to 255 numbers, empty cells, logical values, or text numbers for which you want the minimum." } }
+	},
+	MINIF: {
+		s: "Returns the minimum value for the cells within a range that meet the given condition.",
+		c: "SheetXL",
+		p: {
+			range: { d: "is the range of cells from which you want to count nonblank cells." },
+			criteria: { d: "is the condition in the form of a number, expression, or text that defines which cells will be counted." },
+			minRange: { d: "are the actual cells to be used to find the minimum. If omitted, the cells in range are used." }
+		}
+	},
+	MINIFS: {
+		s: "Returns the minimum value among cells specified by a given set of conditions or criteria.",
+		p: {
+			minRange: { d: "is the range of cells to evaluate for the minimum value." },
+			criteria: { d: "the ranges to evaluate and the conditions to evaluate them against." },
+			"criteria.criteriaRange": { d: "is the range of cells to evaluate against the criteria." },
+			"criteria.criteria": { d: "is the criteria to evaluate against the criteria range." }
+		}
+	},
+	PERMUT: {
+		s: "Returns the number of permutations for a given number of objects that can be selected from the total objects.",
+		p: {
+			number: { d: "is the total number of objects." },
+			numberChoosen: { d: "is the number of objects in each permutation." }
+		}
+	},
+	PERMUTATIONA: {
+		s: "Returns the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects.",
+		p: {
+			number: { d: "is the total number of objects." },
+			numberChoosen: { d: "is the number of objects in each permutation." }
+		}
+	},
+	SMALL: {
+		s: "Returns the k-th smallest value in a data set. For example, the fifth smallest number.",
+		p: {
+			array: { d: "is an array or range of numerical data for which you want to determine the k-th smallest value." },
+			k: { d: "is the position (from the smallest) in the array or range of the value to return." }
+		}
+	}
+};
+export { e as default };