@shbernal/ts-xlsx 1.1.0 → 1.2.0

package/dist/io/xlsb/ptg-functions.js

@@ -1,42 +1,11 @@
-// The `Ftab` built-in function table ([MS-XLS] 2.5.198.17, shared verbatim by BIFF12): the index a
-// `PtgFunc`/`PtgFuncVar` token carries, mapped to the function name that index means.
-//
-// A binary formula names no function — it cites one by number — so this table is the whole difference
-// between `SUM(A1:A5)` and an unreadable stream. It is transcribed from the normative table rather
-// than assembled from Excel's UI, which matters at both ends: the low indices include the XLM macro
-// functions (`GOTO`, `ADD.BAR`, …) that no modern sheet uses but a legacy file may still carry, and
-// the table simply stops at `RTD`. Everything Microsoft added after that — the whole modern library,
-// `TEXTJOIN` through `LAMBDA` — is *not* here and never will be: a post-2007 function is called
-// through index 255 ("user defined") with an `_xlfn.`-prefixed name as its first operand, which is
-// the same indirection the XML form spells out in the function name itself.
-//
-// The four gaps (0x00CA–CB, 0x00D9–DA, 0x00F9–FA, 0x014D) are gaps in the specification: those
-// indices name no function, so a formula citing one is not decodable rather than decodable as
-// something adjacent.
-/** The index [MS-XLS] reserves for a call whose name is given by the token stream's first operand. */
 export const FTAB_USER_DEFINED = 0x00ff;
-/** Look up a built-in function name by its `iftab` index, or `undefined` if the index names none. */
 export function functionNameFor(index) {
     return FTAB[index];
 }
-/**
- * How many arguments a fixed-arity function takes, or `undefined` for one whose argument count varies.
- *
- * A `PtgFunc` token states only *which* function is called, never with how many arguments — it is the
- * token Excel emits precisely because the count is implied by the function. So decoding `ROUND(A1,2)`
- * back from its two operands and one call token is impossible without this: the arity is the only
- * thing that says which operands on the stack belong to the call. (`PtgFuncVar` carries its own count
- * and needs none of this; the two token forms partition the table between them.)
- *
- * Transcribed from the parameter grammar each function's [MS-XLS] 2.5.198.17 entry states.
- */
 export function fixedArityFor(name) {
     return FIXED_ARITY.get(name);
 }
