@rowsncolumns/functions 15.0.1 → 15.1.0

package/Readme.md

@@ -1,5 +1,23 @@
-# Functions
+# @rowsncolumns/functions
 
-Contains function descriptions and custom functions used by calculator
+The function catalog (`functionDescriptions`: name, syntax, description, parameters, category) that
+drives autocomplete and Insert Function, plus the custom functions (`functions`) the legacy
+JavaScript calculator registers.
 
-TODO
+## Entries
+
+| Import | Contents |
+| --- | --- |
+| `@rowsncolumns/functions/descriptions` | `functionDescriptions` only. Pure data, no runtime imports — what a host on `@rowsncolumns/rnc-engine` / `rnc-yrs-store` should use. |
+| `@rowsncolumns/functions` | The catalog **and** `functions`, the custom-function implementations for the JavaScript calculator (pulls in `@rowsncolumns/calculator`, `fast-formula-parser`, `toolkit`). |
+| `@rowsncolumns/functions/server` | The catalog and the server-safe `functions` for the calculation worker. |
+
+```ts
+import { functionDescriptions } from "@rowsncolumns/functions/descriptions";
+
+<CanvasGrid functionDescriptions={functionDescriptions} … />
+```
+
+The package is declared `"sideEffects": false`; `__tests__/descriptions-subpath.spec.ts` holds the
+`descriptions` entry to the catalog alone, and `__tests__/engine-description-coverage.spec.ts` holds
+the catalog to every function the rnc-engine wasm registers.

package/dist/cjs/descriptions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@rowsncolumns/functions/descriptions` — the function catalog on its own.
+ *
+ * The root entry also re-exports the legacy JavaScript calculator's implementations (`functions`),
+ * which pull in `@rowsncolumns/calculator`, `@rowsncolumns/fast-formula-parser` and
+ * `@rowsncolumns/toolkit`. A host on the Rust engine only needs the catalog (autocomplete, Insert
+ * Function, the conditional-format / data-validation editors), so this entry must stay a pure data
+ * module: nothing here may import from `./formulas` or any `@rowsncolumns/*` runtime package.
+ * `__tests__/descriptions-subpath.spec.ts` walks the built import graph to hold that (#1135).
+ *
+ * The specifier carries its `.js` extension so the emitted `dist/esm/descriptions.js` also loads
+ * under Node's own ESM resolver (no bundler), not only under bundlers that resolve bare paths.
+ */
+export { functionDescriptions } from "./function-descriptions.js";
+export type { CalculatorFunction, FunctionParameter } from "./types";
+//# sourceMappingURL=descriptions.d.ts.map

package/dist/cjs/descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../descriptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

package/dist/cjs/descriptions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionDescriptions = void 0;
+/**
+ * `@rowsncolumns/functions/descriptions` — the function catalog on its own.
+ *
+ * The root entry also re-exports the legacy JavaScript calculator's implementations (`functions`),
+ * which pull in `@rowsncolumns/calculator`, `@rowsncolumns/fast-formula-parser` and
+ * `@rowsncolumns/toolkit`. A host on the Rust engine only needs the catalog (autocomplete, Insert
+ * Function, the conditional-format / data-validation editors), so this entry must stay a pure data
+ * module: nothing here may import from `./formulas` or any `@rowsncolumns/*` runtime package.
+ * `__tests__/descriptions-subpath.spec.ts` walks the built import graph to hold that (#1135).
+ *
+ * The specifier carries its `.js` extension so the emitted `dist/esm/descriptions.js` also loads
+ * under Node's own ESM resolver (no bundler), not only under bundlers that resolve bare paths.
+ */
+var function_descriptions_js_1 = require("./function-descriptions.js");
+Object.defineProperty(exports, "functionDescriptions", { enumerable: true, get: function () { return function_descriptions_js_1.functionDescriptions; } });

package/dist/cjs/function-descriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"function-descriptions.d.ts","sourceRoot":"","sources":["../../function-descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,EA8iVpD,CAAC"}
+{"version":3,"file":"function-descriptions.d.ts","sourceRoot":"","sources":["../../function-descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,EAopWpD,CAAC"}

package/dist/cjs/function-descriptions.js

@@ -9805,4 +9805,561 @@ exports.functionDescriptions = [
             },
         ],
     },
