@svgrid/enterprise 3.0.1 → 3.0.2

package/dist/sheet/ast.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The formula AST and the error vocabulary, in their own module so the
+ * tokenizer, parser, evaluator and the reference rewriter can all import the
+ * shapes without importing each other.
+ */
+import type { CellRef } from './address.js';
+export type SheetError = '#REF!' | '#CYCLE!' | '#DIV/0!' | '#VALUE!' | '#NAME?' | '#NUM!' | '#N/A' | '#PARSE!';
+/** A computed cell value. Errors are values, not exceptions, once evaluation
+ *  finishes - that is what lets `=IFERROR(A1, 0)` see one. */
+export type CellValue = string | number | boolean | {
+    error: SheetError;
+};
+export declare function isError(v: CellValue): v is {
+    error: SheetError;
+};
+export declare function err(code: SheetError): {
+    error: SheetError;
+};
+/** Thrown during evaluation and caught at the boundary, where it becomes a
+ *  value. Carrying the code on a real Error keeps stack traces useful in dev
+ *  without the evaluator having to thread a result type through every branch. */
+export declare class FormulaError extends Error {
+    readonly code: SheetError;
+    constructor(code: SheetError);
+}
+export type Node = {
+    k: 'num';
+    v: number;
+} | {
+    k: 'str';
+    v: string;
+} | {
+    k: 'bool';
+    v: boolean;
+}
+/** A single cell. `ref.row` is never null here; a column-only reference
+ *  parses as a range instead. */
+ | {
+    k: 'ref';
+    ref: CellRef;
+}
+/** A rectangle. Either end's row may be null, meaning a whole-column ref
+ *  that runs to the last used row of the sheet. */
+ | {
+    k: 'range';
+    from: CellRef;
+    to: CellRef;
+}
+/** A defined name (`=Tax`), resolved against the workbook at evaluation. */
+ | {
+    k: 'name';
+    name: string;
+}
+/**
+ * A structured reference: `Orders[Amount]`, `[@Amount]`, `Orders[#Totals]`.
+ *
+ * Deliberately NOT resolved to a range here. The range a table reference
+ * means depends on how many rows the table has right now, and the AST is
+ * cached across the edits that change that. Resolving at parse time is how
+ * a total silently stops covering rows added after it was typed, which is
+ * the exact problem tables exist to fix.
+ */
+ | {
+    k: 'table';
+    /** null for the unqualified `[Amount]` form, which only means
+     *  something inside a table. */
+    table: string | null;
+    /** null when the reference names no column, e.g. `Orders[#All]`. */
+    column: string | null;
+    /** The far end of a column span: `Orders[[Qty]:[Amount]]`. */
+    columnTo?: string | null;
+    specifier: '#All' | '#Data' | '#Headers' | '#Totals' | '#ThisRow';
+} | {
+    k: 'unary';
+    op: '-' | '+' | '%';
+    arg: Node;
+} | {
+    k: 'binary';
+    op: BinaryOp;
+    left: Node;
+    right: Node;
+} | {
+    k: 'fn';
+    name: string;
+    args: Node[];
+};
+export type BinaryOp = '+' | '-' | '*' | '/' | '^' | '&' | '=' | '<>' | '<' | '>' | '<=' | '>=';
+/** Binding power. Comparison loosest, then concat, then arithmetic. */
+export declare const PRECEDENCE: Record<BinaryOp, number>;
+/** Walk every node, parents before children. */
+export declare function visit(node: Node, fn: (n: Node) => void): void;
+/** Rebuild the tree with `fn` applied to every node, deepest first. Used by
+ *  the reference rewriter, which must not mutate a cached AST in place. */
+export declare function mapNode(node: Node, fn: (n: Node) => Node): Node;

package/dist/sheet/ast.js

