@shbernal/ts-xlsx 3.1.0 → 3.2.0

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

@@ -1,16 +1,22 @@
 import { Workbook } from '../../core/workbook.js';
+import { WorksheetMerges } from '../../core/worksheet-merges.js';
 import { AuthoringError, quoted } from '../../errors.js';
+import { numInteger } from '../../xml/xml-attrs.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 { ColumnRecordBudget } from '../read-policy/column-budget.js';
+import { admitting, repairedSheetNames } from '../read-policy/read-repair.js';
+import { CellStyleResolver } from '../style/cell-style-resolution.js';
+import { CellAccumulator, WORKSHEET_BODY_EMPTY_CLOSES } from './cell-accumulator.js';
+import { readCellMetadata } from './cell-metadata.js';
+import { takeColumnSpan } from './column-span.js';
 import { XlsxParseError } from './errors.js';
 import { SHARED_STRINGS_PART, STYLES_PART } from './part-names.js';
 import { parseSharedStrings } from './read-shared-strings.js';
-import { workbookPropertiesPass, parseStyleTable, workbookSheetsPass, } from './read.js';
+import { parseStyleTable } from './read-styles.js';
+import { definedNamesPass, workbookPropertiesPass, workbookSheetsPass, } from './read-workbook-xml.js';
 import { RowPositionTracker } from './row-position.js';
 export function* readSheetRows(data, options = {}) {
     const pkg = openPackage(data, options.maxUncompressedBytes);
@@ -18,13 +24,13 @@ export function* readSheetRows(data, options = {}) {
     const sheetXml = pkg.sheetXml(chosen.relId);
     if (sheetXml === undefined)
         return;
-    yield* scanSheet(sheetXml, pkg.sharedStrings, pkg.xfStyles, pkg.dateEpoch, new Set(), []);
+    yield* scanSheet(sheetXml, pkg, new Set(), new WorksheetMerges());
 }
 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, pkg.dateEpoch);
