@svgrid/enterprise 3.0.0 → 3.0.2

package/dist/sheet/rects.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rectangles of cells, and how they move when rows or columns are inserted
+ * or deleted.
+ *
+ * A sheet keys more than its formats by position: validation rules,
+ * conditional formats, merges and an AutoFilter range are all rectangles,
+ * and every one of them has to move with the cells it covers, the way the
+ * format store's entries do. This is the one place that rule lives, so a
+ * band on rows 5-8 and a rule on rows 5-8 cannot disagree about where an
+ * insert above them put them.
+ */
+import type { Rect } from './navigate.js';
+import type { StructuralEdit } from './refs.js';
+export type { Rect };
+/**
+ * Where `rect` is after `edit`, or null when the edit deleted all of it.
+ *
+ * An insert above a range moves it; an insert inside it grows it, the way
+ * a reference to the range would grow. A delete above it moves it up, a
+ * delete overlapping an edge shrinks it to what survives, and a delete of
+ * every line it covers removes it.
+ */
+export declare function shiftRect(rect: Rect, edit: StructuralEdit): Rect | null;
+/** Every item's rectangles moved; an item left with none is dropped. */
+export declare function shiftRects<T extends {
+    rects: ReadonlyArray<Rect>;
+}>(items: ReadonlyArray<T>, edit: StructuralEdit): T[];
+export declare function rectContains(rect: Rect, row: number, col: number): boolean;
+export declare function rectsIntersect(a: Rect, b: Rect): boolean;
+/**
+ * `rect` with `hole` cut out of it: up to four rectangles (above, below,
+ * left and right of the hole), or the rect itself when they do not meet.
+ * Clear Rules on a selection takes the selection out of every rule this way.
+ */
+export declare function subtractRect(rect: Rect, hole: Rect): Rect[];
+/** The grid's notes shape: row id (`r4`) to column id (`B`) to text. */
+export type NotesMap = Record<string, Record<string, string>>;
+/**
+ * Notes moved along with their rows or columns. `shift` says where line i
+ * is after the edit, or null when the edit deleted it, which drops its
+ * notes with it.
+ */
+export declare function remapNotes(notes: NotesMap, axis: 'rows' | 'cols', shift: (index: number) => number | null): NotesMap;
+/** The shift function a structural edit implies, shared by every keyed part. */
+export declare function lineShift(edit: StructuralEdit): (index: number) => number | null;

package/dist/sheet/rects.js

