@shbernal/ts-xlsx 1.0.0

package/dist/core/grid-edits.js

@@ -0,0 +1,206 @@
+// Structural-edit machinery: the splice arithmetic that inserts or deletes whole rows and columns
+// and keeps everything anchored to the grid moving in step — line metadata, merged ranges, tables,
+// anchored images, and shared-formula clones. It is isolated from Worksheet because it is pure grid
+// mechanics: it holds the sheet's storage containers by reference and mutates them in place, and
+// touches none of the public cell API. Worksheet builds the cells an insert introduces, then hands
+// the pre-built rows (or the raw column values) here for the shift.
+import { decodeAddress, decodeRange, encodeAddress } from "./address.js";
+import { Cell, copyCellContent } from "./cell.js";
+import { replaceContents } from "./containers.js";
+import { isOneCellAnchor } from "./image.js";
+import { isSharedFormulaValue } from "./value.js";
+// The shift rule shared by every re-anchoring pass: a coordinate before the edit stays put, one at or
+// after the edited span shifts by `delta`, and one inside a deleted span clamps to the cut line (`start`).
+function shiftIndex(v, start, count, delta) {
+    return v < start ? v : v >= start + count ? v + delta : start;
+}
+export class GridEdits {
+    #rows;
+    #rowProperties;
+    #columns;
+    #merges;
+    #mergeRects;
+    #tables;
+    #images;
+    constructor(storage) {
+        this.#rows = storage.rows;
+        this.#rowProperties = storage.rowProperties;
+        this.#columns = storage.columns;
+        this.#merges = storage.merges;
+        this.#mergeRects = storage.mergeRects;
+        this.#tables = storage.tables;
+        this.#images = storage.images;
+    }
+    // Apply a delete-then-insert to the row grid: surviving rows below the edit shift by
+    // `inserted.length - count`, deleted rows drop out, and the pre-built inserted rows land at `start`.
+    // Row metadata and merged ranges shift the same way, so a formatting-only row or a covered merge
+    // stays aligned with the data it describes.
+    spliceRows(start, count, inserted) {
+        const delta = inserted.length - count;
+        const shifted = new Map();
+        for (const [row, cols] of this.#rows) {
+            if (row < start)
+                shifted.set(row, cols);
+            else if (row >= start + count)
+                shifted.set(row + delta, this.#relocateRow(cols, row + delta));
+        }
+        inserted.forEach((cols, i) => {
+            shifted.set(start + i, this.#relocateRow(cols, start + i));
+        });
+        this.#rows.clear();
+        for (const [row, cols] of shifted)
+            this.#rows.set(row, cols);
+        this.#shiftLineProperties(this.#rowProperties, start, count, delta);
+        this.#shiftMerges('row', start, count, delta);
+        this.#shiftTables('row', start, count, delta);
+        this.#shiftImages('row', start, count, delta);
+        this.#reanchorSharedFormulas('row', start, count, delta);
+    }
+    // Apply a delete-then-insert to the column grid: cells left of the edit stay, cells at or beyond the
+    // deleted span shift by `inserts.length - count` carrying their content, and the inserted column
+    // values materialise as fresh cells at `start`. Column metadata, merges, tables, images, and
+    // shared-formula clones re-anchor the same way.
+    spliceColumns(start, count, inserts) {
+        const delta = inserts.length - count;
+        for (const [row, cols] of this.#rows) {
+            const shifted = new Map();
+            for (const [col, cell] of cols) {
+                if (col < start) {
+                    shifted.set(col, cell);
+                }
+                else if (col >= start + count) {
+                    const dest = col + delta;
+                    const moved = new Cell(row, dest);
+                    copyCellContent(cell, moved);
+                    shifted.set(dest, moved);
+                }
+            }
+            inserts.forEach((values, i) => {
+                const value = values[row - 1];
+                if (value !== undefined) {
+                    const cell = new Cell(row, start + i);
+                    cell.value = value;
+                    shifted.set(start + i, cell);
+                }
+            });
+            this.#rows.set(row, shifted);
+        }
+        this.#shiftLineProperties(this.#columns, start, count, delta);
+        this.#shiftMerges('col', start, count, delta);
+        this.#shiftTables('col', start, count, delta);
+        this.#shiftImages('col', start, count, delta);
+        this.#reanchorSharedFormulas('col', start, count, delta);
+    }
+    // Rebuild a row's cells at a new row index. `Cell` fixes its position at construction, so a moved
+    // row is a fresh set of cells at `destRow` carrying the originals' content.
+    #relocateRow(cols, destRow) {
+        const moved = new Map();
+        for (const [col, cell] of cols) {
+            if (cell.row === destRow) {
+                moved.set(col, cell);
+            }
+            else {
+                const copy = new Cell(destRow, col);
+                copyCellContent(cell, copy);
+                moved.set(col, copy);
+            }
+        }
+        return moved;
+    }
+    // Re-anchor shared-formula clones through a splice on the given axis. A clone stores its master's
+    // absolute address; when the splice shifts the master, that stored address goes stale and the writer
+    // would reject the clone as orphaned. Applying the same shift the grid used keeps each clone pointed
+    // at its master's new cell. A master whose axis coordinate falls in the deleted span clamps to the
+    // cut line like a merge edge — a genuinely orphaned clone the writer then reports legibly.
+    #reanchorSharedFormulas(axis, start, count, delta) {
+        for (const cols of this.#rows.values()) {
+            for (const cell of cols.values()) {
+                const value = cell.value;
+                if (!isSharedFormulaValue(value))
+                    continue;
+                const master = decodeAddress(value.sharedFormula);
+                if (master.col === undefined || master.row === undefined)
+                    continue;
+                const anchored = axis === 'row'
+                    ? encodeAddress(master.col, shiftIndex(master.row, start, count, delta))
+                    : encodeAddress(shiftIndex(master.col, start, count, delta), master.row);
+                if (anchored === value.sharedFormula)
+                    continue;
+                const reanchored = { ...value, sharedFormula: anchored };
+                cell.value = reanchored;
+            }
+        }
+    }
+    // Shift a line-metadata map (row properties keyed by row, or column properties keyed by column)
+    // through a splice: entries before the edit stay, entries within the deleted span drop, entries
+    // after shift by `delta`. Mutates the map in place.
+    #shiftLineProperties(map, start, count, delta) {
+        const shifted = new Map();
+        for (const [index, value] of map) {
+            if (index < start)
+                shifted.set(index, value);
+            else if (index >= start + count)
+                shifted.set(index + delta, value);
+        }
+        map.clear();
+        for (const [index, value] of shifted)
+            map.set(index, value);
+    }
+    // Re-anchor merged ranges through a row or column splice. A range wholly before the edit is
+    // untouched; one wholly after shifts by `nInserts - count`; one whose covered rows/columns are
+    // entirely deleted is dropped. A range straddling the cut is a genuinely ambiguous geometry — its
+    // edges are clamped to the cut line as a best effort. Unbounded whole-row/column merges carry no
+    // rectangle and pass through unchanged.
+    #shiftMerges(axis, start, count, delta) {
+        const shift = (v) => shiftIndex(v, start, count, delta);
+        const merges = [];
+        const rects = [];
+        for (const range of this.#merges) {
+            const { top, left, bottom, right } = decodeRange(range);
+            if (top === undefined || left === undefined || bottom === undefined || right === undefined) {
+                merges.push(range);
+                continue;
+            }
+            const [lo, hi] = axis === 'row' ? [top, bottom] : [left, right];
+            if (lo >= start && hi < start + count)
+                continue;
+            const rect = axis === 'row'
+                ? { top: shift(top), left, bottom: shift(bottom), right }
+                : { top, left: shift(left), bottom, right: shift(right) };
+            rects.push(rect);
+            merges.push(`${encodeAddress(rect.left, rect.top)}:${encodeAddress(rect.right, rect.bottom)}`);
+        }
+        replaceContents(this.#merges, merges);
+        replaceContents(this.#mergeRects, rects);
+    }
+    // Re-pin the sheet's tables through a splice on the given axis, dropping any table a delete leaves
+    // with no row to occupy. `Table` owns the shift arithmetic; the sheet only prunes the casualties.
+    #shiftTables(axis, start, count, delta) {
+        const survivors = this.#tables.filter((table) => axis === 'row'
+            ? table.shiftRows(start, count, delta)
+            : table.shiftColumns(start, count, delta));
+        replaceContents(this.#tables, survivors);
+    }
+    // Re-pin anchored images through a splice. An anchor point moves like a merge edge: a point before
+    // the cut stays, one at or after it shifts by `delta`, and one inside a deleted span clamps to the
+    // cut line. Grid points are 0-based, so each is converted to the 1-based coordinate the shared
+    // shift arithmetic uses and back. An anchor whose points both move keeps its size; an anchor
+    // straddling the cut grows or shrinks, matching how Excel reflows a picture across inserted rows.
+    #shiftImages(axis, start, count, delta) {
+        const shiftPoint = (point) => {
+            const zeroBased = axis === 'row' ? point.row : point.col;
+            const shifted = shiftIndex(zeroBased + 1, start, count, delta) - 1;
+            if (shifted === zeroBased)
+                return point;
+            return axis === 'row' ? { ...point, row: shifted } : { ...point, col: shifted };
+        };
+        const moved = this.#images.map((image) => {
+            const from = shiftPoint(image.anchor.from);
+            const anchor = isOneCellAnchor(image.anchor)
+                ? { ...image.anchor, from }
+                : { ...image.anchor, from, to: shiftPoint(image.anchor.to) };
+            return { imageId: image.imageId, anchor };
+        });
+        replaceContents(this.#images, moved);
+    }
+}

