@shbernal/ts-xlsx 2.1.0 → 3.0.0

package/dist/core/page-setup.d.ts

@@ -1,3 +1,4 @@
+import type { AssertNever } from './internal.ts';
 /**
  * Paper orientation, as `<pageSetup orientation>` carries it.
  *
@@ -7,11 +8,11 @@
  */
 export type PageOrientation = 'portrait' | 'landscape';
 /** Narrow a raw `<pageSetup orientation>` token to a known {@link PageOrientation}. */
-export declare function isPageOrientation(value: string): value is PageOrientation;
+export declare const isPageOrientation: (value: string) => value is PageOrientation;
 /** The order pages are numbered and printed in across a sheet wider and taller than one page. */
 export type PageOrder = 'downThenOver' | 'overThenDown';
 /** Narrow a raw `<pageSetup pageOrder>` token to a known {@link PageOrder}. */
-export declare function isPageOrder(value: string): value is PageOrder;
+export declare const isPageOrder: (value: string) => value is PageOrder;
 /**
  * Print-scaling and orientation settings. These map onto two OOXML elements: `fitToPage` is the
  * `<pageSetUpPr>` flag (a `<sheetPr>` child) that switches Excel from fixed-zoom to fit-to-page
@@ -47,6 +48,61 @@ export interface PageSetup {
      */
     printerSettings?: Uint8Array;
 }
+/**
+ * How one `<pageSetup>` attribute encodes: which model key it is and what kind of value it carries.
+ *
+ * Format-blind on purpose, the same way {@link AlignmentFacet} is: `PageSetup` is a core type and
+ * the layering gate forbids core importing a serialisation, so the table states what an attribute
+ * *is* and each codec supplies the reading and the writing off the `kind`. The OOXML attribute name
+ * is the model key throughout, so it is not restated.
+ */
+export type PageSetupFacet = {
+    readonly key: 'paperSize' | 'scale' | 'fitToWidth' | 'fitToHeight';
+    /** A non-negative integer: a page count, a percentage, or a paper-size id. */
+    readonly kind: 'count';
+} | {
+    readonly key: 'pageOrder' | 'orientation';
+    readonly kind: 'token';
+    /** The enumeration guard, and what to call it in the error when a value fails it. */
+    readonly isValid: (value: string) => boolean;
+    readonly label: string;
+};
+/**
+ * The six `<pageSetup>` attributes, declared once, in CT_PageSetup order. Both directions key off
+ * this list, so an attribute written but not read (it survives a re-write and vanishes on load) or
+ * read but not written is a compile error rather than something a reviewer has to notice.
+ */
+export declare const PAGE_SETUP_FACETS: readonly [{
+    readonly key: 'paperSize';
+    readonly kind: 'count';
+}, {
+    readonly key: 'scale';
+    readonly kind: 'count';
+}, {
+    readonly key: 'fitToWidth';
+    readonly kind: 'count';
+}, {
+    readonly key: 'fitToHeight';
+    readonly kind: 'count';
+}, {
+    readonly key: 'pageOrder';
+    readonly kind: 'token';
+    readonly isValid: (value: string) => value is PageOrder;
+    readonly label: 'page order';
+}, {
+    readonly key: 'orientation';
+    readonly kind: 'token';
+    readonly isValid: (value: string) => value is PageOrientation;
+    readonly label: 'page orientation';
+}];
+/**
+ * Compile-time proof that {@link PAGE_SETUP_FACETS} covers every `<pageSetup>` attribute.
+ *
+ * `fitToPage` and `printerSettings` are excluded because neither is one: `fitToPage` is a
+ * `<sheetPr>` child's flag and `printerSettings` is the blob behind an `r:id`, so both are written
+ * and read somewhere else entirely and a table entry for them would describe nothing.
+ */
+export type EveryPageSetupFacetIsDeclared = AssertNever<Exclude<keyof PageSetup, 'fitToPage' | 'printerSettings' | (typeof PAGE_SETUP_FACETS)[number]['key']>>;
 /**
  * Print-toggle flags from the `<printOptions>` element. Each maps to a boolean OOXML attribute that
  * defaults false, except `gridLinesSet`, which defaults true and gates whether `gridLines` is
@@ -65,6 +121,11 @@ export interface PrintOptions {
     /** Whether the `gridLines` flag is authoritative; when `false`, Excel ignores `gridLines`. */
     gridLinesSet?: boolean;
 }