@@ -0,0 +1,56 @@
+export function isError(v) {
+    return typeof v === 'object' && v !== null && 'error' in v;
+}
+export function err(code) {
+    return { error: code };
+}
+/** Thrown during evaluation and caught at the boundary, where it becomes a
+ *  value. Carrying the code on a real Error keeps stack traces useful in dev
+ *  without the evaluator having to thread a result type through every branch. */
+export class FormulaError extends Error {
+    constructor(code) {
+        super(code);
+        this.name = 'FormulaError';
+        this.code = code;
+    }
+}
+/** Binding power. Comparison loosest, then concat, then arithmetic. */
+export const PRECEDENCE = {
+    '=': 1, '<>': 1, '<': 1, '>': 1, '<=': 1, '>=': 1,
+    '&': 2,
+    '+': 3, '-': 3,
+    '*': 4, '/': 4,
+    '^': 5,
+};
+/** Walk every node, parents before children. */
+export function visit(node, fn) {
+    fn(node);
+    switch (node.k) {
+        case 'unary':
+            visit(node.arg, fn);
+            break;
+        case 'binary':
+            visit(node.left, fn);
+            visit(node.right, fn);
+            break;
+        case 'fn':
+            for (const a of node.args)
+                visit(a, fn);
+            break;
+        default: break;
+    }
+}
+/** Rebuild the tree with `fn` applied to every node, deepest first. Used by
+ *  the reference rewriter, which must not mutate a cached AST in place. */
+export function mapNode(node, fn) {
+    switch (node.k) {
+        case 'unary':
+            return fn({ ...node, arg: mapNode(node.arg, fn) });
+        case 'binary':
+            return fn({ ...node, left: mapNode(node.left, fn), right: mapNode(node.right, fn) });
+        case 'fn':
+            return fn({ ...node, args: node.args.map((a) => mapNode(a, fn)) });
+        default:
+            return fn(node);
+    }
+}

package/dist/sheet/auto-filter.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Excel's AutoFilter: arrows on the header row of a region, each opening a
+ * menu of the column's values to tick and untick, or a condition (equals,
+ * greater than, contains, between...), and the rows that fail fold away.
+ * The rows are hidden through the grid's collapsed rows, kept apart from
+ * the rows the user hid by hand so Unhide and the saved document see
+ * only those.
+ *
+ * This module is the pure part: the state, the values a column offers,
+ * which rows a state hides, and how the state moves with an insert or
+ * delete. Conditions run through the grid's own Excel-filter compiler, so
+ * the operator semantics are the ones the grid's filter row has.
+ */
+import { type ExcelFilterOperator } from '@svgrid/grid/filtering';
+import { type CellValue } from './ast.js';
+import type { StructuralEdit } from './refs.js';
+import { type Rect } from './rects.js';
+export type FilterCondition = {
+    op: ExcelFilterOperator;
+    value?: string;
+    valueTo?: string;
+};
+export type ColumnFilter = {
+    kind: 'values'; /** Display texts left unticked; '' stands for the blanks. */
+    excluded: string[];
+} | {
+    kind: 'condition';
+    first: FilterCondition;
+    join?: 'and' | 'or';
+    second?: FilterCondition;
+};
+export type AutoFilterState = {
+    /** The region, header row first. */
+    range: Rect;
+    /** Filters by column index; a column absent here shows every row. */
+    filters: Record<number, ColumnFilter>;
+};
+export type FilterValue = {
+    text: string;
+    count: number;
+    numeric: number | null;
+};
+/**
+ * The values a column offers, each once with its count: numbers first
+ * in order, then text A to Z, the blanks last. `rowVisible` leaves out the
+ * rows other columns' filters hide, as Excel's list does.
+ */
+export declare function distinctValues(state: AutoFilterState, col: number, valueAt: (r: number, c: number) => CellValue, displayAt: (r: number, c: number) => string, rowVisible?: (r: number) => boolean): FilterValue[];
+/** Whether a row passes one column's filter. */
+export declare function passesFilter(filter: ColumnFilter, value: CellValue, display: string): boolean;
+/**
+ * The rows the state hides: every row of the region under the header
+ * that fails a column's filter. Blanks past the region's edge are not in
+ * it, as Excel's region is what was filtered.
+ */
+export declare function hiddenRowsFor(state: AutoFilterState | null, valueAt: (r: number, c: number) => CellValue, displayAt: (r: number, c: number) => string): Set<number>;
+/** Whether any column is filtered. */
+export declare function isFiltering(state: AutoFilterState | null): boolean;
+/** The state with one column's filter set, or cleared with null. */
+export declare function withColumnFilter(state: AutoFilterState, col: number, filter: ColumnFilter | null): AutoFilterState;
+/** A values filter from the ticked list, or null when everything is ticked. */
+export declare function valuesFilter(all: ReadonlyArray<string>, ticked: ReadonlySet<string>): ColumnFilter | null;
+/** The state after an insert or delete: the region moves, the filters follow their columns. */
+export declare function shiftAutoFilter(state: AutoFilterState | null, edit: StructuralEdit): AutoFilterState | null;
+/** A filter in words, for the menu's heading. */
+export declare function describeFilter(filter: ColumnFilter): string;