package/dist/core/image.d.ts

@@ -0,0 +1,76 @@
+/** A point in the drawing grid: a 0-based column and row, plus an EMU offset into that cell.
+ * The offsets default to zero, pinning the point to the cell's top-left corner. */
+export interface AnchorPoint {
+    /** 0-based column index (column A is 0). */
+    readonly col: number;
+    /** 0-based row index (row 1 is 0). */
+    readonly row: number;
+    /** Horizontal offset into the cell, in EMUs (914400 per inch). Defaults to 0. */
+    readonly colOff?: number;
+    /** Vertical offset into the cell, in EMUs. Defaults to 0. */
+    readonly rowOff?: number;
+}
+/** EMUs per pixel at Excel's notional 96 DPI (914400 EMU/inch ÷ 96 px/inch). The conversion is
+ * DPI-independent by construction: a pixel extent is a fixed physical size regardless of screen. */
+export declare const PX_TO_EMU = 9525;
+/** How a two-cell-anchored image tracks edits to the cells it spans. `twoCell` moves and resizes with
+ * them; `oneCell` moves but keeps its size; `absolute` is pinned to the page and does neither. Excel
+ * defaults to `oneCell` when the attribute is omitted. */
+export type ImageEditAs = 'oneCell' | 'twoCell' | 'absolute';
+/** A fixed image size in EMUs — the extent of a one-cell anchor, which pixel dimensions convert into
+ * via {@link PX_TO_EMU}. */
+export interface Extent {
+    readonly cx: number;
+    readonly cy: number;
+}
+/** A two-cell anchor: the image's top-left (`from`) and bottom-right (`to`) grid points. The image
+ * fills the rectangle between them and reflows as the intervening rows/columns resize; `editAs`
+ * selects how strictly it follows. */
+export interface TwoCellAnchor {
+    readonly from: AnchorPoint;
+    readonly to: AnchorPoint;
+    readonly editAs?: ImageEditAs;
+    /** Clockwise rotation in 1/60000 of a degree (`2700000` = 45°), preserved from a loaded file. */
+    readonly rotation?: number;
+}
+/** A one-cell anchor: a single top-left grid point plus a fixed extent. The image keeps its size as
+ * the grid resizes, moving only with its anchor cell. `editAs` is a two-cell-only attribute and has
+ * no place here. */
+export interface OneCellAnchor {
+    readonly from: AnchorPoint;
+    readonly ext: Extent;
+    /** Clockwise rotation in 1/60000 of a degree (`2700000` = 45°), preserved from a loaded file. */
+    readonly rotation?: number;
+}
+/** Where an image sits on the grid: a rectangle between two cells, or a point plus a fixed extent. */
+export type ImageAnchor = TwoCellAnchor | OneCellAnchor;
+/** Narrow an anchor to its one-cell (fixed-extent) form; the complement is {@link TwoCellAnchor}. */
+export declare function isOneCellAnchor(anchor: ImageAnchor): anchor is OneCellAnchor;
+/** A column's width in characters of the default font, or `undefined` to take Excel's default. */
+export type ColumnWidthLookup = (col: number) => number | undefined;
+/** A row's height in points, or `undefined` to take Excel's default. */
+export type RowHeightLookup = (row: number) => number | undefined;
+/** Resolve a possibly-fractional anchor point to the cell it floors to plus a sub-cell EMU offset
+ * scaled by that cell's real width/height, so `col: 3.5` lands halfway across column 3 regardless of
+ * the column's size. An already-integer point keeps a zero offset (unless one was given). The two
+ * lookups supply each column/row's size; a size they leave `undefined` falls back to Excel's default. */
+export declare function resolveAnchorPoint(point: AnchorPoint, columnWidth: ColumnWidthLookup, rowHeight: RowHeightLookup): AnchorPoint;
+/** An image pinned to a worksheet: which workbook media it shows (`imageId`) and where. */
+export interface AnchoredImage {
+    /** Index into the workbook's media registry (the id {@link Workbook.addImage} returned). */
+    readonly imageId: number;
+    readonly anchor: ImageAnchor;
+}
+/** A picture's bytes and its file kind, as held in the workbook's media registry. */
+export interface WorkbookImage {
+    /** Lower-case file extension without a dot — `"png"`, `"jpeg"`, `"gif"`. Drives the media part's
+     * name and content type. */
+    readonly extension: string;
+    readonly data: Uint8Array;
+}
+/** Reduce a caller-supplied extension to the bare, lower-case alphanumeric token OOXML expects for a
+ * media part's name and `<Default Extension>`. A leading dot (`".png"`), a URL query string
+ * (`"png?alt=media"`), or any other separator a real-world filename/URL drags in is stripped to the
+ * leading run of alphanumerics; a missing or all-punctuation hint falls back to sniffing the bytes'
+ * magic number, so the package is always well-formed. */
+export declare function normalizeImageExtension(extension: string | undefined, data: Uint8Array): string;

