@apertura/xlsx

The format code of a built-in id, or `undefined` when the id is not reserved.

`A` becomes 0, `AA` becomes 26.

0 becomes `A`, 26 becomes `AA`.

Compiles a format code, or returns the cached compilation.

Builds an evaluation context over a workbook. Every sheet is loaded, because a formula on one sheet may read any other and the engine's questions are synchronous. That is the one place where calculation is at odds with the viewer's laziness, and it is why calculation is asked for rather than assumed.

A ready-made evaluator over a workbook, for callers that want one call.

A function that answers "is this predicate true here". The shape the renderer wants: it has a formula and a cell, and needs a value. Everything else — building the context, loading the sheets, turning a result back into a cell value — happens once, here, rather than at the call site.

The inverse: a `Date` as the serial number Excel would store for it.

An empty stylesheet, for a workbook that has no `styles.xml` at all.

Computes the value of one formula. The entry point for everything that has no cached answer: a conditional formatting predicate, a data validation, a cell whose `<f>` came without a `<v>`.

`{ row: 0, column: 0 }` becomes `A1`.

Excel's `General`. Not "the number as JavaScript prints it": Excel keeps about eleven significant digits and falls back to scientific notation outside a fixed range, which is why `0.1 + 0.2` shows as `0.3` in a spreadsheet and as something longer in a console.

Formats a value the way Excel would with the given code. `code` is the format string, not the id: resolving an id through the workbook's `numFmts` and the built-in table happens in the style layer, which is the only place that knows both.

Looks up an indexed colour, falling back to the default palette.

Whether a format code shows a date or a time rather than a number.

Whether the code contains a text section, which is what makes it apply to strings.

Puts the corners in order, so a range written backwards still works.

Opens an Excel workbook.

Packs a cell position into one number. A `Map` keyed by `${row},${column}` allocates a string per lookup, and the renderer does one per visible cell per frame. The column fits in fourteen bits and the row in twenty, so both fit in a double with room to spare.

`A1` becomes `{ row: 0, column: 0 }`; anything else returns `undefined`.

`xl/comments1.xml`. The text of a comment is rich, and its author is an index into a list at the top of the part. The box it is drawn in lives somewhere else entirely — in a VML part that predates the format by a decade — and is not read: a viewer that shows the note on hover does not need the coordinates of a box that was hidden anyway.

Parses `A1:C5`, `A1` or a whole-column/row range such as `A:C` or `2:4`. Whole-column ranges are what an autofilter and most conditional formatting rules are written as, so refusing them would lose the feature rather than one odd file. They come back bounded by the sheet limits.

Parses a space-separated list of ranges, as `sqref` attributes hold.

Streams the shared string table.

`xl/tables/tableN.xml`. A table is a named, styled range with a header row, an optional totals row and filter buttons. It matters to a viewer because the banded style comes from the table rather than from the cells: strip the table and the rows lose their alternating fill.

Reads one `<si>` or `<is>` subtree. Must be called while positioned on the container's start element; it consumes through the matching end element. Phonetic guides (`<rPh>`) are skipped. They hold the reading of a Japanese word and are shown above the text, not in it — concatenating them produces a cell that reads the same thing twice.

Converts a serial number to a JavaScript `Date` in UTC.

Converts a serial number to calendar parts. Returns `undefined` for values Excel itself refuses to show as a date: negative serials in the 1900 system produce `#####`, not a date before the epoch.

Rewrites a formula as if it had been filled from one cell to another. Relative references move with the cell and absolute ones (`$A$1`) do not, which is the whole distinction the dollar signs exist for. A reference that would move off the sheet becomes `#REF!`, as it does in Excel.

A cell. Row and column are stored flat rather than in a nested address object: a large sheet has millions of these, and the object that would hold two numbers costs more than the numbers.

Zero-based cell position.

A comment or a threaded note attached to a cell.

A fully resolved format: what a cell actually looks like.

A rectangular range, inclusive on both ends and zero-based.

One `xf` as written, before its parent style is folded in.

A colour as a workbook writes it. Four ways of saying the same thing, and a file will use all four. `rgb` is literal; `theme` points into the theme's colour scheme and is what a modern file uses so that changing the theme restyles the workbook; `indexed` is the pre-2007 palette; `auto` means "whatever the window text colour is". `tint` lightens or darkens whichever of them was given.

A `<col>` element: formatting for a span of columns.

A conditional formatting threshold (`cfvo`).

Whole and fractional parts of a serial number, in calendar terms.

A defined name: a range or a formula the workbook gave a name to.

A differential format: the parts a conditional rule or a table style changes. Everything is optional by construction — a rule that paints the background red must leave the font alone, and the only way to say that is to say nothing.

An image, chart or shape anchored to the grid.

The result of formatting a value with a format code.

A named style, as the style gallery lists it.

A frozen or split pane.

What the sheet part yields, before the parts it points at are resolved.

One formatting run of a rich string. The font is inline rather than an index: a shared string writes its formatting into itself (`<rPr>`) instead of pointing at the font table, so a cell whose text is half bold carries two runs with two fonts of their own.

What a shape looks like. A shape says its appearance in two places and they compose: `xdr:spPr` is what the shape itself states and has the last word, and `xdr:style` is what it takes from the theme — as *references* (`a:fillRef`, `a:lnRef`, `a:fontRef`) that carry a colour of their own. That colour is what the reference is for: the first fill styles of every theme are a plain solid fill of the placeholder colour, so the colour in the reference is the fill in the overwhelming majority of files.

A shared string: its plain text, and its runs when it has more than one.

A workbook sheet. Contents are loaded on demand.

Everything the sheet parser needs from the workbook around it.

Parsed sheet contents.

One sparkline: the range it draws, and the cell it draws in.

A chart the size of a cell, drawn inside it. The group holds the look and the list holds the cells: every sparkline of a group is drawn the same way, from a range of its own.

The colour scheme of `theme1.xml`, in the order the theme writes it.

A cell value after parsing.

A merged block. Named for what it means; the shape is an ordinary range.

The legacy indexed colour palette. Before themes, a workbook referred to colours by index into a 56-entry table that lived in the file (`<indexedColors>`) and, when it did not, was assumed to be this one. Files still arrive with `indexed="10"` on a font, and number format codes still say `[Color 10]`, so the default table has to be here even though nothing has written it deliberately in twenty years. Indices 0-7 repeat as 8-15: the first eight are the "system" colours and the second eight are the same colours in the user-editable part of the palette. Index 64 is "automatic" — the window text colour — and 65 the window background; both are resolved by the renderer rather than by a table.

The last column and row a worksheet can have: XFD1048576.