+    {
+        datatype: "Logical",
+        title: "LET",
+        syntax: "LET(name1, value1, [name2, value2], …, calculation)",
+        description: "Assigns names to calculation results so a value is computed once and reused by name inside the final calculation.",
+        example: "LET(x, A1*2, x+x)",
+        usage: [
+            "LET(x, A1*2, x+x)",
+            "LET(total, SUM(A1:A10), count, COUNT(A1:A10), total/count)",
+        ],
+        parameters: [
+            {
+                title: "name1",
+                description: "The first name to assign. Must begin with a letter and cannot look like a cell reference.",
+            },
+            {
+                title: "value1",
+                description: "The value assigned to name1.",
+            },
+            {
+                title: "name2, value2, … [OPTIONAL]",
+                description: "Additional name/value pairs; each value can use the names assigned before it.",
+            },
+            {
+                title: "calculation",
+                description: "The expression that uses the assigned names; its result is the result of LET.",
+            },
+        ],
+    },
+    {
+        datatype: "Logical",
+        title: "LAMBDA",
+        syntax: "LAMBDA([parameter1, parameter2, …,] calculation)",
+        description: "Creates a reusable custom function from its parameters and a calculation. Call it in place with LAMBDA(…)(arguments), give it a name in the Name Manager, or pass it to MAP, BYROW, REDUCE and the other helper functions.",
+        example: "LAMBDA(x, y, x+y)(1, 2)",
+        usage: ["LAMBDA(x, y, x+y)(1, 2)", "MAP(A1:A5, LAMBDA(v, v*2))"],
+        parameters: [
+            {
+                title: "parameter1, parameter2, … [OPTIONAL]",
+                description: "Names for the values passed when the function is called. Wrap a name in square brackets to make it optional (see ISOMITTED).",
+            },
+            {
+                title: "calculation",
+                description: "The formula evaluated with the parameters; always the last argument and the function's result.",
+            },
+        ],
+    },
+    {
+        datatype: "Info",
+        title: "ISOMITTED",
+        syntax: "ISOMITTED(argument)",
+        description: "Returns TRUE when the named LAMBDA parameter was left out of the call, so a custom function can supply a default.",
+        example: "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5)",
+        usage: [
+            "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5)",
+            "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5, 2)",
+        ],
+        parameters: [
+            {
+                title: "argument",
+                description: "The LAMBDA parameter to test.",
+            },
+        ],
+    },
+    {
+        datatype: "Lookup",
+        title: "XMATCH",
+        syntax: "XMATCH(lookup_value, lookup_array, [match_mode], [search_mode])",
+        description: "Returns the position of a value in a range or array. Exact match by default, with the same match and search modes as XLOOKUP.",
+        example: "XMATCH(E2, B2:B10)",
+        usage: ["XMATCH(E2, B2:B10)", "XMATCH(E2, B2:B10, 1)", 'XMATCH("gr*", B2:B10, 2)'],
+        parameters: [
+            {
+                title: "lookup_value",
+                description: "The value to search for.",
+            },
+            {
+                title: "lookup_array",
+                description: "The range or array to search in.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for exact match (default), -1 for exact or next smaller, 1 for exact or next larger, 2 for wildcard match.",
+            },
+            {
+                title: "search_mode [OPTIONAL]",
+                description: "1 to search first to last (default), -1 last to first, 2 binary search on ascending data, -2 binary search on descending data.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "VSTACK",
+        syntax: "VSTACK(array1, [array2], …)",
+        description: "Appends arrays vertically, one below the other, into a single array; narrower arrays are padded with #N/A.",
+        example: "VSTACK(A1:C3, E1:G2)",
+        usage: ["VSTACK(A1:C3, E1:G2)", "VSTACK({1,2}, {3,4})"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The first range or array to stack.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional ranges or arrays appended below the previous one.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "HSTACK",
+        syntax: "HSTACK(array1, [array2], …)",
+        description: "Appends arrays horizontally, side by side, into a single array; shorter arrays are padded with #N/A.",
+        example: "HSTACK(A1:A3, C1:C3)",
+        usage: ["HSTACK(A1:A3, C1:C3)", "HSTACK({1;2}, {3;4})"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The first range or array to stack.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional ranges or arrays appended to the right of the previous one.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "CHOOSECOLS",
+        syntax: "CHOOSECOLS(array, col_num1, [col_num2], …)",
+        description: "Returns the specified columns of an array, in the order given; negative numbers count from the last column.",
+        example: "CHOOSECOLS(A1:E10, 1, 3)",
+        usage: ["CHOOSECOLS(A1:E10, 1, 3)", "CHOOSECOLS(A1:E10, -1)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to pick columns from.",
+            },
+            {
+                title: "col_num1",
+                description: "The first column to return; negative counts from the end.",
+            },
+            {
+                title: "col_num2, … [OPTIONAL]",
+                description: "Additional columns to return, in output order.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "CHOOSEROWS",
+        syntax: "CHOOSEROWS(array, row_num1, [row_num2], …)",
+        description: "Returns the specified rows of an array, in the order given; negative numbers count from the last row.",
+        example: "CHOOSEROWS(A1:E10, 1, 3)",
+        usage: ["CHOOSEROWS(A1:E10, 1, 3)", "CHOOSEROWS(A1:E10, -1)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to pick rows from.",
+            },
+            {
+                title: "row_num1",
+                description: "The first row to return; negative counts from the end.",
+            },
+            {
+                title: "row_num2, … [OPTIONAL]",
+                description: "Additional rows to return, in output order.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "TOCOL",
+        syntax: "TOCOL(array, [ignore], [scan_by_column])",
+        description: "Returns an array as a single column, reading it row by row unless scan_by_column is TRUE.",
+        example: "TOCOL(A1:C3)",
+        usage: ["TOCOL(A1:C3)", "TOCOL(A1:C3, 1)", "TOCOL(A1:C3, 0, TRUE)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to flatten.",
+            },
+            {
+                title: "ignore [OPTIONAL]",
+                description: "0 keeps every value (default), 1 ignores blanks, 2 ignores errors, 3 ignores blanks and errors.",
+            },
+            {
+                title: "scan_by_column [OPTIONAL]",
+                description: "TRUE to read the array column by column. Defaults to FALSE (row by row).",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "TOROW",
+        syntax: "TOROW(array, [ignore], [scan_by_column])",
+        description: "Returns an array as a single row, reading it row by row unless scan_by_column is TRUE.",
+        example: "TOROW(A1:C3)",
+        usage: ["TOROW(A1:C3)", "TOROW(A1:C3, 1)", "TOROW(A1:C3, 0, TRUE)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to flatten.",
+            },
+            {
+                title: "ignore [OPTIONAL]",
+                description: "0 keeps every value (default), 1 ignores blanks, 2 ignores errors, 3 ignores blanks and errors.",
+            },
+            {
+                title: "scan_by_column [OPTIONAL]",
+                description: "TRUE to read the array column by column. Defaults to FALSE (row by row).",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "WRAPROWS",
+        syntax: "WRAPROWS(vector, wrap_count, [pad_with])",
+        description: "Wraps a single row or column of values into rows of wrap_count values each; the last row is padded with pad_with (#N/A by default).",
+        example: "WRAPROWS(A1:A10, 3)",
+        usage: ["WRAPROWS(A1:A10, 3)", 'WRAPROWS(A1:A10, 3, "")'],
+        parameters: [
+            {
+                title: "vector",
+                description: "The single row or column to wrap.",
+            },
+            {
+                title: "wrap_count",
+                description: "Maximum number of values per row.",
+            },
+            {
+                title: "pad_with [OPTIONAL]",
+                description: "Value used to fill the last row. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "WRAPCOLS",
+        syntax: "WRAPCOLS(vector, wrap_count, [pad_with])",
+        description: "Wraps a single row or column of values into columns of wrap_count values each; the last column is padded with pad_with (#N/A by default).",
+        example: "WRAPCOLS(A1:A10, 3)",
+        usage: ["WRAPCOLS(A1:A10, 3)", 'WRAPCOLS(A1:A10, 3, "")'],
+        parameters: [
+            {
+                title: "vector",
+                description: "The single row or column to wrap.",
+            },
+            {
+                title: "wrap_count",
+                description: "Maximum number of values per column.",
+            },
+            {
+                title: "pad_with [OPTIONAL]",
+                description: "Value used to fill the last column. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "BYROW",
+        syntax: "BYROW(array, lambda(row))",
+        description: "Applies a LAMBDA to each row of an array and returns one result per row, as a column.",
+        example: "BYROW(A1:C5, LAMBDA(row, SUM(row)))",
+        usage: ["BYROW(A1:C5, LAMBDA(row, SUM(row)))", "BYROW(A1:C5, LAMBDA(row, MAX(row)))"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array whose rows are processed.",
+            },
+            {
+                title: "lambda(row)",
+                description: "A LAMBDA with one parameter that receives a row and returns a single value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "BYCOL",
+        syntax: "BYCOL(array, lambda(column))",
+        description: "Applies a LAMBDA to each column of an array and returns one result per column, as a row.",
+        example: "BYCOL(A1:C5, LAMBDA(col, SUM(col)))",
+        usage: ["BYCOL(A1:C5, LAMBDA(col, SUM(col)))", "BYCOL(A1:C5, LAMBDA(col, MAX(col)))"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array whose columns are processed.",
+            },
+            {
+                title: "lambda(column)",
+                description: "A LAMBDA with one parameter that receives a column and returns a single value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "MAP",
+        syntax: "MAP(array1, [array2, …], lambda(value1, [value2, …]))",
+        description: "Applies a LAMBDA to each value of one or more arrays and returns an array of the same shape.",
+        example: "MAP(A1:A5, LAMBDA(v, v*2))",
+        usage: ["MAP(A1:A5, LAMBDA(v, v*2))", "MAP(A1:A5, B1:B5, LAMBDA(a, b, a&b))"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The range or array to map.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional arrays of the same shape, passed to the LAMBDA as further parameters.",
+            },
+            {
+                title: "lambda(value1, [value2, …])",
+                description: "A LAMBDA with one parameter per array that returns the new value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "REDUCE",
+        syntax: "REDUCE([initial_value], array, lambda(accumulator, value))",
+        description: "Folds an array into a single value by calling a LAMBDA with the running accumulator and each value in turn.",
+        example: "REDUCE(0, A1:A5, LAMBDA(acc, v, acc+v))",
+        usage: ["REDUCE(0, A1:A5, LAMBDA(acc, v, acc+v))", "REDUCE(1, A1:A5, LAMBDA(acc, v, acc*v))"],
+        parameters: [
+            {
+                title: "initial_value [OPTIONAL]",
+                description: "The accumulator's starting value.",
+            },
+            {
+                title: "array",
+                description: "The range or array to fold.",
+            },
+            {
+                title: "lambda(accumulator, value)",
+                description: "A LAMBDA with two parameters that returns the next accumulator.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "SCAN",
+        syntax: "SCAN([initial_value], array, lambda(accumulator, value))",
+        description: "Like REDUCE, but returns every intermediate accumulator as an array of the same shape as the input.",
+        example: "SCAN(0, A1:A5, LAMBDA(acc, v, acc+v))",
+        usage: ["SCAN(0, A1:A5, LAMBDA(acc, v, acc+v))", 'SCAN("", A1:A5, LAMBDA(acc, v, acc&v))'],
+        parameters: [
+            {
+                title: "initial_value [OPTIONAL]",
+                description: "The accumulator's starting value.",
+            },
+            {
+                title: "array",
+                description: "The range or array to scan.",
+            },
+            {
+                title: "lambda(accumulator, value)",
+                description: "A LAMBDA with two parameters that returns the next accumulator.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "MAKEARRAY",
+        syntax: "MAKEARRAY(rows, columns, lambda(row, column))",
+        description: "Builds an array of the given size by calling a LAMBDA with each row and column number.",
+        example: "MAKEARRAY(3, 3, LAMBDA(r, c, r*c))",
+        usage: ["MAKEARRAY(3, 3, LAMBDA(r, c, r*c))", 'MAKEARRAY(2, 2, LAMBDA(r, c, "R"&r&"C"&c))'],
+        parameters: [
+            {
+                title: "rows",
+                description: "Number of rows in the result.",
+            },
+            {
+                title: "columns",
+                description: "Number of columns in the result.",
+            },
+            {
+                title: "lambda(row, column)",
+                description: "A LAMBDA with two parameters that returns the value for that row and column (both 1-based).",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "TEXTBEFORE",
+        syntax: "TEXTBEFORE(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
+        description: "Returns the text that comes before the nth occurrence of a delimiter; a negative instance number counts occurrences from the end.",
+        example: 'TEXTBEFORE("Red riding hood", " ")',
+        usage: [
+            'TEXTBEFORE("Red riding hood", " ")',
+            'TEXTBEFORE("Red riding hood", " ", -1)',
+            'TEXTBEFORE("a-b-c", "-", 2)',
+        ],
+        parameters: [
+            {
+                title: "text",
+                description: "The text to search in.",
+            },
+            {
+                title: "delimiter",
+                description: "The text (or array of texts) that marks the point before which to extract.",
+            },
+            {
+                title: "instance_num [OPTIONAL]",
+                description: "Which occurrence of the delimiter to use. Defaults to 1; negative counts from the end.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for case-sensitive (default) or 1 for case-insensitive delimiter matching.",
+            },
+            {
+                title: "match_end [OPTIONAL]",
+                description: "1 treats the end of the text as a delimiter. Defaults to 0.",
+            },
+            {
+                title: "if_not_found [OPTIONAL]",
+                description: "Value returned when the delimiter is not found. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "TEXTAFTER",
+        syntax: "TEXTAFTER(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
+        description: "Returns the text that comes after the nth occurrence of a delimiter; a negative instance number counts occurrences from the end.",
+        example: 'TEXTAFTER("Red riding hood", " ")',
+        usage: [
+            'TEXTAFTER("Red riding hood", " ")',
+            'TEXTAFTER("Red riding hood", " ", -1)',
+            'TEXTAFTER("a-b-c", "-", 2)',
+        ],
+        parameters: [
+            {
+                title: "text",
+                description: "The text to search in.",
+            },
+            {
+                title: "delimiter",
+                description: "The text (or array of texts) that marks the point after which to extract.",
+            },
+            {
+                title: "instance_num [OPTIONAL]",
+                description: "Which occurrence of the delimiter to use. Defaults to 1; negative counts from the end.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for case-sensitive (default) or 1 for case-insensitive delimiter matching.",
+            },
+            {
+                title: "match_end [OPTIONAL]",
+                description: "1 treats the start of the text as a delimiter. Defaults to 0.",
+            },
+            {
+                title: "if_not_found [OPTIONAL]",
+                description: "Value returned when the delimiter is not found. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "GROUPBY",
+        syntax: "GROUPBY(row_fields, values, function, [field_headers], [total_depth], [sort_order], [filter_array], [field_relationship])",
+        description: "Groups the rows of values by the values in row_fields and aggregates each group with the given function, returning a summary table with totals.",
+        example: "GROUPBY(A2:A20, C2:C20, SUM)",
+        usage: ["GROUPBY(A2:A20, C2:C20, SUM)", "GROUPBY(A2:A20, C2:C20, AVERAGE, 0, 0, -2)"],
+        parameters: [
+            {
+                title: "row_fields",
+                description: "Column-oriented range or array containing the values to group by.",
+            },
+            {
+                title: "values",
+                description: "Column-oriented range or array containing the values to aggregate.",
+            },
+            {
+                title: "function",
+                description: "The aggregation to apply to each group: SUM, PERCENTOF, AVERAGE, MEDIAN, COUNT, COUNTA, MAX, MIN, PRODUCT, ARRAYTOTEXT, CONCAT, STDEV.S, STDEV.P, VAR.S, VAR.P, MODE.SNGL, or a LAMBDA.",
+            },
+            {
+                title: "field_headers [OPTIONAL]",
+                description: "0 no headers, 1 headers in the data but not shown, 2 no headers but generate them, 3 headers in the data and shown. Inferred from the data when omitted.",
+            },
+            {
+                title: "total_depth [OPTIONAL]",
+                description: "0 no totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals above the data.",
+            },
+            {
+                title: "sort_order [OPTIONAL]",
+                description: "Column number to sort the result by; negative sorts descending.",
+            },
+            {
+                title: "filter_array [OPTIONAL]",
+                description: "Column-oriented array of TRUE/FALSE values selecting the rows to include.",
+            },
+            {
+                title: "field_relationship [OPTIONAL]",
+                description: "With more than one row field: 0 for a hierarchy (default) or 1 for a table.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "PIVOTBY",
+        syntax: "PIVOTBY(row_fields, col_fields, values, function, [field_headers], [row_total_depth], [row_sort_order], [col_total_depth], [col_sort_order], [filter_array], [relative_to])",
+        description: "Groups the rows of values by row_fields down the side and col_fields across the top, aggregating each cell with the given function, like a pivot table without the pivot.",
+        example: "PIVOTBY(A2:A20, B2:B20, C2:C20, SUM)",
+        usage: [
+            "PIVOTBY(A2:A20, B2:B20, C2:C20, SUM)",
+            "PIVOTBY(A2:A20, B2:B20, C2:C20, PERCENTOF, 0, 0, 0, 0, 0, , 0)",
+        ],
+        parameters: [
+            {
+                title: "row_fields",
+                description: "Column-oriented range or array containing the values that become rows.",
+            },
+            {
+                title: "col_fields",
+                description: "Column-oriented range or array containing the values that become columns.",
+            },
+            {
+                title: "values",
+                description: "Column-oriented range or array containing the values to aggregate.",
+            },
+            {
+                title: "function",
+                description: "The aggregation to apply to each cell: SUM, PERCENTOF, AVERAGE, MEDIAN, COUNT, COUNTA, MAX, MIN, PRODUCT, ARRAYTOTEXT, CONCAT, STDEV.S, STDEV.P, VAR.S, VAR.P, MODE.SNGL, or a LAMBDA.",
+            },
+            {
+                title: "field_headers [OPTIONAL]",
+                description: "0 no headers, 1 headers in the data but not shown, 2 no headers but generate them, 3 headers in the data and shown. Inferred from the data when omitted.",
+            },
+            {
+                title: "row_total_depth [OPTIONAL]",
+                description: "0 no row totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals above the data.",
+            },
+            {
+                title: "row_sort_order [OPTIONAL]",
+                description: "Column number to sort the rows by; negative sorts descending.",
+            },
+            {
+                title: "col_total_depth [OPTIONAL]",
+                description: "0 no column totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals before the data.",
+            },
+            {
+                title: "col_sort_order [OPTIONAL]",
+                description: "Row number to sort the columns by; negative sorts descending.",
+            },
+            {
+                title: "filter_array [OPTIONAL]",
+                description: "Column-oriented array of TRUE/FALSE values selecting the rows to include.",
+            },
+            {
+                title: "relative_to [OPTIONAL]",
+                description: "For PERCENTOF: 0 column totals (default), 1 row totals, 2 grand total, 3 parent column total, 4 parent row total.",
+            },
+        ],
+    },
 ];

package/dist/cjs/tsconfig.cjs.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../function-descriptions.ts","../../index.ts","../../server.ts","../../types.ts","../../vitest.config.ts","../../formulas/array-formula.ts","../../formulas/crypto-price.ts","../../formulas/datasource.ts","../../formulas/formula-text.ts","../../formulas/get-pivot-data.ts","../../formulas/hyperlink.ts","../../formulas/image.ts","../../formulas/import-data.ts","../../formulas/index.ts","../../formulas/join.ts","../../formulas/multiply.ts","../../formulas/real-time.ts","../../formulas/selection-status.ts","../../formulas/sequence.ts","../../formulas/server.ts","../../formulas/sparkline.ts","../../formulas/split.ts","../../formulas/star-rating.ts","../../formulas/unique.ts"],"version":"5.8.3"}
+{"root":["../../descriptions.ts","../../function-descriptions.ts","../../index.ts","../../server.ts","../../types.ts","../../vitest.config.ts","../../formulas/array-formula.ts","../../formulas/crypto-price.ts","../../formulas/datasource.ts","../../formulas/formula-text.ts","../../formulas/get-pivot-data.ts","../../formulas/hyperlink.ts","../../formulas/image.ts","../../formulas/import-data.ts","../../formulas/index.ts","../../formulas/join.ts","../../formulas/multiply.ts","../../formulas/real-time.ts","../../formulas/selection-status.ts","../../formulas/sequence.ts","../../formulas/server.ts","../../formulas/sparkline.ts","../../formulas/split.ts","../../formulas/star-rating.ts","../../formulas/unique.ts"],"version":"5.8.3"}

package/dist/esm/descriptions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@rowsncolumns/functions/descriptions` — the function catalog on its own.
+ *
+ * The root entry also re-exports the legacy JavaScript calculator's implementations (`functions`),
+ * which pull in `@rowsncolumns/calculator`, `@rowsncolumns/fast-formula-parser` and
+ * `@rowsncolumns/toolkit`. A host on the Rust engine only needs the catalog (autocomplete, Insert
+ * Function, the conditional-format / data-validation editors), so this entry must stay a pure data
+ * module: nothing here may import from `./formulas` or any `@rowsncolumns/*` runtime package.
+ * `__tests__/descriptions-subpath.spec.ts` walks the built import graph to hold that (#1135).
+ *
+ * The specifier carries its `.js` extension so the emitted `dist/esm/descriptions.js` also loads
+ * under Node's own ESM resolver (no bundler), not only under bundlers that resolve bare paths.
+ */
+export { functionDescriptions } from "./function-descriptions.js";
+export type { CalculatorFunction, FunctionParameter } from "./types";
+//# sourceMappingURL=descriptions.d.ts.map

package/dist/esm/descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../descriptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/descriptions.js

@@ -0,0 +1,14 @@
+/**
+ * `@rowsncolumns/functions/descriptions` — the function catalog on its own.
+ *
+ * The root entry also re-exports the legacy JavaScript calculator's implementations (`functions`),
+ * which pull in `@rowsncolumns/calculator`, `@rowsncolumns/fast-formula-parser` and
+ * `@rowsncolumns/toolkit`. A host on the Rust engine only needs the catalog (autocomplete, Insert
+ * Function, the conditional-format / data-validation editors), so this entry must stay a pure data
+ * module: nothing here may import from `./formulas` or any `@rowsncolumns/*` runtime package.
+ * `__tests__/descriptions-subpath.spec.ts` walks the built import graph to hold that (#1135).
+ *
+ * The specifier carries its `.js` extension so the emitted `dist/esm/descriptions.js` also loads
+ * under Node's own ESM resolver (no bundler), not only under bundlers that resolve bare paths.
+ */
+export { functionDescriptions } from "./function-descriptions.js";

package/dist/esm/function-descriptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"function-descriptions.d.ts","sourceRoot":"","sources":["../../function-descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,EA8iVpD,CAAC"}
+{"version":3,"file":"function-descriptions.d.ts","sourceRoot":"","sources":["../../function-descriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,EAopWpD,CAAC"}

package/dist/esm/function-descriptions.js

@@ -9802,4 +9802,561 @@ export const functionDescriptions = [
             },
         ],
     },
+    {
+        datatype: "Logical",
+        title: "LET",
+        syntax: "LET(name1, value1, [name2, value2], …, calculation)",
+        description: "Assigns names to calculation results so a value is computed once and reused by name inside the final calculation.",
+        example: "LET(x, A1*2, x+x)",
+        usage: [
+            "LET(x, A1*2, x+x)",
+            "LET(total, SUM(A1:A10), count, COUNT(A1:A10), total/count)",
+        ],
+        parameters: [
+            {
+                title: "name1",
+                description: "The first name to assign. Must begin with a letter and cannot look like a cell reference.",
+            },
+            {
+                title: "value1",
+                description: "The value assigned to name1.",
+            },
+            {
+                title: "name2, value2, … [OPTIONAL]",
+                description: "Additional name/value pairs; each value can use the names assigned before it.",
+            },
+            {
+                title: "calculation",
+                description: "The expression that uses the assigned names; its result is the result of LET.",
+            },
+        ],
+    },
+    {
+        datatype: "Logical",
+        title: "LAMBDA",
+        syntax: "LAMBDA([parameter1, parameter2, …,] calculation)",
+        description: "Creates a reusable custom function from its parameters and a calculation. Call it in place with LAMBDA(…)(arguments), give it a name in the Name Manager, or pass it to MAP, BYROW, REDUCE and the other helper functions.",
+        example: "LAMBDA(x, y, x+y)(1, 2)",
+        usage: ["LAMBDA(x, y, x+y)(1, 2)", "MAP(A1:A5, LAMBDA(v, v*2))"],
+        parameters: [
+            {
+                title: "parameter1, parameter2, … [OPTIONAL]",
+                description: "Names for the values passed when the function is called. Wrap a name in square brackets to make it optional (see ISOMITTED).",
+            },
+            {
+                title: "calculation",
+                description: "The formula evaluated with the parameters; always the last argument and the function's result.",
+            },
+        ],
+    },
+    {
+        datatype: "Info",
+        title: "ISOMITTED",
+        syntax: "ISOMITTED(argument)",
+        description: "Returns TRUE when the named LAMBDA parameter was left out of the call, so a custom function can supply a default.",
+        example: "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5)",
+        usage: [
+            "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5)",
+            "LAMBDA(x, [y], IF(ISOMITTED(y), x, x+y))(5, 2)",
+        ],
+        parameters: [
+            {
+                title: "argument",
+                description: "The LAMBDA parameter to test.",
+            },
+        ],
+    },
+    {
+        datatype: "Lookup",
+        title: "XMATCH",
+        syntax: "XMATCH(lookup_value, lookup_array, [match_mode], [search_mode])",
+        description: "Returns the position of a value in a range or array. Exact match by default, with the same match and search modes as XLOOKUP.",
+        example: "XMATCH(E2, B2:B10)",
+        usage: ["XMATCH(E2, B2:B10)", "XMATCH(E2, B2:B10, 1)", 'XMATCH("gr*", B2:B10, 2)'],
+        parameters: [
+            {
+                title: "lookup_value",
+                description: "The value to search for.",
+            },
+            {
+                title: "lookup_array",
+                description: "The range or array to search in.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for exact match (default), -1 for exact or next smaller, 1 for exact or next larger, 2 for wildcard match.",
+            },
+            {
+                title: "search_mode [OPTIONAL]",
+                description: "1 to search first to last (default), -1 last to first, 2 binary search on ascending data, -2 binary search on descending data.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "VSTACK",
+        syntax: "VSTACK(array1, [array2], …)",
+        description: "Appends arrays vertically, one below the other, into a single array; narrower arrays are padded with #N/A.",
+        example: "VSTACK(A1:C3, E1:G2)",
+        usage: ["VSTACK(A1:C3, E1:G2)", "VSTACK({1,2}, {3,4})"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The first range or array to stack.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional ranges or arrays appended below the previous one.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "HSTACK",
+        syntax: "HSTACK(array1, [array2], …)",
+        description: "Appends arrays horizontally, side by side, into a single array; shorter arrays are padded with #N/A.",
+        example: "HSTACK(A1:A3, C1:C3)",
+        usage: ["HSTACK(A1:A3, C1:C3)", "HSTACK({1;2}, {3;4})"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The first range or array to stack.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional ranges or arrays appended to the right of the previous one.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "CHOOSECOLS",
+        syntax: "CHOOSECOLS(array, col_num1, [col_num2], …)",
+        description: "Returns the specified columns of an array, in the order given; negative numbers count from the last column.",
+        example: "CHOOSECOLS(A1:E10, 1, 3)",
+        usage: ["CHOOSECOLS(A1:E10, 1, 3)", "CHOOSECOLS(A1:E10, -1)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to pick columns from.",
+            },
+            {
+                title: "col_num1",
+                description: "The first column to return; negative counts from the end.",
+            },
+            {
+                title: "col_num2, … [OPTIONAL]",
+                description: "Additional columns to return, in output order.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "CHOOSEROWS",
+        syntax: "CHOOSEROWS(array, row_num1, [row_num2], …)",
+        description: "Returns the specified rows of an array, in the order given; negative numbers count from the last row.",
+        example: "CHOOSEROWS(A1:E10, 1, 3)",
+        usage: ["CHOOSEROWS(A1:E10, 1, 3)", "CHOOSEROWS(A1:E10, -1)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to pick rows from.",
+            },
+            {
+                title: "row_num1",
+                description: "The first row to return; negative counts from the end.",
+            },
+            {
+                title: "row_num2, … [OPTIONAL]",
+                description: "Additional rows to return, in output order.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "TOCOL",
+        syntax: "TOCOL(array, [ignore], [scan_by_column])",
+        description: "Returns an array as a single column, reading it row by row unless scan_by_column is TRUE.",
+        example: "TOCOL(A1:C3)",
+        usage: ["TOCOL(A1:C3)", "TOCOL(A1:C3, 1)", "TOCOL(A1:C3, 0, TRUE)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to flatten.",
+            },
+            {
+                title: "ignore [OPTIONAL]",
+                description: "0 keeps every value (default), 1 ignores blanks, 2 ignores errors, 3 ignores blanks and errors.",
+            },
+            {
+                title: "scan_by_column [OPTIONAL]",
+                description: "TRUE to read the array column by column. Defaults to FALSE (row by row).",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "TOROW",
+        syntax: "TOROW(array, [ignore], [scan_by_column])",
+        description: "Returns an array as a single row, reading it row by row unless scan_by_column is TRUE.",
+        example: "TOROW(A1:C3)",
+        usage: ["TOROW(A1:C3)", "TOROW(A1:C3, 1)", "TOROW(A1:C3, 0, TRUE)"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array to flatten.",
+            },
+            {
+                title: "ignore [OPTIONAL]",
+                description: "0 keeps every value (default), 1 ignores blanks, 2 ignores errors, 3 ignores blanks and errors.",
+            },
+            {
+                title: "scan_by_column [OPTIONAL]",
+                description: "TRUE to read the array column by column. Defaults to FALSE (row by row).",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "WRAPROWS",
+        syntax: "WRAPROWS(vector, wrap_count, [pad_with])",
+        description: "Wraps a single row or column of values into rows of wrap_count values each; the last row is padded with pad_with (#N/A by default).",
+        example: "WRAPROWS(A1:A10, 3)",
+        usage: ["WRAPROWS(A1:A10, 3)", 'WRAPROWS(A1:A10, 3, "")'],
+        parameters: [
+            {
+                title: "vector",
+                description: "The single row or column to wrap.",
+            },
+            {
+                title: "wrap_count",
+                description: "Maximum number of values per row.",
+            },
+            {
+                title: "pad_with [OPTIONAL]",
+                description: "Value used to fill the last row. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "WRAPCOLS",
+        syntax: "WRAPCOLS(vector, wrap_count, [pad_with])",
+        description: "Wraps a single row or column of values into columns of wrap_count values each; the last column is padded with pad_with (#N/A by default).",
+        example: "WRAPCOLS(A1:A10, 3)",
+        usage: ["WRAPCOLS(A1:A10, 3)", 'WRAPCOLS(A1:A10, 3, "")'],
+        parameters: [
+            {
+                title: "vector",
+                description: "The single row or column to wrap.",
+            },
+            {
+                title: "wrap_count",
+                description: "Maximum number of values per column.",
+            },
+            {
+                title: "pad_with [OPTIONAL]",
+                description: "Value used to fill the last column. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "BYROW",
+        syntax: "BYROW(array, lambda(row))",
+        description: "Applies a LAMBDA to each row of an array and returns one result per row, as a column.",
+        example: "BYROW(A1:C5, LAMBDA(row, SUM(row)))",
+        usage: ["BYROW(A1:C5, LAMBDA(row, SUM(row)))", "BYROW(A1:C5, LAMBDA(row, MAX(row)))"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array whose rows are processed.",
+            },
+            {
+                title: "lambda(row)",
+                description: "A LAMBDA with one parameter that receives a row and returns a single value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "BYCOL",
+        syntax: "BYCOL(array, lambda(column))",
+        description: "Applies a LAMBDA to each column of an array and returns one result per column, as a row.",
+        example: "BYCOL(A1:C5, LAMBDA(col, SUM(col)))",
+        usage: ["BYCOL(A1:C5, LAMBDA(col, SUM(col)))", "BYCOL(A1:C5, LAMBDA(col, MAX(col)))"],
+        parameters: [
+            {
+                title: "array",
+                description: "The range or array whose columns are processed.",
+            },
+            {
+                title: "lambda(column)",
+                description: "A LAMBDA with one parameter that receives a column and returns a single value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "MAP",
+        syntax: "MAP(array1, [array2, …], lambda(value1, [value2, …]))",
+        description: "Applies a LAMBDA to each value of one or more arrays and returns an array of the same shape.",
+        example: "MAP(A1:A5, LAMBDA(v, v*2))",
+        usage: ["MAP(A1:A5, LAMBDA(v, v*2))", "MAP(A1:A5, B1:B5, LAMBDA(a, b, a&b))"],
+        parameters: [
+            {
+                title: "array1",
+                description: "The range or array to map.",
+            },
+            {
+                title: "array2, … [OPTIONAL]",
+                description: "Additional arrays of the same shape, passed to the LAMBDA as further parameters.",
+            },
+            {
+                title: "lambda(value1, [value2, …])",
+                description: "A LAMBDA with one parameter per array that returns the new value.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "REDUCE",
+        syntax: "REDUCE([initial_value], array, lambda(accumulator, value))",
+        description: "Folds an array into a single value by calling a LAMBDA with the running accumulator and each value in turn.",
+        example: "REDUCE(0, A1:A5, LAMBDA(acc, v, acc+v))",
+        usage: ["REDUCE(0, A1:A5, LAMBDA(acc, v, acc+v))", "REDUCE(1, A1:A5, LAMBDA(acc, v, acc*v))"],
+        parameters: [
+            {
+                title: "initial_value [OPTIONAL]",
+                description: "The accumulator's starting value.",
+            },
+            {
+                title: "array",
+                description: "The range or array to fold.",
+            },
+            {
+                title: "lambda(accumulator, value)",
+                description: "A LAMBDA with two parameters that returns the next accumulator.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "SCAN",
+        syntax: "SCAN([initial_value], array, lambda(accumulator, value))",
+        description: "Like REDUCE, but returns every intermediate accumulator as an array of the same shape as the input.",
+        example: "SCAN(0, A1:A5, LAMBDA(acc, v, acc+v))",
+        usage: ["SCAN(0, A1:A5, LAMBDA(acc, v, acc+v))", 'SCAN("", A1:A5, LAMBDA(acc, v, acc&v))'],
+        parameters: [
+            {
+                title: "initial_value [OPTIONAL]",
+                description: "The accumulator's starting value.",
+            },
+            {
+                title: "array",
+                description: "The range or array to scan.",
+            },
+            {
+                title: "lambda(accumulator, value)",
+                description: "A LAMBDA with two parameters that returns the next accumulator.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "MAKEARRAY",
+        syntax: "MAKEARRAY(rows, columns, lambda(row, column))",
+        description: "Builds an array of the given size by calling a LAMBDA with each row and column number.",
+        example: "MAKEARRAY(3, 3, LAMBDA(r, c, r*c))",
+        usage: ["MAKEARRAY(3, 3, LAMBDA(r, c, r*c))", 'MAKEARRAY(2, 2, LAMBDA(r, c, "R"&r&"C"&c))'],
+        parameters: [
+            {
+                title: "rows",
+                description: "Number of rows in the result.",
+            },
+            {
+                title: "columns",
+                description: "Number of columns in the result.",
+            },
+            {
+                title: "lambda(row, column)",
+                description: "A LAMBDA with two parameters that returns the value for that row and column (both 1-based).",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "TEXTBEFORE",
+        syntax: "TEXTBEFORE(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
+        description: "Returns the text that comes before the nth occurrence of a delimiter; a negative instance number counts occurrences from the end.",
+        example: 'TEXTBEFORE("Red riding hood", " ")',
+        usage: [
+            'TEXTBEFORE("Red riding hood", " ")',
+            'TEXTBEFORE("Red riding hood", " ", -1)',
+            'TEXTBEFORE("a-b-c", "-", 2)',
+        ],
+        parameters: [
+            {
+                title: "text",
+                description: "The text to search in.",
+            },
+            {
+                title: "delimiter",
+                description: "The text (or array of texts) that marks the point before which to extract.",
+            },
+            {
+                title: "instance_num [OPTIONAL]",
+                description: "Which occurrence of the delimiter to use. Defaults to 1; negative counts from the end.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for case-sensitive (default) or 1 for case-insensitive delimiter matching.",
+            },
+            {
+                title: "match_end [OPTIONAL]",
+                description: "1 treats the end of the text as a delimiter. Defaults to 0.",
+            },
+            {
+                title: "if_not_found [OPTIONAL]",
+                description: "Value returned when the delimiter is not found. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Text",
+        title: "TEXTAFTER",
+        syntax: "TEXTAFTER(text, delimiter, [instance_num], [match_mode], [match_end], [if_not_found])",
+        description: "Returns the text that comes after the nth occurrence of a delimiter; a negative instance number counts occurrences from the end.",
+        example: 'TEXTAFTER("Red riding hood", " ")',
+        usage: [
+            'TEXTAFTER("Red riding hood", " ")',
+            'TEXTAFTER("Red riding hood", " ", -1)',
+            'TEXTAFTER("a-b-c", "-", 2)',
+        ],
+        parameters: [
+            {
+                title: "text",
+                description: "The text to search in.",
+            },
+            {
+                title: "delimiter",
+                description: "The text (or array of texts) that marks the point after which to extract.",
+            },
+            {
+                title: "instance_num [OPTIONAL]",
+                description: "Which occurrence of the delimiter to use. Defaults to 1; negative counts from the end.",
+            },
+            {
+                title: "match_mode [OPTIONAL]",
+                description: "0 for case-sensitive (default) or 1 for case-insensitive delimiter matching.",
+            },
+            {
+                title: "match_end [OPTIONAL]",
+                description: "1 treats the start of the text as a delimiter. Defaults to 0.",
+            },
+            {
+                title: "if_not_found [OPTIONAL]",
+                description: "Value returned when the delimiter is not found. Defaults to #N/A.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "GROUPBY",
+        syntax: "GROUPBY(row_fields, values, function, [field_headers], [total_depth], [sort_order], [filter_array], [field_relationship])",
+        description: "Groups the rows of values by the values in row_fields and aggregates each group with the given function, returning a summary table with totals.",
+        example: "GROUPBY(A2:A20, C2:C20, SUM)",
+        usage: ["GROUPBY(A2:A20, C2:C20, SUM)", "GROUPBY(A2:A20, C2:C20, AVERAGE, 0, 0, -2)"],
+        parameters: [
+            {
+                title: "row_fields",
+                description: "Column-oriented range or array containing the values to group by.",
+            },
+            {
+                title: "values",
+                description: "Column-oriented range or array containing the values to aggregate.",
+            },
+            {
+                title: "function",
+                description: "The aggregation to apply to each group: SUM, PERCENTOF, AVERAGE, MEDIAN, COUNT, COUNTA, MAX, MIN, PRODUCT, ARRAYTOTEXT, CONCAT, STDEV.S, STDEV.P, VAR.S, VAR.P, MODE.SNGL, or a LAMBDA.",
+            },
+            {
+                title: "field_headers [OPTIONAL]",
+                description: "0 no headers, 1 headers in the data but not shown, 2 no headers but generate them, 3 headers in the data and shown. Inferred from the data when omitted.",
+            },
+            {
+                title: "total_depth [OPTIONAL]",
+                description: "0 no totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals above the data.",
+            },
+            {
+                title: "sort_order [OPTIONAL]",
+                description: "Column number to sort the result by; negative sorts descending.",
+            },
+            {
+                title: "filter_array [OPTIONAL]",
+                description: "Column-oriented array of TRUE/FALSE values selecting the rows to include.",
+            },
+            {
+                title: "field_relationship [OPTIONAL]",
+                description: "With more than one row field: 0 for a hierarchy (default) or 1 for a table.",
+            },
+        ],
+    },
+    {
+        datatype: "Filter",
+        title: "PIVOTBY",
+        syntax: "PIVOTBY(row_fields, col_fields, values, function, [field_headers], [row_total_depth], [row_sort_order], [col_total_depth], [col_sort_order], [filter_array], [relative_to])",
+        description: "Groups the rows of values by row_fields down the side and col_fields across the top, aggregating each cell with the given function, like a pivot table without the pivot.",
+        example: "PIVOTBY(A2:A20, B2:B20, C2:C20, SUM)",
+        usage: [
+            "PIVOTBY(A2:A20, B2:B20, C2:C20, SUM)",
+            "PIVOTBY(A2:A20, B2:B20, C2:C20, PERCENTOF, 0, 0, 0, 0, 0, , 0)",
+        ],
+        parameters: [
+            {
+                title: "row_fields",
+                description: "Column-oriented range or array containing the values that become rows.",
+            },
+            {
+                title: "col_fields",
+                description: "Column-oriented range or array containing the values that become columns.",
+            },
+            {
+                title: "values",
+                description: "Column-oriented range or array containing the values to aggregate.",
+            },
+            {
+                title: "function",
+                description: "The aggregation to apply to each cell: SUM, PERCENTOF, AVERAGE, MEDIAN, COUNT, COUNTA, MAX, MIN, PRODUCT, ARRAYTOTEXT, CONCAT, STDEV.S, STDEV.P, VAR.S, VAR.P, MODE.SNGL, or a LAMBDA.",
+            },
+            {
+                title: "field_headers [OPTIONAL]",
+                description: "0 no headers, 1 headers in the data but not shown, 2 no headers but generate them, 3 headers in the data and shown. Inferred from the data when omitted.",
+            },
+            {
+                title: "row_total_depth [OPTIONAL]",
+                description: "0 no row totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals above the data.",
+            },
+            {
+                title: "row_sort_order [OPTIONAL]",
+                description: "Column number to sort the rows by; negative sorts descending.",
+            },
+            {
+                title: "col_total_depth [OPTIONAL]",
+                description: "0 no column totals, 1 grand totals (default), 2 grand totals and subtotals; negative values place the totals before the data.",
+            },
+            {
+                title: "col_sort_order [OPTIONAL]",
+                description: "Row number to sort the columns by; negative sorts descending.",
+            },
+            {
+                title: "filter_array [OPTIONAL]",
+                description: "Column-oriented array of TRUE/FALSE values selecting the rows to include.",
+            },
+            {
+                title: "relative_to [OPTIONAL]",
+                description: "For PERCENTOF: 0 column totals (default), 1 row totals, 2 grand total, 3 parent column total, 4 parent row total.",
+            },
+        ],
+    },
 ];

package/dist/esm/tsconfig.esm.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../function-descriptions.ts","../../index.ts","../../server.ts","../../types.ts","../../vitest.config.ts","../../formulas/array-formula.ts","../../formulas/crypto-price.ts","../../formulas/datasource.ts","../../formulas/formula-text.ts","../../formulas/get-pivot-data.ts","../../formulas/hyperlink.ts","../../formulas/image.ts","../../formulas/import-data.ts","../../formulas/index.ts","../../formulas/join.ts","../../formulas/multiply.ts","../../formulas/real-time.ts","../../formulas/selection-status.ts","../../formulas/sequence.ts","../../formulas/server.ts","../../formulas/sparkline.ts","../../formulas/split.ts","../../formulas/star-rating.ts","../../formulas/unique.ts"],"version":"5.8.3"}
+{"root":["../../descriptions.ts","../../function-descriptions.ts","../../index.ts","../../server.ts","../../types.ts","../../vitest.config.ts","../../formulas/array-formula.ts","../../formulas/crypto-price.ts","../../formulas/datasource.ts","../../formulas/formula-text.ts","../../formulas/get-pivot-data.ts","../../formulas/hyperlink.ts","../../formulas/image.ts","../../formulas/import-data.ts","../../formulas/index.ts","../../formulas/join.ts","../../formulas/multiply.ts","../../formulas/real-time.ts","../../formulas/selection-status.ts","../../formulas/sequence.ts","../../formulas/server.ts","../../formulas/sparkline.ts","../../formulas/split.ts","../../formulas/star-rating.ts","../../formulas/unique.ts"],"version":"5.8.3"}

package/package.json

@@ -1,20 +1,28 @@
 {
   "name": "@rowsncolumns/functions",
-  "version": "15.0.1",
+  "version": "15.1.0",
   "author": "Vinay M",
   "license": "SEE LICENSE IN LICENSE.md",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "exports": {
     ".": {
+      "types": "./dist/esm/index.d.ts",
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js"
     },
+    "./descriptions": {
+      "types": "./dist/esm/descriptions.d.ts",
+      "import": "./dist/esm/descriptions.js",
+      "require": "./dist/cjs/descriptions.js"
+    },
     "./server": {
+      "types": "./dist/esm/server.d.ts",
       "import": "./dist/esm/server.js",
       "require": "./dist/cjs/server.js"
     }
   },
+  "sideEffects": false,
   "scripts": {
     "build": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json",
     "clean": "rimraf dist",
@@ -34,11 +42,11 @@
     "url": "https://github.com/rowsncolumns/spreadsheet/issues"
   },
   "devDependencies": {
-    "@rowsncolumns/common-types": ">=5.2.34",
-    "@rowsncolumns/calculator": ">=7.3.0",
-    "@rowsncolumns/fast-formula-parser": ">=6.2.40",
-    "@rowsncolumns/utils": ">=9.4.0",
-    "@rowsncolumns/toolkit": ">=24.5.0"
+    "@rowsncolumns/common-types": ">=5.3.1",
+    "@rowsncolumns/calculator": ">=7.3.2",
+    "@rowsncolumns/fast-formula-parser": ">=6.2.43",
+    "@rowsncolumns/utils": ">=9.5.1",
+    "@rowsncolumns/toolkit": ">=24.5.15"
   },
   "peerDependencies": {
     "@rowsncolumns/common-types": ">=5.2.32",