package/dist/core/image.js

@@ -0,0 +1,65 @@
+// Anchored images: the model for a picture pinned to a worksheet's grid.
+//
+// The image *bytes* live once on the workbook (a small media registry, addressed by a numeric id);
+// a worksheet then anchors that image to a rectangle of cells. Storing the bytes centrally means the
+// same picture used on two sheets — a logo in a header band, say — is one media part, not two.
+/** EMUs per pixel at Excel's notional 96 DPI (914400 EMU/inch ÷ 96 px/inch). The conversion is
+ * DPI-independent by construction: a pixel extent is a fixed physical size regardless of screen. */
+export const PX_TO_EMU = 9525;
+/** Narrow an anchor to its one-cell (fixed-extent) form; the complement is {@link TwoCellAnchor}. */
+export function isOneCellAnchor(anchor) {
+    return 'ext' in anchor;
+}
+// Sub-cell anchor geometry. Excel measures a column in characters of the default font (~7 px each at
+// 96 DPI) and a row in points (1/72 inch); a column or row that sets no size falls back to Excel's
+// own defaults. These constants live here, beside the anchor model they serve, rather than in the
+// Worksheet that merely supplies the per-column/row sizes.
+const CHAR_WIDTH_PX = 7;
+const EMU_PER_POINT = 12700;
+const DEFAULT_COL_WIDTH_CHARS = 8.43;
+const DEFAULT_ROW_HEIGHT_POINTS = 15;
+/** Resolve a possibly-fractional anchor point to the cell it floors to plus a sub-cell EMU offset
+ * scaled by that cell's real width/height, so `col: 3.5` lands halfway across column 3 regardless of
+ * the column's size. An already-integer point keeps a zero offset (unless one was given). The two
+ * lookups supply each column/row's size; a size they leave `undefined` falls back to Excel's default. */
+export function resolveAnchorPoint(point, columnWidth, rowHeight) {
+    const col = Math.floor(point.col);
+    const row = Math.floor(point.row);
+    const colWidthEmu = Math.round((columnWidth(col) ?? DEFAULT_COL_WIDTH_CHARS) * CHAR_WIDTH_PX * PX_TO_EMU);
+    const rowHeightEmu = Math.round((rowHeight(row) ?? DEFAULT_ROW_HEIGHT_POINTS) * EMU_PER_POINT);
+    const colOff = (point.colOff ?? 0) + Math.round((point.col - col) * colWidthEmu);
+    const rowOff = (point.rowOff ?? 0) + Math.round((point.row - row) * rowHeightEmu);
+    return { col, row, colOff, rowOff };
+}
+// Leading magic bytes for the raster formats a spreadsheet embeds, most-specific first. Used to infer
+// an extension when the caller supplies none, so a package never declares an `image/undefined` type.
+const IMAGE_MAGIC = [
+    { ext: 'png', sig: [0x89, 0x50, 0x4e, 0x47] },
+    { ext: 'jpeg', sig: [0xff, 0xd8, 0xff] },
+    { ext: 'gif', sig: [0x47, 0x49, 0x46] },
+    { ext: 'bmp', sig: [0x42, 0x4d] },
+    { ext: 'tiff', sig: [0x49, 0x49, 0x2a, 0x00] },
+    { ext: 'tiff', sig: [0x4d, 0x4d, 0x00, 0x2a] },
+];
+function sniffImageExtension(data) {
+    for (const { ext, sig } of IMAGE_MAGIC) {
+        if (sig.every((b, i) => data[i] === b))
+            return ext;
+    }
+    // An unrecognised blob still needs a valid media name and content type; png keeps the package
+    // well-formed rather than emitting a `<Default>` with no or a bogus extension.
+    return 'png';
+}
+/** Reduce a caller-supplied extension to the bare, lower-case alphanumeric token OOXML expects for a
+ * media part's name and `<Default Extension>`. A leading dot (`".png"`), a URL query string
+ * (`"png?alt=media"`), or any other separator a real-world filename/URL drags in is stripped to the
+ * leading run of alphanumerics; a missing or all-punctuation hint falls back to sniffing the bytes'
+ * magic number, so the package is always well-formed. */
+export function normalizeImageExtension(extension, data) {
+    if (typeof extension === 'string') {
+        const token = extension.toLowerCase().match(/[a-z0-9]+/)?.[0];
+        if (token !== undefined)
+            return token;
+    }
+    return sniffImageExtension(data);
+}