+/** The `<printOptions>` flags, in CT_PrintOptions attribute order. Each is a plain OOXML boolean, so
+ * the list is the whole of what either direction needs to know. */
+export declare const PRINT_OPTION_FLAGS: readonly ["horizontalCentered", "verticalCentered", "headings", "gridLines", "gridLinesSet"];
+/** Compile-time proof that {@link PRINT_OPTION_FLAGS} covers every {@link PrintOptions} flag. */
+export type EveryPrintOptionFlagIsDeclared = AssertNever<Exclude<keyof PrintOptions, (typeof PRINT_OPTION_FLAGS)[number]>>;
 /**
  * A manual page break (`<brk>`). For a row break, `id` is the row the layout splits *before*; for a
  * column break it is the column. `max` bounds the break's extent across the other axis (Excel writes
@@ -92,6 +153,10 @@ export interface PageMargins {
     header?: number;
     footer?: number;
 }
+/** The `<pageMargins>` sides, in the order CT_PageMargins declares them. */
+export declare const MARGIN_SIDES: readonly ["left", "right", "top", "bottom", "header", "footer"];
+/** Compile-time proof that {@link MARGIN_SIDES} covers every {@link PageMargins} side. */
+export type EveryMarginSideIsDeclared = AssertNever<Exclude<keyof PageMargins, (typeof MARGIN_SIDES)[number]>>;
 /**
  * Page header/footer text, one string per page class. Excel only honours the even- and
  * first-page variants when the writer also sets the gating flags (`differentOddEven`,
@@ -106,3 +171,8 @@ export interface HeaderFooter {
     firstHeader?: string;
     firstFooter?: string;
 }
+/** The `<headerFooter>` children, in CT_HeaderFooter child order. The element name is the model key
+ * throughout, so one list serves the reader's capture, the reader's commit, and the writer. */
+export declare const HEADER_FOOTER_ELEMENTS: readonly ["oddHeader", "oddFooter", "evenHeader", "evenFooter", "firstHeader", "firstFooter"];
+/** Compile-time proof that {@link HEADER_FOOTER_ELEMENTS} covers every {@link HeaderFooter} slot. */
+export type EveryHeaderFooterElementIsDeclared = AssertNever<Exclude<keyof HeaderFooter, (typeof HEADER_FOOTER_ELEMENTS)[number]>>;

package/dist/core/page-setup.js

@@ -1,8 +1,34 @@
-const PAGE_ORIENTATIONS = { portrait: true, landscape: true };
-export function isPageOrientation(value) {
-    return Object.hasOwn(PAGE_ORIENTATIONS, value);
-}
-const PAGE_ORDERS = { downThenOver: true, overThenDown: true };
-export function isPageOrder(value) {
-    return Object.hasOwn(PAGE_ORDERS, value);
-}
+import { tokenSet } from '../token-set.js';
+export const isPageOrientation = tokenSet({ portrait: true, landscape: true });
+export const isPageOrder = tokenSet({ downThenOver: true, overThenDown: true });
+export const PAGE_SETUP_FACETS = [
+    { key: 'paperSize', kind: 'count' },
+    { key: 'scale', kind: 'count' },
+    { key: 'fitToWidth', kind: 'count' },
+    { key: 'fitToHeight', kind: 'count' },
+    { key: 'pageOrder', kind: 'token', isValid: isPageOrder, label: 'page order' },
+    { key: 'orientation', kind: 'token', isValid: isPageOrientation, label: 'page orientation' },
+];
+export const PRINT_OPTION_FLAGS = [
+    'horizontalCentered',
+    'verticalCentered',
+    'headings',
+    'gridLines',
+    'gridLinesSet',
+];
+export const MARGIN_SIDES = [
+    'left',
+    'right',
+    'top',
+    'bottom',
+    'header',
+    'footer',
+];
+export const HEADER_FOOTER_ELEMENTS = [
+    'oddHeader',
+    'oddFooter',
+    'evenHeader',
+    'evenFooter',
+    'firstHeader',
+    'firstFooter',
+];

package/dist/core/pivot-table.d.ts

