@svgrid/enterprise 3.0.2 → 3.0.3

package/dist/sheet/sparklines.js

@@ -0,0 +1,204 @@
+import { shiftRect, rectContains } from './rects.js';
+// The geometry only, through the grid's own subpath: this module is read by
+// the xlsx writer and by tests that run without a DOM, and the package root
+// would drag every component in with it.
+import { buildSparkline } from '@svgrid/grid/sparkline';
+/** The three Excel offers: Line, Column and Win/Loss. */
+export const SPARKLINE_TYPES = ['line', 'column', 'winloss'];
+let nextSparklineId = 1;
+/** An id no other group of this session carries. */
+export const sparklineId = () => `spark-${Date.now().toString(36)}-${(nextSparklineId += 1).toString(36)}`;
+/** A copy safe to hand out or save. */
+export function copySparkline(group) {
+    return { ...group, location: [...group.location], data: [...group.data] };
+}
+/**
+ * The group after an insert or delete: both rectangles move with their
+ * cells. Null when the edit took every cell the group was drawn in, or
+ * every cell it read.
+ */
+export function shiftSparkline(group, edit) {
+    const location = shiftRect(group.location, edit);
+    if (!location)
+        return null;
+    const data = shiftRect(group.data, edit);
+    if (!data)
+        return null;
+    return { ...copySparkline(group), location: location, data: data };
+}
+/** The groups of a sheet after an insert or delete, the gone ones dropped. */
+export function shiftSparklines(groups, edit) {
+    return groups.map((g) => shiftSparkline(g, edit)).filter((g) => g !== null);
+}
+/** True when the group draws down a column of cells rather than along a row. */
+export function isColumnLocation(group) {
+    const [r1, c1, r2, c2] = group.location;
+    // A single cell counts as a column: its data is read as one line either way.
+    return r2 - r1 >= c2 - c1;
+}
+/** A cell's value as a number, or null when it is not one. */
+function numberOf(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+/**
+ * The numbers one location cell draws, read through `valueAt`. The nth cell
+ * of the location reads the nth line of the data: the nth row when the
+ * sparklines run down a column, the nth column when they run along a row.
+ * A blank or a text cell inside the line is a gap, which Excel draws as a
+ * zero rather than breaking the line.
+ */
+export function sparklineSeries(group, row, col, valueAt) {
+    if (!rectContains(group.location, row, col))
+        return null;
+    const [lr1, lc1] = group.location;
+    const [dr1, dc1, dr2, dc2] = group.data;
+    const down = isColumnLocation(group);
+    const index = down ? row - lr1 : col - lc1;
+    const values = [];
+    if (down) {
+        const r = dr1 + index;
+        if (r > dr2)
+            return null;
+        for (let c = dc1; c <= dc2; c += 1)
+            values.push(numberOf(valueAt(r, c)) ?? 0);
+    }
+    else {
+        const c = dc1 + index;
+        if (c > dc2)
+            return null;
+        for (let r = dr1; r <= dr2; r += 1)
+            values.push(numberOf(valueAt(r, c)) ?? 0);
+    }
+    return values.length ? values : null;
+}
+/** The group drawn in a cell, or null: the last one wins, as Excel's does. */
+/**
+ * One line per cell of the group: the cell the sparkline is drawn in and
+ * the block of numbers it reads.
+ *
+ * The drawing works this out cell by cell as it paints; a writer needs the
+ * whole list, because Excel stores a sparkline group as one entry per cell
+ * with its own reference.
+ */
+/**
+ * A sparkline as standalone SVG markup, for a page the component cannot
+ * draw on: the printed sheet.
+ *
+ * The geometry is the grid's own `buildSparkline`, so the printed line is
+ * the line on screen rather than a second drawing that can disagree with
+ * it. The markup carries its colours inline, since the print document has
+ * no stylesheet of ours.
+ */
+export function sparklineSvg(values, options) {
+    const geo = buildSparkline([...values], {
+        type: options.type === 'column' ? 'bar' : options.type === 'winloss' ? 'winloss' : 'line',
+        width: options.width,
+        height: options.height,
+        ...(options.color ? { color: options.color } : {}),
+        ...(options.negativeColor ? { negativeColor: options.negativeColor } : {}),
+        ...(options.min !== undefined ? { min: options.min } : {}),
+        ...(options.max !== undefined ? { max: options.max } : {}),
+        lastPoint: Boolean(options.markers),
+    });
+    if (!geo)
+        return '';
+    const parts = [];
+    if (geo.bars.length) {
+        for (const bar of geo.bars) {
+            const fill = bar.negative ? geo.negativeColor : geo.color;
+            parts.push(`<rect x="${round(bar.x)}" y="${round(bar.y)}" width="${round(bar.w)}" height="${round(bar.h)}" fill="${fill}"/>`);
+        }
+    }
+    if (geo.linePath) {
+        parts.push(`<path d="${geo.linePath}" fill="none" stroke="${geo.color}" stroke-width="${geo.lineWidth}" stroke-linejoin="round" stroke-linecap="round"/>`);
+    }
+    if (geo.lastPoint && options.markers) {
+        parts.push(`<circle cx="${round(geo.lastPoint.x)}" cy="${round(geo.lastPoint.y)}" r="${geo.lineWidth + 0.5}" fill="${geo.color}"/>`);
+    }
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${geo.width}" height="${geo.height}" viewBox="0 0 ${geo.width} ${geo.height}" role="img" aria-hidden="true">${parts.join('')}</svg>`;
+}
+const round = (n) => Math.round(n * 100) / 100;
+export function sparklineLines(group) {
+    const [lr1, lc1, lr2, lc2] = group.location;
+    const [dr1, dc1, dr2, dc2] = group.data;
+    const down = isColumnLocation(group);
+    const out = [];
+    const count = down ? lr2 - lr1 + 1 : lc2 - lc1 + 1;
+    for (let i = 0; i < count; i += 1) {
+        if (down) {
+            const r = dr1 + i;
+            if (r > dr2)
+                break;
+            out.push({ row: lr1 + i, col: lc1, data: [r, dc1, r, dc2] });
+        }
+        else {
+            const c = dc1 + i;
+            if (c > dc2)
+                break;
+            out.push({ row: lr1, col: lc1 + i, data: [dr1, c, dr2, c] });
+        }
+    }
+    return out;
+}
+export function sparklineAt(groups, row, col) {
+    for (let i = groups.length - 1; i >= 0; i -= 1) {
+        if (rectContains(groups[i].location, row, col))
+            return groups[i];
+    }
+    return null;
+}
+/**
+ * The scale a group is drawn on when every sparkline in it shares one, which
+ * is Excel's "Same for All": the smallest and largest number anywhere in the
+ * data range. Null when the group scales each sparkline on its own.
+ */
+export function sparklineScale(group, valueAt) {
+    if (!group.sameScale)
+        return null;
+    const [r1, c1, r2, c2] = group.data;
+    let min = Infinity;
+    let max = -Infinity;
+    for (let r = r1; r <= r2; r += 1) {
+        for (let c = c1; c <= c2; c += 1) {
+            const n = numberOf(valueAt(r, c));
+            if (n === null)
+                continue;
+            if (n < min)
+                min = n;
+            if (n > max)
+                max = n;
+        }
+    }
+    if (min === Infinity)
+        return null;
+    return min === max ? { min: min - 1, max: max + 1 } : { min, max };
+}
+/**
+ * Where Excel's Create Sparklines dialog opens: the data is the selected
+ * block, and the location the column just past it (or the row just under it
+ * when the block is a single row). A block one cell tall gets a location of
+ * one cell, which is the common "a row of months, a sparkline beside it".
+ */
+export function sparklinesFromRange(data, type = 'line') {
+    const [r1, c1, r2, c2] = data;
+    const alongARow = r2 === r1 && c2 > c1;
+    const location = alongARow
+        ? [r1, c2 + 1, r1, c2 + 1]
+        : [r1, c2 + 1, r2, c2 + 1];
+    return { id: sparklineId(), location, data: [r1, c1, r2, c2], type, markers: type === 'line' };
+}
+/** The groups left after clearing every one the rectangles touch. */
+export function clearSparklines(groups, rects) {
+    return groups.filter((g) => !rects.some((rect) => overlaps(g.location, rect)));
+}
+function overlaps(a, b) {
+    return !(a[2] < b[0] || b[2] < a[0] || a[3] < b[1] || b[3] < a[1]);
+}

package/dist/sheet/table-styles.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The table styles gallery: Excel's presets, by the names Excel stores.
+ *
+ * A table's look is drawn rather than written into the cells, which is what
+ * lets a row typed under the last one arrive already banded. That drawing
+ * needs colours, and "the theme's accent" is one look rather than a gallery,
+ * so this is the set to pick from.
+ *
+ * The ids are Excel's own (`TableStyleMedium2`), and the colours are the
+ * Office theme's accents, so a table saved here opens in Excel wearing the
+ * same style rather than something approximate. A style is three tones of
+ * one accent: Light tints the header, Medium fills it, Dark fills it with a
+ * deeper shade, exactly as Excel's three families do.
+ */
+export type TableStyleTone = 'light' | 'medium' | 'dark';
+export type TableStyle = {
+    /** Excel's name for it, which is what goes in the file. */
+    id: string;
+    /** The colour's name, for the gallery. */
+    colour: string;
+    tone: TableStyleTone;
+    /** The Office theme accent it is built from. */
+    accent: string;
+};
+/**
+ * Eighteen styles: six accents in three tones. Excel numbers each family
+ * from 1, with 1 reserved for the black-and-white variant, so the accents
+ * start at 2 and this maps one for one onto the built-in names.
+ */
+export declare const TABLE_STYLES: ReadonlyArray<TableStyle>;
+/** What a table wears unless it is given something else: Excel's own default. */
+export declare const DEFAULT_TABLE_STYLE = "TableStyleMedium2";
+/** No style at all: the cells keep whatever formats they carry. */
+export declare const NO_TABLE_STYLE = "None";
+export declare function findTableStyle(id: string | undefined): TableStyle | undefined;
+/**
+ * Black or white over a fill, whichever can be read.
+ *
+ * Excel paints a header's text white whatever the fill, which on its gold
+ * and sky accents is about 2:1: legible to some people, not to others, and
+ * flagged by every checker. Picking the readable one keeps Excel's colours
+ * and drops the part of Excel's behaviour that fails.
+ */
+export declare function readableOn(fill: string): string;
+/**
+ * The fill a filled header takes: the accent, darkened only when neither
+ * black nor white can be read on it.
+ *
+ * Mid grey is the one accent where that happens: white is 4.0 against it
+ * and near-black 4.3, so both sit under the 4.5 a checker asks for. A few
+ * steps darker keeps it recognisably the same grey and lets the white text
+ * clear it, which is a smaller lie than a header nobody can read.
+ */
+export declare function headerFill(accent: string): string;
+export type TableStyleColours = {
+    /** The header row's fill, and the colour its text needs to stay readable. */
+    header: string;
+    headerText: string;
+    /** Every other data row. */
+    band: string;
+    /** The totals row, and the line over it. */
+    totals: string;
+    border: string;
+};
+/**
+ * A style as CSS colours.
+ *
+ * `color-mix` rather than fixed hexes for the tints, so a table keeps its
+ * colour over a dark sheet as well as a light one: the accent is mixed with
+ * the surface underneath rather than painted over it.
+ */
+export declare function tableStyleColours(style: TableStyle | string | undefined): TableStyleColours | null;
+/** "Blue, Medium", for the gallery's tooltip and for a screen reader. */
+export declare function tableStyleLabel(style: TableStyle): string;

package/dist/sheet/table-styles.js

@@ -0,0 +1,152 @@
+/**
+ * The table styles gallery: Excel's presets, by the names Excel stores.
+ *
+ * A table's look is drawn rather than written into the cells, which is what
+ * lets a row typed under the last one arrive already banded. That drawing
+ * needs colours, and "the theme's accent" is one look rather than a gallery,
+ * so this is the set to pick from.
+ *
+ * The ids are Excel's own (`TableStyleMedium2`), and the colours are the
+ * Office theme's accents, so a table saved here opens in Excel wearing the
+ * same style rather than something approximate. A style is three tones of
+ * one accent: Light tints the header, Medium fills it, Dark fills it with a
+ * deeper shade, exactly as Excel's three families do.
+ */
+/** The Office theme's six accents, in Excel's order. */
+const ACCENTS = [
+    { name: 'Blue', hex: '#4472c4' },
+    { name: 'Orange', hex: '#ed7d31' },
+    { name: 'Grey', hex: '#7f7f7f' },
+    { name: 'Gold', hex: '#ffc000' },
+    { name: 'Sky', hex: '#5b9bd5' },
+    { name: 'Green', hex: '#70ad47' },
+];
+const TONES = [
+    { tone: 'light', family: 'Light' },
+    { tone: 'medium', family: 'Medium' },
+    { tone: 'dark', family: 'Dark' },
+];
+/**
+ * Eighteen styles: six accents in three tones. Excel numbers each family
+ * from 1, with 1 reserved for the black-and-white variant, so the accents
+ * start at 2 and this maps one for one onto the built-in names.
+ */
+export const TABLE_STYLES = TONES.flatMap(({ tone, family }) => ACCENTS.map((accent, i) => ({
+    id: `TableStyle${family}${i + 2}`,
+    colour: accent.name,
+    tone,
+    accent: accent.hex,
+})));
+/** What a table wears unless it is given something else: Excel's own default. */
+export const DEFAULT_TABLE_STYLE = 'TableStyleMedium2';
+/** No style at all: the cells keep whatever formats they carry. */
+export const NO_TABLE_STYLE = 'None';
+export function findTableStyle(id) {
+    if (!id || id === NO_TABLE_STYLE)
+        return undefined;
+    return TABLE_STYLES.find((s) => s.id.toLowerCase() === id.toLowerCase());
+}
+/** A hex colour as its three channels, 0 to 255. */
+function channels(hex) {
+    const value = hex.trim().replace('#', '');
+    const full = value.length === 3 ? value.split('').map((c) => c + c).join('') : value;
+    const n = Number.parseInt(full.slice(0, 6), 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+/** Relative luminance, the way WCAG defines it. */
+function luminance(hex) {
+    const [r, g, b] = channels(hex).map((c) => {
+        const s = c / 255;
+        return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrast(a, b) {
+    const [x, y] = [luminance(a), luminance(b)].sort((p, q) => q - p);
+    return (x + 0.05) / (y + 0.05);
+}
+/**
+ * Black or white over a fill, whichever can be read.
+ *
+ * Excel paints a header's text white whatever the fill, which on its gold
+ * and sky accents is about 2:1: legible to some people, not to others, and
+ * flagged by every checker. Picking the readable one keeps Excel's colours
+ * and drops the part of Excel's behaviour that fails.
+ */
+export function readableOn(fill) {
+    const dark = '#0f172a';
+    const light = '#ffffff';
+    return contrast(fill, light) >= contrast(fill, dark) ? light : dark;
+}
+/**
+ * The fill a filled header takes: the accent, darkened only when neither
+ * black nor white can be read on it.
+ *
+ * Mid grey is the one accent where that happens: white is 4.0 against it
+ * and near-black 4.3, so both sit under the 4.5 a checker asks for. A few
+ * steps darker keeps it recognisably the same grey and lets the white text
+ * clear it, which is a smaller lie than a header nobody can read.
+ */
+export function headerFill(accent) {
+    const best = Math.max(contrast(accent, '#ffffff'), contrast(accent, '#0f172a'));
+    if (best >= 4.5)
+        return accent;
+    for (let percent = 92; percent >= 60; percent -= 8) {
+        const darker = mixWithBlack(accent, percent);
+        if (contrast(darker, '#ffffff') >= 4.5)
+            return darker;
+    }
+    return mixWithBlack(accent, 60);
+}
+/** The colour a mix of an accent with black comes out as, for the dark tone. */
+function mixWithBlack(hex, percent) {
+    const mixed = channels(hex).map((c) => Math.round((c * percent) / 100));
+    return `#${mixed.map((c) => c.toString(16).padStart(2, '0')).join('')}`;
+}
+/**
+ * A style as CSS colours.
+ *
+ * `color-mix` rather than fixed hexes for the tints, so a table keeps its
+ * colour over a dark sheet as well as a light one: the accent is mixed with
+ * the surface underneath rather than painted over it.
+ */
+export function tableStyleColours(style) {
+    const found = typeof style === 'string' || style === undefined ? findTableStyle(style) : style;
+    if (!found)
+        return null;
+    const accent = found.accent;
+    const mix = (percent, into = 'transparent') => `color-mix(in srgb, ${accent} ${percent}%, ${into})`;
+    if (found.tone === 'light') {
+        return {
+            header: mix(18),
+            headerText: 'inherit',
+            band: mix(8),
+            totals: mix(14),
+            border: mix(50),
+        };
+    }
+    if (found.tone === 'dark') {
+        return {
+            header: `color-mix(in srgb, ${accent} 65%, #000)`,
+            headerText: readableOn(mixWithBlack(accent, 65)),
+            band: mix(22),
+            totals: mix(30),
+            border: mix(70),
+        };
+    }
+    const fill = headerFill(accent);
+    return {
+        header: fill,
+        // White where white can be read, near-black where it cannot: Excel's
+        // gold and sky headers are about 2:1 against white.
+        headerText: readableOn(fill),
+        band: mix(13),
+        totals: mix(20),
+        border: mix(55),
+    };
+}
+/** "Blue, Medium", for the gallery's tooltip and for a screen reader. */
+export function tableStyleLabel(style) {
+    const tone = style.tone === 'light' ? 'Light' : style.tone === 'dark' ? 'Dark' : 'Medium';
+    return `${style.colour}, ${tone}`;
+}

package/dist/sheet/tables.d.ts

@@ -14,6 +14,7 @@
  * the range depends on the table's size at that moment rather than at parse
  * time.
  */
+import type { StructuralEdit } from './refs.js';
 export type TableRegion = {
     name: string;
     sheet: string;
@@ -26,6 +27,12 @@ export type TableRegion = {
     lastRow: number;
     /** Whether the row after `lastRow` is a totals row. */
     hasTotals: boolean;
+    /**
+     * The look, by Excel's name for it (`TableStyleMedium2`), or `'None'` for
+     * cells that keep whatever formats they carry. Absent means the default,
+     * which is Excel's default too.
+     */
+    style?: string;
 };
 /** Which part of a table a structured reference asks for. */
 export type TableSpecifier = '#All' | '#Data' | '#Headers' | '#Totals' | '#ThisRow';
@@ -68,3 +75,15 @@ export declare function resolveTableRange(table: TableRegion, specifier: TableSp
 } | null, currentRow: number | null): TableRange | null;
 /** How many data rows a table holds. */
 export declare function rowCountOf(table: TableRegion): number;
+/**
+ * A table after an insert or delete on its own sheet: its header row, its
+ * columns and its last row move with the cells. Null when the edit took the
+ * header row, or every column, which is what deleting a table looks like.
+ *
+ * A totals row sits on `lastRow + 1`, so it moves with the rest; an insert
+ * INSIDE the table grows it, which is what Excel does when a row is added
+ * in the middle of one.
+ */
+export declare function shiftTable(table: TableRegion, sheet: string, edit: StructuralEdit): TableRegion | null;
+/** Every table after an edit, the gone ones dropped. */
+export declare function shiftTables(tables: ReadonlyArray<TableRegion>, sheet: string, edit: StructuralEdit): TableRegion[];

package/dist/sheet/tables.js

@@ -14,6 +14,7 @@
  * the range depends on the table's size at that moment rather than at parse
  * time.
  */
+import { shiftRect } from './rects.js';
 /** Excel's rules for a table name are the same as for a defined name. */
 export function isValidTableName(name) {
     if (!/^[A-Za-z_][A-Za-z0-9_.]*$/.test(name))
@@ -145,3 +146,33 @@ export function resolveTableRange(table, specifier, columns, currentRow) {
 export function rowCountOf(table) {
     return Math.max(0, table.lastRow - table.headerRow);
 }
+/**
+ * A table after an insert or delete on its own sheet: its header row, its
+ * columns and its last row move with the cells. Null when the edit took the
+ * header row, or every column, which is what deleting a table looks like.
+ *
+ * A totals row sits on `lastRow + 1`, so it moves with the rest; an insert
+ * INSIDE the table grows it, which is what Excel does when a row is added
+ * in the middle of one.
+ */
+export function shiftTable(table, sheet, edit) {
+    if (table.sheet.toLowerCase() !== sheet.toLowerCase())
+        return table;
+    const rows = edit.kind === 'insertRows' || edit.kind === 'deleteRows';
+    const rect = rows
+        ? [table.headerRow, table.firstCol, table.lastRow + (table.hasTotals ? 1 : 0), table.lastCol]
+        : [table.headerRow, table.firstCol, table.lastRow + (table.hasTotals ? 1 : 0), table.lastCol];
+    const moved = shiftRect(rect, edit);
+    if (!moved)
+        return null;
+    const [r1, c1, r2, c2] = moved;
+    // A table with no data rows left is gone, as is one whose header went.
+    const lastRow = r2 - (table.hasTotals ? 1 : 0);
+    if (lastRow < r1 + 1)
+        return null;
+    return { ...table, headerRow: r1, firstCol: c1, lastCol: c2, lastRow };
+}
+/** Every table after an edit, the gone ones dropped. */
+export function shiftTables(tables, sheet, edit) {
+    return tables.map((t) => shiftTable(t, sheet, edit)).filter((t) => t !== null);
+}

package/dist/sheet/tokenize.d.ts

@@ -11,7 +11,7 @@
  * is what keeps absolute references absolute.
  */
 import { type CellRef } from './address.js';
-import { type BinaryOp } from './ast.js';
+import { type BinaryOp, type SheetError } from './ast.js';
 export type TableRefToken = {
     t: 'table';
     table: string | null;
@@ -28,13 +28,30 @@ export type Token = TableRefToken | {
 } | {
     t: 'bool';
     v: boolean;
+} | {
+    t: 'err';
+    v: SheetError;
 } | {
     t: 'ref';
     ref: CellRef;
+}
+/** The spilled-range operator `A1#`: the anchor a spill is read from. */
+ | {
+    t: 'spill';
+    ref: CellRef;
 } | {
     t: 'range';
     from: CellRef;
     to: CellRef;
+}
+/** A 3D reference `Sheet1:Sheet3!A1`: the cell or rectangle on every sheet
+ *  in the tab range. `from`/`to` carry no sheet of their own. */
+ | {
+    t: 'range3d';
+    sheetFrom: string;
+    sheetTo: string;
+    from: CellRef;
+    to: CellRef;
 } | {
     t: 'name';
     v: string;

package/dist/sheet/tokenize.js

@@ -20,6 +20,9 @@ const SPECIFIERS = {
     '#totals': '#Totals',
     '#this row': '#ThisRow',
 };
+/** The error values a formula can name, longest first so #NUM! cannot win
+ *  the prefix of a longer code. */
+const ERROR_LITERAL = /^(#NULL!|#DIV\/0!|#VALUE!|#NAME\?|#NUM!|#N\/A|#REF!|#SPILL!|#CALC!|#CYCLE!)/i;
 const TWO_CHAR_OPS = new Set(['<=', '>=', '<>']);
 const ONE_CHAR_OPS = '+-*/^%&=<>';
 export function tokenize(src) {
@@ -161,6 +164,15 @@ export function tokenize(src) {
             out.push({ t: 'name', v: word });
             return;
         }
+        // `A1#` is the spilled-range operator: the `#` binds to the reference
+        // right before it, with no space between, and names the whole array the
+        // cell anchors. A `#` that starts an error literal is handled elsewhere;
+        // one sitting immediately after a cell is only ever this.
+        if (src[i] === '#') {
+            i += 1;
+            out.push({ t: 'spill', ref: left });
+            return;
+        }
         out.push({ t: 'ref', ref: left });
     };
     while (i < src.length) {
@@ -252,34 +264,73 @@ export function tokenize(src) {
         if (/[A-Za-z$_]/.test(ch)) {
             const word = readWord();
             const upper = word.toUpperCase();
+            // A 3D reference: Sheet1:Sheet3!A1, the same cell on every sheet in the
+            // tab range. The `!` after the second name is what tells it apart from
+            // an ordinary A1:B2 range, so on anything else this backtracks.
+            if (src[i] === ':') {
+                const save = i;
+                i += 1;
+                const second = readWord();
+                if (second !== '' && src[i] === '!') {
+                    i += 1;
+                    const from = parseA1(readWord(), null);
+                    if (!from || from.row === null)
+                        throw new FormulaError('#PARSE!');
+                    let to = from;
+                    if (src[i] === ':') {
+                        i += 1;
+                        const right = parseA1(readWord(), null);
+                        if (!right || right.row === null)
+                            throw new FormulaError('#PARSE!');
+                        to = right;
+                    }
+                    out.push({ t: 'range3d', sheetFrom: word, sheetTo: second, from, to });
+                    continue;
+                }
+                i = save;
+            }
             // Unquoted sheet name: Orders!A1
             if (src[i] === '!') {
                 i += 1;
                 pushWord(readWord(), word);
                 continue;
             }
-            if (upper === 'TRUE') {
-                out.push({ t: 'bool', v: true });
-                continue;
-            }
-            if (upper === 'FALSE') {
-                out.push({ t: 'bool', v: false });
-                continue;
-            }
             // A word followed by `[` is a table: Orders[Amount].
             if (src[i] === '[') {
                 i += 1;
                 out.push(readTableBracket(word));
                 continue;
             }
-            // A word followed by `(` is a call, whatever else it might look like.
+            // A word followed by `(` is a call, whatever else it might look like -
+            // TRUE and FALSE included, since Excel has TRUE() and FALSE() as
+            // functions and that is how LibreOffice writes a boolean cell.
             if (src[skipSpace()] === '(') {
                 out.push({ t: 'fn', v: upper });
                 continue;
             }
+            if (upper === 'TRUE') {
+                out.push({ t: 'bool', v: true });
+                continue;
+            }
+            if (upper === 'FALSE') {
+                out.push({ t: 'bool', v: false });
+                continue;
+            }
             pushWord(word, null);
             continue;
         }
+        // An error written into the formula: =#N/A, =IFERROR(A1, #REF!). Excel
+        // reads one as a value, and a file can carry an error cell as a formula
+        // that is nothing else.
+        if (ch === '#') {
+            const code = ERROR_LITERAL.exec(src.slice(i));
+            if (code) {
+                out.push({ t: 'err', v: code[0].toUpperCase() });
+                i += code[0].length;
+                continue;
+            }
+            throw new FormulaError('#PARSE!');
+        }
         // A bare `[` is the unqualified form, which only means something in a
         // formula sitting inside a table: [@Amount].
         if (ch === '[') {

package/dist/sheet/validation.d.ts

@@ -37,6 +37,12 @@ export type ValidationRule = {
         title?: string;
         message?: string;
     };
+    /** Excel's Input Message: shown under the cell while it is selected.
+     *  Absent when the rule has none. */
+    input?: {
+        title?: string;
+        message?: string;
+    };
 };
 /** How a rule reads the sheet: the shell wires the workbook in. */
 export type ValidationContext = {
@@ -90,3 +96,13 @@ export declare function shiftValidation(rules: ReadonlyArray<ValidationRule>, ed
 export declare function removeValidation(rules: ReadonlyArray<ValidationRule>, rects: ReadonlyArray<Rect>): ValidationRule[];
 /** A short description for a rule, the way Excel's dialog title reads it. */
 export declare function describeRule(rule: ValidationRule): string;
+/**
+ * Excel's Circle Invalid Data: every cell under a rule whose current text
+ * breaks it. Blank cells count when the rule says they do. The rectangles
+ * are clipped to `rows` by `cols`, the sheet's used extent, so a rule over
+ * a whole column costs the cells that hold something.
+ */
+export declare function invalidCells(rules: ReadonlyArray<ValidationRule>, ctx: ValidationContext, rawAt: (row: number, col: number) => string, rows: number, cols: number): Array<{
+    row: number;
+    col: number;
+}>;