package/dist/core/internal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Keys the codec-only operations on `Workbook` and `Worksheet` (see `WorkbookInternals` /
+ * `WorksheetInternals`, declared beside their classes).
+ */
+export declare const INTERNAL: unique symbol;
+/**
+ * Keys a `Cell`'s link to a named cell style — its OOXML `xfId`. A single hidden property rather than
+ * a channel object, so it stays a prototype accessor: cells are the one model class allocated in the
+ * millions, and a per-instance internals object would be a real cost for state most cells never carry.
+ */
+export declare const NAMED_STYLE_ID: unique symbol;

package/dist/core/internal.js

@@ -0,0 +1,29 @@
+// The codec's back channel into the model.
+//
+// A reader has to push state into a `Workbook` that no authoring path can produce: a `<dxfs>` table
+// whose indices existing rules already point at, a theme part carried as opaque bytes, a protection
+// credential in finished agile form with no recoverable password. The streaming writer likewise has
+// to drop a row's cells the moment they are serialised. All of that used to be public methods on the
+// model classes — so they shipped in the `.d.ts`, appeared in the generated API reference, and a
+// caller who tried one put the workbook in a state nothing else could reach or repair. There was no
+// authoring/codec boundary at all: the model class *was* the codec's mutation interface.
+//
+// These symbols are that boundary. The operations still live on the classes and still mutate exactly
+// the state they always did — this moves no data — but reaching them requires a symbol that is not on
+// the public barrel and, because `package.json` exposes only the root entry, is not importable from
+// outside the package at all. Inside the tree, the import is the audit trail: `grep` for this module
+// and you have the complete list of code that can restore preserved state.
+//
+// Prefer an ordinary public method whenever a caller could reasonably want the operation. This is for
+// operations that are *only* meaningful mid-deserialisation.
+/**
+ * Keys the codec-only operations on `Workbook` and `Worksheet` (see `WorkbookInternals` /
+ * `WorksheetInternals`, declared beside their classes).
+ */
+export const INTERNAL = Symbol('ts-xlsx codec channel');
+/**
+ * Keys a `Cell`'s link to a named cell style — its OOXML `xfId`. A single hidden property rather than
+ * a channel object, so it stays a prototype accessor: cells are the one model class allocated in the
+ * millions, and a per-instance internals object would be a real cost for state most cells never carry.
+ */
+export const NAMED_STYLE_ID = Symbol('ts-xlsx named style link');

