@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/sheet/cell-images.js

@@ -0,0 +1,90 @@
+/**
+ * Excel's `IMAGE` function: a picture IN a cell rather than floating over
+ * it.
+ *
+ * The difference is the whole point. A picture object hangs from a cell and
+ * covers whatever is under it; an `IMAGE` cell IS the picture, so it sorts
+ * with its row, filters with it, copies as a formula and moves when the
+ * cells move, with nothing to keep in step. A catalogue with a thumbnail
+ * column wants this one.
+ *
+ * The function answers with the source, which is what makes `=IMAGE(A2)`
+ * read like any other formula: the value is text, `ISTEXT` says so, and a
+ * cell that reads it gets the address rather than a picture it cannot use.
+ * Drawing it is the shell's part, and this is what the shell reads to know
+ * a cell is one.
+ */
+/**
+ * The call's arguments when a formula IS one `IMAGE(...)` call, or null.
+ *
+ * Read off the text rather than the parsed tree on purpose: this runs for
+ * every cell that paints, and a scan is cheaper than a parse. A formula
+ * that merely CONTAINS an IMAGE call (`=IF(A1, IMAGE(B1), "")`) is not one,
+ * because its value is not a picture in every case.
+ */
+export function imageCall(text) {
+    const trimmed = text.trim();
+    const head = /^=\s*IMAGE\s*\(/i.exec(trimmed);
+    if (!head)
+        return null;
+    const inside = trimmed.slice(head[0].length);
+    const args = [];
+    let depth = 0;
+    let quoted = false;
+    let start = 0;
+    let closed = -1;
+    for (let i = 0; i < inside.length; i += 1) {
+        const ch = inside[i];
+        if (quoted) {
+            if (ch === '"') {
+                if (inside[i + 1] === '"')
+                    i += 1;
+                else
+                    quoted = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            quoted = true;
+            continue;
+        }
+        if (ch === '(') {
+            depth += 1;
+            continue;
+        }
+        if (ch === ')') {
+            if (depth === 0) {
+                args.push(inside.slice(start, i));
+                closed = i;
+                break;
+            }
+            depth -= 1;
+            continue;
+        }
+        if (ch === ',' && depth === 0) {
+            args.push(inside.slice(start, i));
+            start = i + 1;
+        }
+    }
+    // Anything after the closing bracket means the call is part of a larger
+    // formula, so the cell is not simply a picture.
+    if (closed < 0 || inside.slice(closed + 1).trim() !== '')
+        return null;
+    const source = (args[0] ?? '').trim();
+    if (!source)
+        return null;
+    const alt = (args[1] ?? '').trim();
+    return { source, ...(alt ? { alt } : {}) };
+}
+/**
+ * Whether a source is one a browser will load. A `data:` URL and an
+ * ordinary web address are; anything else (a file path, a `javascript:`
+ * scheme) is not, and a cell showing it as text says more than a broken
+ * image would.
+ */
+export function isDrawableImageSource(source) {
+    const value = source.trim();
+    if (/^data:image\//i.test(value))
+        return true;
+    return /^https?:\/\/\S+$/i.test(value);
+}

package/dist/sheet/cell-types.d.ts

@@ -0,0 +1,58 @@
+import type { StructuralEdit } from './refs.js';
+import { type Rect } from './rects.js';
+/** Excel writes a ticked box as TRUE and an unticked one as FALSE. */
+export declare const CHECKED = "TRUE";
+export declare const UNCHECKED = "FALSE";
+export type CellTypeKind = 'checkbox' | 'button' | 'radio';
+export type CellTypeRegion = {
+    id: string;
+    rects: ReadonlyArray<Rect>;
+    kind: CellTypeKind;
+    /**
+     * A checkbox's two values, when the sheet wants something other than
+     * Excel's TRUE and FALSE (a Yes / No column, say). Compared as text,
+     * ignoring case, the way the engine compares a boolean typed by hand.
+     */
+    checked?: string;
+    unchecked?: string;
+    /** A button's face. The cell's own text when this is absent. */
+    label?: string;
+    /** What a button press reports through `onCellAction`. */
+    action?: string;
+    /** A radio group's choices, in order. */
+    choices?: ReadonlyArray<string>;
+};
+export declare const newCellTypeId: () => string;
+/** The region that applies at a cell, or null. The last one wins. */
+export declare function cellTypeAt(regions: ReadonlyArray<CellTypeRegion>, row: number, col: number): CellTypeRegion | null;
+/** The two texts a checkbox toggles between, Excel's by default. */
+export declare const checkboxValues: (region: CellTypeRegion) => {
+    on: string;
+    off: string;
+};
+/**
+ * Is the cell ticked?
+ *
+ * Read off the cell's own text so a formula, a paste or a typed TRUE all
+ * show the same way. Anything that is not the ticked value reads as
+ * unticked, which is what Excel does with a stray entry.
+ */
+export declare function isChecked(region: CellTypeRegion, raw: string): boolean;
+/** What clicking a checkbox should write into its cell. */
+export declare function toggledValue(region: CellTypeRegion, raw: string): string;
+/** Which radio choice a cell holds, or -1. Compared ignoring case. */
+export declare function radioIndex(region: CellTypeRegion, raw: string): number;
+/** The regions after an insert or delete, moved the way the rules move. */
+export declare function shiftCellTypes(regions: ReadonlyArray<CellTypeRegion>, edit: StructuralEdit): CellTypeRegion[];
+/** The regions with the rectangles cut out: what Clear All removes. */
+export declare function removeCellTypes(regions: ReadonlyArray<CellTypeRegion>, rects: ReadonlyArray<Rect>): CellTypeRegion[];
+/**
+ * Lay a region over some cells, taking those cells out of any region that
+ * already claimed them.
+ *
+ * Without the cut, two regions would overlap and the later one would win
+ * silently; cutting makes the model say what the screen shows.
+ */
+export declare function applyCellType(regions: ReadonlyArray<CellTypeRegion>, region: CellTypeRegion): CellTypeRegion[];
+/** A deep-enough copy for the document's snapshot. */
+export declare const copyCellType: (region: CellTypeRegion) => CellTypeRegion;

package/dist/sheet/cell-types.js

@@ -0,0 +1,96 @@
+/**
+ * What a cell IS, rather than what it holds: a checkbox, a button or a
+ * group of radio choices drawn in the cell and driven from it.
+ *
+ * Excel has one of these, the checkbox its Insert tab puts in a cell, and
+ * it is deliberately thin: the cell's value is still `TRUE` or `FALSE`, so
+ * every formula over it keeps working and the file carries an ordinary
+ * boolean. That is the model here, widened to the two other controls a
+ * data-entry sheet actually asks for.
+ *
+ * The rule that keeps this honest: **a cell type is a rendering, never a
+ * second source of truth.** A checkbox is ticked because its cell reads
+ * TRUE, not because the checkbox remembers being clicked; a radio is on
+ * because the cell holds its choice. Clicking one writes the cell and
+ * nothing else, so undo, the formula engine, a paste and the file all keep
+ * working without knowing this module exists.
+ *
+ * Regions are kept and moved the way validation rules are, and the LAST
+ * region covering a cell wins, so a narrower one laid over a wider one
+ * overrides it.
+ */
+import { toText } from './coerce.js';
+import { rectContains, shiftRects, subtractRect } from './rects.js';
+/** Excel writes a ticked box as TRUE and an unticked one as FALSE. */
+export const CHECKED = 'TRUE';
+export const UNCHECKED = 'FALSE';
+let counter = 0;
+export const newCellTypeId = () => `ct${(counter += 1)}`;
+/** The region that applies at a cell, or null. The last one wins. */
+export function cellTypeAt(regions, row, col) {
+    for (let i = regions.length - 1; i >= 0; i -= 1) {
+        const region = regions[i];
+        if (region.rects.some((rect) => rectContains(rect, row, col)))
+            return region;
+    }
+    return null;
+}
+/** The two texts a checkbox toggles between, Excel's by default. */
+export const checkboxValues = (region) => ({
+    on: region.checked ?? CHECKED,
+    off: region.unchecked ?? UNCHECKED,
+});
+/**
+ * Is the cell ticked?
+ *
+ * Read off the cell's own text so a formula, a paste or a typed TRUE all
+ * show the same way. Anything that is not the ticked value reads as
+ * unticked, which is what Excel does with a stray entry.
+ */
+export function isChecked(region, raw) {
+    const { on } = checkboxValues(region);
+    return toText(raw).trim().toLowerCase() === on.trim().toLowerCase();
+}
+/** What clicking a checkbox should write into its cell. */
+export function toggledValue(region, raw) {
+    const { on, off } = checkboxValues(region);
+    return isChecked(region, raw) ? off : on;
+}
+/** Which radio choice a cell holds, or -1. Compared ignoring case. */
+export function radioIndex(region, raw) {
+    const choices = region.choices ?? [];
+    const value = toText(raw).trim().toLowerCase();
+    return choices.findIndex((choice) => choice.trim().toLowerCase() === value);
+}
+/** The regions after an insert or delete, moved the way the rules move. */
+export function shiftCellTypes(regions, edit) {
+    return shiftRects(regions, edit);
+}
+/** The regions with the rectangles cut out: what Clear All removes. */
+export function removeCellTypes(regions, rects) {
+    const out = [];
+    for (const region of regions) {
+        let kept = [...region.rects];
+        for (const hole of rects)
+            kept = kept.flatMap((rect) => subtractRect(rect, hole));
+        if (kept.length)
+            out.push({ ...region, rects: kept });
+    }
+    return out;
+}
+/**
+ * Lay a region over some cells, taking those cells out of any region that
+ * already claimed them.
+ *
+ * Without the cut, two regions would overlap and the later one would win
+ * silently; cutting makes the model say what the screen shows.
+ */
+export function applyCellType(regions, region) {
+    return [...removeCellTypes(regions, region.rects), region];
+}
+/** A deep-enough copy for the document's snapshot. */
+export const copyCellType = (region) => ({
+    ...region,
+    rects: region.rects.map((rect) => [...rect]),
+    ...(region.choices ? { choices: [...region.choices] } : {}),
+});

package/dist/sheet/coerce.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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';
+/** A date from a cell: a serial number, or text `new Date` can read
+ *  (`2024-03-09`, `2024-03-09 13:45`). Anything else is `#VALUE!`. */
+export declare function toDate(v: CellValue): Date;
+/** The `yyyy-mm-dd` the date functions hand back. */
+export declare const isoDate: (d: Date) => string;
+/** Excel's serial for a date, fractional when it carries a time. */
+export declare function dateSerial(d: Date): number;
+/**
+ * The serial a date or a time written as text is worth in arithmetic, or
+ * null when the text is neither. Dates are `yyyy-mm-dd` text in a sheet
+ * (see `toDate`), so `=A1+1` under one has to read it as Excel reads a
+ * date cell: as its day number, so the sum is the next day rather than
+ * `#VALUE!`. A clock time is the fraction of a day it is, `="10:30"*2` being
+ * 0.875, and `m/d/yyyy` is read the way `new Date` reads it, as toDate does.
+ */
+export declare function dateTextSerial(text: string): number | null;
+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;
+/**
+ * Excel's wildcards, which every text criterion and exact lookup speaks:
+ * `*` stands for any run of characters, `?` for exactly one, and `~` asks
+ * for the next character itself, so `"~*"` is a literal asterisk.
+ */
+export declare function hasWildcards(pattern: string): boolean;
+/** The pattern as a regular expression, anchored at both ends and
+ *  case-insensitive, which is how Excel compares text. */
+export declare function wildcardRegExp(pattern: string): RegExp;
+/** The pattern with its `~` escapes taken off, which is the text a plain
+ *  comparison should look for: `"~*"` means a literal asterisk. */
+export declare function unescapeWildcards(pattern: string): string;
+/** Does this cell match a wildcard pattern? Only text takes part: Excel
+ *  never turns a number into text to match `"1*"`. */
+export declare function wildcardMatches(value: CellValue, pattern: string): boolean;
+/** Equality as a criterion or an exact lookup reads it: a pattern carrying
+ *  wildcards matches, anything else compares as `=` does. */
+export declare function patternEquals(value: CellValue, operand: 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;
+/** The indexes in `range` that meet `criterion`, for the IF family. */
+export declare function criteriaHits(range: ReadonlyArray<CellValue>, criterion: CellValue): number[];
+/** SUMIFS and its family: every (range, criterion) pair must match at an index. */
+export declare function multiCriteriaHits(pairs: Array<[ReadonlyArray<CellValue>, CellValue]>): number[];
+/** The (range, criterion) pairs of a *IFS call, starting at argument `from`. */
+export declare function criteriaPairs(args: ReadonlyArray<ReadonlyArray<CellValue>>, from: number): Array<[ReadonlyArray<CellValue>, CellValue]>;

package/dist/sheet/coerce.js

@@ -0,0 +1,289 @@
+/**
+ * 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 { FormulaError, isError } from './ast.js';
+/** The epoch Excel's date serials count from: serial 1 is 1900-01-01. Day 60
+ *  is Excel's phantom 1900-02-29, so every date from 1900-03-01 on is right
+ *  and the two months before it are a day out, which no sheet has cared
+ *  about. */
+const EXCEL_EPOCH_MS = Date.UTC(1899, 11, 30);
+/** A date from a cell: a serial number, or text `new Date` can read
+ *  (`2024-03-09`, `2024-03-09 13:45`). Anything else is `#VALUE!`. */
+export function toDate(v) {
+    if (typeof v === 'number')
+        return new Date(EXCEL_EPOCH_MS + v * 86400000);
+    const d = new Date(toText(v));
+    if (Number.isNaN(d.getTime()))
+        throw new FormulaError('#VALUE!');
+    return d;
+}
+/** The `yyyy-mm-dd` the date functions hand back. */
+export const isoDate = (d) => d.toISOString().slice(0, 10);
+/** Excel's serial for a date, fractional when it carries a time. */
+export function dateSerial(d) {
+    return (d.getTime() - EXCEL_EPOCH_MS) / 86400000;
+}
+const ISO_DATE_TEXT = /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{1,2}):(\d{2})(?::(\d{2}))?)?$/;
+const SLASH_DATE_TEXT = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
+const CLOCK_TEXT = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/;
+/**
+ * The serial a date or a time written as text is worth in arithmetic, or
+ * null when the text is neither. Dates are `yyyy-mm-dd` text in a sheet
+ * (see `toDate`), so `=A1+1` under one has to read it as Excel reads a
+ * date cell: as its day number, so the sum is the next day rather than
+ * `#VALUE!`. A clock time is the fraction of a day it is, `="10:30"*2` being
+ * 0.875, and `m/d/yyyy` is read the way `new Date` reads it, as toDate does.
+ */
+export function dateTextSerial(text) {
+    const t = text.trim();
+    let m = ISO_DATE_TEXT.exec(t);
+    if (m) {
+        const month = Number(m[2]), day = Number(m[3]), hours = Number(m[4] ?? 0), minutes = Number(m[5] ?? 0);
+        if (month < 1 || month > 12 || day < 1 || day > 31 || hours > 23 || minutes > 59)
+            return null;
+        const ms = Date.UTC(Number(m[1]), month - 1, day, hours, minutes, Number(m[6] ?? 0));
+        return (ms - EXCEL_EPOCH_MS) / 86400000;
+    }
+    m = SLASH_DATE_TEXT.exec(t);
+    if (m) {
+        const month = Number(m[1]), day = Number(m[2]);
+        if (month < 1 || month > 12 || day < 1 || day > 31)
+            return null;
+        return (Date.UTC(Number(m[3]), month - 1, day) - EXCEL_EPOCH_MS) / 86400000;
+    }
+    m = CLOCK_TEXT.exec(t);
+    if (m) {
+        const hours = Number(m[1]), minutes = Number(m[2]), seconds = Number(m[3] ?? 0);
+        if (hours > 23 || minutes > 59 || seconds > 59)
+            return null;
+        return (hours * 3600 + minutes * 60 + seconds) / 86400;
+    }
+    return null;
+}
+export function toNumber(v) {
+    if (typeof v === 'number')
+        return v;
+    if (typeof v === 'boolean')
+        return v ? 1 : 0;
+    if (typeof v === 'string') {
+        if (v.trim() === '')
+            return 0;
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+        const serial = dateTextSerial(v);
+        if (serial !== null)
+            return serial;
+        throw new FormulaError('#VALUE!');
+    }
+    if (isError(v))
+        throw new FormulaError(v.error);
+    return 0;
+}
+export function toBool(v) {
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return v !== 0;
+    if (typeof v === 'string') {
+        const upper = v.trim().toUpperCase();
+        if (upper === 'TRUE')
+            return true;
+        if (upper === 'FALSE')
+            return false;
+        return v.length > 0;
+    }
+    if (isError(v))
+        throw new FormulaError(v.error);
+    return false;
+}
+export function toText(v) {
+    if (typeof v === 'string')
+        return v;
+    if (typeof v === 'boolean')
+        return v ? 'TRUE' : 'FALSE';
+    if (typeof v === 'number')
+        return String(v);
+    if (isError(v))
+        throw new FormulaError(v.error);
+    return '';
+}
+/** Excel's `=` between two values. Text compares case-insensitively; a number
+ *  never equals the text that looks like it. */
+export function looseEquals(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a === b;
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a.toLowerCase() === b.toLowerCase();
+    }
+    if (typeof a === 'boolean' && typeof b === 'boolean')
+        return a === b;
+    if (isError(a) || isError(b))
+        return false;
+    return false;
+}
+/**
+ * Excel's wildcards, which every text criterion and exact lookup speaks:
+ * `*` stands for any run of characters, `?` for exactly one, and `~` asks
+ * for the next character itself, so `"~*"` is a literal asterisk.
+ */
+export function hasWildcards(pattern) {
+    for (let i = 0; i < pattern.length; i += 1) {
+        const ch = pattern[i];
+        if (ch === '~') {
+            i += 1;
+            continue;
+        }
+        if (ch === '*' || ch === '?')
+            return true;
+    }
+    return false;
+}
+const LITERAL = /[\\^$.*+?()[\]{}|]/g;
+/** The pattern as a regular expression, anchored at both ends and
+ *  case-insensitive, which is how Excel compares text. */
+export function wildcardRegExp(pattern) {
+    let out = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const ch = pattern[i];
+        if (ch === '~' && i + 1 < pattern.length) {
+            out += pattern[i + 1].replace(LITERAL, '\\$&');
+            i += 1;
+            continue;
+        }
+        if (ch === '*') {
+            out += '[\\s\\S]*';
+            continue;
+        }
+        if (ch === '?') {
+            out += '[\\s\\S]';
+            continue;
+        }
+        out += ch.replace(LITERAL, '\\$&');
+    }
+    return new RegExp(`^${out}$`, 'i');
+}
+/** The pattern with its `~` escapes taken off, which is the text a plain
+ *  comparison should look for: `"~*"` means a literal asterisk. */
+export function unescapeWildcards(pattern) {
+    if (!pattern.includes('~'))
+        return pattern;
+    let out = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const ch = pattern[i];
+        if (ch === '~' && i + 1 < pattern.length) {
+            out += pattern[i + 1];
+            i += 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/** Does this cell match a wildcard pattern? Only text takes part: Excel
+ *  never turns a number into text to match `"1*"`. */
+export function wildcardMatches(value, pattern) {
+    if (typeof value !== 'string')
+        return false;
+    return wildcardRegExp(pattern).test(value);
+}
+/** Equality as a criterion or an exact lookup reads it: a pattern carrying
+ *  wildcards matches, anything else compares as `=` does. */
+export function patternEquals(value, operand) {
+    if (typeof operand !== 'string')
+        return looseEquals(value, operand);
+    if (hasWildcards(operand))
+        return wildcardMatches(value, operand);
+    return looseEquals(value, unescapeWildcards(operand));
+}
+/** Ordering for `<` and friends. Excel orders number < text < boolean. */
+export function compare(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return a < b ? -1 : a > b ? 1 : 0;
+    if (typeof a === 'string' && typeof b === 'string') {
+        const x = a.toLowerCase();
+        const y = b.toLowerCase();
+        return x < y ? -1 : x > y ? 1 : 0;
+    }
+    return toNumber(a) < toNumber(b) ? -1 : toNumber(a) > toNumber(b) ? 1 : 0;
+}
+/** 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 function numericOnly(values) {
+    const out = [];
+    for (const v of values) {
+        if (typeof v === 'number' && Number.isFinite(v))
+            out.push(v);
+    }
+    return out;
+}
+/** Is this cell empty for COUNTA / COUNTBLANK purposes. */
+export function isBlank(v) {
+    return v === '' || v === null || v === undefined;
+}
+/**
+ * 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 function matchesCriterion(value, criterion) {
+    if (typeof criterion === 'string') {
+        const m = /^(<=|>=|<>|<|>|=)(.*)$/.exec(criterion.trim());
+        if (m) {
+            const opText = m[1];
+            const rest = m[2].trim();
+            const n = Number(rest);
+            const operand = rest !== '' && Number.isFinite(n) ? n : rest;
+            switch (opText) {
+                case '=': return patternEquals(value, operand);
+                case '<>': return !patternEquals(value, operand);
+                case '<': return compare(value, operand) < 0;
+                case '>': return compare(value, operand) > 0;
+                case '<=': return compare(value, operand) <= 0;
+                case '>=': return compare(value, operand) >= 0;
+                default: break;
+            }
+        }
+    }
+    return patternEquals(value, criterion);
+}
+/** The indexes in `range` that meet `criterion`, for the IF family. */
+export function criteriaHits(range, criterion) {
+    const out = [];
+    for (let i = 0; i < range.length; i += 1) {
+        if (matchesCriterion(range[i], criterion))
+            out.push(i);
+    }
+    return out;
+}
+/** SUMIFS and its family: every (range, criterion) pair must match at an index. */
+export function multiCriteriaHits(pairs) {
+    const firstPair = pairs[0];
+    if (!firstPair)
+        return [];
+    const out = [];
+    for (let i = 0; i < firstPair[0].length; i += 1) {
+        if (pairs.every(([range, crit]) => matchesCriterion(range[i] ?? '', crit)))
+            out.push(i);
+    }
+    return out;
+}
+/** The (range, criterion) pairs of a *IFS call, starting at argument `from`. */
+export function criteriaPairs(args, from) {
+    const pairs = [];
+    for (let i = from; i < args.length; i += 2) {
+        const range = args[i];
+        if (!range)
+            break;
+        pairs.push([range, args[i + 1]?.[0] ?? '']);
+    }
+    return pairs;
+}