@shbernal/ts-xlsx 2.1.0 → 3.1.0

package/dist/io/xlsx/read-parts.js

@@ -0,0 +1,252 @@
+import { decodeRange } from '../../core/address.js';
+import { INTERNAL } from '../../core/internal.js';
+import { Workbook } from '../../core/workbook.js';
+import { isAnyRelType } from '../../rel-type.js';
+import { localName } from '../../xml/xml-scan.js';
+import { relAttr } from '../opc/namespaces.js';
+import { extensionOf, resolveRelativePart } from '../opc/part-paths.js';
+import { capturePartClosure, parseRelationshipRecords, readPartRelationships, } from '../opc/read-opc.js';
+import { parseComments } from './comments.js';
+import { drawingHasUnmodeledContent, parseDrawing } from './images.js';
+import { parsePivotTable } from './read-pivot.js';
+import { admitting } from './read-repair.js';
+import { parseTable } from './tables.js';
+import { parseThemeColorScheme, parseThemeFontScheme } from './theme-xml.js';
+import { buildCommentThreads, parsePersons, parseThreadedComments } from './threaded-comments.js';
+export function readSheetComments(sheetRels) {
+    const commentsXml = sheetRels.relatedText('comments');
+    return commentsXml === undefined ? undefined : parseComments(commentsXml);
+}
+export function readWorkbookPersons({ workbook }, workbookRels) {
+    const xml = workbookRels.relatedText('person');
+    if (xml !== undefined)
+        workbook[INTERNAL].restorePersons(parsePersons(xml));
+}
+export function readWorkbookTheme(context, workbookRels) {
+    const { pkg, contentTypeOf, workbook } = context;
+    const entryPath = workbookRels.targetPath('theme');
+    if (entryPath === undefined)
+        return;
+    const parts = capturePartClosure(entryPath, pkg.partText, pkg.partBytes, contentTypeOf);
+    if (parts === undefined)
+        return;
+    const xml = pkg.partText(entryPath) ?? '';
+    workbook[INTERNAL].restoreThemePart({ entryPath, parts }, { colors: parseThemeColorScheme(xml), fonts: parseThemeFontScheme(xml) });
+}
+export function readSheetCommentThreads({ workbook }, sheetRels) {
+    const xml = sheetRels.relatedText('threadedComment');
+    if (xml === undefined)
+        return [];
+    return buildCommentThreads(parseThreadedComments(xml), (id) => workbook.getPerson(id));
+}
+export function readSheetPrinterSettings(sheetRels) {
+    return sheetRels.relatedBytes('printerSettings');
+}
+function internImage(context, mediaPath) {
+    const { workbook, pkg, imageIdByMediaPath } = context;
+    const known = imageIdByMediaPath.get(mediaPath);
+    if (known !== undefined)
+        return known;
+    const bytes = pkg.partBytes(mediaPath);
+    if (bytes === undefined)
+        return undefined;
+    const id = workbook.addImage({ buffer: bytes, extension: extensionOf(mediaPath) });
+    imageIdByMediaPath.set(mediaPath, id);
+    return id;
+}
+export function readSheetImages(context, sheetRels, sheet) {
+    const { partText } = context.pkg;
+    const drawingPath = sheetRels.targetPath('drawing');
+    if (drawingPath === undefined)
+        return;
+    const drawingXml = partText(drawingPath);
+    if (drawingXml === undefined)
+        return;
+    if (drawingHasUnmodeledContent(drawingXml))
+        return;
+    const drawingRels = readPartRelationships(drawingPath, partText);
+    for (const anchor of parseDrawing(drawingXml)) {
+        const embedded = drawingRels.byId(anchor.embed);
+        if (embedded === undefined)
+            continue;
+        const mediaPath = drawingRels.pathOf(embedded.target);
+        const id = internImage(context, mediaPath);
+        if (id === undefined)
+            continue;
+        const rot = anchor.rotation !== undefined ? { rotation: anchor.rotation } : {};
+        if (anchor.to !== undefined) {
+            const mode = anchor.editAs !== undefined ? { editAs: anchor.editAs } : {};
+            sheet.addImageAnchor(id, { from: anchor.from, to: anchor.to, ...mode, ...rot });
+        }
+        else if (anchor.ext !== undefined) {
+            sheet.addImageAnchor(id, { from: anchor.from, ext: anchor.ext, ...rot });
+        }
+    }
+}
+export function readSheetBackground(context, sheetRels, sheet) {
+    const mediaPath = sheetRels.targetPath('image');
+    if (mediaPath === undefined)
+        return;
+    const id = internImage(context, mediaPath);
+    if (id !== undefined)
+        sheet.addBackgroundImage(id);
+}
+export function readSheetPreservedReferences(context, sheetRels, referenceRelIds, sheet) {
+    const { contentTypeOf } = context;
+    const { partText, partBytes } = context.pkg;
+    const capture = (element, relType, target) => {
+        const entryPath = sheetRels.pathOf(target);
+        const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
+        if (parts !== undefined)
+            sheet[INTERNAL].addPreservedReference({ element, relType, entryPath, parts });
+    };
+    const referenceElements = sheet.images.length === 0 ? ['drawing', 'legacyDrawingHF'] : ['legacyDrawingHF'];
+    for (const element of referenceElements) {
+        const relId = referenceRelIds[element];
+        const record = relId === undefined ? undefined : sheetRels.byId(relId);
+        if (record !== undefined && !record.external)
+            capture(element, record.type, record.target);
+    }
+    for (const record of sheetRels.records) {
+        if (record.external)
+            continue;
+        if (isPreservedSheetRelType(record.type))
+            capture(undefined, record.type, record.target);
+    }
+}
+function isPreservedSheetRelType(type) {
+    return isAnyRelType(type, 'pivotTable', 'slicer');
+}
+export function readWorkbookPreservedReferences(context, workbookRels, registrations) {
+    const { contentTypeOf, workbook } = context;
+    const { partText, partBytes } = context.pkg;
+    const { cacheIdByRelId, externalIndexByRelId } = registrations;
+    for (const record of workbookRels.records) {
+        if (record.external || !isPreservedWorkbookRelType(record.type))
+            continue;
+        const entryPath = workbookRels.pathOf(record.target);
+        const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
+        if (parts === undefined)
+            continue;
+        const cacheId = cacheIdByRelId.get(record.id);
+        const externalReferenceIndex = externalIndexByRelId.get(record.id);
+        workbook[INTERNAL].addPreservedReference({
+            relType: record.type,
+            entryPath,
+            parts,
+            ...(cacheId !== undefined ? { pivotCacheId: cacheId } : {}),
+            ...(externalReferenceIndex !== undefined ? { externalReferenceIndex } : {}),
+        });
+    }
+}
+export function readRootPreservedReferences(context) {
+    const { contentTypeOf, workbook } = context;
+    const { partText, partBytes } = context.pkg;
+    const relsXml = partText('_rels/.rels');
+    if (relsXml === undefined)
+        return;
+    for (const record of parseRelationshipRecords(relsXml)) {
+        if (record.external || isRegeneratedRootRelType(record.type))
+            continue;
+        const entryPath = resolveRelativePart('', record.target);
+        const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
+        if (parts === undefined)
+            continue;
+        workbook[INTERNAL].addPreservedRootReference({ relType: record.type, entryPath, parts });
+    }
+}
+function isRegeneratedRootRelType(type) {
+    return isAnyRelType(type, 'officeDocument', 'core-properties', 'extended-properties');
+}
+function isPreservedWorkbookRelType(type) {
+    return isAnyRelType(type, 'pivotCacheDefinition', 'slicerCache', 'vbaProject', 'externalLink');
+}
+export function pivotCacheRegistrationsPass() {
+    const byRelId = new Map();
+    return {
+        handlers: {
+            onOpen(name, attrs, _selfClosing, scope) {
+                if (localName(name) !== 'pivotCache')
+                    return;
+                const relId = relAttr(scope, attrs, 'id');
+                if (relId !== undefined && attrs.cacheId !== undefined)
+                    byRelId.set(relId, attrs.cacheId);
+            },
+        },
+        result: () => byRelId,
+    };
+}
+export function externalReferenceRegistrationsPass() {
+    const byRelId = new Map();
+    let index = 0;
+    return {
+        handlers: {
+            onOpen(name, attrs, _selfClosing, scope) {
+                if (localName(name) !== 'externalReference')
+                    return;
+                const relId = relAttr(scope, attrs, 'id');
+                if (relId !== undefined)
+                    byRelId.set(relId, index++);
+            },
+        },
+        result: () => byRelId,
+    };
+}
+export function worksheetReferencePass() {
+    const relIds = {};
+    return {
+        handlers: {
+            onOpen(name, attrs, _selfClosing, scope) {
+                const local = localName(name);
+                if (local !== 'drawing' && local !== 'legacyDrawingHF')
+                    return;
+                if (relIds[local] !== undefined)
+                    return;
+                const relId = relAttr(scope, attrs, 'id');
+                if (relId !== undefined)
+                    relIds[local] = relId;
+            },
+        },
+        result: () => relIds,
+    };
+}
+export function readSheetTables({ pkg }, sheetRels, sheet) {
+    for (const tablePath of sheetRels.targetPaths('table')) {
+        const tableXml = pkg.partText(tablePath);
+        if (tableXml === undefined)
+            continue;
+        const options = parseTable(tableXml);
+        if (options !== undefined) {
+            admitting(() => {
+                sheet.addTable(options);
+            });
+        }
+    }
+    dropMergesInsideTables(sheet);
+}
+export function readSheetPivotTables({ pkg }, sheetRels, sheet) {
+    const { partText } = pkg;
+    for (const tablePath of sheetRels.targetPaths('pivotTable')) {
+        const tableXml = partText(tablePath);
+        if (tableXml === undefined)
+            continue;
+        const cacheXml = readPartRelationships(tablePath, partText).relatedText('pivotCacheDefinition') ?? '';
+        sheet[INTERNAL].addLoadedPivotTable(parsePivotTable(tableXml, cacheXml));
+    }
+}
+function dropMergesInsideTables(sheet) {
+    const regions = sheet.tables.map((table) => table.region);
+    if (regions.length === 0)
+        return;
+    for (const range of [...sheet.merges]) {
+        const { top, left, bottom, right } = decodeRange(range);
+        if (top === undefined || left === undefined || bottom === undefined || right === undefined)
+            continue;
+        const overlaps = regions.some((region) => left <= region.right &&
+            right >= region.left &&
+            top <= region.bottom &&
+            bottom >= region.top);
+        if (overlaps)
+            sheet.unmergeCells(range);
+    }
+}