package/dist/sheet/auto-filter.js

@@ -0,0 +1,147 @@
+/**
+ * Excel's AutoFilter: arrows on the header row of a region, each opening a
+ * menu of the column's values to tick and untick, or a condition (equals,
+ * greater than, contains, between...), and the rows that fail fold away.
+ * The rows are hidden through the grid's collapsed rows, kept apart from
+ * the rows the user hid by hand so Unhide and the saved document see
+ * only those.
+ *
+ * This module is the pure part: the state, the values a column offers,
+ * which rows a state hides, and how the state moves with an insert or
+ * delete. Conditions run through the grid's own Excel-filter compiler, so
+ * the operator semantics are the ones the grid's filter row has.
+ */
+import { compileExcelFilter } from '@svgrid/grid/filtering';
+import { isError } from './ast.js';
+import { shiftRect, lineShift } from './rects.js';
+/** The operators that compare as numbers; the rest compare the display text. */
+const NUMERIC_OPS = new Set(['greaterThan', 'lessThan', 'between']);
+/**
+ * The values a column offers, each once with its count: numbers first
+ * in order, then text A to Z, the blanks last. `rowVisible` leaves out the
+ * rows other columns' filters hide, as Excel's list does.
+ */
+export function distinctValues(state, col, valueAt, displayAt, rowVisible = () => true) {
+    const seen = new Map();
+    for (let r = state.range[0] + 1; r <= state.range[2]; r += 1) {
+        if (!rowVisible(r))
+            continue;
+        const text = displayAt(r, col);
+        const v = valueAt(r, col);
+        const entry = seen.get(text);
+        if (entry) {
+            entry.count += 1;
+            continue;
+        }
+        seen.set(text, { text, count: 1, numeric: typeof v === 'number' && Number.isFinite(v) ? v : null });
+    }
+    return [...seen.values()].sort((a, b) => {
+        if (a.text === '')
+            return 1;
+        if (b.text === '')
+            return -1;
+        if (a.numeric !== null && b.numeric !== null)
+            return a.numeric - b.numeric;
+        if (a.numeric !== null)
+            return -1;
+        if (b.numeric !== null)
+            return 1;
+        return a.text.localeCompare(b.text, undefined, { sensitivity: 'base' });
+    });
+}
+function passesCondition(cond, value, display) {
+    const test = compileExcelFilter({ id: 'f', operator: cond.op, value: cond.value, valueTo: cond.valueTo });
+    if (NUMERIC_OPS.has(cond.op)) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return false;
+        return test(value);
+    }
+    if (cond.op === 'isBlank' || cond.op === 'isNotBlank')
+        return test(display === '' ? null : display);
+    return test(isError(value) ? value.error : display);
+}
+/** Whether a row passes one column's filter. */
+export function passesFilter(filter, value, display) {
+    if (filter.kind === 'values')
+        return !filter.excluded.includes(display);
+    const first = passesCondition(filter.first, value, display);
+    if (!filter.second)
+        return first;
+    const second = passesCondition(filter.second, value, display);
+    return filter.join === 'or' ? first || second : first && second;
+}
+/**
+ * The rows the state hides: every row of the region under the header
+ * that fails a column's filter. Blanks past the region's edge are not in
+ * it, as Excel's region is what was filtered.
+ */
+export function hiddenRowsFor(state, valueAt, displayAt) {
+    const out = new Set();
+    if (!state)
+        return out;
+    const columns = Object.entries(state.filters).map(([c, f]) => [Number(c), f]);
+    if (!columns.length)
+        return out;
+    for (let r = state.range[0] + 1; r <= state.range[2]; r += 1) {
+        for (const [c, filter] of columns) {
+            if (!passesFilter(filter, valueAt(r, c), displayAt(r, c))) {
+                out.add(r);
+                break;
+            }
+        }
+    }
+    return out;
+}
+/** Whether any column is filtered. */
+export function isFiltering(state) {
+    return !!state && Object.keys(state.filters).length > 0;
+}
+/** The state with one column's filter set, or cleared with null. */
+export function withColumnFilter(state, col, filter) {
+    const filters = { ...state.filters };
+    if (filter === null)
+        delete filters[col];
+    else
+        filters[col] = filter;
+    return { range: state.range, filters };
+}
+/** A values filter from the ticked list, or null when everything is ticked. */
+export function valuesFilter(all, ticked) {
+    const excluded = all.filter((text) => !ticked.has(text));
+    return excluded.length ? { kind: 'values', excluded } : null;
+}
+/** The state after an insert or delete: the region moves, the filters follow their columns. */
+export function shiftAutoFilter(state, edit) {
+    if (!state)
+        return null;
+    const range = shiftRect(state.range, edit);
+    if (!range)
+        return null;
+    if (edit.kind === 'insertRows' || edit.kind === 'deleteRows')
+        return { range, filters: { ...state.filters } };
+    const shift = lineShift(edit);
+    const filters = {};
+    for (const [c, f] of Object.entries(state.filters)) {
+        const next = shift(Number(c));
+        if (next !== null)
+            filters[next] = f;
+    }
+    return { range, filters };
+}
+const OP_WORDS = {
+    equals: 'equals', notEquals: 'does not equal', greaterThan: 'is greater than', lessThan: 'is less than',
+    between: 'is between', contains: 'contains', notContains: 'does not contain', startsWith: 'begins with',
+    endsWith: 'ends with', isBlank: 'is blank', isNotBlank: 'is not blank',
+};
+/** A filter in words, for the menu's heading. */
+export function describeFilter(filter) {
+    if (filter.kind === 'values')
+        return filter.excluded.length === 1 ? '1 value hidden' : `${filter.excluded.length} values hidden`;
+    const one = (c) => {
+        const word = OP_WORDS[c.op] ?? c.op;
+        if (c.op === 'isBlank' || c.op === 'isNotBlank')
+            return word;
+        return c.op === 'between' ? `${word} ${c.value ?? ''} and ${c.valueTo ?? ''}` : `${word} ${c.value ?? ''}`;
+    };
+    return filter.second ? `${one(filter.first)} ${filter.join ?? 'and'} ${one(filter.second)}` : one(filter.first);
+}