@@ -0,0 +1,112 @@
+import { colToLetters, lettersToCol } from './address.js';
+/**
+ * Where `rect` is after `edit`, or null when the edit deleted all of it.
+ *
+ * An insert above a range moves it; an insert inside it grows it, the way
+ * a reference to the range would grow. A delete above it moves it up, a
+ * delete overlapping an edge shrinks it to what survives, and a delete of
+ * every line it covers removes it.
+ */
+export function shiftRect(rect, edit) {
+    const [r1, c1, r2, c2] = rect;
+    const { at, count } = edit;
+    const rows = edit.kind === 'insertRows' || edit.kind === 'deleteRows';
+    const lo = rows ? r1 : c1;
+    const hi = rows ? r2 : c2;
+    let nlo;
+    let nhi;
+    if (edit.kind === 'insertRows' || edit.kind === 'insertCols') {
+        nlo = lo >= at ? lo + count : lo;
+        nhi = hi >= at ? hi + count : hi;
+    }
+    else {
+        const end = at + count;
+        if (lo >= at && hi < end)
+            return null;
+        nlo = lo >= end ? lo - count : lo >= at ? at : lo;
+        nhi = hi >= end ? hi - count : hi >= at ? at - 1 : hi;
+    }
+    if (nhi < nlo)
+        return null;
+    return rows ? [nlo, c1, nhi, c2] : [r1, nlo, r2, nhi];
+}
+/** Every item's rectangles moved; an item left with none is dropped. */
+export function shiftRects(items, edit) {
+    const out = [];
+    for (const item of items) {
+        const rects = [];
+        for (const rect of item.rects) {
+            const moved = shiftRect(rect, edit);
+            if (moved)
+                rects.push(moved);
+        }
+        if (rects.length)
+            out.push({ ...item, rects });
+    }
+    return out;
+}
+export function rectContains(rect, row, col) {
+    return row >= rect[0] && row <= rect[2] && col >= rect[1] && col <= rect[3];
+}
+export function rectsIntersect(a, b) {
+    return a[0] <= b[2] && b[0] <= a[2] && a[1] <= b[3] && b[1] <= a[3];
+}
+/**
+ * `rect` with `hole` cut out of it: up to four rectangles (above, below,
+ * left and right of the hole), or the rect itself when they do not meet.
+ * Clear Rules on a selection takes the selection out of every rule this way.
+ */
+export function subtractRect(rect, hole) {
+    if (!rectsIntersect(rect, hole))
+        return [rect];
+    const [r1, c1, r2, c2] = rect;
+    const [h1, hc1, h2, hc2] = hole;
+    const out = [];
+    if (h1 > r1)
+        out.push([r1, c1, h1 - 1, c2]);
+    if (h2 < r2)
+        out.push([h2 + 1, c1, r2, c2]);
+    const top = Math.max(r1, h1);
+    const bottom = Math.min(r2, h2);
+    if (hc1 > c1)
+        out.push([top, c1, bottom, hc1 - 1]);
+    if (hc2 < c2)
+        out.push([top, hc2 + 1, bottom, c2]);
+    return out;
+}
+/**
+ * Notes moved along with their rows or columns. `shift` says where line i
+ * is after the edit, or null when the edit deleted it, which drops its
+ * notes with it.
+ */
+export function remapNotes(notes, axis, shift) {
+    const out = {};
+    for (const [rowId, line] of Object.entries(notes)) {
+        if (axis === 'rows') {
+            const index = Number(rowId.slice(1));
+            const next = Number.isInteger(index) ? shift(index) : index;
+            if (next === null)
+                continue;
+            out[`r${next}`] = { ...line };
+            continue;
+        }
+        const moved = {};
+        for (const [columnId, text] of Object.entries(line)) {
+            const index = lettersToCol(columnId);
+            const next = index < 0 ? index : shift(index);
+            if (next === null)
+                continue;
+            moved[index < 0 ? columnId : colToLetters(next)] = text;
+        }
+        if (Object.keys(moved).length)
+            out[rowId] = moved;
+    }
+    return out;
+}
+/** The shift function a structural edit implies, shared by every keyed part. */
+export function lineShift(edit) {
+    const { at, count } = edit;
+    if (edit.kind === 'insertRows' || edit.kind === 'insertCols')
+        return (i) => (i >= at ? i + count : i);
+    return (i) => (i >= at + count ? i - count : i >= at ? null : i);
+}