package/dist/io/xlsx/read-pivot.js

@@ -1,5 +1,7 @@
 import { isDeclarablePivotSourceKind, pivotMetricFromSubtotal, } from '../../core/pivot-table.js';
-import { localName, numInteger, parseXml } from '../../xml/xml-read.js';
+import { numInteger } from '../../xml/xml-attrs.js';
+import { parseXml } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
 export function parsePivotTable(tableXml, cacheXml) {
     const { fields, source } = parsePivotCacheDefinition(cacheXml);
     const def = parsePivotTableDefinition(tableXml);

package/dist/io/xlsx/read-repair.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A sheet name from a file, rewritten into one the model will accept.
+ *
+ * Excel's own repair, in the order the constraints interact: forbidden characters go first (they
+ * can be anywhere), then the length ceiling, then the apostrophe rule *again*, because truncating
+ * can expose an interior apostrophe at the new edge. An empty result becomes `Sheet{n}`, and a
+ * collision takes a ` (2)` suffix that is itself made to fit inside the 31-character limit.
+ *
+ * @param taken the lower-cased names already in the workbook; sheet names collide
+ *   case-insensitively, which is the comparison `Workbook.getWorksheet` makes.
+ */
+export declare function repairSheetName(name: string, taken: ReadonlySet<string>): string;
+/**
+ * Run a model call that is being handed foreign input, and answer `undefined` where the model
+ * refuses it.
+ *
+ * The three caught types are the three a model method raises *about its argument*: an
+ * `AuthoringError` for a composite that cannot exist, and the native `RangeError` / `SyntaxError`
+ * the taxonomy assigns to a single scalar that is out of range or does not parse. Every one of them
+ * is a statement about the caller, and on this path the caller is a file.
+ *
+ * Nothing else is caught. An `XlsxError` raised by a layer below is a real failure of the read and
+ * keeps its identity; an `InternalError` is a bug of ours and must not be swallowed by a reader
+ * being tolerant about somebody else's file.
+ */
+export declare function admitting<T>(build: () => T): T | undefined;