package/dist/sheet/autocomplete.d.ts

@@ -0,0 +1,42 @@
+export type FunctionSuggestion = {
+    name: string;
+    /** Where the partial name starts, so accepting can splice it out. */
+    start: number;
+    /** Where the caret is, i.e. where the partial name ends. */
+    end: number;
+};
+/** Signature hints, for the ones whose argument order is not obvious. */
+export declare const SIGNATURES: Record<string, string>;
+/**
+ * The word being typed immediately before the caret, if it could be a function
+ * name. Returns null when the caret is not in a formula, or sits somewhere a
+ * function name cannot start (inside a string, or right after a reference).
+ */
+export declare function partialAt(text: string, caret: number): {
+    word: string;
+    start: number;
+} | null;
+/**
+ * Function names matching what is being typed.
+ *
+ * Prefix matches first, then anything merely containing the text, so typing
+ * "look" still finds VLOOKUP. Within each group, SHORTER names rank first:
+ * alphabetical order puts SUBSTITUTE above SUM for "SU", which is exactly
+ * backwards from what someone typing two letters wants.
+ */
+export declare function suggestFunctions(text: string, caret: number, limit?: number): FunctionSuggestion[];
+/** Splice an accepted suggestion in, leaving the caret inside the parens. */
+export declare function applySuggestion(text: string, suggestion: FunctionSuggestion): {
+    text: string;
+    caret: number;
+};
+/**
+ * Close the parentheses a formula left open, the way Excel corrects
+ * "=SUM(A1:A3" to "=SUM(A1:A3)" when it is entered. Quoted text is skipped,
+ * so a ")" inside a string neither closes nor needs closing. Text that is
+ * not a formula, or has more closers than openers, is returned as it is:
+ * that one is an error the engine should report, not paper over.
+ */
+export declare function balanceParens(text: string): string;
+/** The signature hint for whatever call the caret is inside, if any. */
+export declare function signatureAt(text: string, caret: number): string | null;

package/dist/sheet/autocomplete.js

