@shbernal/ts-xlsx 1.0.3 → 1.2.0

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

@@ -1,22 +1,3 @@
-// Streaming row reader: yield a worksheet's rows one at a time, without ever building the whole
-// {@link Workbook} model.
-//
-// `readXlsx` materialises every cell of every sheet as a live `Cell` object held in nested Maps —
-// fine for editing, but for a large sheet read purely to extract its data it holds the entire grid
-// in memory at once. This reader instead *pulls* the sheet's XML through `xmlEvents` and yields a
-// plain {@link StreamedRow} at each `</row>`, retaining only the row currently in hand. Peak model
-// memory is one row, not the sheet.
-//
-// Two entry points sit on the same scanner:
-//   - {@link readSheetRows} streams a single selected sheet's rows (the terse data-extraction case).
-//   - {@link readWorkbookStream} yields a {@link StreamedSheet} per worksheet in workbook order, so a
-//     caller can walk every sheet — each sheet's rows still stream one at a time.
-//
-// Scope of this slice: the package is still inflated whole (bounded by the running counter in
-// `./inflate.ts`) and shared strings / styles are read as whole parts — both are legitimately
-// document-sized and cheap. What this avoids is retaining N materialised cells. A later slice can
-// make the inflate itself per-part lazy; the pull primitive this stands on (`xmlEvents`) is the
-// same one that path will use.
 import { MAX_COLUMN } from '../../core/address.js';
 import { AuthoringError } from '../../errors.js';
 import { boolStrict, closeEmptyElements, localName, xmlEvents } from '../../xml/xml-read.js';
@@ -25,50 +6,18 @@ import { inflateSpreadsheetPackage, unsupportedWorkbookPart } from '../opc/sniff
 import { CellAccumulator } from './cell-accumulator.js';
 import { XlsxParseError } from './errors.js';
 import { DEFAULT_MAX_UNCOMPRESSED, parseRelationships, parseStyleTable, parseWorkbookSheets, resolveWorkbookPart, } from './read.js';
-import { parseSharedStrings } from './shared-strings-read.js';
-/**
- * Stream a worksheet's rows from an `.xlsx` package, yielding each in sheet order without building
- * the workbook model. Only rows the sheet actually declares are yielded, and within a row only its
- * non-empty cells — a blank or style-only cell contributes nothing, matching the intent of a data
- * read.
- *
- * @param data The raw `.xlsx` bytes.
- * @param options Sheet selector and the inflate bound (see {@link ReadSheetRowsOptions}).
- * @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).
- * @throws {XlsxParseError} if the package's workbook part declares no worksheets.
- * @throws {RangeError} / {@link AuthoringError} if `options.sheet` selects a position, or a name,
- *   that no worksheet has.
- */
+import { parseSharedStrings } from './read-shared-strings.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);
-    // The sheet is named but its part is missing (a truncated or foreign package) — it has no rows.
     if (sheetXml === undefined)
         return;
     yield* scanSheet(sheetXml, pkg.sharedStrings, pkg.xfStyles, new Set(), []);
 }