package/dist/sheet/refs.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Reference rewriting. The one module allowed to move a reference.
+ *
+ * Two jobs, both of which the demo engines could not do because they discarded
+ * `$` at parse time:
+ *
+ *   - `translateFormula` shifts RELATIVE parts by a delta and leaves pinned
+ *     parts alone. This is what makes fill-down, copy/paste and drag-fill
+ *     correct: `=$A$1*B2` filled one row down becomes `=$A$1*B3`.
+ *   - `fixupReferences` rewrites every formula in a sheet after rows or columns
+ *     are inserted or removed. A reference to a deleted cell becomes `#REF!`;
+ *     everything past the edit shifts; a range straddling an insertion grows.
+ *
+ * Both re-serialise from the AST rather than editing text, so `SUM( A1 : B2 )`
+ * comes back normalised instead of half-rewritten.
+ */
+import { type Node } from './ast.js';
+/** Serialise an AST back to formula text, with the leading `=`. */
+export declare function formatFormula(node: Node): string;
+/**
+ * Shift every relative reference in a formula by (dRow, dCol).
+ *
+ * Anything that is not a formula comes back untouched, so callers can pass a
+ * whole column of mixed literals and formulas through it.
+ */
+export declare function translateFormula(text: unknown, dRow: number, dCol: number): unknown;
+/**
+ * Point every reference that names sheet `from` at `to` instead: what a
+ * sheet rename owes the formulas on the other sheets and the defined
+ * names, and what Excel does on one. Parsed and re-rendered rather than
+ * substituted as text, so a string literal that happens to contain the old
+ * name is left alone and a new name with a space comes out quoted. A
+ * formula that names no such sheet is returned as it was, untouched.
+ */
+/**
+ * Excel's reference colours: the A1 references in a formula being typed,
+ * each occurrence with the colour of its range, so the cells a formula
+ * names and the text that names them can be painted alike. Colours go by
+ * distinct range in order of first appearance, so `B5` twice is one
+ * colour; `$` anchors and case do not tell ranges apart; a reference into
+ * another sheet and anything inside a string are skipped. `rect` is
+ * [row1, col1, row2, col2], zero-based and normalised.
+ */
+export type ReferenceSpan = {
+    start: number;
+    end: number;
+    key: string;
+    colour: string;
+    rect: readonly [number, number, number, number];
+};
+export declare const REFERENCE_COLOURS: ReadonlyArray<string>;
+export declare function referenceSpans(text: string, colours?: ReadonlyArray<string>): ReferenceSpan[];
+export declare function renameSheetReferences(text: unknown, from: string, to: string): unknown;
+export type StructuralEdit = {
+    kind: 'insertRows' | 'deleteRows' | 'insertCols' | 'deleteCols';
+    /** 0-based index the edit happens at. */
+    at: number;
+    count: number;
+};
+/**
+ * Rewrite a formula's references after rows or columns are inserted or
+ * removed. A reference into the deleted span becomes `#REF!`.
+ *
+ * A RANGE only breaks when the edit removes all of it. Deleting rows inside a
+ * range shrinks it, which is what Excel does and what keeps `=SUM(A1:A10)`
+ * meaningful after you delete row 5.
+ */
+/**
+ * Which sheet an edit happened on, and which sheet the formula being
+ * rewritten lives on. With a scope, only references INTO the edited sheet
+ * move: an unqualified reference belongs to `self`, a qualified one to the
+ * sheet it names. Without one every reference moves, which is right for a
+ * single grid that has no sheets to tell apart.
+ */
+export type EditScope = {
+    /** The sheet the rows or columns were inserted in or deleted from. */
+    sheet: string;
+    /** The sheet the formula lives on; null for a defined name, which has no
+     *  home sheet, so only its qualified references can match. */
+    self: string | null;
+};
+export declare function fixupReferences(text: unknown, edit: StructuralEdit, scope?: EditScope): unknown;

package/dist/sheet/refs.js