@@ -0,0 +1,162 @@
+/**
+ * Formula-bar autocomplete, kept out of the component so the interesting part
+ * is testable without mounting anything.
+ *
+ * The job is narrow: given the text in the bar and where the caret is, work out
+ * whether the user is partway through typing a function name, and if so which
+ * ones match. Everything else (arrow keys, accepting a suggestion) is a list
+ * with an index, which the component owns.
+ */
+import { FUNCTIONS } from './functions.js';
+const NAMES = Object.keys(FUNCTIONS).sort();
+/** Signature hints, for the ones whose argument order is not obvious. */
+export const SIGNATURES = {
+    VLOOKUP: 'VLOOKUP(lookup, table, colIndex)',
+    HLOOKUP: 'HLOOKUP(lookup, table, rowIndex)',
+    XLOOKUP: 'XLOOKUP(lookup, haystack, results, [ifMissing])',
+    INDEX: 'INDEX(range, row, [col])',
+    MATCH: 'MATCH(lookup, range, [mode])',
+    SUMIF: 'SUMIF(range, criterion, [sumRange])',
+    SUMIFS: 'SUMIFS(sumRange, range, criterion, ...)',
+    COUNTIF: 'COUNTIF(range, criterion)',
+    COUNTIFS: 'COUNTIFS(range, criterion, ...)',
+    AVERAGEIF: 'AVERAGEIF(range, criterion, [avgRange])',
+    IF: 'IF(condition, then, else)',
+    IFS: 'IFS(condition, value, ...)',
+    IFERROR: 'IFERROR(value, fallback)',
+    SWITCH: 'SWITCH(subject, case, value, ..., [default])',
+    ROUND: 'ROUND(number, digits)',
+    TEXT: 'TEXT(number, pattern)',
+    TEXTJOIN: 'TEXTJOIN(separator, skipEmpty, ...)',
+    SUBSTITUTE: 'SUBSTITUTE(text, find, replace)',
+    MID: 'MID(text, start, length)',
+    DATE: 'DATE(year, month, day)',
+    EOMONTH: 'EOMONTH(date, months)',
+};
+/**
+ * The word being typed immediately before the caret, if it could be a function
+ * name. Returns null when the caret is not in a formula, or sits somewhere a
+ * function name cannot start (inside a string, or right after a reference).
+ */
+export function partialAt(text, caret) {
+    if (!text.startsWith('='))
+        return null;
+    const upto = text.slice(0, caret);
+    // Inside a string literal there is nothing to suggest. Count unescaped
+    // quotes: an odd number means the caret is inside one.
+    let quotes = 0;
+    for (let i = 0; i < upto.length; i += 1) {
+        if (upto[i] === '"') {
+            if (upto[i + 1] === '"') {
+                i += 1;
+                continue;
+            }
+            quotes += 1;
+        }
+    }
+    if (quotes % 2 === 1)
+        return null;
+    const m = /([A-Za-z][A-Za-z0-9.]*)$/.exec(upto);
+    if (!m)
+        return null;
+    const word = m[1];
+    const start = caret - word.length;
+    // A word followed by digits is a cell reference being typed, not a function.
+    if (/\d$/.test(word))
+        return null;
+    return { word, start };
+}
+/**
+ * Function names matching what is being typed.
+ *
+ * Prefix matches first, then anything merely containing the text, so typing
+ * "look" still finds VLOOKUP. Within each group, SHORTER names rank first:
+ * alphabetical order puts SUBSTITUTE above SUM for "SU", which is exactly
+ * backwards from what someone typing two letters wants.
+ */
+export function suggestFunctions(text, caret, limit = 8) {
+    const partial = partialAt(text, caret);
+    if (!partial || partial.word.length < 1)
+        return [];
+    const upper = partial.word.toUpperCase();
+    const prefix = [];
+    const contains = [];
+    for (const name of NAMES) {
+        if (name === upper)
+            continue;
+        if (name.startsWith(upper))
+            prefix.push(name);
+        else if (name.includes(upper))
+            contains.push(name);
+    }
+    const byCloseness = (a, b) => a.length - b.length || a.localeCompare(b);
+    return [...prefix.sort(byCloseness), ...contains.sort(byCloseness)]
+        .slice(0, limit)
+        .map((name) => ({ name, start: partial.start, end: caret }));
+}
+/** Splice an accepted suggestion in, leaving the caret inside the parens. */
+export function applySuggestion(text, suggestion) {
+    const before = text.slice(0, suggestion.start);
+    const after = text.slice(suggestion.end);
+    // Do not double up a parenthesis the user already typed.
+    const needsParen = !after.startsWith('(');
+    // Only the OPENING parenthesis, as Excel inserts it. Inserting the pair
+    // put the caret between them, and everyone who then typed the arguments
+    // finished with a ")" of their own and got =SUM(A1:A3)) and #PARSE!.
+    // The closing one is supplied at commit by `balanceParens` when it is
+    // still missing, which is what Excel does too.
+    const inserted = needsParen ? `${suggestion.name}(` : suggestion.name;
+    return {
+        text: before + inserted + after,
+        caret: before.length + inserted.length,
+    };
+}
+/**
+ * Close the parentheses a formula left open, the way Excel corrects
+ * "=SUM(A1:A3" to "=SUM(A1:A3)" when it is entered. Quoted text is skipped,
+ * so a ")" inside a string neither closes nor needs closing. Text that is
+ * not a formula, or has more closers than openers, is returned as it is:
+ * that one is an error the engine should report, not paper over.
+ */
+export function balanceParens(text) {
+    if (!text.startsWith('='))
+        return text;
+    let depth = 0;
+    let inString = false;
+    for (const ch of text) {
+        if (ch === '"')
+            inString = !inString;
+        else if (!inString && ch === '(')
+            depth += 1;
+        else if (!inString && ch === ')')
+            depth -= 1;
+    }
+    return depth > 0 ? text + ')'.repeat(depth) : text;
+}
+/** The signature hint for whatever call the caret is inside, if any. */
+export function signatureAt(text, caret) {
+    if (!text.startsWith('='))
+        return null;
+    const upto = text.slice(0, caret);
+    // Walk back looking for an unclosed '(' and read the name before it.
+    let depth = 0;
+    for (let i = upto.length - 1; i >= 0; i -= 1) {
+        const ch = upto[i];
+        if (ch === ')') {
+            depth += 1;
+            continue;
+        }
+        if (ch === '(') {
+            if (depth > 0) {
+                depth -= 1;
+                continue;
+            }
+            const name = /([A-Za-z][A-Za-z0-9.]*)$/.exec(upto.slice(0, i))?.[1];
+            if (!name)
+                return null;
+            const upper = name.toUpperCase();
+            return SIGNATURES[upper] ?? (upper in FUNCTIONS ? `${upper}(...)` : null);
+        }
+    }
+    return null;
+}