@@ -18,7 +18,7 @@ export interface ParsedPivotField {
  * `unknown` covers a `type` the file declares that is none of these. */
 export type PivotSourceKind = 'worksheet' | 'external' | 'consolidation' | 'scenario' | 'unknown';
 /** Narrow a raw `<cacheSource type>` token to a {@link PivotSourceKind} a file may declare. */
-export declare function isDeclarablePivotSourceKind(value: string): value is Exclude<PivotSourceKind, 'unknown'>;
+export declare const isDeclarablePivotSourceKind: (value: string) => value is "consolidation" | "external" | "scenario" | "worksheet";
 /** Where a pivot cache draws its rows from. {@link kind} names the source type; {@link sheet} and
  * {@link ref} locate the range only when it is `worksheet` and are empty strings otherwise, so a
  * consumer can tell a genuinely non-worksheet source apart from a worksheet source that failed to

package/dist/core/pivot-table.js

@@ -1,4 +1,5 @@
 import { AuthoringError, InternalError } from '../errors.js';
+import { tokenSet } from '../token-set.js';
 import { encodeAddress } from './address.js';
 import { isErrorValue, isFormulaValue, isHyperlinkValue, isRichTextValue, isSharedFormulaValue, richTextToPlain, } from './value.js';
 const PIVOT_METRICS = {
@@ -14,23 +15,18 @@ const PIVOT_METRICS = {
     var: true,
     varp: true,
 };
-function isPivotMetric(value) {
-    return Object.hasOwn(PIVOT_METRICS, value);
-}
+const isPivotMetric = tokenSet(PIVOT_METRICS);
 export function pivotMetricFromSubtotal(subtotal) {
     if (subtotal === undefined)
         return 'sum';
     return isPivotMetric(subtotal) ? subtotal : 'sum';
 }
-const DECLARABLE_PIVOT_SOURCE_KINDS = {
+export const isDeclarablePivotSourceKind = tokenSet({
     worksheet: true,
     external: true,
     consolidation: true,
     scenario: true,
-};
-export function isDeclarablePivotSourceKind(value) {
-    return Object.hasOwn(DECLARABLE_PIVOT_SOURCE_KINDS, value);
-}
+});
 const BLANK = { kind: 'blank' };
 export class PivotTable {
     metric;

package/dist/core/row.d.ts

@@ -1,9 +1,10 @@
+import { AxisHandle } from './axis-handle.ts';
 import type { Cell } from './cell.ts';
 import { type AssertNever } from './internal.ts';
 import type { Fill } from './style.ts';
 import type { CellValue } from './value.ts';
 import type { RowProperties, Worksheet } from './worksheet.ts';
-export declare class Row {
+export declare class Row extends AxisHandle<RowProperties> {
     #private;
     /** 1-based row number. Fixed for this handle's lifetime. */
     readonly number: number;
@@ -16,6 +17,8 @@ export declare class Row {
      * formatted, and they create the record on first write.
      */
     get properties(): Readonly<RowProperties> | undefined;
+    protected propertiesOf(): RowProperties | undefined;
+    protected ensureProperties(): RowProperties;
     /**
      * Row height in points; `undefined` leaves the sheet default in force.
      *

package/dist/core/row.js

@@ -1,45 +1,53 @@
 import { assertRowInBounds, columnToNumber, encodeAddress } from './address.js';
+import { AxisHandle } from './axis-handle.js';
 import { INTERNAL } from './internal.js';
-export class Row {
+export class Row extends AxisHandle {
     #sheet;
     number;
     constructor(sheet, number) {
+        super();
         assertRowInBounds(number);
         this.#sheet = sheet;
         this.number = number;
     }
     get properties() {
+        return this.propertiesOf();
+    }
+    propertiesOf() {
         return this.#sheet[INTERNAL].rowPropertiesOf(this.number);
     }
+    ensureProperties() {
+        return this.#sheet[INTERNAL].ensureRowProperties(this.number);
+    }
     get height() {
-        return this.#read('height');
+        return this.read('height');
     }
     set height(height) {
-        this.#write('height', height);
+        this.write('height', height);
     }
     get hidden() {
-        return this.#read('hidden');
+        return this.read('hidden');
     }
     set hidden(hidden) {
-        this.#write('hidden', hidden);
+        this.write('hidden', hidden);
     }
     get outlineLevel() {
-        return this.#read('outlineLevel');
+        return this.read('outlineLevel');
     }
     set outlineLevel(outlineLevel) {
-        this.#write('outlineLevel', outlineLevel);
+        this.write('outlineLevel', outlineLevel);
     }
     get collapsed() {
-        return this.#read('collapsed');
+        return this.read('collapsed');
     }
     set collapsed(collapsed) {
-        this.#write('collapsed', collapsed);
+        this.write('collapsed', collapsed);
     }
     get fill() {
-        return this.#read('fill');
+        return this.read('fill');
     }
     set fill(fill) {
-        this.#write('fill', fill);
+        this.write('fill', fill);
     }
     getCell(column) {
         const index = typeof column === 'number' ? column : columnToNumber(column);
@@ -60,16 +68,4 @@ export class Row {
                 this.getCell(index + 1).value = value;
         });
     }
-    #read(key) {
-        return this.#sheet[INTERNAL].rowPropertiesOf(this.number)?.[key];
-    }
-    #write(key, value) {
-        if (value === undefined) {
-            const properties = this.#sheet[INTERNAL].rowPropertiesOf(this.number);
-            if (properties !== undefined)
-                delete properties[key];
-            return;
-        }
-        this.#sheet[INTERNAL].ensureRowProperties(this.number)[key] = value;
-    }
 }

package/dist/core/style.d.ts

@@ -1,7 +1,8 @@
+import type { AssertNever } from './internal.ts';
 /** Underline can be a plain flag or one of Excel's named underline styles. */
 export type UnderlineStyle = boolean | 'none' | 'single' | 'double' | 'singleAccounting' | 'doubleAccounting';
 /** Narrow a raw `<u val>` token to a named {@link UnderlineStyle} (the non-boolean members). */
-export declare function isNamedUnderlineStyle(value: string): value is Exclude<UnderlineStyle, boolean>;
+export declare const isNamedUnderlineStyle: (value: string) => value is "double" | "doubleAccounting" | "none" | "single" | "singleAccounting";
 /** A colour, expressed as an ARGB hex string (`"FF0000FF"`) or an indexed theme colour. */
 export interface Color {
     /** 8-digit ARGB hex, uppercase, no leading `#`. */
@@ -41,7 +42,7 @@ export declare function parseArgb(value: string): string | undefined;
  */
 export type FillPatternType = 'none' | 'solid' | 'gray125' | 'darkGray' | 'mediumGray' | 'lightGray' | 'gray0625' | 'darkHorizontal' | 'darkVertical' | 'darkDown' | 'darkUp' | 'darkGrid' | 'darkTrellis' | 'lightHorizontal' | 'lightVertical' | 'lightDown' | 'lightUp' | 'lightGrid' | 'lightTrellis';
 /** Narrow a raw `<patternFill patternType>` token to a known {@link FillPatternType}. */
-export declare function isFillPatternType(value: string): value is FillPatternType;
+export declare const isFillPatternType: (value: string) => value is FillPatternType;
 /**
  * A pattern fill. For a `solid` fill the visible colour is the pattern *foreground*
  * (`fgColor`), OOXML's counter-intuitive rule, while `bgColor` is the automatic
@@ -84,7 +85,7 @@ export type Fill = PatternFill | GradientFill;
  */
 export type BorderStyle = 'thin' | 'medium' | 'thick' | 'dashed' | 'dotted' | 'double' | 'hair' | 'mediumDashed' | 'dashDot' | 'mediumDashDot' | 'dashDotDot' | 'mediumDashDotDot' | 'slantDashDot';
 /** Narrow a raw border-edge `style` attribute to a known {@link BorderStyle}. */
-export declare function isBorderStyle(value: string): value is BorderStyle;
+export declare const isBorderStyle: (value: string) => value is BorderStyle;
 /** One edge of a cell border: its line style, and optionally the line colour. */
 export interface BorderEdge {
     readonly style: BorderStyle;
@@ -108,12 +109,12 @@ export interface Border {
 /** Vertical alignment of a font relative to the baseline (super/subscript). */
 export type FontVerticalAlignment = 'superscript' | 'subscript';
 /** Narrow a raw `<vertAlign val>` token to a known {@link FontVerticalAlignment}. */
-export declare function isFontVerticalAlignment(value: string): value is FontVerticalAlignment;
+export declare const isFontVerticalAlignment: (value: string) => value is FontVerticalAlignment;
 /** The theme-font role a `<scheme val>` names: `"minor"`/`"major"` bind the font to whichever
  * face the workbook theme assigns that role, `"none"` leaves it a literal, unbound face. */
 export type FontScheme = 'minor' | 'major' | 'none';
 /** Narrow a raw `<scheme val>` token to a known {@link FontScheme}. */
-export declare function isFontScheme(value: string): value is FontScheme;
+export declare const isFontScheme: (value: string) => value is FontScheme;
 /** A font, as it applies to a cell or a single rich-text run. Every facet is optional and
  * independent, like {@link Border}/{@link Alignment}/{@link Protection}: a font sets only the
  * facets it overrides (Excel's own default font backs the rest), so no consumer ever holds every
@@ -137,12 +138,12 @@ export interface Font {
  *  back as no explicit horizontal alignment. */
 export type HorizontalAlignment = 'general' | 'left' | 'center' | 'right' | 'fill' | 'justify' | 'centerContinuous' | 'distributed';
 /** Narrow a raw `<alignment horizontal>` token to a known {@link HorizontalAlignment}. */
-export declare function isHorizontalAlignment(value: string): value is HorizontalAlignment;
+export declare const isHorizontalAlignment: (value: string) => value is HorizontalAlignment;
 /** How a cell's content sits vertically within its bounds, as OOXML's `ST_VerticalAlignment`
  *  enumerates it. */
 export type VerticalAlignment = 'top' | 'center' | 'bottom' | 'justify' | 'distributed';
 /** Narrow a raw `<alignment vertical>` token to a known {@link VerticalAlignment}. */
-export declare function isVerticalAlignment(value: string): value is VerticalAlignment;
+export declare const isVerticalAlignment: (value: string) => value is VerticalAlignment;
 /**
  * A cell's alignment. Every facet is optional and independent; an absent facet means the cell
  * takes Excel's default for it. The boolean flags default to off, so a cell that never enabled
@@ -158,6 +159,49 @@ export interface Alignment {
     readonly shrinkToFit?: boolean;
     readonly readingOrder?: number;
 }
+/**
+ * How one `<alignment>` facet encodes: which model key it is, what kind of value it carries, and the
+ * value that means "default", which the writer omits and the reader drops.
+ *
+ * Format-blind on purpose. `Alignment` is a core type and the layering gate forbids core importing a
+ * serialisation, so the table states what a facet *is* and each codec supplies the reading and the
+ * writing off the `kind`. That is where {@link SHEET_PROTECTION_FLAGS} sits and how it is consumed,
+ * and it is the shape the BIFF12 codec would want if alignment ever reaches it.
+ *
+ * The OOXML attribute name is the model key for all seven facets, so it is not restated here: a
+ * second list that is always identical is a second list to keep in step. A future facet whose
+ * attribute differs from its key is the one that would have to add the field.
+ */
+export type AlignmentFacet = {
+    readonly key: 'horizontal' | 'vertical';
+    readonly kind: 'token';
+    /** The enumeration guard, and what to call it in the error when a value fails it. */
+    readonly isValid: (value: string) => boolean;
+    readonly label: string;
+    /** The token that means the OOXML default, expressed by omitting the attribute. */
+    readonly omit?: string;
+} | {
+    readonly key: 'textRotation' | 'indent' | 'readingOrder';
+    readonly kind: 'number';
+} | {
+    readonly key: 'wrapText' | 'shrinkToFit';
+    readonly kind: 'flag';
+};
+/**
+ * The seven `<alignment>` facets, declared once. Both directions key off this list, so a facet
+ * written but not read (it survives a re-write and vanishes on load) or read but not written (the
+ * reverse) is no longer something a reviewer has to notice: {@link EveryAlignmentFacetIsDeclared}
+ * makes a facet added to {@link Alignment} and forgotten here a compile error.
+ *
+ * In ECMA-376 CT_CellAlignment order, which is the order the writer emits.
+ */
+export declare const ALIGNMENT_FACETS: readonly AlignmentFacet[];
+/**
+ * Compile-time proof that {@link ALIGNMENT_FACETS} covers every {@link Alignment} facet. A facet
+ * added to the type without a table entry resolves this to that facet's name, which does not satisfy
+ * `never`, so the error names what is missing.
+ */
+export type EveryAlignmentFacetIsDeclared = AssertNever<Exclude<keyof Alignment, (typeof ALIGNMENT_FACETS)[number]['key']>>;
 /**
  * A cell's protection state, enforced only when the worksheet itself is protected. The flags
  * do nothing on an unprotected sheet. `locked` defaults to TRUE in OOXML (every cell is locked

package/dist/core/style.js

@@ -1,19 +1,17 @@
-const NAMED_UNDERLINE_STYLES = {
+import { tokenSet } from '../token-set.js';
+export const isNamedUnderlineStyle = tokenSet({
     none: true,
     single: true,
     double: true,
     singleAccounting: true,
     doubleAccounting: true,
-};
-export function isNamedUnderlineStyle(value) {
-    return Object.hasOwn(NAMED_UNDERLINE_STYLES, value);
-}
+});
 export function parseArgb(value) {
     const hex = value.startsWith('#') ? value.slice(1) : value;
     const argb = hex.length === 6 ? `FF${hex}` : hex;
     return /^[0-9a-fA-F]{8}$/.test(argb) ? argb : undefined;
 }
-const FILL_PATTERN_TYPES = {
+export const isFillPatternType = tokenSet({
     none: true,
     solid: true,
     gray125: true,
@@ -33,11 +31,8 @@ const FILL_PATTERN_TYPES = {
     lightUp: true,
     lightGrid: true,
     lightTrellis: true,
-};
-export function isFillPatternType(value) {
-    return Object.hasOwn(FILL_PATTERN_TYPES, value);
-}
-const BORDER_STYLES = {
+});
+export const isBorderStyle = tokenSet({
     thin: true,
     medium: true,
     thick: true,
@@ -51,22 +46,13 @@ const BORDER_STYLES = {
     dashDotDot: true,
     mediumDashDotDot: true,
     slantDashDot: true,
-};
-export function isBorderStyle(value) {
-    return Object.hasOwn(BORDER_STYLES, value);
-}
-const FONT_VERTICAL_ALIGNMENTS = {
+});
+export const isFontVerticalAlignment = tokenSet({
     superscript: true,
     subscript: true,
-};
-export function isFontVerticalAlignment(value) {
-    return Object.hasOwn(FONT_VERTICAL_ALIGNMENTS, value);
-}
-const FONT_SCHEMES = { minor: true, major: true, none: true };
-export function isFontScheme(value) {
-    return Object.hasOwn(FONT_SCHEMES, value);
-}
-const HORIZONTAL_ALIGNMENTS = {
+});
+export const isFontScheme = tokenSet({ minor: true, major: true, none: true });
+export const isHorizontalAlignment = tokenSet({
     general: true,
     left: true,
     center: true,
@@ -75,20 +61,29 @@ const HORIZONTAL_ALIGNMENTS = {
     justify: true,
     centerContinuous: true,
     distributed: true,
-};
-export function isHorizontalAlignment(value) {
-    return Object.hasOwn(HORIZONTAL_ALIGNMENTS, value);
-}
-const VERTICAL_ALIGNMENTS = {
+});
+export const isVerticalAlignment = tokenSet({
     top: true,
     center: true,
     bottom: true,
     justify: true,
     distributed: true,
-};
-export function isVerticalAlignment(value) {
-    return Object.hasOwn(VERTICAL_ALIGNMENTS, value);
-}
+});
+export const ALIGNMENT_FACETS = [
+    {
+        key: 'horizontal',
+        kind: 'token',
+        isValid: isHorizontalAlignment,
+        label: 'horizontal alignment',
+        omit: 'general',
+    },
+    { key: 'vertical', kind: 'token', isValid: isVerticalAlignment, label: 'vertical alignment' },
+    { key: 'textRotation', kind: 'number' },
+    { key: 'wrapText', kind: 'flag' },
+    { key: 'indent', kind: 'number' },
+    { key: 'shrinkToFit', kind: 'flag' },
+    { key: 'readingOrder', kind: 'number' },
+];
 const CELL_STYLE_FACET_KEYS = {
     fill: true,
     numFmt: true,

package/dist/core/table.d.ts

@@ -75,7 +75,7 @@ export declare const TOTALS_ROW_SUBTOTAL_CODE: Readonly<Partial<Record<TotalsRow
  */
 export type TotalsRowFunction = 'average' | 'countNums' | 'count' | 'max' | 'min' | 'stdDev' | 'sum' | 'var' | 'custom' | 'none';
 /** Narrow a raw `totalsRowFunction` attribute to a known {@link TotalsRowFunction}. */
-export declare function isTotalsRowFunction(value: string): value is TotalsRowFunction;
+export declare const isTotalsRowFunction: (value: string) => value is TotalsRowFunction;
 /** One column of a table: a header name and its optional totals-row behaviour. */
 export interface TableColumn {
     /** The column's header/display name. Must be unique within the table (case-insensitively):

package/dist/core/table.js

@@ -1,4 +1,5 @@
 import { AuthoringError } from '../errors.js';
+import { tokenSet } from '../token-set.js';
 import { decodeCellRef, encodeAddress } from './address.js';
 import { isDeletedSpan, shiftIndex } from './grid-shift.js';
 function cloneStyleInfo(style) {
@@ -25,7 +26,7 @@ export const TOTALS_ROW_SUBTOTAL_CODE = {
     sum: 109,
     var: 110,
 };
-const TOTALS_ROW_FUNCTIONS = {
+export const isTotalsRowFunction = tokenSet({
     average: true,
     countNums: true,
     count: true,
@@ -36,10 +37,7 @@ const TOTALS_ROW_FUNCTIONS = {
     var: true,
     custom: true,
     none: true,
-};
-export function isTotalsRowFunction(value) {
-    return Object.hasOwn(TOTALS_ROW_FUNCTIONS, value);
-}
+});
 const IDENTIFIER = /^[\p{L}\\_][\p{L}\p{N}._]*$/u;
 function disambiguateColumnNames(columns) {
     const seen = new Set();

package/dist/core/used-extent.d.ts

@@ -0,0 +1,44 @@
+import { type Cell } from './cell.ts';
+import type { MergeRect } from './merge.ts';
+/**
+ * The sheet storage an extent reads. Held by reference and never reassigned, so the extent always
+ * sees the live grid; the value types are irrelevant to it, only which keys are present.
+ */
+export interface ExtentStorage {
+    readonly rows: ReadonlyMap<number, ReadonlyMap<number, Cell>>;
+    readonly rowProperties: ReadonlyMap<number, unknown>;
+    readonly columns: ReadonlyMap<number, unknown>;
+    readonly mergeRects: readonly MergeRect[];
+}
+/**
+ * The last used row and column of a sheet, tracked incrementally. The sheet reports every edit that
+ * can move the grid's outer keys; this turns those reports into the two accessors behind
+ * `Worksheet.rowCount` and `Worksheet.columnCount`.
+ */
+export declare class UsedExtent {
+    #private;
+    constructor(storage: ExtentStorage);
+    /** Note a cell materialised at `(row, col)`. Whether it goes on to carry anything is not this
+     * class's business: the bound is on where a used cell *could* be, and the read confirms it. */
+    noteCell(row: number, col: number): void;
+    /** Note a row that bounds the used range by declaration: one given properties of its own. */
+    noteDeclaredRow(row: number): void;
+    /** Note a column that bounds the used range by declaration: one given properties of its own. */
+    noteDeclaredColumn(col: number): void;
+    /** Note a merged region, which occupies its whole rectangle and so bounds both axes. */
+    noteMerge(rect: MergeRect): void;
+    /**
+     * Report an edit that can pull the grid's outer keys inward: an eviction, a splice, an unmerge, a
+     * row replaced wholesale. The bounds are recomputed once, on the next read, rather than adjusted
+     * here, because finding the *new* maximum after a deletion is the same scan as finding it from
+     * scratch. Appending never invalidates, which is the whole point.
+     */
+    invalidate(): void;
+    /** Report that the grid has been emptied, which puts the bounds at a known zero rather than
+     * stale: nothing is left to scan. */
+    reset(): void;
+    /** The 1-based index of the last row carrying anything, or 0 when the sheet holds nothing. */
+    get lastRow(): number;
+    /** The 1-based index of the last column carrying anything, or 0 when the sheet holds nothing. */
+    get lastColumn(): number;
+}