-/**
- * Stream every worksheet of an `.xlsx` package in workbook order, without building the workbook
- * model. Each yielded {@link StreamedSheet} carries the declared sheet name and lets the caller
- * stream that sheet's rows and read its hidden-column and merge summaries — the streaming analogue
- * of walking `readXlsx(data).worksheets`.
- *
- * @param data The raw `.xlsx` bytes.
- * @param options The inflate bound (see {@link ReadXlsxOptions}).
- * @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 function* readWorkbookStream(data, options = {}) {
     const pkg = openPackage(data, options.maxUncompressedBytes);
     for (const sheet of pkg.sheets) {
-        // A named sheet whose part is missing (truncated/foreign package) still surfaces — with no rows,
-        // no hidden columns, and no merges — rather than vanishing from the workbook's sheet list.
         const xml = pkg.sheetXml(sheet.relId) ?? '';
         yield new StreamedSheetReader(sheet.name, xml, pkg.sharedStrings, pkg.xfStyles);
     }
@@ -77,9 +26,6 @@ function openPackage(data, maxUncompressedBytes) {
     const cap = maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED;
     const { partText: text } = packageAccessors(inflateSpreadsheetPackage(data, cap));
     const workbookXml = text('xl/workbook.xml');
-    // A binary `.xlsb` is a workbook this library *can* read — just not through here. Row streaming is
-    // built on the XML worksheet parser, so the binary cell table has no streaming path yet; say so,
-    // rather than reporting the format as unreadable when `readXlsx` would take the very same bytes.
     if (workbookXml === undefined) {
         throw unsupportedWorkbookPart(text, 'the binary .xlsb format (BIFF12) cannot be row-streamed yet; read it with readXlsx or readXlsb');
     }
@@ -115,10 +61,6 @@ function pickSheet(sheets, selector) {
         throw new AuthoringError(`no worksheet named ${JSON.stringify(selector)}`);
     return sheet;
 }
-// A single worksheet exposed by readWorkbookStream. Its rows() re-scans on each call (a fresh pass,
-// so it is safely re-iterable); the hidden-column and merge accessors reuse a completed scan or, if
-// the rows were never drained, drive one of their own. The hidden/merge state is filled in by the
-// same scanSheet pass that yields the rows.
 class StreamedSheetReader {
     name;
     #xml;
@@ -148,37 +90,19 @@ class StreamedSheetReader {
         this.#ensureScanned();
         return this.#merges;
     }
-    // Drain a scan purely for its summaries when the caller reads them without (or before) iterating
-    // rows. A completed row iteration already set #scanned, so this re-scans nothing in the common
-    // streaming idiom.
     #ensureScanned() {
         if (this.#scanned)
             return;
         for (const _row of this.rows()) {
-            // The rows themselves are irrelevant here — we only want the hidden/merge side effects.
         }
     }
 }
-// A formatted-but-empty `<c/>` is expanded to open+close so it finalises once on close, matching
-// the buffered reader; the text-bearing `<f/>`/`<v/>`/`<t/>` are excluded so an empty one never
-// commits (their close captures text, which an empty tag has none of).
 const CELL_EMPTY_CLOSE = new Set(['c']);
-// Pull the sheet XML through the event stream, yielding a StreamedRow at each `</row>`, while
-// recording the sheet's hidden columns (from `<col hidden>`, before <sheetData>) and merged ranges
-// (from `<mergeCells>`, after <sheetData>) into the caller-supplied collectors. The cell state
-// mirrors the buffered reader's `parseWorksheet` (same self-closing-`<c/>` handling, same capture
-// flags), but commits into a row buffer that is handed off and discarded per row rather than into a
-// persistent Worksheet — that hand-off is what bounds retained memory to one row.
 function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
     let rowNumber = 0;
     let lastRow = 0;
     let rowHidden = false;
     let cells = [];
-    // The in-flight `<c>`, gathered exactly as the buffered reader gathers it. This reader drives the
-    // same beginCell/setFormula/setValue/appendText methods, then takes only the cell's plain decoded
-    // value (via decode) — never the shared-formula / data-table resolution the buffered finalize adds,
-    // which a data read does not want. Rich `<r>` runs are deliberately not opened here, so a rich
-    // inline string flattens to its concatenated text as a streamed value always has.
     const cell = new CellAccumulator();
     let inInlineString = false;
     let capture = false;
@@ -188,8 +112,6 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
             return;
         const style = cell.styleIndex >= 0 ? xfStyles[cell.styleIndex] : undefined;
         const value = cell.decode(sharedStrings, style);
-        // A blank or purely style-only cell decodes to null; a data read wants only cells that carry
-        // something (a formula object, an empty string, a false, and a 0 all count — only null drops).
         if (value !== null) {
             const { col, ref } = cell;
             cells.push(style ? { col, address: ref, value, style } : { col, address: ref, value });
@@ -243,7 +165,6 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
                 capture = false;
             continue;
         }
-        // close
         const local = localName(event.name);
         switch (local) {
             case 'f':
@@ -270,9 +191,6 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
         capture = false;
     }
 }
-// Record the hidden columns a `<col min max hidden>` element declares. The span is clamped to the
-// format's column ceiling and gathered into a Set, so even a hostile file full of full-width hidden
-// spans can add at most MAX_COLUMN distinct entries — never an unbounded allocation.
 function collectHiddenColumn(attrs, hiddenColumns) {
     if (attrs.hidden !== '1' && attrs.hidden !== 'true')
         return;

package/dist/io/xlsx/{shared-strings-read.js → read-shared-strings.js}

@@ -1,19 +1,9 @@
-// Parser for the shared-string table (`xl/sharedStrings.xml`), the pool that `t="s"` cells index into.
-// Split out of read.ts beside its sibling parsers (read-styles.ts, rich-runs.ts) so read.ts stays
-// orchestration; the run structure it decodes is owned by RunAccumulator, shared with inline strings.
 import { localName, parseXml } from '../../xml/xml-read.js';
 import { RunAccumulator } from './rich-runs.js';
-// Shared strings resolve `t="s"` cells. Each `<si>` is one entry: a plain `<si><t>…</t>` decodes to a
-// string, while a rich `<si><r><rPr>…</rPr><t>…</t></r>…` decodes to a {@link RichTextValue} whose runs
-// carry their per-run fonts — so rich text Excel pooled reads back formatted, not flattened to text.
-// The run structure inside an `<si>` is identical to an inline string's `<is>`, so it is parsed the
-// same way (see the inline-run accumulation in `parseWorksheet`).
 export function parseSharedStrings(xml) {
     if (xml === '')
         return [];
     const strings = [];
-    // Per-`<si>` accumulation: `plain` gathers a bare `<t>`; `runs` gathers `<r>` runs. An `<si>` is
-    // rich the moment it holds one `<r>`, at which point its runs — not `plain` — become the entry.
     let plain = '';
     const runs = new RunAccumulator();
     let isRich = false;
@@ -52,7 +42,6 @@ export function parseSharedStrings(xml) {
             const local = localName(name);
             switch (local) {
                 case 't':
-                    // A `<t>` inside a run is that run's text; a bare `<t>` directly in the `<si>` is plain.
                     if (!runs.appendText(text))
                         plain += text;
                     capture = false;

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

@@ -1,4 +1,4 @@
-import { type Font } from '../../core/style.ts';
+import { type Font, type TableStyleTable } from '../../core/style.ts';
 import { type XmlAttributes } from '../../xml/xml-read.ts';
 import { type StyleTable } from '../style/xf-style.ts';
 export type FontDraft = {
@@ -6,3 +6,27 @@ export type FontDraft = {
 };
 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
+ * — 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

@@ -1,24 +1,9 @@
-// The style-table reader: `xl/styles.xml` in, a flat table of resolved cell formats out. It is a
-// single streaming pass over the shared sub-tables (`<numFmts>`, `<fills>`, `<fonts>`, `<borders>`)
-// and the two xf tables (`<cellXfs>`, `<cellStyleXfs>`), flattening the id-indirection so a cell's
-// `s` index maps straight to its facets. A construct it does not recognise is skipped, never guessed.
-//
-// Only the parsing is XML-specific. What an xf resolves *to* — `XfStyle`, the built-in number
-// formats, applying an xf to a cell — is a property of the OOXML style model rather than of its
-// spelling, and lives above both codecs in `../style/xf-style.ts`; the `.xlsb` style reader builds
-// the same table from BIFF12 records.
 import { assignStyleFacets, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isHorizontalAlignment, isNamedUnderlineStyle, isVerticalAlignment, } from '../../core/style.js';
-import { boolPresent, boolStrict, closeEmptyElements, localName, xmlEvents, } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, closeEmptyElements, localName, openElements, xmlEvents, } from '../../xml/xml-read.js';
 import { numFmtCodeFor } from '../style/xf-style.js';
-import { parseColor } from './styles.js';
-// The four sides plus the diagonal — the edge elements a <border> can hold, in the order the
-// schema lists them. This one tuple drives the edge-name union, the membership set (which drives
-// edge parsing without a per-name branch), and the "does any edge carry a style" scan below.
+import { parseColor } from './color-xml.js';
 const BORDER_EDGE_NAMES = ['left', 'right', 'top', 'bottom', 'diagonal'];
 const BORDER_EDGES = new Set(BORDER_EDGE_NAMES);
-// Style-table elements that commit on their close: a bare <font/>/<border/>/<patternFill/>/
-// <gradientFill/>/<xf/> or a self-closing border edge is expanded to open+close so each commits
-// exactly once in onClose, never in a duplicated (and easily-forgotten) self-closing branch.
 const STYLE_EMPTY_CLOSES = new Set([
     'font',
     'border',
@@ -27,11 +12,6 @@ const STYLE_EMPTY_CLOSES = new Set([
     'xf',
     ...BORDER_EDGES,
 ]);
-// styles.xml is a shared table: <numFmts> defines custom format codes by id, <fills> lists
-// the fills, and <cellXfs> lists the cell formats, each naming a fill and a number format by
-// id. We flatten that indirection into one array — cellXfs index → resolved {fill, numFmt} —
-// so a cell/row/column style index maps straight to its facets. The schema orders <numFmts>
-// and <fills> before <cellXfs>, so both lookups are complete before an xf references them.
 export function parseStyleTable(xml) {
     if (xml === '')
         return { cellXfs: [], namedStyles: [] };
@@ -40,16 +20,8 @@ export function parseStyleTable(xml) {
     let borders = [];
     let numFmtCodes = new Map();
     const xfStyles = [];
-    // The named-style layer: <cellStyleXfs> holds the base formats a cell's xfId links to; <cellStyles>
-    // labels them by name/builtinId. Parsed in parallel with cellXfs, then zipped and merged below.
     const namedXfs = [];
     let cellStyleNames = [];
-    // One streaming pass, but each top-level sub-table drives its own focused sub-parser over the slice
-    // of events between its open and close. The schema orders the shared tables (<numFmts>, <fonts>,
-    // <fills>, <borders>) before the xf tables, so their results are complete before an <xf> resolves
-    // against them. Every recognised container name is plural and unique to the styleSheet root — none
-    // appears inside a <dxf>'s singular <font>/<fill>/<border> children — so skipping an unrecognised
-    // section here drops exactly what the old flat pass gated off with its `in*` flags.
     const events = closeEmptyElements(xmlEvents(xml), STYLE_EMPTY_CLOSES);
     let next = events.next();
     while (next.done !== true) {
@@ -81,18 +53,12 @@ export function parseStyleTable(xml) {
         }
         next = events.next();
     }
-    // Layer each cellXfs entry over the named style its xfId links to: a facet the direct format sets
-    // wins; one it leaves unset falls through to the named style. The xfId is carried through so the
-    // link survives a re-write. A draft only holds keys for facets it actually set, so the spread merge
-    // takes the named base and lets the direct entry override exactly what it names.
     const cellXfs = xfStyles.map((xf) => {
         if (xf.xfId === undefined)
             return xf;
         const named = namedXfs[xf.xfId];
         return named === undefined ? xf : { ...named, ...xf };
     });
-    // Zip the resolved cellStyleXfs facets with their cellStyles name/builtinId into the model's named
-    // styles, index for index (a cellStyle's xfId is its cellStyleXfs index).
     const namedStyles = namedXfs.map((xf, index) => {
         const label = cellStyleNames.find((entry) => entry.xfId === index);
         const style = {};
@@ -103,15 +69,9 @@ export function parseStyleTable(xml) {
             style.builtinId = label.builtinId;
         return style;
     });
-    // Font 0 is the workbook's declared default, so it is carried out whole as well as flattened onto
-    // the xfs that name it — see {@link StyleTable.defaultFont}.
     const defaultFont = fonts[0];
     return defaultFont === undefined ? { cellXfs, namedStyles } : { cellXfs, namedStyles, defaultFont };
 }
-// Pull events off the shared stream up to — and consuming — the close of `container`, yielding only
-// those strictly inside it. A sub-table parser loops this to completion (never breaking), so it drives
-// its own small state machine over exactly its section without closing the underlying generator, and
-// the outer pass resumes at the element after the container's close.
 function* until(events, container) {
     let next = events.next();
     while (next.done !== true) {
@@ -122,8 +82,6 @@ function* until(events, container) {
         next = events.next();
     }
 }
-// <numFmts> entries are self-closing, so they are read on open. A code with no id, or the General
-// id 0, contributes nothing.
 function parseNumFmts(events) {
     const codes = new Map();
     for (const event of until(events, 'numFmts')) {
@@ -142,7 +100,6 @@ function parseFonts(events) {
     for (const event of until(events, 'fonts')) {
         if (event.kind === 'open') {
             const local = localName(event.name);
-            // A <font>'s children are self-closing, so they are read here on open.
             if (local === 'font')
                 fontDraft = {};
             else if (fontDraft !== null)
@@ -160,9 +117,6 @@ function parseFills(events) {
     let pattern = '';
     let fgColor;
     let bgColor;
-    // A gradient fill accumulates from <gradientFill> open to close; its stops fill in as <stop>/<color>
-    // pairs arrive. `fillSlotAt` marks where in `fills` the current <fill> began, so its close can keep a
-    // slot even when the fill body was neither a pattern nor a gradient — index alignment is load-bearing.
     let gradientDraft = null;
     let fillSlotAt = -1;
     for (const event of until(events, 'fills')) {
@@ -170,9 +124,6 @@ function parseFills(events) {
             const attrs = event.attrs;
             switch (localName(event.name)) {
                 case 'fill':
-                    // Mark where this <fill> starts so its close can guarantee exactly one slot — a fill body
-                    // that is neither <patternFill> nor <gradientFill> (or a gradient we could not parse) must
-                    // still consume an id, or every later fill index shifts and cells mis-resolve their fill.
                     fillSlotAt = fills.length;
                     break;
                 case 'patternFill':
@@ -206,7 +157,6 @@ function parseFills(events) {
                     }
                     break;
                 case 'color':
-                    // The colour of the open <stop>; committed to a GradientStop when the stop closes.
                     if (gradientDraft !== null)
                         gradientDraft.stopColor = parseColor(attrs);
                     break;
@@ -235,8 +185,6 @@ function parseFills(events) {
                     }
                     break;
                 case 'fill':
-                    // Backstop the slot: if this <fill>'s body pushed nothing (unparsed/unknown content), keep an
-                    // empty slot so id alignment holds and later fills still resolve to the right cells.
                     if (fills.length === fillSlotAt)
                         fills.push(undefined);
                     break;
@@ -248,7 +196,6 @@ function parseFills(events) {
 function parseBorders(events) {
     const borders = [];
     let borderDraft = null;
-    // Which edge of the current border a nested <color> belongs to; null between edges.
     let currentEdge = null;
     for (const event of until(events, 'borders')) {
         if (event.kind === 'open') {
@@ -263,9 +210,6 @@ function parseBorders(events) {
                     borderDraft.diagonalDown = true;
             }
             else if (borderDraft !== null) {
-                // A border's edges and their <color> children are all read on open (each is self-closing bar a
-                // coloured edge, whose colour child is itself self-closing). An edge whose style is absent or
-                // an unrecognised token is dropped — the side simply carries no border.
                 if (BORDER_EDGES.has(local)) {
                     if (attrs.style !== undefined && isBorderStyle(attrs.style)) {
                         currentEdge = local;
@@ -292,39 +236,28 @@ function parseBorders(events) {
                 }
             }
             else if (borderDraft !== null && BORDER_EDGES.has(local)) {
-                // A coloured edge closes after its <color> child; drop the edge context so a stray later
-                // <color> cannot attach to it.
                 currentEdge = null;
             }
         }
     }
     return borders;
 }
-// Both <cellXfs> and <cellStyleXfs> hold <xf> with identical structure; they differ only in which
-// table the result lands in and whether an xfId link is meaningful (only cellXfs entries link to a
-// named style). One parser serves both, told by `container` which it is reading.
 function parseXfTable(events, container, deps) {
     const xfs = [];
     const captureXfId = container === 'cellXfs';
-    // The xf being read; held from open to close so its <alignment>/<protection> children can attach
-    // before it is committed. null outside an <xf>.
     let pendingXf = null;
     for (const event of until(events, container)) {
         if (event.kind === 'open') {
             const local = localName(event.name);
             if (local === 'xf') {
-                // Hold the xf open until its close so an <alignment>/<protection> child can attach first; a
-                // self-closing <xf/> is expanded to a close, so it commits there too, child-free.
                 pendingXf = resolveXf(event.attrs, deps, captureXfId);
             }
             else if (pendingXf !== null && local === 'alignment') {
-                // An xf's <alignment> child arrives before the xf closes; attach it to the pending xf.
                 const alignment = parseAlignment(event.attrs);
                 if (alignment !== undefined)
                     pendingXf.alignment = alignment;
             }
             else if (pendingXf !== null && local === 'protection') {
-                // An xf's <protection> child likewise arrives before the xf closes.
                 const protection = parseProtection(event.attrs);
                 if (protection !== undefined)
                     pendingXf.protection = protection;
@@ -337,18 +270,12 @@ function parseXfTable(events, container, deps) {
     }
     return xfs;
 }
-// Resolve an <xf>'s facet ids against the shared sub-tables into a draft. `captureXfId` is set only
-// for cellXfs entries, the sole table whose xfId links to a named style.
 function resolveXf(attrs, deps, captureXfId) {
     const fillId = Number(attrs.fillId);
     const fill = Number.isInteger(fillId) ? deps.fills[fillId] : undefined;
     const fontId = Number(attrs.fontId);
-    // Font id 0 is the workbook default font (a real Calibri-11-style face), not an absence — unlike
-    // border id 0, which is a genuinely empty border. So an xf naming font 0 resolves to that default
-    // face, giving every cell a concrete font to render.
     const font = Number.isInteger(fontId) ? deps.fonts[fontId] : undefined;
     const borderId = Number(attrs.borderId);
-    // Border id 0 is the empty default; only a custom border (id > 0) is an explicit one.
     const border = Number.isInteger(borderId) && borderId > 0 ? deps.borders[borderId] : undefined;
     const numFmt = resolveNumFmt(attrs.numFmtId, deps.numFmtCodes);
     const draft = {};
@@ -360,12 +287,8 @@ function resolveXf(attrs, deps, captureXfId) {
         draft.font = font;
     if (border)
         draft.border = border;
-    // The quote-prefix flag is an attribute on the xf itself (no shared sub-table); carry it only when
-    // set so an ordinary cell does not gain a spurious `quotePrefix: false`.
     if (boolStrict(attrs.quotePrefix))
         draft.quotePrefix = true;
-    // A cellXfs entry's xfId links it to a named style; capture it only when it points beyond the Normal
-    // default (0), so an ordinary cell carries no spurious named-style link.
     if (captureXfId && attrs.xfId !== undefined) {
         const xfId = Number(attrs.xfId);
         if (Number.isInteger(xfId) && xfId > 0)
@@ -373,8 +296,6 @@ function resolveXf(attrs, deps, captureXfId) {
     }
     return draft;
 }
-// A <cellStyle> (inside <cellStyles>) names a cellStyleXfs entry by xfId; it is self-closing, so it
-// is read on open.
 function parseCellStyles(events) {
     const names = [];
     for (const event of until(events, 'cellStyles')) {
@@ -396,9 +317,6 @@ function parseCellStyles(events) {
     }
     return names;
 }
-// A <font> child element sets one facet on the draft. Boolean flags honour their `val`: a
-// bare tag or val="1"/"true" is on, val="0"/"false" is off (an explicit-false flag is not
-// truthy merely because the tag is present). An unrecognised child is ignored.
 export function applyFontChild(draft, local, attrs) {
     switch (local) {
         case 'b':
@@ -414,10 +332,6 @@ export function applyFontChild(draft, local, attrs) {
             draft.outline = boolPresent(attrs.val);
             break;
         case 'u':
-            // A bare <u/> is a single underline; a named style (single/double/…) carries through; but
-            // val="none" is the explicit ABSENCE of an underline, so it must read back falsy — not the
-            // truthy string "none" that a consumer's `if (font.underline)` would mistake for underlined. An
-            // unrecognised token keeps the "is underlined" fact but drops the unknown style (a plain true).
             draft.underline =
                 attrs.val === undefined
                     ? true
@@ -440,7 +354,6 @@ export function applyFontChild(draft, local, attrs) {
         case 'color':
             draft.color = parseColor(attrs);
             break;
-        // `<name>` in a styles `<font>`, `<rFont>` in a rich-text run's `<rPr>` — the same font face.
         case 'name':
         case 'rFont':
             if (attrs.val !== undefined)
@@ -466,15 +379,10 @@ export function applyFontChild(draft, local, attrs) {
             break;
     }
 }
-// An xf's numFmtId resolves against the custom codes first, then the built-in table; the
-// General format (id 0) and any unrecognised id mean the cell carries no explicit format.
 function resolveNumFmt(raw, custom) {
     return raw === undefined ? undefined : numFmtCodeFor(Number(raw), custom);
 }
 function toFill(pattern, fgColor, bgColor) {
-    // `none` (and an absent patternType) is the absence of a fill; an unrecognised token is dropped the
-    // same way — like the border-edge style above — so a foreign pattern we do not model leaves the cell
-    // unfilled rather than propagating a token the writer would later re-emit unvalidated.
     if (!isFillPatternType(pattern) || pattern === 'none')
         return undefined;
     return {
@@ -484,8 +392,6 @@ function toFill(pattern, fgColor, bgColor) {
         ...(bgColor ? { bgColor } : {}),
     };
 }
-// Copy the numeric <gradientFill> attributes (degree; the path insets) onto a gradient draft, keeping
-// only the finite ones so an absent or malformed attribute leaves the field its OOXML default (unset).
 function assignGradientNumbers(fill, attrs) {
     for (const key of ['degree', 'left', 'right', 'top', 'bottom']) {
         const value = Number(attrs[key]);
@@ -493,22 +399,14 @@ function assignGradientNumbers(fill, attrs) {
             fill[key] = value;
     }
 }
-// An accumulated border with no styled edge and no diagonal direction is the empty default:
-// it carries nothing, so it resolves to undefined rather than an all-empty Border object.
 function borderToStyle(draft) {
     const hasEdge = BORDER_EDGE_NAMES.some((edge) => draft[edge] !== undefined);
     if (!hasEdge && draft.diagonalUp === undefined && draft.diagonalDown === undefined)
         return undefined;
     return draft;
 }
-// Read an <alignment> element's attributes into an Alignment, keeping only facets that differ
-// from the default. Boolean flags honour their parsed value — wrapText="0" is off, so it must
-// not fabricate a { wrapText: false } alignment — and an element carrying only defaults yields
-// undefined rather than an empty alignment object.
 function parseAlignment(attrs) {
     const out = {};
-    // `general` is the default and reads back as no explicit horizontal alignment; an unrecognised
-    // token (like an out-of-enum vertical one) is dropped rather than trusted into the model.
     if (attrs.horizontal !== undefined &&
         attrs.horizontal !== 'general' &&
         isHorizontalAlignment(attrs.horizontal)) {
@@ -537,10 +435,6 @@ function parseAlignment(attrs) {
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
-// Read a <protection> element into a Protection, keeping only facets that differ from the OOXML
-// default. `locked` defaults to TRUE, so only an explicit `locked="0"` carries information (an
-// unlocked cell) — a default or explicit-true cell must not read back as { locked: true }; `hidden`
-// defaults to false, so only `hidden="1"` is carried. An element with only defaults yields undefined.
 function parseProtection(attrs) {
     const out = {};
     if (attrs.locked === '0' || attrs.locked === 'false')
@@ -549,3 +443,62 @@ function parseProtection(attrs) {
         out.hidden = true;
     return Object.keys(out).length > 0 ? out : undefined;
 }
+export function parseIndexedColors(stylesXml) {
+    return elementFragments(stylesXml, 'indexedColors', 'rgbColor');
+}
+export function parseMruColors(stylesXml) {
+    return elementFragments(stylesXml, 'mruColors', 'color');
+}
+export function parseTableStyles(stylesXml) {
+    const styles = elementFragments(stylesXml, 'tableStyles', 'tableStyle');
+    const table = { styles };
+    for (const { attrs } of openElements(stylesXml, 'tableStyles')) {
+        if (attrs.defaultTableStyle !== undefined)
+            table.defaultTableStyle = attrs.defaultTableStyle;
+        if (attrs.defaultPivotStyle !== undefined)
+            table.defaultPivotStyle = attrs.defaultPivotStyle;
+        break;
+    }
+    const namespaces = fragmentNamespaces(stylesXml, styles);
+    if (namespaces.length > 0)
+        table.namespaces = namespaces;
+    return table;
+}
+function fragmentNamespaces(stylesXml, fragments) {
+    if (fragments.length === 0)
+        return [];
+    const declared = new Map();
+    const ignorable = new Set();
+    for (const { attrs } of openElements(stylesXml, 'styleSheet')) {
+        for (const [name, value] of Object.entries(attrs)) {
+            if (name.startsWith('xmlns:'))
+                declared.set(name.slice('xmlns:'.length), value);
+        }
+        for (const prefix of (attrs['mc:Ignorable'] ?? '').split(/\s+/)) {
+            if (prefix !== '')
+                ignorable.add(prefix);
+        }
+        break;
+    }
+    const used = new Set();
+    for (const fragment of fragments) {
+        for (const match of fragment.matchAll(/[\s</]([A-Za-z_][\w.-]*):[A-Za-z_]/g)) {
+            used.add(match[1]);
+        }
+    }
+    return [...used]
+        .filter((prefix) => declared.has(prefix))
+        .map((prefix) => ({
+        prefix,
+        uri: declared.get(prefix),
+        ignorable: ignorable.has(prefix),
+    }));
+}
+function elementFragments(xml, container, child) {
+    const block = new RegExp(`<${container}\\b[^>]*>([\\s\\S]*?)</${container}>`).exec(xml);
+    if (block === null)
+        return [];
+    const inner = block[1] ?? '';
+    const pattern = new RegExp(`<${child}\\b[^>]*/>|<${child}\\b[^>]*>[\\s\\S]*?</${child}>`, 'g');
+    return [...inner.matchAll(pattern)].map((m) => m[0] ?? '');
+}