package/dist/core/merge.d.ts

@@ -0,0 +1,13 @@
+/** A merged region as inclusive 1-based grid bounds. */
+export interface MergeRect {
+    readonly top: number;
+    readonly left: number;
+    readonly bottom: number;
+    readonly right: number;
+}
+/** Whether two inclusive grid rectangles share at least one cell. */
+export declare function rectsOverlap(a: MergeRect, b: MergeRect): boolean;
+/** Decode an OOXML `sqref` (one or more space-separated ranges) into containment rectangles. A whole
+ * column or row leaves one axis unbounded, so its missing edges open to `Infinity` rather than
+ * clamping — a cell anywhere down the column still resolves inside it. */
+export declare function decodeSqrefRects(sqref: string): MergeRect[];

package/dist/core/merge.js

@@ -0,0 +1,26 @@
+// Inclusive grid rectangles and the geometry a worksheet uses to reason about merged regions and the
+// `sqref` ranges that overlays (data validations, conditional formats) apply to: overlap detection and
+// decoding an OOXML `sqref` into containment rectangles.
+import { decodeRange } from "./address.js";
+/** Whether two inclusive grid rectangles share at least one cell. */
+export function rectsOverlap(a, b) {
+    return a.left <= b.right && b.left <= a.right && a.top <= b.bottom && b.top <= a.bottom;
+}
+/** Decode an OOXML `sqref` (one or more space-separated ranges) into containment rectangles. A whole
+ * column or row leaves one axis unbounded, so its missing edges open to `Infinity` rather than
+ * clamping — a cell anywhere down the column still resolves inside it. */
+export function decodeSqrefRects(sqref) {
+    const rects = [];
+    for (const part of sqref.split(/\s+/)) {
+        if (part === '')
+            continue;
+        const { top, left, bottom, right } = decodeRange(part);
+        rects.push({
+            top: top ?? 1,
+            left: left ?? 1,
+            bottom: bottom ?? Infinity,
+            right: right ?? Infinity,
+        });
+    }
+    return rects;
+}