@@ -0,0 +1,266 @@
+/**
+ * Reference rewriting. The one module allowed to move a reference.
+ *
+ * Two jobs, both of which the demo engines could not do because they discarded
+ * `$` at parse time:
+ *
+ *   - `translateFormula` shifts RELATIVE parts by a delta and leaves pinned
+ *     parts alone. This is what makes fill-down, copy/paste and drag-fill
+ *     correct: `=$A$1*B2` filled one row down becomes `=$A$1*B3`.
+ *   - `fixupReferences` rewrites every formula in a sheet after rows or columns
+ *     are inserted or removed. A reference to a deleted cell becomes `#REF!`;
+ *     everything past the edit shifts; a range straddling an insertion grows.
+ *
+ * Both re-serialise from the AST rather than editing text, so `SUM( A1 : B2 )`
+ * comes back normalised instead of half-rewritten.
+ */
+import { mapNode, PRECEDENCE } from './ast.js';
+import { formatA1, colToLetters, lettersToCol } from './address.js';
+import { parseFormula } from './parse.js';
+/** Shift a single reference's relative parts. */
+function translateRef(ref, dRow, dCol) {
+    return {
+        ...ref,
+        col: ref.colAbs ? ref.col : ref.col + dCol,
+        row: ref.row === null || ref.rowAbs ? ref.row : ref.row + dRow,
+    };
+}
+/** True once a reference has been shifted off the sheet. */
+function isBroken(ref) {
+    return ref.col < 0 || (ref.row !== null && ref.row < 0);
+}
+/** Serialise an AST back to formula text, with the leading `=`. */
+export function formatFormula(node) {
+    return `=${render(node)}`;
+}
+/** Render `node` as an operand of something binding at `minPrec`, adding
+ *  parentheses when it would otherwise re-associate. */
+function wrap(node, minPrec) {
+    const text = render(node);
+    if (node.k === 'binary' && PRECEDENCE[node.op] < minPrec)
+        return `(${text})`;
+    // A unary minus has to be parenthesised inside anything tighter than it,
+    // so -(A1+B1) and 2^-A1 both survive.
+    if (node.k === 'unary' && node.op !== '%' && minPrec > 5)
+        return `(${text})`;
+    return text;
+}
+function render(node) {
+    switch (node.k) {
+        case 'num': return String(node.v);
+        case 'str': return `"${node.v.replace(/"/g, '""')}"`;
+        case 'bool': return node.v ? 'TRUE' : 'FALSE';
+        case 'ref': return node.ref.col < 0 || (node.ref.row ?? 0) < 0 ? '#REF!' : formatA1(node.ref);
+        case 'range': {
+            if (isBroken(node.from) || isBroken(node.to))
+                return '#REF!';
+            // A whole-column range prints as A:C, not A1:C.
+            if (node.from.row === null || node.to.row === null) {
+                const left = `${node.from.colAbs ? '$' : ''}${colToLetters(node.from.col)}`;
+                const right = `${node.to.colAbs ? '$' : ''}${colToLetters(node.to.col)}`;
+                const prefix = node.from.sheet ? `${formatA1({ ...node.from, row: null }).split('!')[0]}!` : '';
+                return `${prefix}${left}:${right}`;
+            }
+            const from = formatA1(node.from);
+            // The right-hand side drops a repeated sheet prefix: Sheet1!A1:B2.
+            const to = formatA1({ ...node.to, sheet: null });
+            return `${from}:${to}`;
+        }
+        case 'name': return node.name;
+        case 'table': {
+            // Re-serialised, never translated: the whole point of a structured
+            // reference is that it does not move when the formula does.
+            const parts = [];
+            if (node.specifier === '#ThisRow')
+                parts.push(node.column ? `@${node.column}` : '@');
+            else if (node.specifier !== '#Data')
+                parts.push(node.specifier);
+            if (node.specifier !== '#ThisRow' && node.column) {
+                parts.push(node.columnTo ? `[${node.column}]:[${node.columnTo}]` : node.column);
+            }
+            return `${node.table ?? ''}[${parts.join(',')}]`;
+        }
+        case 'unary':
+            return node.op === '%'
+                ? `${wrap(node.arg, 6)}%`
+                : `${node.op}${wrap(node.arg, 5)}`;
+        case 'binary': {
+            const prec = PRECEDENCE[node.op];
+            // The AST does not record parentheses, so they have to be reconstructed
+            // from precedence. Emitting the operands bare turns =(A1+B1)*2 into
+            // =A2+B2*2, which is a silent wrong answer on every fill and paste.
+            //
+            // Which SIDE needs one at equal precedence depends on associativity.
+            // Left-associative: the right operand does, because a-(b-c) is not
+            // a-b-c. Right-associative `^` is the mirror: the LEFT operand does,
+            // because (a^b)^c is not a^b^c.
+            const rightAssociative = node.op === '^';
+            const leftMin = rightAssociative ? prec + 1 : prec;
+            const rightMin = rightAssociative ? prec : prec + 1;
+            return `${wrap(node.left, leftMin)}${node.op}${wrap(node.right, rightMin)}`;
+        }
+        case 'fn': return `${node.name}(${node.args.map(render).join(',')})`;
+    }
+}
+/**
+ * Shift every relative reference in a formula by (dRow, dCol).
+ *
+ * Anything that is not a formula comes back untouched, so callers can pass a
+ * whole column of mixed literals and formulas through it.
+ */
+export function translateFormula(text, dRow, dCol) {
+    if (typeof text !== 'string' || !text.startsWith('='))
+        return text;
+    if (dRow === 0 && dCol === 0)
+        return text;
+    let ast;
+    try {
+        ast = parseFormula(text);
+    }
+    catch {
+        // Not parseable: leave it exactly as the user typed it. Rewriting a
+        // half-understood formula is worse than leaving it alone.
+        return text;
+    }
+    const moved = mapNode(ast, (n) => {
+        if (n.k === 'ref')
+            return { ...n, ref: translateRef(n.ref, dRow, dCol) };
+        if (n.k === 'range') {
+            return { ...n, from: translateRef(n.from, dRow, dCol), to: translateRef(n.to, dRow, dCol) };
+        }
+        return n;
+    });
+    return formatFormula(moved);
+}
+export const REFERENCE_COLOURS = ['#1e6fd9', '#d62828', '#8e44ad', '#0f9d58', '#e67e22', '#0097a7'];
+export function referenceSpans(text, colours = REFERENCE_COLOURS) {
+    const out = [];
+    if (!text.startsWith('='))
+        return out;
+    const blanked = text
+        .replace(/"[^"]*"/g, (m) => ' '.repeat(m.length))
+        // A sheet-qualified reference belongs to another sheet.
+        .replace(/(?:'[^']*'|[A-Za-z_][\w.]*)!\$?[A-Z]{1,3}\$?\d+(?::\$?[A-Z]{1,3}\$?\d+)?/gi, (m) => ' '.repeat(m.length));
+    // Case-insensitive: a reference is typed as "b5" as often as "B5", and
+    // the engine reads both.
+    const re = /(?<![A-Za-z0-9_.!])\$?([A-Za-z]{1,3})\$?(\d{1,7})(?::\$?([A-Za-z]{1,3})\$?(\d{1,7}))?(?![A-Za-z0-9_(])/g;
+    const order = new Map();
+    for (const m of blanked.matchAll(re)) {
+        const key = m[0].replace(/\$/g, '').toUpperCase();
+        const c1 = lettersToCol(m[1].toUpperCase()), r1 = Number(m[2]) - 1;
+        const c2 = m[3] ? lettersToCol(m[3].toUpperCase()) : c1, r2 = m[4] ? Number(m[4]) - 1 : r1;
+        if (c1 < 0 || c2 < 0 || r1 < 0 || r2 < 0)
+            continue;
+        let index = order.get(key);
+        if (index === undefined) {
+            index = order.size;
+            order.set(key, index);
+        }
+        out.push({
+            start: m.index,
+            end: m.index + m[0].length,
+            key,
+            colour: colours[index % colours.length],
+            rect: [Math.min(r1, r2), Math.min(c1, c2), Math.max(r1, r2), Math.max(c1, c2)],
+        });
+    }
+    return out;
+}
+export function renameSheetReferences(text, from, to) {
+    if (typeof text !== 'string' || !text.startsWith('='))
+        return text;
+    const wanted = from.toLowerCase();
+    if (!text.toLowerCase().includes(wanted))
+        return text;
+    let ast;
+    try {
+        ast = parseFormula(text);
+    }
+    catch {
+        return text;
+    }
+    let changed = false;
+    const swap = (ref) => {
+        if (ref.sheet === null || ref.sheet.toLowerCase() !== wanted)
+            return ref;
+        changed = true;
+        return { ...ref, sheet: to };
+    };
+    const moved = mapNode(ast, (n) => {
+        if (n.k === 'ref')
+            return { ...n, ref: swap(n.ref) };
+        if (n.k === 'range')
+            return { ...n, from: swap(n.from), to: swap(n.to) };
+        return n;
+    });
+    return changed ? formatFormula(moved) : text;
+}
+/**
+ * Shift one coordinate through a structural edit. Returns null when the thing
+ * it pointed at was deleted, which becomes `#REF!`.
+ */
+function shiftCoord(value, edit, inserting) {
+    if (inserting) {
+        return value >= edit.at ? value + edit.count : value;
+    }
+    if (value < edit.at)
+        return value;
+    if (value < edit.at + edit.count)
+        return null;
+    return value - edit.count;
+}
+function fixRef(ref, edit) {
+    const rows = edit.kind === 'insertRows' || edit.kind === 'deleteRows';
+    const inserting = edit.kind === 'insertRows' || edit.kind === 'insertCols';
+    if (rows) {
+        if (ref.row === null)
+            return ref;
+        const next = shiftCoord(ref.row, edit, inserting);
+        return next === null ? null : { ...ref, row: next };
+    }
+    const next = shiftCoord(ref.col, edit, inserting);
+    return next === null ? null : { ...ref, col: next };
+}
+const sameSheet = (a, b) => a !== null && a.toLowerCase() === b.toLowerCase();
+export function fixupReferences(text, edit, scope) {
+    if (typeof text !== 'string' || !text.startsWith('='))
+        return text;
+    if (edit.count <= 0)
+        return text;
+    let ast;
+    try {
+        ast = parseFormula(text);
+    }
+    catch {
+        return text;
+    }
+    const broken = { col: -1, colAbs: false, row: -1, rowAbs: false, sheet: null };
+    const touched = (sheet) => !scope || sameSheet(sheet ?? scope.self, scope.sheet);
+    const moved = mapNode(ast, (n) => {
+        if (n.k === 'ref') {
+            if (!touched(n.ref.sheet))
+                return n;
+            const next = fixRef(n.ref, edit);
+            return next === null ? { k: 'ref', ref: broken } : { ...n, ref: next };
+        }
+        if (n.k === 'range') {
+            if (!touched(n.from.sheet ?? n.to.sheet))
+                return n;
+            const from = fixRef(n.from, edit);
+            const to = fixRef(n.to, edit);
+            // Both ends gone means the whole range was deleted.
+            if (from === null && to === null)
+                return { k: 'ref', ref: broken };
+            // One end gone: clamp it to the edit point so the range shrinks.
+            const rows = edit.kind === 'deleteRows';
+            const clamp = (ref) => rows ? { ...ref, row: Math.max(edit.at - 1, 0) } : { ...ref, col: Math.max(edit.at - 1, 0) };
+            return {
+                ...n,
+                from: from ?? clamp(n.from),
+                to: to ?? clamp(n.to),
+            };
+        }
+        return n;
+    });
+    return formatFormula(moved);
+}

package/dist/sheet/ribbon-icons.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The ribbon's icons, as path data on a 16 x 16 grid.
+ *
+ * Drawn here rather than pulled from an icon font or a package: the ribbon
+ * is the one place in the library that needs a coordinated set of command
+ * glyphs (a clipboard, scissors, a paint bucket, a funnel), and an icon set
+ * that is part of the source can be read, tested and tuned like anything
+ * else. `SvRibbonIcon.svelte` renders one by name; a large button draws the
+ * same paths at twice the size, which is why they are vectors.
+ *
+ * One style, one colour. These are line icons - a 1.4px stroke with round
+ * caps and joins, the way Excel's own monochrome set is drawn - and every
+ * one of them is `currentColor`, so they are black on a light ribbon and
+ * white on a dark one and never carry a colour of their own. The only fills
+ * are the small solid parts Excel also fills: a dot, a corner, the head of
+ * an arrow. Colour belongs to the colour bar under Fill Colour and Font
+ * Colour, which shows the colour the face will apply, not to the glyph.
+ */
+export type IconPath = {
+    d: string;
+    /** Solid shape in the icon colour instead of a stroked outline. */
+    fill?: boolean;
+    /** Stroke width when not the default 1.4. */
+    width?: number;
+    /** Dashed stroke, for the "no border" sides. */
+    dash?: string;
+};
+export type RibbonIconName = 'undo' | 'redo' | 'paste' | 'cut' | 'copy' | 'paste-special' | 'font-grow' | 'font-shrink' | 'borders' | 'border-none' | 'border-bottom' | 'border-top' | 'border-left' | 'border-right' | 'border-all' | 'border-outside' | 'border-thick-bottom' | 'fill-colour' | 'font-colour' | 'align-left' | 'align-center' | 'align-right' | 'wrap' | 'dec-more' | 'dec-less' | 'insert-cells' | 'delete-cells' | 'freeze' | 'unfreeze' | 'autosum' | 'fill-down' | 'fill-right' | 'clear' | 'find' | 'filter' | 'sort-asc' | 'sort-desc' | 'chart' | 'table' | 'function' | 'new-sheet' | 'name-manager' | 'show-formulas' | 'calculate' | 'goal-seek' | 'text-to-columns' | 'remove-duplicates' | 'chevron-down' | 'format-cells' | 'format-painter' | 'protect' | 'unprotect' | 'lock' | 'comment' | 'comment-delete' | 'comment-prev' | 'comment-next' | 'comments-all' | 'validation' | 'cf' | 'cf-greater' | 'cf-less' | 'cf-between' | 'cf-equal' | 'cf-text' | 'cf-duplicates' | 'cf-top' | 'cf-bottom' | 'cf-above' | 'cf-below' | 'cf-bar' | 'cf-scale' | 'cf-icons' | 'merge' | 'unmerge' | 'gridlines' | 'formula-bar' | 'headings' | 'font' | 'number' | 'clear-formats' | 'column-width' | 'row-height' | 'hide' | 'unhide';
+export declare const RIBBON_ICONS: Record<RibbonIconName, ReadonlyArray<IconPath>>;
+/** The names, for tests and for anyone building their own toolbar. */
+export declare const RIBBON_ICON_NAMES: RibbonIconName[];