+        yield new StreamedSheetReader(sheet.name, xml, pkg);
     }
 }
 function openPackage(data, maxUncompressedBytes) {
@@ -35,8 +41,9 @@ function openPackage(data, maxUncompressedBytes) {
     }
     const properties = new Workbook();
     const sheetsPass = workbookSheetsPass();
-    parseXmlPasses(workbookXml, [sheetsPass, workbookPropertiesPass(properties)]);
-    const sheets = sheetsPass.result();
+    const namesPass = definedNamesPass();
+    parseXmlPasses(workbookXml, [sheetsPass, workbookPropertiesPass(properties), namesPass]);
+    const sheets = repairedSheetNames(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));
@@ -45,6 +52,8 @@ function openPackage(data, maxUncompressedBytes) {
         sharedStrings,
         xfStyles,
         dateEpoch: properties.dateEpoch,
+        definedNames: namesPass.spellings(),
+        cellMetadata: readCellMetadata(rels),
         sheetXml(relId) {
             const target = rels.byId(relId)?.target;
             return target === undefined ? undefined : text(rels.pathOf(target));
@@ -71,24 +80,20 @@ function pickSheet(sheets, selector) {
 class StreamedSheetReader {
     name;
     #xml;
-    #sharedStrings;
-    #xfStyles;
-    #dateEpoch;
+    #tables;
     #hiddenColumns = new Set();
-    #merges = [];
+    #merges = new WorksheetMerges();
     #scanned = false;
-    constructor(name, xml, sharedStrings, xfStyles, dateEpoch) {
+    constructor(name, xml, tables) {
         this.name = name;
         this.#xml = xml;
-        this.#sharedStrings = sharedStrings;
-        this.#xfStyles = xfStyles;
-        this.#dateEpoch = dateEpoch;
+        this.#tables = tables;
     }
     *rows() {
         this.#hiddenColumns = new Set();
-        this.#merges = [];
+        this.#merges = new WorksheetMerges();
         this.#scanned = false;
-        yield* scanSheet(this.#xml, this.#sharedStrings, this.#xfStyles, this.#dateEpoch, this.#hiddenColumns, this.#merges);
+        yield* scanSheet(this.#xml, this.#tables, this.#hiddenColumns, this.#merges);
         this.#scanned = true;
     }
     get hiddenColumns() {
@@ -97,7 +102,7 @@ class StreamedSheetReader {
     }
     get merges() {
         this.#ensureScanned();
-        return [...this.#merges];
+        return [...this.#merges.ranges];
     }
     #ensureScanned() {
         if (this.#scanned)
@@ -106,28 +111,28 @@ class StreamedSheetReader {
         }
     }
 }
-const CELL_EMPTY_CLOSE = new Set(['c']);
-function* scanSheet(xml, sharedStrings, xfStyles, dateEpoch, hiddenColumns, merges) {
+function* scanSheet(xml, tables, hiddenColumns, merges) {
+    const { sharedStrings, xfStyles, dateEpoch, definedNames, cellMetadata } = tables;
     let rowNumber = 0;
     let rowHidden = false;
-    let rowInGrid = true;
     let cells = [];
     const columnBudget = new ColumnRecordBudget();
     const styleResolution = new CellStyleResolver();
     const rowPosition = new RowPositionTracker();
-    const cell = new CellAccumulator({ richRuns: false, dateEpoch });
+    const cell = new CellAccumulator({ dateEpoch, definedNames, cellMetadata });
     const finalizeCell = () => {
-        if (cell.ref === '' || cell.col < 0 || !rowInGrid)
+        if (cell.ref === '')
             return;
-        const styleIndex = styleResolution.indexFor(cell.col, cell.styleIndex);
-        const style = styleIndex >= 0 ? xfStyles[styleIndex] : undefined;
+        const style = styleResolution.styleFor(cell.col, cell.styleIndex, xfStyles);
         const value = cell.decode(sharedStrings, style);
         if (value !== null) {
             const { col, ref } = cell;
-            cells.push(style ? { col, address: ref, value, style } : { col, address: ref, value });
+            cells.push(style !== undefined && styleResolution.declaresFormat(col, cell.styleIndex)
+                ? { col, address: ref, value, style }
+                : { col, address: ref, value });
         }
     };
-    for (const event of closeEmptyElements(xmlEvents(xml), CELL_EMPTY_CLOSE)) {
+    for (const event of closeEmptyElements(xmlEvents(xml), WORKSHEET_BODY_EMPTY_CLOSES)) {
         if (event.kind === 'text') {
             cell.appendChunk(event.text);
             continue;
@@ -138,20 +143,22 @@ function* scanSheet(xml, sharedStrings, xfStyles, dateEpoch, hiddenColumns, merg
                 continue;
             switch (local) {
                 case 'row': {
-                    ({ number: rowNumber, inGrid: rowInGrid } = rowPosition.open(event.attrs));
+                    const position = rowPosition.open(event.attrs);
+                    rowNumber = position.number;
                     rowHidden = boolStrict(event.attrs.hidden);
-                    cell.openRow(rowInGrid ? rowNumber : -1);
-                    styleResolution.openRow(event.attrs);
-                    cells = [];
+                    cell.openRow(position.number, position.inGrid);
+                    styleResolution.openRow(numInteger(event.attrs.s, 0) ?? -1, boolStrict(event.attrs.customFormat));
                     break;
                 }
                 case 'col':
                     collectColumn(event.attrs, hiddenColumns, styleResolution, columnBudget);
                     break;
-                case 'mergeCell':
-                    if (event.attrs.ref !== undefined)
-                        merges.push(event.attrs.ref);
+                case 'mergeCell': {
+                    const ref = event.attrs.ref;
+                    if (ref !== undefined)
+                        admitting(() => merges.add(ref));
                     break;
+                }
                 default:
                     break;
             }
@@ -163,8 +170,11 @@ function* scanSheet(xml, sharedStrings, xfStyles, dateEpoch, hiddenColumns, merg
             finalizeCell();
         else if (claimed === 'other' && local === 'row') {
             styleResolution.closeRow();
-            if (rowInGrid)
+            const inGrid = cell.rowOpen;
+            cell.closeRow();
+            if (inGrid)
                 yield { number: rowNumber, hidden: rowHidden, cells };
+            cells = [];
         }
     }
 }
@@ -173,7 +183,7 @@ function collectColumn(attrs, hiddenColumns, styleResolution, budget) {
     if (span === undefined)
         return;
     const { first: min, last } = span;
-    styleResolution.noteColumnSpan(min, last, attrs);
+    styleResolution.noteColumnSpan(min, last, numInteger(attrs.style, 0) ?? -1);
     if (!boolStrict(attrs.hidden))
         return;
     for (let index = min; index <= last; index++)

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

@@ -1,27 +1,2 @@
-import type { TableStyleTable } from '../../core/workbook-styles.ts';
 import { type StyleTable } from '../style/xf-style.ts';
 export declare function parseStyleTable(xml: string): StyleTable;
-/**
- * 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
- * rather than parsed into RGB and re-serialised, so the exact entries (count, order, casing) a
- * source file declared survive a round-trip and every `indexed="…"` reference keeps its RGB.
- */
-export declare function parseIndexedColors(stylesXml: string): string[];
-/**
- * Extract the most-recently-used colour swatches (`<colors><mruColors>`) from styles.xml as verbatim
- * `<color .../>` fragments, or an empty list when the file declares none. Kept raw for the same reason
- * the indexed palette is: the list is the author's own working set of colours and the model has no
- * use for its contents, only for not losing them.
- */
-export declare function parseMruColors(stylesXml: string): string[];
-/**
- * Extract the `<tableStyles>` block from styles.xml: each `<tableStyle>` definition verbatim, plus the
- * container's nominated `defaultTableStyle`/`defaultPivotStyle`. See {@link TableStyleTable} for why
- * the definitions stay raw while the two names are decoded.
- *
- * A file with no such block, or with the self-closing `count="0"` container Excel writes when it has
- * only defaults to state, yields an empty {@link TableStyleTable.styles} and whichever names it did
- * carry.
- */
-export declare function parseTableStyles(stylesXml: string): TableStyleTable;

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

@@ -11,6 +11,7 @@ const isBorderEdgeName = (name) => BORDER_EDGES.has(name);
 const STYLE_EMPTY_CLOSES = new Set([
     'font',
     'border',
+    'fill',
     'patternFill',
     'gradientFill',
     'xf',
@@ -111,30 +112,37 @@ function parseFonts(events) {
 }
 function parseFills(events) {
     const fills = [];
-    let pattern = '';
-    let fgColor;
-    let bgColor;
+    let fillDraft = null;
+    let patternDraft = null;
     let gradientDraft = null;
-    let fillSlotAt = -1;
     for (const event of until(events, 'fills')) {
         if (event.kind === 'open') {
             const attrs = event.attrs;
+            const bodyExpected = fillDraft !== null && !fillDraft.bodyRead;
             switch (localName(event.name)) {
                 case 'fill':
-                    fillSlotAt = fills.length;
+                    fillDraft = { body: undefined, bodyRead: false };
                     break;
                 case 'patternFill':
-                    pattern = attrs.patternType ?? 'none';
-                    fgColor = undefined;
-                    bgColor = undefined;
+                    if (!bodyExpected)
+                        break;
+                    patternDraft = {
+                        pattern: attrs.patternType ?? 'none',
+                        fgColor: undefined,
+                        bgColor: undefined,
+                    };
                     break;
                 case 'fgColor':
-                    fgColor = parseColor(attrs);
+                    if (patternDraft !== null)
+                        patternDraft.fgColor = parseColor(attrs);
                     break;
                 case 'bgColor':
-                    bgColor = parseColor(attrs);
+                    if (patternDraft !== null)
+                        patternDraft.bgColor = parseColor(attrs);
                     break;
                 case 'gradientFill':
+                    if (!bodyExpected)
+                        break;
                     gradientDraft = {
                         fill: {
                             type: 'gradient',
@@ -161,7 +169,12 @@ function parseFills(events) {
         else if (event.kind === 'close') {
             switch (localName(event.name)) {
                 case 'patternFill':
-                    fills.push(toFill(pattern, fgColor, bgColor));
+                    if (fillDraft !== null && patternDraft !== null) {
+                        const { pattern, fgColor, bgColor } = patternDraft;
+                        fillDraft.body = toFill(pattern, fgColor, bgColor);
+                        fillDraft.bodyRead = true;
+                        patternDraft = null;
+                    }
                     break;
                 case 'stop':
                     if (gradientDraft !== null && gradientDraft.stopPosition !== null) {
@@ -175,14 +188,18 @@ function parseFills(events) {
                     }
                     break;
                 case 'gradientFill':
-                    if (gradientDraft !== null) {
-                        fills.push(gradientDraft.fill);
+                    if (fillDraft !== null && gradientDraft !== null) {
+                        fillDraft.body = gradientDraft.fill;
+                        fillDraft.bodyRead = true;
                         gradientDraft = null;
                     }
                     break;
                 case 'fill':
-                    if (fills.length === fillSlotAt)
-                        fills.push(undefined);
+                    if (fillDraft !== null)
+                        fills.push(fillDraft.body);
+                    fillDraft = null;
+                    patternDraft = null;
+                    gradientDraft = null;
                     break;
             }
         }
@@ -368,29 +385,24 @@ function assignAlignmentToken(out, key, raw) {
 function parseProtection(attrs) {
     return protectionFrom({ locked: boolTristate(attrs.locked), hidden: boolStrict(attrs.hidden) });
 }
-export function parseIndexedColors(stylesXml) {
-    return capturedFragments(stylesXml, 'indexedColors');
-}
-export function parseMruColors(stylesXml) {
-    return capturedFragments(stylesXml, 'mruColors');
-}
-export function parseTableStyles(stylesXml) {
-    const { fragments, attributes } = elementSubtrees(stylesXml, new Map([['tableStyles', 'tableStyle']]));
-    return buildTableStyleTable(stylesXml, fragments.get('tableStyles') ?? [], attributes.get('tableStyles'));
-}
 function buildTableStyleTable(stylesXml, styles, containerAttrs) {
-    const table = { styles: [...styles] };
+    const table = { styles: styles.map((xml) => ({ name: tableStyleNameOf(xml), xml })) };
     if (containerAttrs?.defaultTableStyle !== undefined) {
         table.defaultTableStyle = containerAttrs.defaultTableStyle;
     }
     if (containerAttrs?.defaultPivotStyle !== undefined) {
         table.defaultPivotStyle = containerAttrs.defaultPivotStyle;
     }
-    const namespaces = fragmentNamespaces(stylesXml, table.styles);
+    const namespaces = fragmentNamespaces(stylesXml, styles);
     if (namespaces.length > 0)
         table.namespaces = namespaces;
     return table;
 }
+function tableStyleNameOf(fragment) {
+    for (const { attrs } of openElements(fragment, 'tableStyle'))
+        return attrs.name ?? '';
+    return '';
+}
 function fragmentNamespaces(stylesXml, fragments) {
     if (fragments.length === 0)
         return [];
@@ -427,10 +439,3 @@ const PRESERVED_SUBTREES = new Map([
     ['mruColors', 'color'],
     ['tableStyles', 'tableStyle'],
 ]);
-function capturedFragments(xml, container) {
-    const child = PRESERVED_SUBTREES.get(container);
-    if (child === undefined)
-        return [];
-    const { fragments } = elementSubtrees(xml, new Map([[container, child]]));
-    return [...(fragments.get(container) ?? [])];
-}

package/dist/io/xlsx/read-workbook-xml.d.ts

@@ -30,6 +30,12 @@ export interface DefinedNamesPass extends SaxPass {
      * and repaired the names it had to; resolving during the scan would have forced a second one.
      */
     result(sheetOrder: readonly string[]): DefinedName[];
+    /**
+     * Every name the part defines, whatever its scope, as `definedNameKeys` spells them. Known once the
+     * scan ends, before any sheet is read, and needed then: whether a function a formula passes as a value
+     * sheds its `_xleta.` depends on them.
+     */
+    spellings(): ReadonlySet<string>;
 }
 export declare function definedNamesPass(): DefinedNamesPass;
 export declare function applyCoreProperties(workbook: Workbook, xml: string): void;

package/dist/io/xlsx/read-workbook-xml.js

@@ -1,5 +1,5 @@
 import { parseDateText } from '../../core/date.js';
-import { unmangleFunctions } from '../../core/formula.js';
+import { definedNameKeys, unmangleFunctions } from '../../core/formula.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS, } from '../../core/workbook-protection.js';
 import { isVisibility } from '../../core/worksheet.js';
 import { enumToken, numInteger } from '../../xml/xml-attrs.js';
@@ -125,17 +125,22 @@ export function definedNamesPass() {
                 const text = refersTo.close(localName(name));
                 if (text === undefined || pending === undefined)
                     return;
-                drafts.push({ ...pending, refersTo: unmangleFunctions(text) });
+                drafts.push({ ...pending, refersTo: text });
                 pending = undefined;
             },
         },
         closeEmptyElements: new Set(['definedName']),
         result(sheetOrder) {
-            return drafts.map(({ localSheetId, ...draft }) => {
+            const names = definedNameKeys(drafts);
+            return drafts.map(({ localSheetId, refersTo: stored, ...draft }) => {
+                const named = { ...draft, refersTo: unmangleFunctions(stored, names) };
                 const scope = sheetOrder[localSheetId];
-                return scope === undefined ? draft : { ...draft, scope };
+                return scope === undefined ? named : { ...named, scope };
             });
         },
+        spellings() {
+            return definedNameKeys(drafts);
+        },
     };
 }
 const CORE_PROPERTY_LOCAL_NAMES = new Set([

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

@@ -1,6 +1,7 @@
 import type { DateEpoch } from '../../core/date.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import { type SaxPass } from '../../xml/xml-read.ts';
+import type { CellMetadataIndex } from '../cell-metadata/metadata.ts';
 import type { XfStyle } from '../style/xf-style.ts';
 import type { SharedString } from './cell-value.ts';
 /**
@@ -8,7 +9,11 @@ import type { SharedString } from './cell-value.ts';
  * merges, the autofilter, page breaks, and the view and print layout. It commits as it goes rather
  * than gathering, so it has nothing to hand back once the parse ends.
  *
- * Offered as a pass because the worksheet is the largest part in a package and four other readers
- * want the same events, so the five share one parse of it rather than scanning it once each.
+ * Offered as a pass because the worksheet is the largest part in a package and other readers want
+ * the same events, so they all share one parse of it rather than scanning it once each.
+ *
+ * `definedNames` is every name the workbook defines, as `definedNameKeys` spells them: the workbook
+ * part is read before any sheet, so they are known before the first formula is. `cellMetadata` is
+ * what the workbook's `cm` and `vm` values resolve to, read from the parts they index.
  */
-export declare function worksheetPass(sheet: Worksheet, sharedStrings: readonly SharedString[], xfStyles: ReadonlyArray<XfStyle>, dateEpoch: DateEpoch): SaxPass;
+export declare function worksheetPass(sheet: Worksheet, sharedStrings: readonly SharedString[], xfStyles: ReadonlyArray<XfStyle>, dateEpoch: DateEpoch, definedNames: ReadonlySet<string>, cellMetadata: CellMetadataIndex): SaxPass;

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

@@ -1,22 +1,26 @@
-import { tryDecodeRange } from '../../core/address.js';
+import { boundedRect, tryDecodeRange } from '../../core/address.js';
 import { isCustomFilterOperator, } from '../../core/autofilter.js';
 import { INTERNAL } from '../../core/internal.js';
 import { HEADER_FOOTER_ELEMENTS } from '../../core/page-setup.js';
 import { assignStyleFacets } from '../../core/style.js';
 import { decodeSpreadsheetText, numFinite, numInteger } from '../../xml/xml-attrs.js';
-import {} from '../../xml/xml-read.js';
+import { TextCapture } from '../../xml/xml-read.js';
 import { boolPresent, boolStrict, localName } from '../../xml/xml-scan.js';
-import { CellAccumulator } from './cell-accumulator.js';
-import { CellStyleResolver } from './cell-style-resolution.js';
-import { ColumnRecordBudget, takeColumnSpan } from './column-budget.js';
-import { admitting } from './read-repair.js';
+import { ColumnRecordBudget } from '../read-policy/column-budget.js';
+import { admitting } from '../read-policy/read-repair.js';
+import { CellStyleResolver } from '../style/cell-style-resolution.js';
+import { CellAccumulator, WORKSHEET_BODY_EMPTY_CLOSES } from './cell-accumulator.js';
+import { takeColumnSpan } from './column-span.js';
 import { RowPositionTracker } from './row-position.js';
 import { applySheetProperties, PageBreakAccumulator, parseSheetProtection, } from './sheet-properties.js';
 const HEADER_FOOTER_CHILDREN = new Set(HEADER_FOOTER_ELEMENTS);
 function isHeaderFooterElement(local) {
     return HEADER_FOOTER_CHILDREN.has(local);
 }
-const WORKSHEET_EMPTY_CLOSES = new Set(['c', 'autoFilter']);
+const WORKSHEET_EMPTY_CLOSES = new Set([
+    ...WORKSHEET_BODY_EMPTY_CLOSES,
+    'autoFilter',
+]);
 function pendingFilterCriteria(values, blank, predicates, and) {
     if (values !== null && (values.length > 0 || blank)) {
         return { kind: 'values', values, blank };
@@ -75,35 +79,44 @@ class AutoFilterAccumulator {
         if (this.#ref === null)
             return;
         const decoded = tryDecodeRange(this.#ref);
-        const left = decoded?.left;
-        const right = decoded?.right;
-        if (left !== undefined && right !== undefined) {
-            const width = right - left + 1;
+        const rect = decoded === undefined ? undefined : boundedRect(decoded);
+        if (rect !== undefined) {
+            const width = rect.right - rect.left + 1;
             sheet.autoFilter = { ref: this.#ref, columns: this.#columns.filter((c) => c.colId < width) };
         }
         this.#ref = null;
         this.#columns = [];
     }
 }
-export function worksheetPass(sheet, sharedStrings, xfStyles, dateEpoch) {
-    const cell = new CellAccumulator({ richRuns: true, dateEpoch });
+export function worksheetPass(sheet, sharedStrings, xfStyles, dateEpoch, definedNames, cellMetadata) {
+    const cell = new CellAccumulator({ dateEpoch, definedNames, cellMetadata });
     const autoFilter = new AutoFilterAccumulator();
     const pageBreaks = new PageBreakAccumulator();
     const styleResolution = new CellStyleResolver();
     const columnBudget = new ColumnRecordBudget();
     const rowPosition = new RowPositionTracker();
+    const headerFooterText = new TextCapture(HEADER_FOOTER_ELEMENTS);
+    let customViewDepth = 0;
     const finalizeCellFromState = () => {
-        const styleIndex = styleResolution.indexFor(cell.col, cell.styleIndex);
-        const style = styleIndex >= 0 ? xfStyles[styleIndex] : xfStyles[0];
-        cell.finalize(sheet, sharedStrings, style);
+        cell.finalize(sheet, sharedStrings, styleResolution.styleFor(cell.col, cell.styleIndex, xfStyles));
     };
     const handlers = {
         onOpen(name, attrs, selfClosing) {
             const local = localName(name);
+            if (customViewDepth > 0) {
+                if (!selfClosing)
+                    customViewDepth++;
+                return;
+            }
+            if (local === 'customSheetViews') {
+                if (!selfClosing)
+                    customViewDepth = 1;
+                return;
+            }
             if (cell.openElement(local, attrs, selfClosing))
                 return;
-            if (HEADER_FOOTER_CHILDREN.has(local)) {
-                cell.capture();
+            if (isHeaderFooterElement(local)) {
+                headerFooterText.open(local, selfClosing);
                 return;
             }
             switch (local) {
@@ -114,8 +127,8 @@ export function worksheetPass(sheet, sharedStrings, xfStyles, dateEpoch) {
                     const { number, inGrid } = rowPosition.open(attrs);
                     if (inGrid)
                         applyRow(sheet, number, attrs);
-                    cell.openRow(inGrid ? number : -1);
-                    styleResolution.openRow(attrs);
+                    cell.openRow(number, inGrid);
+                    styleResolution.openRow(numInteger(attrs.s, 0) ?? -1, boolStrict(attrs.customFormat));
                     break;
                 }
                 case 'mergeCell':
@@ -173,9 +186,16 @@ export function worksheetPass(sheet, sharedStrings, xfStyles, dateEpoch) {
             }
         },
         onText(chunk) {
+            if (customViewDepth > 0)
+                return;
             cell.appendChunk(chunk);
+            headerFooterText.text(chunk);
         },
         onClose(name) {
+            if (customViewDepth > 0) {
+                customViewDepth--;
+                return;
+            }
             const local = localName(name);
             const claimed = cell.closeElement(local);
             if (claimed === 'cell') {
@@ -184,13 +204,15 @@ export function worksheetPass(sheet, sharedStrings, xfStyles, dateEpoch) {
             }
             if (claimed === 'claimed')
                 return;
-            if (isHeaderFooterElement(local)) {
-                sheet.headerFooter[local] = decodeSpreadsheetText(cell.capturedText);
+            const headerFooter = headerFooterText.close(local);
+            if (headerFooter !== undefined && isHeaderFooterElement(local)) {
+                sheet.headerFooter[local] = decodeSpreadsheetText(headerFooter);
                 return;
             }
             switch (local) {
                 case 'row':
                     styleResolution.closeRow();
+                    cell.closeRow();
                     break;
                 case 'filterColumn':
                     autoFilter.endColumn();
@@ -232,7 +254,7 @@ function applyColumn(sheet, attrs, xfStyles, styleResolution, budget) {
         if (style !== undefined)
             assignStyleFacets(column, style);
     }
-    styleResolution.noteColumnSpan(min, last, attrs);
+    styleResolution.noteColumnSpan(min, last, numInteger(attrs.style, 0) ?? -1);
 }
 function applyRow(sheet, number, attrs) {
     const row = sheet.getRow(number);

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

@@ -1,9 +1,5 @@
 import { Workbook } from '../../core/workbook.ts';
 import type { ReadPackageOptions } from '../opc/read-options.ts';
-export type { ReadPackageOptions } from '../opc/read-options.ts';
-export type { StyleTable, XfStyle } from '../style/xf-style.ts';
-export { parseStyleTable } from './read-styles.ts';
-export { type SheetEntry, workbookPropertiesPass, workbookSheetsPass, workbookViewPass, } from './read-workbook-xml.ts';
 /**
  * Read a spreadsheet package into a {@link Workbook}.
  *