package/dist/core/modern-functions.d.ts

@@ -0,0 +1 @@
+export declare const MODERN_FUNCTIONS: ReadonlySet<string>;

package/dist/core/modern-functions.js

@@ -0,0 +1,165 @@
+// The post-2007 functions Excel persists with an `_xlfn.` prefix, keyed by their uppercased name.
+// OOXML froze its function grammar around Excel 2007; everything Microsoft added since is unknown to
+// older readers under its bare name, so the writer stores it prefixed and the reader strips the prefix
+// back — the mangling in `formula.ts` is the single place that applies and removes it. That mangler
+// treats '.' as part of a function name, so both the plain modern functions and the dotted 2010
+// statistical rename family below are matched as whole names and prefixed.
+export const MODERN_FUNCTIONS = new Set([
+    // Dynamic arrays (Excel 365)
+    'FILTER',
+    'SORT',
+    'SORTBY',
+    'UNIQUE',
+    'SEQUENCE',
+    'RANDARRAY',
+    'XLOOKUP',
+    'XMATCH',
+    // LAMBDA and its helpers
+    'LAMBDA',
+    'LET',
+    'BYROW',
+    'BYCOL',
+    'MAKEARRAY',
+    'MAP',
+    'REDUCE',
+    'SCAN',
+    'ISOMITTED',
+    // Array shaping (Excel 365)
+    'VSTACK',
+    'HSTACK',
+    'TOROW',
+    'TOCOL',
+    'WRAPROWS',
+    'WRAPCOLS',
+    'TAKE',
+    'DROP',
+    'EXPAND',
+    'CHOOSEROWS',
+    'CHOOSECOLS',
+    // Text (Excel 2019 / 365)
+    'TEXTJOIN',
+    'CONCAT',
+    'TEXTBEFORE',
+    'TEXTAFTER',
+    'TEXTSPLIT',
+    'ARRAYTOTEXT',
+    'VALUETOTEXT',
+    // Logical and conditional aggregation (Excel 2016 / 2019)
+    'IFS',
+    'SWITCH',
+    'MAXIFS',
+    'MINIFS',
+    // Other bare-name functions added after the frozen grammar (Excel 2010 / 2013) — trigonometric,
+    // bitwise, engineering, information, and math/financial additions. Their names carry no '.', so
+    // they need no tokenizer work; they simply have to be recognised as modern to earn the prefix.
+    'AGGREGATE',
+    'ACOT',
+    'ACOTH',
+    'COT',
+    'COTH',
+    'CSC',
+    'CSCH',
+    'SEC',
+    'SECH',
+    'ARABIC',
+    'BASE',
+    'DECIMAL',
+    'COMBINA',
+    'PERMUTATIONA',
+    'GAMMA',
+    'GAUSS',
+    'PHI',
+    'MUNIT',
+    'BITAND',
+    'BITOR',
+    'BITXOR',
+    'BITLSHIFT',
+    'BITRSHIFT',
+    'IMCOSH',
+    'IMCOT',
+    'IMCSC',
+    'IMCSCH',
+    'IMSEC',
+    'IMSECH',
+    'IMSINH',
+    'IMTAN',
+    'DAYS',
+    'ISOWEEKNUM',
+    'IFNA',
+    'NUMBERVALUE',
+    'SHEET',
+    'SHEETS',
+    'FORMULATEXT',
+    'ISFORMULA',
+    'ENCODEURL',
+    'WEBSERVICE',
+    'FILTERXML',
+    'UNICHAR',
+    'UNICODE',
+    'XOR',
+    'PDURATION',
+    'RRI',
+    // The Excel 2010 statistical-consistency rename family and the handful of other post-2007
+    // functions whose canonical names contain a '.'. They carry the same `_xlfn.` prefix; the whole
+    // dotted name is stored, e.g. `_xlfn.NORM.DIST`, `_xlfn.T.DIST.2T`.
+    'BETA.DIST',
+    'BETA.INV',
+    'BINOM.DIST',
+    'BINOM.DIST.RANGE',
+    'BINOM.INV',
+    'CHISQ.DIST',
+    'CHISQ.DIST.RT',
+    'CHISQ.INV',
+    'CHISQ.INV.RT',
+    'CHISQ.TEST',
+    'CONFIDENCE.NORM',
+    'CONFIDENCE.T',
+    'COVARIANCE.P',
+    'COVARIANCE.S',
+    'EXPON.DIST',
+    'F.DIST',
+    'F.DIST.RT',
+    'F.INV',
+    'F.INV.RT',
+    'F.TEST',
+    'GAMMA.DIST',
+    'GAMMA.INV',
+    'GAMMALN.PRECISE',
+    'HYPGEOM.DIST',
+    'LOGNORM.DIST',
+    'LOGNORM.INV',
+    'MODE.MULT',
+    'MODE.SNGL',
+    'NEGBINOM.DIST',
+    'NORM.DIST',
+    'NORM.INV',
+    'NORM.S.DIST',
+    'NORM.S.INV',
+    'PERCENTILE.EXC',
+    'PERCENTILE.INC',
+    'PERCENTRANK.EXC',
+    'PERCENTRANK.INC',
+    'POISSON.DIST',
+    'QUARTILE.EXC',
+    'QUARTILE.INC',
+    'RANK.AVG',
+    'RANK.EQ',
+    'SKEW.P',
+    'STDEV.P',
+    'STDEV.S',
+    'T.DIST',
+    'T.DIST.2T',
+    'T.DIST.RT',
+    'T.INV',
+    'T.INV.2T',
+    'T.TEST',
+    'VAR.P',
+    'VAR.S',
+    'WEIBULL.DIST',
+    'Z.TEST',
+    'CEILING.PRECISE',
+    'FLOOR.PRECISE',
+    'ISO.CEILING',
+    'ERF.PRECISE',
+    'ERFC.PRECISE',
+]);