-// Keyed by name rather than index: an arity belongs to the function, and a name is checkable at a
-// glance where a hex index is not.
 const FIXED_ARITY = new Map(Object.entries({
-    // "This function takes no parameters."
     NA: 0,
     PI: 0,
     TRUE: 0,
@@ -248,8 +217,6 @@ const FIXED_ARITY = new Map(Object.entries({
     TTEST: 4,
     WEIBULL: 4,
 }));
-// The table as contiguous runs, each `[first index, names in order]`. Written this way so the four
-// specification gaps are visible as run boundaries instead of hiding as miscounted array entries.
 const RUNS = [
     [
         0x0000,
@@ -650,7 +617,6 @@ const RUNS = [
         ],
     ],
 ];
-// Indexed by `iftab`; a hole is an index the specification does not define.
 const FTAB = RUNS.reduce((table, [start, names]) => {
     names.forEach((name, offset) => {
         table[start + offset] = name;

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

@@ -1,13 +1,6 @@
-// The BIFF12 shared-string table: `xl/sharedStrings.bin` in, the pool a `BrtCellIsst` cell indexes.
-//
-// The binary table is a flat run of `BrtSSTItem` records between a Begin/End pair, each holding one
-// `RichStr`. Only the text is taken: a pooled string's per-run formatting is not modelled in this cut,
-// so the runs are left unread rather than half-decoded (see `primitives.ts`). Reading stops at the
-// closing record, so trailing future-record blocks are never framed.
 import { RecordReader } from './primitives.js';
 import { readRecords } from './record-stream.js';
 import { BRT } from './record-types.js';
-/** Parse `xl/sharedStrings.bin` into the pool, in index order. An absent part is an empty pool. */
 export function parseSharedStrings(part) {
     if (part === undefined)
         return [];

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

@@ -1,14 +1,3 @@
-// The BIFF12 style-sheet reader: `xl/styles.bin` in, the same {@link StyleTable} the XML reader
-// produces out. Every collection (`fmts`, `fonts`, `fills`, `borders`, `cellStyleXfs`, `cellXfs`,
-// `styles`) is a Begin/End record pair around its entries, so the pass tracks which collection it is
-// inside — `BrtXF` appears in two of them and is meaningless without that context.
-//
-// The resolution *rules* are deliberately not restated here: number-format ids go through the XML
-// reader's `numFmtCodeFor`, and each facet is emitted with the same "only when it differs from the
-// default" discipline the XML path uses. That is what makes the binary and XML readings of one
-// workbook the same model rather than two similar ones — a bottom vertical alignment, a locked cell,
-// or a General number format is written explicitly in BIFF12 and omitted in XML, so the binary side
-// has to drop exactly what the XML side never had.
 import { assignStyleFacets } from '../../core/style.js';
 import { numFmtCodeFor } from '../style/xf-style.js';
 import { RecordReader } from './primitives.js';
@@ -32,7 +21,6 @@ const COLLECTION_ENDS = new Set([
     BRT.EndCellXFs,
     BRT.EndStyles,
 ]);
-/** Parse `xl/styles.bin` into the flat cell-format table a worksheet's style indices resolve against. */
 export function parseStyleTable(part) {
     if (part === undefined)
         return { cellXfs: [], namedStyles: [] };
@@ -86,8 +74,6 @@ export function parseStyleTable(part) {
                 break;
         }
     }
-    // Layer each direct format over the named style its xfId links to, exactly as the XML reader does:
-    // a facet the cell's own xf sets wins, one it leaves unset falls through to the named base.
     const cellXfs = directXfs.map((xf) => {
         if (xf.xfId === undefined)
             return xf;
@@ -104,22 +90,15 @@ export function parseStyleTable(part) {
             style.builtinId = label.builtinId;
         return style;
     });
-    // Font 0 is the workbook's declared default, carried out whole as well as flattened onto the xfs
-    // that name it — see {@link StyleTable.defaultFont}. The XML reader does the same.
     const defaultFont = fonts[0];
     return defaultFont === undefined ? { cellXfs, namedStyles } : { cellXfs, namedStyles, defaultFont };
 }
-// `BrtXF` ([MS-XLSB] 2.4.876): five facet indices, the two inline alignment scalars, then two flag
-// words. `isDirect` distinguishes a cellXfs entry (whose ixfeParent links to a named style) from a
-// cellStyleXfs entry (whose ixfeParent is the 0xFFFF "I am the named style" marker).
 function readXf(reader, deps, isDirect) {
     const parent = reader.u16();
     const numFmt = numFmtCodeFor(reader.u16(), deps.numFmtCodes);
     const font = deps.fonts[reader.u16()];
     const fill = deps.fills[reader.u16()];
     const borderIndex = reader.u16();
-    // Border 0 is the genuinely empty default (font 0, by contrast, is the workbook's real default
-    // face), so only a custom index names an actual border — the same asymmetry the XML reader keeps.
     const border = borderIndex > 0 ? deps.borders[borderIndex] : undefined;
     const rotation = reader.u8();
     const indent = reader.u8();
@@ -139,20 +118,13 @@ function readXf(reader, deps, isDirect) {
     const protection = readProtection(flags);
     if (protection !== undefined)
         draft.protection = protection;
-    // f123Prefix is the binary spelling of the `quotePrefix` attribute: the cell's text is displayed
-    // with a leading apostrophe stripped.
     if ((flags & 0x8000) !== 0)
         draft.quotePrefix = true;
-    // Only a link beyond the Normal default (0) carries information, and only a direct format has one.
     if (isDirect && parent !== NOT_A_CELL_XF && parent > 0)
         draft.xfId = parent;
     return draft;
 }
-// The `ixfeParent` value a cell *style* XF carries in place of a link, since it is itself the base.
 const NOT_A_CELL_XF = 0xffff;
-// BIFF12 states every alignment field on every xf, where XML omits the ones at their default. Keep
-// only what the XML reader would have seen, so the two readings of one workbook agree: `general`
-// horizontal, `bottom` vertical, and zero rotation/indent/reading-order are absences, not values.
 function readAlignment(flags, rotation, indent) {
     const out = {};
     const horizontal = HORIZONTAL_ALIGNMENTS[flags & 0b111];
@@ -174,8 +146,6 @@ function readAlignment(flags, rotation, indent) {
         out.readingOrder = readingOrder;
     return Object.keys(out).length > 0 ? out : undefined;
 }
-// `locked` defaults to TRUE in OOXML, so an *unlocked* cell is the state that carries information;
-// `hidden` defaults to false, so only a set flag does. A default xf yields no protection at all.
 function readProtection(flags) {
     const out = {};
     if ((flags & 0x1000) === 0)
@@ -184,8 +154,6 @@ function readProtection(flags) {
         out.hidden = true;
     return Object.keys(out).length > 0 ? out : undefined;
 }
-// `alc` ([MS-XLSB] 2.4.876), indexed by its stored value. `general` is index 0 and is left out
-// deliberately: it is the type-dependent default, which the model spells as no horizontal alignment.
 const HORIZONTAL_ALIGNMENTS = [
     undefined,
     'left',
@@ -196,7 +164,6 @@ const HORIZONTAL_ALIGNMENTS = [
     'centerContinuous',
     'distributed',
 ];
-// `alcv`, likewise — with `bottom` (index 2) left out as the default.
 const VERTICAL_ALIGNMENTS = [
     'top',
     'center',
@@ -204,8 +171,6 @@ const VERTICAL_ALIGNMENTS = [
     'justify',
     'distributed',
 ];
-// `BrtFont` ([MS-XLSB] 2.4.690). Weight is a numeric scale (400 normal, 700 bold) rather than a flag,
-// and the italic/strike/outline bits live in a separate word from it.
 function readFont(reader) {
     const height = reader.u16();
     const flags = reader.u16();
@@ -214,14 +179,13 @@ function readFont(reader) {
     const underline = reader.u8();
     const family = reader.u8();
     const charset = reader.u8();
-    reader.skip(1); // unused
+    reader.skip(1);
     const color = reader.color();
     const scheme = reader.u8();
     const name = reader.wideString();
     const font = {};
     if (name !== '')
         font.name = name;
-    // Stored in twips; the model (like the XML) carries points.
     if (height > 0)
         font.size = height / 20;
     if (family !== 0)
@@ -234,8 +198,6 @@ function readFont(reader) {
         font.scheme = 'minor';
     if (color !== undefined)
         font.color = color;
-    // Each boolean facet is recorded only when on, mirroring XML's present-or-absent `<b/>`/`<i/>`:
-    // a non-bold font must not read back as `bold: false`.
     if (weight >= BOLD_WEIGHT)
         font.bold = true;
     if ((flags & 0b0000_0010) !== 0)
@@ -254,27 +216,16 @@ function readFont(reader) {
     return font;
 }
 const BOLD_WEIGHT = 700;
-// `uls` ([MS-XLSB] 2.4.690). A single underline is `true`, not `'single'`, because that is what XML's
-// bare `<u/>` — which is what Excel writes for it — reads back as.
 const UNDERLINE_STYLES = new Map([
     [0x01, true],
     [0x02, 'double'],
     [0x21, 'singleAccounting'],
     [0x22, 'doubleAccounting'],
 ]);
-// `BrtFill` ([MS-XLSB] 2.4.681). The pattern code and OOXML's `ST_PatternType` enumerate the same
-// patterns in the same order, so the code indexes the name list directly.
 function readFill(reader) {
     const pattern = FILL_PATTERNS[reader.u32()];
-    // `none` is the absence of a fill, and an unmodelled pattern (a gradient — see below) is dropped
-    // rather than guessed, so an unfilled cell reads back unfilled either way.
     if (pattern === undefined)
         return undefined;
-    // BIFF12 always states both colours; XML states only the ones the fill actually has, using the two
-    // legacy-palette sentinels for the rest — 64 is "automatic foreground", 65 "automatic background".
-    // Dropping each in its own slot reproduces exactly what the XML reader sees: an untouched hatch
-    // pattern carries no colours at all, while a solid fill keeps the explicit `bgColor indexed="64"`
-    // Excel writes beside its foreground.
     const fgColor = notSentinel(reader.color(), AUTOMATIC_FOREGROUND);
     const bgColor = notSentinel(reader.color(), AUTOMATIC_BACKGROUND);
     return {
@@ -289,10 +240,6 @@ const AUTOMATIC_BACKGROUND = 65;
 function notSentinel(color, sentinel) {
     return color?.indexed === sentinel ? undefined : color;
 }
-// Indexed by the stored `fls` value. Index 0 (`none`) is deliberately absent: an unfilled cell
-// carries no fill. Gradient fills (`fls` 0x28) are not decoded in this cut — the stop array's layout
-// is the one piece of BrtFill this reader has no Excel-authored sample to check against, and a
-// silently wrong gradient is worse than none.
 const FILL_PATTERNS = [
     undefined,
     'solid',
@@ -314,9 +261,6 @@ const FILL_PATTERNS = [
     'gray125',
     'gray0625',
 ];
-// `BrtBorder` ([MS-XLSB] 2.4.314): the two diagonal-direction bits, then five `Blxf` edges in the
-// order top, bottom, left, right, diagonal — which is *not* the model's or the schema's order, so
-// the edges are read positionally and named here.
 function readBorder(reader) {
     const flags = reader.u8();
     const top = readEdge(reader);
@@ -339,21 +283,16 @@ function readBorder(reader) {
         border.diagonalDown = true;
     if ((flags & 0b10) !== 0)
         border.diagonalUp = true;
-    // An all-default border is the empty one every unbordered cell shares; it carries nothing.
     return Object.keys(border).length > 0 ? border : undefined;
 }
-// A `Blxf` ([MS-XLSB] 2.5.5): a line style, a reserved byte, and a colour. Style 0 is "no edge",
-// which the model spells by omitting the edge rather than by a `none` value.
 function readEdge(reader) {
     const style = BORDER_STYLES[reader.u8()];
-    reader.skip(1); // reserved
+    reader.skip(1);
     const color = reader.color();
     if (style === undefined)
         return undefined;
     return color === undefined ? { style } : { style, color };
 }
-// Indexed by the stored `dg` value; index 0 (`none`) is absent, as above. The order is the binary
-// format's own and differs from `ST_BorderStyle`'s declaration order, so it cannot be shared.
 const BORDER_STYLES = [
     undefined,
     'thin',
@@ -370,13 +309,11 @@ const BORDER_STYLES = [
     'mediumDashDotDot',
     'slantDashDot',
 ];
-// `BrtStyle` ([MS-XLSB] 2.4.809): which cellStyleXfs entry this names, and how it is labelled. The
-// gallery index is only meaningful for a built-in style, which the flag word declares.
 function readStyleLabel(reader) {
     const xfId = reader.u32();
     const flags = reader.u16();
     const builtinId = reader.u8();
-    reader.skip(1); // iLevel: the outline depth of a built-in RowLevel/ColLevel style.
+    reader.skip(1);
     const name = reader.wideString();
     return {
         xfId,

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

@@ -1,21 +1,3 @@
-// The BIFF12 worksheet-body reader: one `xl/worksheets/sheetN.bin` in, one populated {@link Worksheet}
-// out — the binary counterpart of `../xlsx/read-worksheet.ts`, filling the very same model.
-//
-// The cell table is a flat, row-major run of records: a `BrtRowHdr` opens a row and every cell record
-// until the next one belongs to it, so the open row is a single variable rather than nested state.
-// Each cell record is a `Cell` header followed by a value shaped by the record's own type — which is
-// what makes the binary form quick to parse: there is no `t=` attribute to interpret, the record
-// number *is* the type.
-//
-// A formula cell carries both halves of what the XML form spells in `<f>` and `<v>`: a `Ptg` token
-// stream, decoded back to text by `./formula.ts`, and the result Excel last computed. The two are
-// filled independently — a formula whose stream uses a token this reader does not decode still
-// surfaces its cached value, which is exactly what the reader could see before the decoder existed.
-//
-// One shape needs a second look at the sheet. An array formula's member cells hold a `PtgExp`
-// pointing at the group's top-left, and the `BrtArrFmla` record carrying the group's actual formula
-// comes *after* those cells in the stream. Those cells are therefore parked and resolved once the
-// whole part has been read.
 import { encodeAddress, MAX_COLUMN } from '../../core/address.js';
 import { isDateFormat, serialToDate } from '../../core/date.js';
 import { unmangleFunctions } from '../../core/formula.js';
@@ -25,9 +7,6 @@ import { decodeFormula, formulaAnchor } from './formula.js';
 import { errorCodeFor, RecordReader } from './primitives.js';
 import { readRecords } from './record-stream.js';
 import { BRT } from './record-types.js';
-// Every record that carries a plain cell — one whose payload is a value and nothing else. Membership
-// drives the dispatch below, so a record type absent from both this set and {@link FORMULA_RECORDS}
-// is skipped whole rather than being mistaken for a cell and consuming the reader.
 const CELL_RECORDS = new Set([
     BRT.CellBlank,
     BRT.CellRk,
@@ -38,40 +17,23 @@ const CELL_RECORDS = new Set([
     BRT.CellIsst,
     BRT.CellRString,
 ]);
-// Every record that carries a formula: a cached result of the record's own kind, then the token
-// stream that produced it.
 const FORMULA_RECORDS = new Set([
     BRT.FmlaString,
     BRT.FmlaNum,
     BRT.FmlaBool,
     BRT.FmlaError,
 ]);
-/**
- * Read a worksheet part into `sheet`: its column and row geometry, its merged ranges, and every
- * non-empty cell with the style its index resolves to in `xfStyles` and, for a formula cell, the text
- * its token stream decodes to through `scope`.
- */
 export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
-    // The open row, one-based as the model counts them. -1 means none is open, which a cell record
-    // arriving before any row header (a malformed sheet) is dropped against rather than guessed at.
     let row = -1;
-    // A row that declares a format supplies the default for its cells that carry none, as a column
-    // does; the next row header replaces it.
     let rowStyle = -1;
-    // A column's format is the last fallback. Column records always precede the cell table.
     const columnStyle = new Map();
-    // The sheet's default row height, in twips. Every row header restates its height whether or not the
-    // row has one of its own, so the default is what tells the two apart — see {@link applyRow}.
-    // `BrtWsFmtInfo` precedes the cell table, so it is always known by the time a row is read.
     let defaultRowHeight = -1;
-    // The formula of each array-formula group, keyed by the group's top-left cell, and the member cells
-    // waiting on one. Both are needed because `BrtArrFmla` follows the cells it speaks for.
     const groups = new Map();
     const deferred = [];
     for (const record of readRecords(part)) {
         const reader = new RecordReader(record.data);
         if (record.type === BRT.WsFmtInfo) {
-            reader.skip(6); // dxGCol, cchDefColWidth: the default *column* width, which the model does not read.
+            reader.skip(6);
             defaultRowHeight = reader.u16();
         }
         else if (record.type === BRT.ColInfo) {
@@ -90,7 +52,7 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
         }
         else if (record.type === BRT.ArrFmla) {
             const { rowFirst, colFirst } = reader.range();
-            reader.skip(1); // fAlwaysCalc: a recalculation hint, not part of the formula.
+            reader.skip(1);
             groups.set(groupKey(rowFirst, colFirst), {
                 rgce: reader.bytes(reader.u32()),
                 rgcb: reader.bytes(reader.u32()),
@@ -100,9 +62,6 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
             const { column, styleIndex } = reader.cell();
             if (!inGrid(column, row - 1))
                 continue;
-            // A cell's own format wins, then its row's, then its column's — the order Excel applies.
-            // Index 0 is the default xf, which BIFF12 writes where XML simply omits `s`, so it means
-            // "no format of my own" and lets the row/column default through.
             const resolved = styleIndex > 0 ? styleIndex : rowStyle >= 0 ? rowStyle : (columnStyle.get(column) ?? -1);
             const style = resolved >= 0 ? xfStyles[resolved] : xfStyles[0];
             const cell = sheet.getCell(encodeAddress(column + 1, row));
@@ -112,7 +71,7 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
                 continue;
             }
             const result = cachedResult(record.type, reader, style?.numFmt);
-            reader.skip(2); // grbitFlags: per-cell recalculation hints the model does not carry.
+            reader.skip(2);
             const rgce = reader.bytes(reader.u32());
             const rgcb = reader.bytes(reader.u32());
             const anchor = formulaAnchor(rgce, rgcb);
@@ -132,8 +91,6 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
         }
     }
     for (const member of deferred) {
-        // Only the group's top-left cell states the formula; the rest carry the value it produced, which
-        // is exactly what the XML form writes for them.
         const group = groups.get(groupKey(member.anchorRow, member.anchorColumn));
         const own = member.row === member.anchorRow && member.column === member.anchorColumn;
         member.cell.value =
@@ -145,23 +102,15 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
 function groupKey(row, column) {
     return `${row}:${column}`;
 }
-// Pair a decoded formula with its cached result, in the shape the XML reader produces for the same
-// cell. A formula the decoder could not read leaves the value alone: the cached result is still true,
-// and is what this reader surfaced before formulas were decoded at all.
 function formulaValue(formula, result) {
     if (formula === undefined)
         return result ?? null;
-    // Strip the `_xlfn.`/`_xlpm.` on-disk mangling, as the XML reader does, so the model never holds it.
     const stored = unmangleFunctions(formula);
     return result === undefined ? { formula: stored } : { formula: stored, result };
 }
-// The result a formula record cached, decoded by the record's own kind — the binary counterpart of
-// reading `<v>` under the `t` attribute.
 function cachedResult(type, reader, numFmt) {
     switch (type) {
         case BRT.FmlaNum:
-            // A formula's cached numeric result honours the cell's date format exactly as a bare number
-            // does, so a date-valued formula reads back as a Date rather than a serial.
             return asNumberOrDate(reader.f64(), numFmt);
         case BRT.FmlaBool:
             return reader.u8() !== 0;
@@ -173,19 +122,11 @@ function cachedResult(type, reader, numFmt) {
             return reader.wideString();
     }
 }
-// Excel's grid bounds, zero-based as the binary format counts. [MS-XLSB] states them as MUST
-// constraints, which is exactly why a reader has to check them: a damaged or hostile file states
-// whatever it likes, and an address beyond the grid has nowhere to go. Everything positional funnels
-// through here before it reaches the model, so an out-of-grid record is dropped rather than turned
-// into an unrepresentable address (which the address encoder would reject) or, worse, a column loop
-// four billion iterations long.
 const MAX_ROW_INDEX = 1048575;
 const MAX_COLUMN_INDEX = MAX_COLUMN - 1;
 function inGrid(column, row) {
     return column >= 0 && column <= MAX_COLUMN_INDEX && row >= 0 && row <= MAX_ROW_INDEX;
 }
-// Decode a cell record's payload — the reader is positioned just past the shared `Cell` header, so
-// what remains is exactly the value this record type carries.
 function decodeCell(type, reader, sharedStrings, numFmt) {
     switch (type) {
         case BRT.CellRk:
@@ -195,45 +136,32 @@ function decodeCell(type, reader, sharedStrings, numFmt) {
         case BRT.CellBool:
             return reader.u8() !== 0;
         case BRT.CellError: {
-            // An unrecognised error byte keeps the cell non-empty without inventing an error the model
-            // does not define; there is no text form to fall back to as there is in XML.
             const error = errorCodeFor(reader.u8());
             return error === undefined ? null : { error };
         }
         case BRT.CellSt:
             return reader.wideString();
         case BRT.CellRString:
-            // Rich runs are not modelled in this cut; the flattened text is what a consumer sees.
             return reader.richString();
         case BRT.CellIsst:
             return sharedStrings[reader.u32()] ?? '';
         default:
-            // BrtCellBlank: formatted but empty. The style is already applied; the value is genuinely none.
             return null;
     }
 }
-// A number stored under a date format is a date serial — surface it as a Date so a date read from an
-// `.xlsb` is the same value the `.xlsx` twin yields, not a bare number.
 function asNumberOrDate(value, numFmt) {
     return numFmt !== undefined && isDateFormat(numFmt) ? serialToDate(value) : value;
 }
-// `BrtRowHdr` ([MS-XLSB] 2.4.770): the row index, its default format, its height, and a byte of
-// layout flags. Returns the open row (one-based) and the style index its cells inherit.
 function applyRow(reader, sheet, defaultRowHeight) {
     const index = reader.u32();
     const styleIndex = reader.u32();
     const height = reader.u16();
-    reader.skip(1); // fExtraAsc/fExtraDsc: border padding, a rendering hint the model does not carry.
+    reader.skip(1);
     const flags = reader.u8();
-    // A row beyond the grid closes the open row without opening another, so its cells are dropped too.
     if (index > MAX_ROW_INDEX)
         return { row: -1, styleIndex: -1 };
     const row = index + 1;
     const handle = sheet.getRow(row);
-    // Every row header restates a height; only a row whose height is its *own* has one to record. That
-    // is a row the user sized by hand, or one Excel auto-fitted to a taller font or wrapped text — both
-    // differ from the sheet default, which is exactly when XML emits `ht`. A row merely restating the
-    // default carries no height, so it must not read back with one.
     if ((flags & ROW_CUSTOM_HEIGHT) !== 0 || height !== defaultRowHeight) {
         handle.height = height / TWIPS_PER_POINT;
     }
@@ -244,7 +172,6 @@ function applyRow(reader, sheet, defaultRowHeight) {
         handle.outlineLevel = outlineLevel;
     if ((flags & ROW_COLLAPSED) !== 0)
         handle.collapsed = true;
-    // The row's format applies only when it says so, mirroring XML's `customFormat="1"` gate.
     return { row, styleIndex: (flags & ROW_CUSTOM_FORMAT) !== 0 ? styleIndex : -1 };
 }
 const TWIPS_PER_POINT = 20;
@@ -253,7 +180,6 @@ const ROW_COLLAPSED = 0b0000_1000;
 const ROW_HIDDEN = 0b0001_0000;
 const ROW_CUSTOM_HEIGHT = 0b0010_0000;
 const ROW_CUSTOM_FORMAT = 0b0100_0000;
-// `BrtColInfo` ([MS-XLSB] 2.4.319): one record per run of identically-sized columns.
 function applyColumn(reader, sheet, xfStyles, columnStyle) {
     const first = reader.u32();
     const last = reader.u32();
@@ -262,24 +188,16 @@ function applyColumn(reader, sheet, xfStyles, columnStyle) {
     const flags = reader.u16();
     const style = styleIndex > 0 ? xfStyles[styleIndex] : undefined;
     const outlineLevel = (flags >> COLUMN_OUTLINE_SHIFT) & 0b111;
-    // A run can name every column to the right of the data; materialising all 16 384 of them would
-    // turn a two-column sheet into a 16 384-entry model, so a run is only applied where it carries
-    // something a default column does not.
     if (style === undefined &&
         outlineLevel === 0 &&
         (flags & (COLUMN_HIDDEN | COLUMN_CUSTOM_WIDTH | COLUMN_COLLAPSED)) === 0) {
         return;
     }
-    // The loop bound comes from the file, so it is clamped to the grid before it is one: an unclamped
-    // run declaring four billion columns is a denial of service, not a wide sheet.
     const lastInGrid = Math.min(last, MAX_COLUMN_INDEX);
     if (first > lastInGrid)
         return;
     for (let index = first; index <= lastInGrid; index++) {
         const column = sheet.getColumn(index + 1);
-        // The stored width is taken whether or not the file marks it user-set, matching the XML reader:
-        // a `<col>`/`BrtColInfo` exists only for a column that differs from the sheet default in *some*
-        // way, and it always states the width that column actually has.
         column.width = width / COLUMN_WIDTH_UNITS;
         if ((flags & COLUMN_HIDDEN) !== 0)
             column.hidden = true;
@@ -293,7 +211,6 @@ function applyColumn(reader, sheet, xfStyles, columnStyle) {
             columnStyle.set(index, styleIndex);
     }
 }
-// Column width is stored in 1/256ths of a character, where XML states the character count directly.
 const COLUMN_WIDTH_UNITS = 256;
 const COLUMN_HIDDEN = 0b0000_0001;
 const COLUMN_CUSTOM_WIDTH = 0b0000_0010;