@svgrid/enterprise 3.0.1 → 3.0.2

package/dist/sheet/format-store.js

@@ -0,0 +1,233 @@
+/**
+ * Keys are "rowId columnId" with each half percent-encoded.
+ *
+ * Encoding is what makes the key reversible. Ids come from the grid and may
+ * contain spaces, so a plain join cannot be split back apart - and `hydrate`
+ * has to split it, or the row and column indexes come back empty and
+ * `forgetRow` / `forgetColumn` become silent no-ops on a restored store.
+ */
+function keyOf(rowId, columnId) {
+    return `${encodeURIComponent(rowId)} ${encodeURIComponent(columnId)}`;
+}
+function splitKey(key) {
+    const gap = key.indexOf(' ');
+    if (gap < 0)
+        return null;
+    try {
+        return {
+            rowId: decodeURIComponent(key.slice(0, gap)),
+            columnId: decodeURIComponent(key.slice(gap + 1)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function createFormatStore(initial) {
+    const cells = new Map();
+    const rowsIndex = new Map();
+    const colsIndex = new Map();
+    function remember(rowId, columnId, key) {
+        let byRow = rowsIndex.get(rowId);
+        if (!byRow) {
+            byRow = new Set();
+            rowsIndex.set(rowId, byRow);
+        }
+        byRow.add(key);
+        let byCol = colsIndex.get(columnId);
+        if (!byCol) {
+            byCol = new Set();
+            colsIndex.set(columnId, byCol);
+        }
+        byCol.add(key);
+    }
+    function eachCell(rects, at, fn) {
+        const seen = new Set();
+        for (const [minRow, minCol, maxRow, maxCol] of rects) {
+            for (let r = minRow; r <= maxRow; r += 1) {
+                const rowId = at.rowIdAt(r);
+                if (rowId === null)
+                    continue;
+                for (let c = minCol; c <= maxCol; c += 1) {
+                    const columnId = at.columnIdAt(c);
+                    if (columnId === null)
+                        continue;
+                    // Overlapping ranges must not apply a toggle twice.
+                    const key = keyOf(rowId, columnId);
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    fn(rowId, columnId);
+                }
+            }
+        }
+    }
+    const store = {
+        get(rowId, columnId) {
+            return cells.get(keyOf(rowId, columnId));
+        },
+        set(rects, patch, at) {
+            eachCell(rects, at, (rowId, columnId) => {
+                const key = keyOf(rowId, columnId);
+                const next = { ...(cells.get(key) ?? {}), ...patch };
+                // Strip keys explicitly set to undefined so an entry does not grow
+                // a field that means nothing.
+                for (const [k, v] of Object.entries(next)) {
+                    if (v === undefined)
+                        delete next[k];
+                }
+                if (Object.keys(next).length === 0) {
+                    cells.delete(key);
+                    return;
+                }
+                cells.set(key, next);
+                remember(rowId, columnId, key);
+            });
+        },
+        clear(rects, at) {
+            eachCell(rects, at, (rowId, columnId) => {
+                cells.delete(keyOf(rowId, columnId));
+            });
+        },
+        toggle(rects, field, at) {
+            // Excel's rule, and the one users expect: a mixed selection turns ON.
+            let all = true;
+            eachCell(rects, at, (rowId, columnId) => {
+                if (!cells.get(keyOf(rowId, columnId))?.[field])
+                    all = false;
+            });
+            // `set` treats undefined as "remove this field", so one pass does both
+            // directions.
+            store.set(rects, { [field]: all ? undefined : true }, at);
+        },
+        forgetRow(rowId) {
+            for (const key of rowsIndex.get(rowId) ?? [])
+                cells.delete(key);
+            rowsIndex.delete(rowId);
+        },
+        forgetColumn(columnId) {
+            for (const key of colsIndex.get(columnId) ?? [])
+                cells.delete(key);
+            colsIndex.delete(columnId);
+        },
+        get size() {
+            return cells.size;
+        },
+        serialize() {
+            return Object.fromEntries(cells);
+        },
+        hydrate(entries) {
+            cells.clear();
+            rowsIndex.clear();
+            colsIndex.clear();
+            for (const [key, entry] of Object.entries(entries)) {
+                cells.set(key, entry);
+                // Rebuild the indexes, or forgetRow / forgetColumn do nothing on a
+                // store that came back from storage.
+                const parts = splitKey(key);
+                if (parts)
+                    remember(parts.rowId, parts.columnId, key);
+            }
+        },
+        clearAll() {
+            cells.clear();
+            rowsIndex.clear();
+            colsIndex.clear();
+        },
+        remapRows(fn) {
+            const next = {};
+            for (const [key, entry] of cells) {
+                const parts = splitKey(key);
+                if (!parts)
+                    continue;
+                const rowId = fn(parts.rowId);
+                if (rowId !== null)
+                    next[keyOf(rowId, parts.columnId)] = entry;
+            }
+            store.hydrate(next);
+        },
+        remapColumns(fn) {
+            const next = {};
+            for (const [key, entry] of cells) {
+                const parts = splitKey(key);
+                if (!parts)
+                    continue;
+                const columnId = fn(parts.columnId);
+                if (columnId !== null)
+                    next[keyOf(parts.rowId, columnId)] = entry;
+            }
+            store.hydrate(next);
+        },
+    };
+    if (initial)
+        store.hydrate(initial);
+    return store;
+}
+/** Turn an entry into inline style text for a cell renderer. */
+export function entryToStyle(entry) {
+    if (!entry)
+        return '';
+    const parts = [];
+    if (entry.bold)
+        parts.push('font-weight:700');
+    if (entry.italic)
+        parts.push('font-style:italic');
+    if (entry.underline && entry.strike)
+        parts.push('text-decoration:underline line-through');
+    else if (entry.underline)
+        parts.push('text-decoration:underline');
+    else if (entry.strike)
+        parts.push('text-decoration:line-through');
+    if (entry.color)
+        parts.push(`color:${entry.color}`);
+    if (entry.fill)
+        parts.push(`background:${entry.fill}`);
+    if (entry.align)
+        parts.push(`text-align:${entry.align}`);
+    if (entry.fontFamily)
+        parts.push(`font-family:${entry.fontFamily}`);
+    if (entry.fontSize)
+        parts.push(`font-size:${entry.fontSize}px`);
+    if (entry.wrap)
+        parts.push('white-space:pre-wrap');
+    if (entry.indent)
+        parts.push(`padding-left:${entry.indent * 12}px`);
+    const borders = borderShadows(entry.border);
+    if (borders)
+        parts.push(`box-shadow:${borders}`);
+    return parts.join(';');
+}
+/**
+ * Cell borders as inset shadows, one per side.
+ *
+ * The cell span fills its td edge to edge, so an inset shadow along one
+ * edge is a border that costs no layout: a real border would push the text
+ * and change the cell's size, and a bordered cell next to a plain one would
+ * misalign. Shadows stack, so a cell can carry any combination of sides.
+ */
+export function borderShadows(border) {
+    if (!border)
+        return '';
+    const parts = [];
+    const line = (spec) => ({
+        w: spec?.width ?? 1,
+        c: spec?.color ?? 'currentColor',
+    });
+    if (border.top) {
+        const { w, c } = line(border.top);
+        parts.push(`inset 0 ${w}px 0 0 ${c}`);
+    }
+    if (border.bottom) {
+        const { w, c } = line(border.bottom);
+        parts.push(`inset 0 -${w}px 0 0 ${c}`);
+    }
+    if (border.left) {
+        const { w, c } = line(border.left);
+        parts.push(`inset ${w}px 0 0 0 ${c}`);
+    }
+    if (border.right) {
+        const { w, c } = line(border.right);
+        parts.push(`inset -${w}px 0 0 0 ${c}`);
+    }
+    return parts.join(',');
+}

package/dist/sheet/freeze.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Freeze panes, over what the grid already has.
+ *
+ * Columns freeze through `api.setColumnPinning({ left: [...] })`, which
+ * makes them sticky and excludes them from the horizontal scroll, and rows
+ * through the grid's `frozenRows` prop, set here with `api.setOption`: the
+ * first N rows stay under the header, still the grid's own rows, editable
+ * and numbered, while the virtualized body scrolls beneath them. Both halves
+ * go through the api, so Freeze Panes is one call for any consumer.
+ *
+ * `splitFrozenRows` stays for a grid that renders its own pinned band from
+ * `pinnedTopRows` instead.
+ */
+import type { GridCommandContext } from '@svgrid/grid/shortcuts';
+export type FreezeState = {
+    /** How many leading rows should be pinned. */
+    rows: number;
+    /** How many leading columns should be pinned. */
+    cols: number;
+};
+export type FreezeSplit<TData> = {
+    /** Pass as `pinnedTopRows`. */
+    pinnedTopRows: ReadonlyArray<TData>;
+    /** Pass as `data`. The pinned rows are REMOVED, so nothing renders twice. */
+    bodyRows: ReadonlyArray<TData>;
+};
+/**
+ * Split a row array for a frozen-row count.
+ *
+ * ```svelte
+ * {@const split = splitFrozenRows(rows, freeze.rows)}
+ * <SvGrid data={split.bodyRows} pinnedTopRows={split.pinnedTopRows} ... />
+ * ```
+ */
+export declare function splitFrozenRows<TData>(rows: ReadonlyArray<TData>, count: number): FreezeSplit<TData>;
+/** Column ids left of `cols`, which is what column pinning takes. */
+export declare function frozenColumnIds(cmd: GridCommandContext, cols: number): string[];
+/**
+ * Apply both halves through the api and report the state: the columns pin,
+ * the rows freeze. Zero rows clears the row half.
+ */
+export declare function applyFreeze(cmd: GridCommandContext, state: FreezeState): FreezeState;
+/**
+ * Excel's Freeze Panes: everything above and to the left of the active cell
+ * freezes. With the cursor on B3 you get two frozen rows and one frozen
+ * column.
+ */
+export declare function freezeAtActiveCell(cmd: GridCommandContext): FreezeState;
+/** Freeze Top Row. */
+export declare function freezeTopRow(cmd: GridCommandContext): FreezeState;
+/** Freeze First Column. */
+export declare function freezeFirstColumn(cmd: GridCommandContext): FreezeState;
+/** Unfreeze everything. */
+export declare function unfreeze(cmd: GridCommandContext): FreezeState;

package/dist/sheet/freeze.js

@@ -0,0 +1,58 @@
+/**
+ * Split a row array for a frozen-row count.
+ *
+ * ```svelte
+ * {@const split = splitFrozenRows(rows, freeze.rows)}
+ * <SvGrid data={split.bodyRows} pinnedTopRows={split.pinnedTopRows} ... />
+ * ```
+ */
+export function splitFrozenRows(rows, count) {
+    const n = Math.max(0, Math.min(Math.floor(count), rows.length));
+    if (n === 0)
+        return { pinnedTopRows: [], bodyRows: rows };
+    return { pinnedTopRows: rows.slice(0, n), bodyRows: rows.slice(n) };
+}
+/** Column ids left of `cols`, which is what column pinning takes. */
+export function frozenColumnIds(cmd, cols) {
+    const out = [];
+    for (let c = 0; c < Math.min(cols, cmd.colCount); c += 1) {
+        const id = cmd.columnIdAt(c);
+        if (id !== null)
+            out.push(id);
+    }
+    return out;
+}
+/**
+ * Apply both halves through the api and report the state: the columns pin,
+ * the rows freeze. Zero rows clears the row half.
+ */
+export function applyFreeze(cmd, state) {
+    const api = cmd.api;
+    api.setColumnPinning?.({ left: frozenColumnIds(cmd, state.cols) });
+    api.setOption?.('frozenRows', state.rows > 0 ? state.rows : undefined);
+    return state;
+}
+/**
+ * Excel's Freeze Panes: everything above and to the left of the active cell
+ * freezes. With the cursor on B3 you get two frozen rows and one frozen
+ * column.
+ */
+export function freezeAtActiveCell(cmd) {
+    const active = cmd.activeCell;
+    const state = active
+        ? { rows: active.rowIndex, cols: active.colIndex }
+        : { rows: 0, cols: 0 };
+    return applyFreeze(cmd, state);
+}
+/** Freeze Top Row. */
+export function freezeTopRow(cmd) {
+    return applyFreeze(cmd, { rows: 1, cols: 0 });
+}
+/** Freeze First Column. */
+export function freezeFirstColumn(cmd) {
+    return applyFreeze(cmd, { rows: 0, cols: 1 });
+}
+/** Unfreeze everything. */
+export function unfreeze(cmd) {
+    return applyFreeze(cmd, { rows: 0, cols: 0 });
+}

package/dist/sheet/function-catalog.d.ts

@@ -0,0 +1,10 @@
+export type FunctionGroup = 'Math' | 'Statistical' | 'Logical' | 'Information' | 'Text' | 'Date & Time' | 'Lookup & Reference' | 'Other';
+export type FunctionInfo = {
+    name: string;
+    group: FunctionGroup;
+    signature: string;
+    description: string;
+};
+export declare const FUNCTION_GROUPS: ReadonlyArray<FunctionGroup>;
+/** Every function the engine knows, described, alphabetical. */
+export declare function functionCatalog(): FunctionInfo[];

package/dist/sheet/function-catalog.js

@@ -0,0 +1,94 @@
+/**
+ * What Insert Function shows for each function: its group, the argument
+ * list, and one line on what it does. The engine's table (`FUNCTIONS`) is
+ * the source of truth for which names exist; a name missing here is listed
+ * with a bare `NAME(...)` and no description rather than left out, so a
+ * custom function registered through `withCustomFunctions` appears too.
+ */
+import { FUNCTIONS } from './functions.js';
+import { SIGNATURES } from './autocomplete.js';
+const CATALOG = {
+    SUM: { group: 'Math', description: 'Adds all the numbers in a range of cells.', signature: 'SUM(number1, [number2], ...)' },
+    ABS: { group: 'Math', description: 'Returns the absolute value of a number, a number without its sign.', signature: 'ABS(number)' },
+    INT: { group: 'Math', description: 'Rounds a number down to the nearest integer.', signature: 'INT(number)' },
+    MOD: { group: 'Math', description: 'Returns the remainder after a number is divided by a divisor.', signature: 'MOD(number, divisor)' },
+    POWER: { group: 'Math', description: 'Returns the result of a number raised to a power.', signature: 'POWER(number, power)' },
+    SQRT: { group: 'Math', description: 'Returns the square root of a number.', signature: 'SQRT(number)' },
+    ROUND: { group: 'Math', description: 'Rounds a number to a specified number of digits.' },
+    ROUNDUP: { group: 'Math', description: 'Rounds a number up, away from zero.', signature: 'ROUNDUP(number, digits)' },
+    ROUNDDOWN: { group: 'Math', description: 'Rounds a number down, toward zero.', signature: 'ROUNDDOWN(number, digits)' },
+    SUMIF: { group: 'Math', description: 'Adds the cells specified by a given condition or criteria.' },
+    SUMIFS: { group: 'Math', description: 'Adds the cells specified by a given set of conditions or criteria.' },
+    AVERAGE: { group: 'Statistical', description: 'Returns the average (arithmetic mean) of its arguments.', signature: 'AVERAGE(number1, [number2], ...)' },
+    AVG: { group: 'Statistical', description: 'The same as AVERAGE.', signature: 'AVG(number1, [number2], ...)' },
+    MIN: { group: 'Statistical', description: 'Returns the smallest number in a set of values.', signature: 'MIN(number1, [number2], ...)' },
+    MAX: { group: 'Statistical', description: 'Returns the largest value in a set of values.', signature: 'MAX(number1, [number2], ...)' },
+    COUNT: { group: 'Statistical', description: 'Counts the number of cells in a range that contain numbers.', signature: 'COUNT(value1, [value2], ...)' },
+    COUNTA: { group: 'Statistical', description: 'Counts the number of cells in a range that are not empty.', signature: 'COUNTA(value1, [value2], ...)' },
+    COUNTBLANK: { group: 'Statistical', description: 'Counts the number of empty cells in a range.', signature: 'COUNTBLANK(range)' },
+    MEDIAN: { group: 'Statistical', description: 'Returns the median, the number in the middle of a set of numbers.', signature: 'MEDIAN(number1, [number2], ...)' },
+    STDEV: { group: 'Statistical', description: 'Estimates standard deviation based on a sample.', signature: 'STDEV(number1, [number2], ...)' },
+    RANK: { group: 'Statistical', description: 'Returns the rank of a number in a list of numbers.', signature: 'RANK(number, ref, [order])' },
+    COUNTIF: { group: 'Statistical', description: 'Counts the number of cells within a range that meet the given condition.' },
+    COUNTIFS: { group: 'Statistical', description: 'Counts the number of cells specified by a given set of conditions.' },
+    AVERAGEIF: { group: 'Statistical', description: 'Finds the average of the cells specified by a given condition.' },
+    IF: { group: 'Logical', description: 'Checks whether a condition is met, and returns one value if TRUE and another if FALSE.' },
+    IFS: { group: 'Logical', description: 'Checks whether one or more conditions are met and returns a value corresponding to the first TRUE condition.' },
+    IFERROR: { group: 'Logical', description: 'Returns a value you specify if a formula evaluates to an error; otherwise, returns the result of the formula.' },
+    IFNA: { group: 'Logical', description: 'Returns the value you specify if the expression resolves to #N/A, otherwise returns the result of the expression.', signature: 'IFNA(value, fallback)' },
+    SWITCH: { group: 'Logical', description: 'Evaluates an expression against a list of values and returns the result corresponding to the first matching value.' },
+    AND: { group: 'Logical', description: 'Checks whether all arguments are TRUE, and returns TRUE if all arguments are TRUE.', signature: 'AND(logical1, [logical2], ...)' },
+    OR: { group: 'Logical', description: 'Checks whether any of the arguments are TRUE, and returns TRUE or FALSE.', signature: 'OR(logical1, [logical2], ...)' },
+    NOT: { group: 'Logical', description: 'Changes FALSE to TRUE, or TRUE to FALSE.', signature: 'NOT(logical)' },
+    XOR: { group: 'Logical', description: 'Returns a logical exclusive OR of all arguments.', signature: 'XOR(logical1, [logical2], ...)' },
+    ISNUMBER: { group: 'Information', description: 'Checks whether a value is a number, and returns TRUE or FALSE.', signature: 'ISNUMBER(value)' },
+    ISTEXT: { group: 'Information', description: 'Checks whether a value is text, and returns TRUE or FALSE.', signature: 'ISTEXT(value)' },
+    ISLOGICAL: { group: 'Information', description: 'Checks whether a value is a logical value (TRUE or FALSE), and returns TRUE or FALSE.', signature: 'ISLOGICAL(value)' },
+    ISBLANK: { group: 'Information', description: 'Checks whether a reference is to an empty cell, and returns TRUE or FALSE.', signature: 'ISBLANK(value)' },
+    LEN: { group: 'Text', description: 'Returns the number of characters in a text string.', signature: 'LEN(text)' },
+    LEFT: { group: 'Text', description: 'Returns the specified number of characters from the start of a text string.', signature: 'LEFT(text, [count])' },
+    RIGHT: { group: 'Text', description: 'Returns the specified number of characters from the end of a text string.', signature: 'RIGHT(text, [count])' },
+    MID: { group: 'Text', description: 'Returns the characters from the middle of a text string, given a starting position and length.' },
+    UPPER: { group: 'Text', description: 'Converts a text string to all uppercase letters.', signature: 'UPPER(text)' },
+    LOWER: { group: 'Text', description: 'Converts all letters in a text string to lowercase.', signature: 'LOWER(text)' },
+    TRIM: { group: 'Text', description: 'Removes all spaces from a text string except for single spaces between words.', signature: 'TRIM(text)' },
+    CONCAT: { group: 'Text', description: 'Concatenates a list or range of text strings.', signature: 'CONCAT(text1, [text2], ...)' },
+    CONCATENATE: { group: 'Text', description: 'Joins several text strings into one text string.', signature: 'CONCATENATE(text1, [text2], ...)' },
+    TEXTJOIN: { group: 'Text', description: 'Concatenates a list or range of text strings using a delimiter.' },
+    SUBSTITUTE: { group: 'Text', description: 'Replaces existing text with new text in a text string.' },
+    FIND: { group: 'Text', description: 'Returns the starting position of one text string within another; case-sensitive.', signature: 'FIND(find, within, [start])' },
+    SEARCH: { group: 'Text', description: 'Returns the position of one text string within another; not case-sensitive.', signature: 'SEARCH(find, within, [start])' },
+    TEXT: { group: 'Text', description: 'Converts a value to text in a specific number format.' },
+    TODAY: { group: 'Date & Time', description: "Returns the current date formatted as a date.", signature: 'TODAY()' },
+    NOW: { group: 'Date & Time', description: 'Returns the current date and time formatted as a date and time.', signature: 'NOW()' },
+    YEAR: { group: 'Date & Time', description: 'Returns the year of a date, an integer in the range 1900 - 9999.', signature: 'YEAR(date)' },
+    MONTH: { group: 'Date & Time', description: 'Returns the month, a number from 1 (January) to 12 (December).', signature: 'MONTH(date)' },
+    DAY: { group: 'Date & Time', description: 'Returns the day of the month, a number from 1 to 31.', signature: 'DAY(date)' },
+    DATE: { group: 'Date & Time', description: 'Returns the date for a given year, month and day.' },
+    EOMONTH: { group: 'Date & Time', description: 'Returns the last day of the month before or after a specified number of months.' },
+    DAYS: { group: 'Date & Time', description: 'Returns the number of days between two dates.', signature: 'DAYS(end_date, start_date)' },
+    DATEDIF: { group: 'Date & Time', description: 'Calculates the number of days, months or years between two dates.', signature: 'DATEDIF(start_date, end_date, unit)' },
+    VLOOKUP: { group: 'Lookup & Reference', description: 'Looks for a value in the leftmost column of a table, and returns a value in the same row from a column you specify.' },
+    HLOOKUP: { group: 'Lookup & Reference', description: 'Looks for a value in the top row of a table, and returns a value in the same column from a row you specify.' },
+    XLOOKUP: { group: 'Lookup & Reference', description: 'Searches a range for a match and returns the corresponding item from a second range.' },
+    INDEX: { group: 'Lookup & Reference', description: 'Returns a value from a range at the intersection of a given row and column.' },
+    MATCH: { group: 'Lookup & Reference', description: 'Returns the relative position of an item in a range that matches a specified value.' },
+};
+/** The IF family is dispatched by the evaluator, not the function table. */
+const EVALUATOR_FUNCTIONS = ['IF', 'IFS', 'IFERROR', 'IFNA', 'SWITCH'];
+export const FUNCTION_GROUPS = [
+    'Math', 'Statistical', 'Logical', 'Information', 'Text', 'Date & Time', 'Lookup & Reference', 'Other',
+];
+/** Every function the engine knows, described, alphabetical. */
+export function functionCatalog() {
+    const names = new Set([...Object.keys(FUNCTIONS), ...EVALUATOR_FUNCTIONS]);
+    return [...names].sort().map((name) => {
+        const entry = CATALOG[name];
+        return {
+            name,
+            group: entry?.group ?? 'Other',
+            signature: entry?.signature ?? SIGNATURES[name] ?? `${name}(...)`,
+            description: entry?.description ?? '',
+        };
+    });
+}

package/dist/sheet/functions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The function table.
+ *
+ * Each entry receives its arguments already evaluated, in two shapes:
+ *   - `flat`  every argument flattened into one list, ranges expanded. What
+ *             SUM and COUNT want.
+ *   - `args`  one list per argument, so a function can tell `SUM(A1:A3, 5)`
+ *             from `SUM(A1:A3)` and `SUMIF` can line a range up against a
+ *             parallel one.
+ *   - `grids` the 2-D shape of any range argument, kept for VLOOKUP / INDEX /
+ *             MATCH, which lose meaning once flattened.
+ *
+ * Functions that must NOT evaluate every argument (IF, IFERROR, AND, OR with
+ * short-circuit semantics) are handled in the evaluator instead, because by the
+ * time a table entry runs, evaluation has already happened.
+ */
+import { isError, type CellValue } from './ast.js';
+export type FnArgs = {
+    flat: ReadonlyArray<CellValue>;
+    args: ReadonlyArray<ReadonlyArray<CellValue>>;
+    grids: ReadonlyArray<ReadonlyArray<ReadonlyArray<CellValue>> | null>;
+};
+export type SheetFunction = (a: FnArgs) => CellValue;
+export declare const FUNCTIONS: Record<string, SheetFunction>;
+/** Merge caller-supplied functions over the built-ins. Keys are uppercased so
+ *  a consumer can register `myFn` and write `=MYFN()`. */
+export declare function withCustomFunctions(custom: Record<string, SheetFunction> | undefined): Record<string, SheetFunction>;
+export { isError };