package/dist/io/xlsx/read-repair.js

@@ -0,0 +1,39 @@
+import { INVALID_SHEET_NAME_CHARS, MAX_SHEET_NAME_LENGTH } from '../../core/limits.js';
+import { AuthoringError } from '../../errors.js';
+const INVALID_SHEET_NAME_CHARS_GLOBAL = new RegExp(INVALID_SHEET_NAME_CHARS.source, 'g');
+export function repairSheetName(name, taken) {
+    const stripped = trimApostrophes(name.replace(INVALID_SHEET_NAME_CHARS_GLOBAL, '')).slice(0, MAX_SHEET_NAME_LENGTH);
+    const base = trimApostrophes(stripped);
+    if (base.length === 0)
+        return firstFree((n) => `Sheet${n}`, taken);
+    if (!taken.has(base.toLowerCase()))
+        return base;
+    return firstFree((n) => withSuffix(base, ` (${n})`), taken, 2);
+}
+function trimApostrophes(name) {
+    return name.replace(/^'+/, '').replace(/'+$/, '');
+}
+function firstFree(candidate, taken, from = 1) {
+    for (let n = from;; n++) {
+        const name = candidate(n);
+        if (!taken.has(name.toLowerCase()))
+            return name;
+    }
+}
+function withSuffix(base, suffix) {
+    const room = MAX_SHEET_NAME_LENGTH - suffix.length;
+    return trimApostrophes(base.slice(0, room)) + suffix;
+}
+export function admitting(build) {
+    try {
+        return build();
+    }
+    catch (error) {
+        if (error instanceof AuthoringError ||
+            error instanceof RangeError ||
+            error instanceof SyntaxError) {
+            return undefined;
+        }
+        throw error;
+    }
+}