package/dist/sheet/coerce.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Value coercions, shared by the evaluator and the function table.
+ *
+ * Excel's rules, not JavaScript's. The differences that matter:
+ *   - An empty cell is 0 in arithmetic but is NOT counted by COUNT or averaged
+ *     by AVERAGE, so "coerce to number" and "is a number" are separate tests.
+ *   - Text that does not parse as a number is `#VALUE!`, not NaN. Returning NaN
+ *     would let a bad cell poison a total silently.
+ *   - Text comparison is case-insensitive: `="a"="A"` is TRUE.
+ *   - Booleans are 1 and 0 in arithmetic but are skipped by numeric aggregates.
+ */
+import { type CellValue } from './ast.js';
+export declare function toNumber(v: CellValue): number;
+export declare function toBool(v: CellValue): boolean;
+export declare function toText(v: CellValue): string;
+/** Excel's `=` between two values. Text compares case-insensitively; a number
+ *  never equals the text that looks like it. */
+export declare function looseEquals(a: CellValue, b: CellValue): boolean;
+/** Ordering for `<` and friends. Excel orders number < text < boolean. */
+export declare function compare(a: CellValue, b: CellValue): number;
+/** The numeric members of a flattened argument list. Blanks, text and booleans
+ *  are skipped, which is what makes AVERAGE of a column with a header work. */
+export declare function numericOnly(values: ReadonlyArray<CellValue>): number[];
+/** Is this cell empty for COUNTA / COUNTBLANK purposes. */
+export declare function isBlank(v: CellValue): boolean;
+/**
+ * An Excel criterion: a bare value matches by equality, a string starting with
+ * an operator compares (`">100"`, `"<>x"`). Used by SUMIF / COUNTIF / their
+ * plural forms, which all share this grammar.
+ */
+export declare function matchesCriterion(value: CellValue, criterion: CellValue): boolean;