package/dist/io/xlsx/{rich-runs.d.ts → read-rich-runs.d.ts}

@@ -1,5 +1,5 @@
 import type { RichTextRun } from '../../core/value.ts';
-import { type XmlAttributes } from '../../xml/xml-read.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
 /**
  * What {@link RunAccumulator.close} did with an element: `'container'` means the `<si>`/`<is>` itself
  * closed and the caller should commit whatever it makes of the gathered runs, the one step the two

package/dist/io/xlsx/{rich-runs.js → read-rich-runs.js}

@@ -1,5 +1,7 @@
-import { decodeSpreadsheetText, TextCapture } from '../../xml/xml-read.js';
-import { applyFontChild } from './read-styles.js';
+import { decodeSpreadsheetText } from '../../xml/xml-attrs.js';
+import { TextCapture } from '../../xml/xml-read.js';
+import {} from '../../xml/xml-scan.js';
+import { applyFontChild } from './font-xml.js';
 export class RunAccumulator {
     #container;
     #readRuns;
@@ -33,12 +35,14 @@ export class RunAccumulator {
         this.#plain = '';
         this.#inRun = false;
         this.#isRich = false;
+        this.#inContainer = false;
+        this.#capture.reset();
     }
     open(local, attrs, selfClosing) {
         switch (local) {
             case this.#container:
-                this.#inContainer = true;
                 this.beginContainer();
+                this.#inContainer = !selfClosing;
                 return true;
             case 'r':
                 if (!this.#readRuns || !this.#inContainer)

package/dist/io/xlsx/read-rows.d.ts

@@ -1,6 +1,6 @@
 import type { CellValue } from '../../core/value.ts';
-import { type ReadXlsxOptions, type XfStyle } from './read.ts';
-export interface ReadSheetRowsOptions extends ReadXlsxOptions {
+import { type ReadPackageOptions, type XfStyle } from './read.ts';
+export interface ReadSheetRowsOptions extends ReadPackageOptions {
     /**
      * Which worksheet to stream: its name, or its 1-based position in the workbook. Defaults to the
      * first sheet.
@@ -11,9 +11,18 @@ export interface ReadSheetRowsOptions extends ReadXlsxOptions {
  * The resolved style facets of a streamed cell: its own `<c s>` cell format, flattened exactly as
  * the buffered reader resolves it. Present only when the cell carries a format; a consumer can copy
  * these straight onto a writer cell to preserve its look through a streaming read→write.
+ *
+ * @unpublished A named commitment this surface is not ready to make. `entries/xlsx.ts` records the
+ * decision: the streaming reader's granular output shapes stay inferred structural types while the
+ * surface settles, so a consumer destructures them and never has to spell them.
  */
 export type StreamedCellStyle = XfStyle;
-/** One non-empty cell in a {@link StreamedRow}. */
+/** One non-empty cell in a {@link StreamedRow}.
+ *
+ * @unpublished A named commitment this surface is not ready to make. `entries/xlsx.ts` records the
+ * decision: the streaming reader's granular output shapes stay inferred structural types while the
+ * surface settles, so a consumer destructures them and never has to spell them.
+ */
 export interface StreamedCell {
     /** 1-based column index. */
     readonly col: number;
@@ -41,6 +50,10 @@ export interface StreamedRow {
  * its rows have not already been consumed, so their order relative to `rows()` never matters. (When
  * rows *are* consumed first, the streaming idiom, the accessors reuse that pass and re-scan
  * nothing.)
+ *
+ * @unpublished A named commitment this surface is not ready to make. `entries/xlsx.ts` records the
+ * decision: the streaming reader's granular output shapes stay inferred structural types while the
+ * surface settles, so a consumer destructures them and never has to spell them.
  */
 export interface StreamedSheet {
     /** The worksheet's declared name, joined from the workbook part. Never a positional placeholder. */
@@ -76,10 +89,10 @@ export declare function readSheetRows(data: Uint8Array, options?: ReadSheetRowsO
  * of walking `readXlsx(data).worksheets`.
  *
  * @param data The raw `.xlsx` bytes.
- * @param options The inflate bound (see {@link ReadXlsxOptions}).
+ * @param options The inflate bound (see {@link ReadPackageOptions}).
  * @throws {UnsupportedFormatError} if the input is not a readable `.xlsx` package (a legacy `.xls`, a
  *   binary `.xlsb`, or an unrecognised/non-ZIP blob; branch on `.format`).
  * @throws {PackageReadError} if the input is a ZIP that cannot be unpacked: a corrupt or
  *   truncated archive, or one exceeding the inflate bound (a probable zip bomb).
  */
-export declare function readWorkbookStream(data: Uint8Array, options?: ReadXlsxOptions): Generator<StreamedSheet, void, undefined>;
+export declare function readWorkbookStream(data: Uint8Array, options?: ReadPackageOptions): Generator<StreamedSheet, void, undefined>;

package/dist/io/xlsx/read-rows.js

@@ -1,46 +1,53 @@
-import { MAX_COLUMN, MAX_ROW } from '../../core/address.js';
-import { AuthoringError } from '../../errors.js';
-import { boolStrict, closeEmptyElements, localName, numInteger, xmlEvents, } from '../../xml/xml-read.js';
-import { packageAccessors } from '../opc/read-opc.js';
-import { inflateSpreadsheetPackage, unsupportedWorkbookPart } from '../opc/sniff-format.js';
+import { Workbook } from '../../core/workbook.js';
+import { AuthoringError, quoted } from '../../errors.js';
+import { closeEmptyElements, parseXmlPasses } from '../../xml/xml-read.js';
+import { boolStrict, localName, xmlEvents } from '../../xml/xml-scan.js';
+import { openSpreadsheetPackage, readPartRelationships } from '../opc/read-opc.js';
+import { unsupportedWorkbookPart } from '../opc/sniff-format.js';
 import { CellAccumulator } from './cell-accumulator.js';
+import { CellStyleResolver } from './cell-style-resolution.js';
+import { ColumnRecordBudget, takeColumnSpan } from './column-budget.js';
 import { XlsxParseError } from './errors.js';
+import { SHARED_STRINGS_PART, STYLES_PART } from './part-names.js';
 import { parseSharedStrings } from './read-shared-strings.js';
-import { DEFAULT_MAX_UNCOMPRESSED, parseRelationships, parseStyleTable, parseWorkbookSheets, resolveWorkbookPart, } from './read.js';
+import { workbookPropertiesPass, parseStyleTable, workbookSheetsPass, } from './read.js';
+import { RowPositionTracker } from './row-position.js';
 export function* readSheetRows(data, options = {}) {
     const pkg = openPackage(data, options.maxUncompressedBytes);
     const chosen = pickSheet(pkg.sheets, options.sheet);
     const sheetXml = pkg.sheetXml(chosen.relId);
     if (sheetXml === undefined)
         return;
-    yield* scanSheet(sheetXml, pkg.sharedStrings, pkg.xfStyles, new Set(), []);
+    yield* scanSheet(sheetXml, pkg.sharedStrings, pkg.xfStyles, pkg.dateEpoch, new Set(), []);
 }
 export function* readWorkbookStream(data, options = {}) {
     const pkg = openPackage(data, options.maxUncompressedBytes);
     for (const sheet of pkg.sheets) {
         const xml = pkg.sheetXml(sheet.relId) ?? '';
-        yield new StreamedSheetReader(sheet.name, xml, pkg.sharedStrings, pkg.xfStyles);
+        yield new StreamedSheetReader(sheet.name, xml, pkg.sharedStrings, pkg.xfStyles, pkg.dateEpoch);
     }
 }
 function openPackage(data, maxUncompressedBytes) {
-    const cap = maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED;
-    const { partText: text } = packageAccessors(inflateSpreadsheetPackage(data, cap));
-    const workbookXml = text('xl/workbook.xml');
+    const { pkg, documentPath, workbookXml } = openSpreadsheetPackage(data, maxUncompressedBytes);
+    const { partText: text, partBytes } = pkg;
     if (workbookXml === undefined) {
-        throw unsupportedWorkbookPart(text, 'the binary .xlsb format (BIFF12) cannot be row-streamed yet; read it with readXlsx or readXlsb');
+        throw unsupportedWorkbookPart(partBytes, documentPath, 'the binary .xlsb format (BIFF12) cannot be row-streamed yet; read it with readXlsx or readXlsb');
     }
-    const sheets = parseWorkbookSheets(workbookXml);
-    const rels = parseRelationships(text('xl/_rels/workbook.xml.rels') ?? '');
-    const sharedStrings = parseSharedStrings(text('xl/sharedStrings.xml') ?? '');
-    const { cellXfs: xfStyles } = parseStyleTable(text('xl/styles.xml') ?? '');
+    const properties = new Workbook();
+    const sheetsPass = workbookSheetsPass();
+    parseXmlPasses(workbookXml, [sheetsPass, workbookPropertiesPass(properties)]);
+    const sheets = sheetsPass.result();
+    const rels = readPartRelationships(documentPath, text);
+    const sharedStrings = parseSharedStrings(rels.relatedTextOrPath('sharedStrings', SHARED_STRINGS_PART));
+    const { cellXfs: xfStyles } = parseStyleTable(rels.relatedTextOrPath('styles', STYLES_PART));
     return {
         sheets,
         sharedStrings,
         xfStyles,
+        dateEpoch: properties.dateEpoch,
         sheetXml(relId) {
-            const target = rels.get(relId);
-            const path = target === undefined ? undefined : resolveWorkbookPart(target);
-            return path === undefined ? undefined : text(path);
+            const target = rels.byId(relId)?.target;
+            return target === undefined ? undefined : text(rels.pathOf(target));
         },
     };
 }
@@ -58,7 +65,7 @@ function pickSheet(sheets, selector) {
     }
     const sheet = sheets.find((candidate) => candidate.name === selector);
     if (sheet === undefined)
-        throw new AuthoringError(`no worksheet named ${JSON.stringify(selector)}`);
+        throw new AuthoringError(`no worksheet named ${quoted(selector)}`);
     return sheet;
 }
 class StreamedSheetReader {
@@ -66,20 +73,22 @@ class StreamedSheetReader {
     #xml;
     #sharedStrings;
     #xfStyles;
+    #dateEpoch;
     #hiddenColumns = new Set();
     #merges = [];
     #scanned = false;
-    constructor(name, xml, sharedStrings, xfStyles) {
+    constructor(name, xml, sharedStrings, xfStyles, dateEpoch) {
         this.name = name;
         this.#xml = xml;
         this.#sharedStrings = sharedStrings;
         this.#xfStyles = xfStyles;
+        this.#dateEpoch = dateEpoch;
     }
     *rows() {
         this.#hiddenColumns = new Set();
         this.#merges = [];
         this.#scanned = false;
-        yield* scanSheet(this.#xml, this.#sharedStrings, this.#xfStyles, this.#hiddenColumns, this.#merges);
+        yield* scanSheet(this.#xml, this.#sharedStrings, this.#xfStyles, this.#dateEpoch, this.#hiddenColumns, this.#merges);
         this.#scanned = true;
     }
     get hiddenColumns() {
@@ -88,7 +97,7 @@ class StreamedSheetReader {
     }
     get merges() {
         this.#ensureScanned();
-        return this.#merges;
+        return [...this.#merges];
     }
     #ensureScanned() {
         if (this.#scanned)
@@ -98,17 +107,20 @@ class StreamedSheetReader {
     }
 }
 const CELL_EMPTY_CLOSE = new Set(['c']);
-function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
+function* scanSheet(xml, sharedStrings, xfStyles, dateEpoch, hiddenColumns, merges) {
     let rowNumber = 0;
-    let lastRow = 0;
     let rowHidden = false;
     let rowInGrid = true;
     let cells = [];
-    const cell = new CellAccumulator({ richRuns: false });
+    const columnBudget = new ColumnRecordBudget();
+    const styleResolution = new CellStyleResolver();
+    const rowPosition = new RowPositionTracker();
+    const cell = new CellAccumulator({ richRuns: false, dateEpoch });
     const finalizeCell = () => {
         if (cell.ref === '' || cell.col < 0 || !rowInGrid)
             return;
-        const style = cell.styleIndex >= 0 ? xfStyles[cell.styleIndex] : undefined;
+        const styleIndex = styleResolution.indexFor(cell.col, cell.styleIndex);
+        const style = styleIndex >= 0 ? xfStyles[styleIndex] : undefined;
         const value = cell.decode(sharedStrings, style);
         if (value !== null) {
             const { col, ref } = cell;
@@ -126,15 +138,15 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
                 continue;
             switch (local) {
                 case 'row': {
-                    rowNumber = numInteger(event.attrs.r, 1) ?? lastRow + 1;
-                    lastRow = rowNumber;
-                    rowInGrid = rowNumber <= MAX_ROW;
+                    ({ number: rowNumber, inGrid: rowInGrid } = rowPosition.open(event.attrs));
                     rowHidden = boolStrict(event.attrs.hidden);
+                    cell.openRow(rowInGrid ? rowNumber : -1);
+                    styleResolution.openRow(event.attrs);
                     cells = [];
                     break;
                 }
                 case 'col':
-                    collectHiddenColumn(event.attrs, hiddenColumns);
+                    collectColumn(event.attrs, hiddenColumns, styleResolution, columnBudget);
                     break;
                 case 'mergeCell':
                     if (event.attrs.ref !== undefined)
@@ -150,19 +162,20 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
         if (claimed === 'cell')
             finalizeCell();
         else if (claimed === 'other' && local === 'row') {
+            styleResolution.closeRow();
             if (rowInGrid)
                 yield { number: rowNumber, hidden: rowHidden, cells };
         }
     }
 }
-function collectHiddenColumn(attrs, hiddenColumns) {
-    if (attrs.hidden !== '1' && attrs.hidden !== 'true')
+function collectColumn(attrs, hiddenColumns, styleResolution, budget) {
+    const span = takeColumnSpan(attrs, budget);
+    if (span === undefined)
         return;
-    const min = numInteger(attrs.min, 1);
-    const max = numInteger(attrs.max, 1);
-    if (min === undefined || max === undefined)
+    const { first: min, last } = span;
+    styleResolution.noteColumnSpan(min, last, attrs);
+    if (!boolStrict(attrs.hidden))
         return;
-    const last = Math.min(max, MAX_COLUMN);
     for (let index = min; index <= last; index++)
         hiddenColumns.add(index);
 }

package/dist/io/xlsx/read-shared-strings.js

@@ -1,5 +1,7 @@
-import { localName, parseXml } from '../../xml/xml-read.js';
-import { RunAccumulator } from './rich-runs.js';
+import { parseXml } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
+import { RunAccumulator } from './read-rich-runs.js';
+const SHARED_STRING_EMPTY_CLOSES = new Set(['si']);
 export function parseSharedStrings(xml) {
     if (xml === '')
         return [];
@@ -17,6 +19,6 @@ export function parseSharedStrings(xml) {
                 return;
             strings.push(runs.isRich ? { richText: runs.runs } : runs.plainText);
         },
-    });
+    }, { closeEmptyElements: SHARED_STRING_EMPTY_CLOSES });
     return strings;
 }

package/dist/io/xlsx/read-styles.d.ts

@@ -1,11 +1,6 @@
-import { type Font, type TableStyleTable } from '../../core/style.ts';
-import { type XmlAttributes } from '../../xml/xml-read.ts';
+import type { TableStyleTable } from '../../core/workbook-styles.ts';
 import { type StyleTable } from '../style/xf-style.ts';
-export type FontDraft = {
-    -readonly [K in keyof Font]?: Font[K];
-};
 export declare function parseStyleTable(xml: string): StyleTable;
-export declare function applyFontChild(draft: FontDraft, local: string, attrs: XmlAttributes): void;
 /**
  * Extract the custom indexed-color palette (`<colors><indexedColors>`) from styles.xml as verbatim
  * `<rgbColor rgb="…"/>` fragments, or an empty list when the file rides the default palette. Kept raw