doc-codec 2.2.4 → 2.3.0

package/README.md

@@ -16,7 +16,7 @@ Built and shipped, on the read side:
 - **The piece table** — `parseClx` resolves a `Clx` (skipping any leading `Prc` array) into the pieces the logical text stream is assembled from, including the compressed 8-bit spelling and its halved byte offset.
 - **Text reconstruction** — `readTextRange` turns a range of character positions into real characters through [MS-DOC] 2.4.1's own Retrieving Text algorithm, applying the specification's byte-to-code-point mapping for compressed pieces, and returns each character's byte offset alongside it.
 - **Character and paragraph formatting** — the `PlcBteChpx`/`PlcBtePapx` bin tables and the `ChpxFkp`/`PapxFkp` pages behind them, the `Sprm`/`Prl` operand-sizing rules, and the subset of the character- and paragraph-property tables listed under [What is converted](#what-is-converted), now including `sprmCRgFtc0`'s font-table lookup (see [The font table](#the-font-table)).
-- **The style sheet** — `parseStsh` reads each style's index, name, kind and parent, and `headingLevelFromIstd` applies `sprmPIstd`'s own rule that an `istd` of 1 through 9 states an outline level.
+- **The style sheet** — `parseStsh` reads each style's index, name, kind, parent, and (for a paragraph or character style) its own `grLPUpxSw` formatting sets; `resolveStyleFormatting` walks the `istdBase` inheritance chain and folds each style's own paragraph/character properties, most-specific style winning, beneath a paragraph's or run's own direct exceptions ([ExaDev/documents.js#1005](https://github.com/ExaDev/documents.js/issues/1005)). `headingLevelFromIstd` applies `sprmPIstd`'s own rule that an `istd` of 1 through 9 states an outline level.
 - **Tables** — `table/read.ts`'s `assembleBlocks` folds a contiguous run of table-depth-1 paragraphs into a real `ContentTable`: cell boundaries at each cell-mark (`0x07`) character, a cell holding more than one paragraph where only its last ends in a cell mark, and each row's own trailing mark (`sprmPFTtp`) resolved through `table/tap.ts`'s `applyTableSprms` for its TAP — column boundaries and every physical cell's own horizontal/vertical merge state, from `sprmTDefTable`'s `TDefTableOperand` (and a `sprmTMerge` range or `sprmTVertMerge` per-cell flag where a real producer states a merge that way instead — see [Tables](#tables) below for why both are read). A table nested inside a table cell (table depth greater than 1, detected via `sprmPItap`/`sprmPFInnerTableCell`/`sprmPFInnerTtp`) is refused with `DocUnsupportedError` rather than mis-read; a row whose own TAP this reader cannot resolve at all — no direct `sprmTDefTable` anywhere in its grpprl, or a cell-mark count that disagrees with it — degrades the whole run back to flat paragraphs instead, since that is a legal producer choice this reader does not yet follow rather than corruption (see [Tables](#tables)).
 - **Table cell decoration** — `ContentTableCell.background` and `.borders`, from every encoding [MS-DOC] states them in: each cell's own four `Brc80` borders inside `TC80`, the exact-colour `sprmTSetBrc` layer a real producer writes beside them, the row-level shading arrays (`sprmTDefTableShd`/`2nd`/`3rd`, their `Raw` counterparts, the Word 97-era `sprmTDefTableShd80`, and `sprmTSetShd`/`sprmTSetShdOdd`), and, cascaded onto whichever cells and sides those leave unstated, the row/table-level `sprmTTableBorders`/`sprmTTableBorders80` border set and `sprmTSetShdTable`'s own per-row background. See [Cell decoration](#cell-decoration).
 - **`readDocContent`** — the whole chain, producing a `'wordprocessing'` `ContentDocument` of paragraphs, runs and tables.
@@ -32,18 +32,19 @@ Built and shipped, on the write side — see [Writing](#writing) for the full sc
 
 **Not built, and not approximated, on either side.** Each of these is a genuine layer of [MS-DOC] that this package does not implement; none is silently faked, and a document using one reads (or fails to write) as though it did not:
 
-| Absent                                                          | Consequence                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Nested tables**                                               | A table inside a table cell (table depth greater than 1) is a genuinely different [MS-DOC] structure — `sprmPFInnerTableCell`/`sprmPFInnerTtp` mark its cell/row ends rather than `sprmPFInTable`/`sprmPFTtp`, and `sprmPItap`/`sprmPDtap` state the depth. Neither side of this package descends into one: `readDocContent` refuses with `DocUnsupportedError` the moment it detects a table depth greater than 1, and `writeDocContent` refuses a `ContentTable` block found inside a table cell's own blocks the same way. See [Tables](#tables) for the full scope of what a depth-1 table does resolve.                                                                                                                                                                                                                                                                                                          |
-| **Images and drawn objects**                                    | The anchor characters (`U+0001`, `U+0008`) are dropped rather than emitted as control characters. No picture data is read. `writeDocContent` refuses an image block.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| **Style-inherited formatting**                                  | A style's own property sets live in the `STD`'s `grLPUpxSw` and are not read, so a paragraph's formatting is the document defaults plus its own direct exceptions. A `Heading 1` paragraph reports its `styleId` and `headingLevel` but not the boldness or size its style would supply. `writeDocContent` writes no paragraph styles at all (every paragraph is `istd` 0) and does not round-trip `styleId`/`headingLevel`. Tracked as its own, genuinely separate piece of work in [ExaDev/documents.js#1005](https://github.com/ExaDev/documents.js/issues/1005).                                                                                                                                                                                                                                                                                                                                                  |
-| **Subdocuments**                                                | Only the main document (character positions 0 to `ccpText`) is converted. Footnotes, endnotes, headers, footers, comments and text boxes are not, in either direction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| **Section boundaries**                                          | Section boundaries themselves are not read — the whole document is always treated as one section, spanning the entire main document — so a multi-section `.doc`'s later sections' own page size and margins are never consulted, only the first's (see the read-side page-size/margins bullet above for what is now read of that one section). `writeDocContent` refuses a `ContentDocument` with more than one section, rather than silently merging their content into what would read back as one.                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| **Extended and user-defined document properties**               | `title`/`subject`/`author`/`keywords`/`createdIso`/`modifiedIso` are read from and written to a `"\x05SummaryInformation"` stream when present (see [Metadata](#metadata)); the sibling `"\x05DocumentSummaryInformation"` stream (company, manager, and custom user-defined properties) is not read or written at all.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| **Encryption**                                                  | An encrypted or XOR-obfuscated document is refused with a `DocUnsupportedError` rather than read as plaintext. `writeDocContent` never encrypts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| **`sprmPHugePapx` / `sprmPTableProps`**                         | Paragraph properties stored indirectly in the Data stream are not followed, so such a paragraph reads with fewer properties than it states. [MS-DOC] 2.4.3's own Overview of Tables text names `sprmPTableProps` as a real, legal alternative to `sprmTDefTable` some applications process — but a real producer's row mark is not shown to prefer it: a genuine LibreOffice-authored `.doc` table's own row mark states its TAP through the identical direct `sprmTDefTable` this package's reader and writer already use (confirmed by parsing a LibreOffice 26.2.5.2-authored table's raw `PapxFkp` bytes; see [ExaDev/documents.js#892](https://github.com/ExaDev/documents.js/issues/892)), matching 2.4.3's own compatibility guidance ("An application SHOULD use sprmTDefTable to define table cells for applications that do not process sprmPTableProps"). `writeDocContent` never writes an indirect Papx. |
-| **Hyperlinks and fields**                                       | `ContentRun.hyperlink`, footnote/comment/annotation references, and every other field or anchor character are read as plain text or dropped (see [What is converted](#what-is-converted)) and are not written.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| **Every FIB field beyond what this package's own reader needs** | `writeDocContent` populates only the fc/lcb pairs its own reader consults (the style sheet, the two property bin tables, the Clx, the font table). Roughly 140 other `FibRgFcLcb97` pairs — `SttbfAssoc`, `Dop`, the printer-driver structures among them — are left zero, which is the format's own "undefined, MUST be ignored" contract for most of them, but not a certification that every third-party [MS-DOC] reader accepts the result; see `fib/write.ts`'s own note.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| Absent                                                          | Consequence                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Nested tables**                                               | A table inside a table cell (table depth greater than 1) is a genuinely different [MS-DOC] structure — `sprmPFInnerTableCell`/`sprmPFInnerTtp` mark its cell/row ends rather than `sprmPFInTable`/`sprmPFTtp`, and `sprmPItap`/`sprmPDtap` state the depth. Neither side of this package descends into one: `readDocContent` refuses with `DocUnsupportedError` the moment it detects a table depth greater than 1, and `writeDocContent` refuses a `ContentTable` block found inside a table cell's own blocks the same way. See [Tables](#tables) for the full scope of what a depth-1 table does resolve.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| **Images and drawn objects**                                    | The anchor characters (`U+0001`, `U+0008`) are dropped rather than emitted as control characters. No picture data is read. `writeDocContent` refuses an image block.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| **A style's own formatting on write**                           | A style's own property sets (`STD.grLPUpxSw`) are resolved and folded on read ([ExaDev/documents.js#1005](https://github.com/ExaDev/documents.js/issues/1005)): a paragraph's formatting is its style's own grpprlPapx/grpprlChpx (walked up the full `istdBase` inheritance chain, most-specific style winning) plus its own direct exceptions on top, and a run's own referenced character style (`sprmCIstd`) folds in the same way. `writeDocContent` mints a real STSH entry for every distinct `styleId`/`headingLevel` a document's paragraphs use ([ExaDev/documents.js#1059](https://github.com/ExaDev/documents.js/issues/1059)), so style IDENTITY round-trips -- but every minted entry carries an empty `grLPUpxSw` (no formatting of its own), since doc-codec's flat `ContentDocument` has no style-vs-direct-formatting split to draw a real one from: every property this writer emits is already, unconditionally, a direct exception. A style's own inherited formatting therefore never round-trips through a write -- only its name and istd position do. |
+| **Table and numbering style formatting**                        | `STD.grLPUpxSw` is resolved only for paragraph and character styles (`stk` 1/2, see the row above) -- a table style's `StkTableGRLPUPX` (its own `TAPX` plus `CNFC`-conditional per-region formatting, [MS-DOC] 2.4.6.6's own table-specific steps 6-9) and a numbering style's `StkListGRLPUPX` are neither read nor written. A table applying a named table style, or a paragraph using a numbering style rather than direct list formatting, reports none of the formatting either would supply.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| **Subdocuments**                                                | Only the main document (character positions 0 to `ccpText`) is converted. Footnotes, endnotes, headers, footers, comments and text boxes are not, in either direction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| **Section boundaries**                                          | Section boundaries themselves are not read — the whole document is always treated as one section, spanning the entire main document — so a multi-section `.doc`'s later sections' own page size and margins are never consulted, only the first's (see the read-side page-size/margins bullet above for what is now read of that one section). `writeDocContent` refuses a `ContentDocument` with more than one section, rather than silently merging their content into what would read back as one.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| **Extended and user-defined document properties**               | `title`/`subject`/`author`/`keywords`/`createdIso`/`modifiedIso` are read from and written to a `"\x05SummaryInformation"` stream when present (see [Metadata](#metadata)); the sibling `"\x05DocumentSummaryInformation"` stream (company, manager, and custom user-defined properties) is not read or written at all.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| **Encryption**                                                  | An encrypted or XOR-obfuscated document is refused with a `DocUnsupportedError` rather than read as plaintext. `writeDocContent` never encrypts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| **`sprmPHugePapx` / `sprmPTableProps`**                         | Paragraph properties stored indirectly in the Data stream are not followed, so such a paragraph reads with fewer properties than it states. [MS-DOC] 2.4.3's own Overview of Tables text names `sprmPTableProps` as a real, legal alternative to `sprmTDefTable` some applications process — but a real producer's row mark is not shown to prefer it: a genuine LibreOffice-authored `.doc` table's own row mark states its TAP through the identical direct `sprmTDefTable` this package's reader and writer already use (confirmed by parsing a LibreOffice 26.2.5.2-authored table's raw `PapxFkp` bytes; see [ExaDev/documents.js#892](https://github.com/ExaDev/documents.js/issues/892)), matching 2.4.3's own compatibility guidance ("An application SHOULD use sprmTDefTable to define table cells for applications that do not process sprmPTableProps"). `writeDocContent` never writes an indirect Papx.                                                                                                                                                          |
+| **Hyperlinks and fields**                                       | `ContentRun.hyperlink`, footnote/comment/annotation references, and every other field or anchor character are read as plain text or dropped (see [What is converted](#what-is-converted)) and are not written.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| **Every FIB field beyond what this package's own reader needs** | `writeDocContent` populates only the fc/lcb pairs its own reader consults (the style sheet, the two property bin tables, the Clx, the font table). Roughly 140 other `FibRgFcLcb97` pairs — `SttbfAssoc`, `Dop`, the printer-driver structures among them — are left zero, which is the format's own "undefined, MUST be ignored" contract for most of them, but not a certification that every third-party [MS-DOC] reader accepts the result; see `fib/write.ts`'s own note.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
 One construct is refused rather than mis-read: a `sprmPChgTabs` whose `cb` is the `255` sentinel encodes its own length as a formula over tab-stop counts this package does not parse, and its length is needed to find the next `Prl`. Rather than guess and silently mis-read every property after it, `operandSize` throws.
 
@@ -51,15 +52,15 @@ One construct is refused rather than mis-read: a `sprmPChgTabs` whose `cb` is th
 
 Character properties, from `Chpx` grpprls:
 
-| Sprm                                                                    | Becomes                                                                                                   |
-| ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
-| `sprmCFBold` (0x0835), `sprmCFItalic` (0x0836), `sprmCFStrike` (0x0837) | `bold` / `italic` / `strike`, honouring `ToggleOperand`'s inherit (0x80) and invert (0x81) values         |
-| `sprmCKul` (0x2A3E)                                                     | `underline` (any non-zero `Kul` style)                                                                    |
-| `sprmCHps` (0x4A43)                                                     | `sizePt`, the operand being half-points                                                                   |
-| `sprmCIco` (0x2A42)                                                     | `color`, through [MS-DOC] 2.9.119's fixed palette                                                         |
-| `sprmCCv` (0x6870)                                                      | `color`, from a `COLORREF`                                                                                |
-| `sprmCIstd` (0x4A30)                                                    | the character style index, carried for a caller to resolve                                                |
-| `sprmCRgFtc0` (0x4A4F)                                                  | `fontFamily`, looked up by index in the document's own font table (see [The font table](#the-font-table)) |
+| Sprm                                                                    | Becomes                                                                                                                                                                                                                                     |
+| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `sprmCFBold` (0x0835), `sprmCFItalic` (0x0836), `sprmCFStrike` (0x0837) | `bold` / `italic` / `strike`, honouring `ToggleOperand`'s inherit (0x80) and invert (0x81) values                                                                                                                                           |
+| `sprmCKul` (0x2A3E)                                                     | `underline` (any non-zero `Kul` style)                                                                                                                                                                                                      |
+| `sprmCHps` (0x4A43)                                                     | `sizePt`, the operand being half-points                                                                                                                                                                                                     |
+| `sprmCIco` (0x2A42)                                                     | `color`, through [MS-DOC] 2.9.119's fixed palette                                                                                                                                                                                           |
+| `sprmCCv` (0x6870)                                                      | `color`, from a `COLORREF`                                                                                                                                                                                                                  |
+| `sprmCIstd` (0x4A30)                                                    | resolves the named character style's own formatting and folds it in ([ExaDev/documents.js#1005](https://github.com/ExaDev/documents.js/issues/1005)), between the paragraph style's own defaults and this run's remaining direct exceptions |
+| `sprmCRgFtc0` (0x4A4F)                                                  | `fontFamily`, looked up by index in the document's own font table (see [The font table](#the-font-table))                                                                                                                                   |
 
 Paragraph properties, from `PapxInFkp` grpprls:
 
@@ -171,7 +172,7 @@ Only the fixed SummaryInformation property set is read or written — the siblin
 
 ## Writing
 
-`writeDocContent` takes a `'wordprocessing'` `ContentDocument` with exactly one section, an optional `WriteDocContentOptions`, and produces real [MS-DOC] bytes wrapped in a real [MS-CFB] compound file, inverting every read-side structure listed above: a real piece table (`text/piece-table-write.ts`, always one uncompressed 16-bit piece — see [Why always uncompressed](#why-the-writer-always-writes-uncompressed-text)), `Sprm`-encoded grpprls for each run's and paragraph's own direct formatting (`prop/chp-write.ts`, `prop/pap-write.ts`), `ChpxFkp`/`PapxFkp` pages packed and split across as many 512-byte pages as the content needs (`prop/fkp-write.ts`), a spec-conformant style sheet carrying zero styles (`style/stsh.ts`'s `buildEmptyStsh` — `FibRgFcLcb97.lcbStshf` "MUST be a nonzero value", so a document is never written without one, even though this package's own reader tolerates a missing one), and a font table when at least one run names a font (`style/fonts.ts`). `WriteDocContentOptions.onWarning`, when given, is called for a non-fatal write-time degradation this writer chooses over throwing — today, only the lost-boundary fallback's own per-row budget check (see [Tables](#tables)'s own note on [ExaDev/documents.js#1013](https://github.com/ExaDev/documents.js/issues/1013)) — but that is not a guarantee the write itself goes on to succeed: a row whose own assigned lost boundaries cannot be trimmed down to a split that fits at all still reports one warning, describing its boundaries as unrecoverable and its fully-unsplit encoding as the fallback being attempted — and, should that unsplit encoding also overflow the row's own byte budget once `buildPapxPages` actually packs it, `writeDocContent` can still throw further down the same pipeline, after any rows still to come have had their own chance to report a warning: a caller can genuinely see this warning followed by a hard failure, but not necessarily right away, and not necessarily for the row whose warning it just read, since `buildPapxPages` packs paragraphs in document order and can fail first on an earlier row that also overflowed. Every genuine refusal this writer makes outright — the kinds named in the table below — still throws `DocFormatError`/`DocUnsupportedError` directly, with no warning first.
+`writeDocContent` takes a `'wordprocessing'` `ContentDocument` with exactly one section, an optional `WriteDocContentOptions`, and produces real [MS-DOC] bytes wrapped in a real [MS-CFB] compound file, inverting every read-side structure listed above: a real piece table (`text/piece-table-write.ts`, always one uncompressed 16-bit piece — see [Why always uncompressed](#why-the-writer-always-writes-uncompressed-text)), `Sprm`-encoded grpprls for each run's and paragraph's own direct formatting (`prop/chp-write.ts`, `prop/pap-write.ts`), `ChpxFkp`/`PapxFkp` pages packed and split across as many 512-byte pages as the content needs (`prop/fkp-write.ts`), a real style sheet minting one entry per distinct `styleId`/`headingLevel` a document's paragraphs actually use (`style/stsh.ts`'s `buildStshForStyles`, [ExaDev/documents.js#1059](https://github.com/ExaDev/documents.js/issues/1059) — identity only, no formatting of a style's own; `FibRgFcLcb97.lcbStshf` "MUST be a nonzero value", so a document is never written without one, even one carrying zero styles, though this package's own reader tolerates a missing one), and a font table when at least one run names a font (`style/fonts.ts`). `WriteDocContentOptions.onWarning`, when given, is called for a non-fatal write-time degradation this writer chooses over throwing — today, only the lost-boundary fallback's own per-row budget check (see [Tables](#tables)'s own note on [ExaDev/documents.js#1013](https://github.com/ExaDev/documents.js/issues/1013)) — but that is not a guarantee the write itself goes on to succeed: a row whose own assigned lost boundaries cannot be trimmed down to a split that fits at all still reports one warning, describing its boundaries as unrecoverable and its fully-unsplit encoding as the fallback being attempted — and, should that unsplit encoding also overflow the row's own byte budget once `buildPapxPages` actually packs it, `writeDocContent` can still throw further down the same pipeline, after any rows still to come have had their own chance to report a warning: a caller can genuinely see this warning followed by a hard failure, but not necessarily right away, and not necessarily for the row whose warning it just read, since `buildPapxPages` packs paragraphs in document order and can fail first on an earlier row that also overflowed. Every genuine refusal this writer makes outright — the kinds named in the table below — still throws `DocFormatError`/`DocUnsupportedError` directly, with no warning first.
 
 Character properties this writer converts, the exact inverse of [What is converted](#what-is-converted)'s character table above: `bold`, `italic`, `strike`, `underline` (as `kulSingle`, the only style a plain boolean can express), `sizePt`, `color` (via `sprmCCv`'s exact `COLORREF`, never the lossy 17-entry `sprmCIco` palette), and `fontFamily`. Paragraph properties: `alignment` (the four `ST_Jc`-aligned values this package's reader itself maps — `left`/`center`/`right`/`justify`), `indentLeftPt`, `indentRightPt`, `indentFirstLinePt`, `spacingBeforePt`, `spacingAfterPt`, `lineSpacing` (only `LSPD`'s multiplier form, matching the reader), `pageBreakBefore`, and `list` membership (`sprmPIlfo`/`sprmPIlvl` — see [Numbering definitions](#numbering-definitions) for the numbering tables this depends on).
 
@@ -219,7 +220,7 @@ The modules layer in the order [MS-DOC]'s own algorithms chain:
 | `src/prop/fkp.ts`                                | The formatted disk pages and the bin tables that address them.                                                                                                                                                                                                                                               |
 | `src/prop/chp.ts`, `src/prop/pap.ts`             | Folding a grpprl into character and paragraph properties.                                                                                                                                                                                                                                                    |
 | `src/list/numbering.ts`                          | Resolving `PlfLst`/`PlfLfo` into `NumberingDefinitions` (see [Numbering definitions](#numbering-definitions)).                                                                                                                                                                                               |
-| `src/style/stsh.ts`                              | The style sheet.                                                                                                                                                                                                                                                                                             |
+| `src/style/stsh.ts`                              | The style sheet, plus resolving a style's own inherited formatting up its `istdBase` chain.                                                                                                                                                                                                                  |
 | `src/style/fonts.ts`                             | The font table (`SttbfFfn`/`FFN`) — read and write together, since both directions share one small, self-contained field layout.                                                                                                                                                                             |
 | `src/metadata.ts`                                | Wraps `archive-codec`'s own `SummaryInformationProperties` <-> `LayoutMetadata` mapping with this package's `createdIso`/`modifiedIso` date validation, throwing `DocFormatError` for a malformed one rather than letting an opaque `RangeError` escape the FILETIME conversion (see [Metadata](#metadata)). |
 | `src/table/decoration.ts`                        | A cell's border and background-shading encodings -- `Brc80`, `Brc`, `Shd`, `Shd80`, and the `BrcType`/`Ipat` vocabularies -- read and written in one place, so neither direction can drift from the other (see [Cell decoration](#cell-decoration)).                                                         |

package/dist/index.cjs

@@ -66,14 +66,15 @@ exports.applyCharacterSprms = require_prop_chp.applyCharacterSprms;
 exports.applyParagraphSprms = require_prop_pap.applyParagraphSprms;
 exports.applySectionSprms = require_prop_sep.applySectionSprms;
 exports.buildChpxPages = require_prop_fkp_write.buildChpxPages;
-exports.buildEmptyStsh = require_style_stsh.buildEmptyStsh;
 exports.buildFib = require_fib_write.buildFib;
 exports.buildFontTable = require_style_fonts.buildFontTable;
 exports.buildPapxPages = require_prop_fkp_write.buildPapxPages;
 exports.buildPlcfSed = require_prop_sep_write.buildPlcfSed;
 exports.buildPropertyBinTable = require_prop_fkp_write.buildPropertyBinTable;
 exports.buildSepx = require_prop_sep_write.buildSepx;
+exports.buildStshForStyles = require_style_stsh.buildStshForStyles;
 exports.buildTextClx = require_text_piece_table_write.buildTextClx;
+exports.characterIstdFromGrpprl = require_prop_chp.characterIstdFromGrpprl;
 exports.characterOffset = require_text_piece_table.characterOffset;
 exports.characterSize = require_text_piece_table.characterSize;
 exports.decodeSprm = require_prop_sprm.decodeSprm;
@@ -107,6 +108,7 @@ exports.readTextRange = require_text_characters.readTextRange;
 exports.readUint16LE = require_bytes.readUint16LE;
 exports.readUint32LE = require_bytes.readUint32LE;
 exports.readUint8 = require_bytes.readUint8;
+exports.resolveStyleFormatting = require_style_stsh.resolveStyleFormatting;
 exports.slice = require_bytes.slice;
 exports.tableStreamName = require_fib_fib.tableStreamName;
 exports.writeDocContent = require_write.writeDocContent;

package/dist/index.d.cts

@@ -13,15 +13,15 @@ import { ANNOTATION_REFERENCE, CELL_MARK, DRAWN_OBJECT, FIELD_BEGIN, FIELD_END,
 import { a as operandSize, i as decodeSprm, n as SGC, o as readGrpprl, r as Sprm, t as Prl } from "./sprm-DEyvdOo0.cjs";
 import { ChpxFkp, FKP_PAGE_SIZE, PapxFkp, PapxLookup, PapxRecord, PropertyBinTable, parseChpxFkp, parsePapxFkp } from "./prop/fkp.cjs";
 import { ChpxRunToWrite, PapxParagraphToWrite, buildChpxPages, buildPapxPages, buildPropertyBinTable, firstFcOfPage, fitsAloneOnPapxPage } from "./prop/fkp-write.cjs";
-import { CharacterProperties, applyCharacterSprms } from "./prop/chp.cjs";
+import { CharacterProperties, applyCharacterSprms, characterIstdFromGrpprl } from "./prop/chp.cjs";
 import { encodeCharacterGrpprl } from "./prop/chp-write.cjs";
 import { n as applyParagraphSprms, t as ParagraphProperties } from "./pap-BT1p0uzu.cjs";
 import { encodeParagraphGrpprl } from "./prop/pap-write.cjs";
 import { SectionProperties, applySectionSprms, readSectionProperties } from "./prop/sep.cjs";
 import { buildPlcfSed, buildSepx, encodeSectionGrpprl } from "./prop/sep-write.cjs";
-import { STI_USER_DEFINED, STK, Style, StyleSheet, buildEmptyStsh, headingLevelFromIstd, parseStsh } from "./style/stsh.cjs";
+import { ResolvedStyleFormatting, STI_USER_DEFINED, STK, Style, StyleSheet, buildStshForStyles, headingLevelFromIstd, parseStsh, resolveStyleFormatting } from "./style/stsh.cjs";
 import { buildFontTable, parseFontTable } from "./style/fonts.cjs";
 import { a as readNumberingDefinitions, i as NumberingLevel, n as NumberingDefinition, r as NumberingDefinitions, t as NUMBER_FORMAT_BY_NFC } from "./numbering-Bivayss4.cjs";
 import { DocContent, DocStreams, ParagraphEntry, readDocContent, readDocStreams } from "./read.cjs";
 import { WriteDocContentOptions, writeDocContent } from "./write.cjs";
-export { ANNOTATION_REFERENCE, CELL_MARK, COMPRESSED_CHARACTER_MAP, CharacterProperties, ChpxFkp, ChpxRunToWrite, DRAWN_OBJECT, DocContent, DocFormatError, DocStreams, DocUnsupportedError, FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, FIELD_BEGIN, FIELD_END, FIELD_SEPARATOR, FKP_PAGE_SIZE, FOOTNOTE_REFERENCE, Fib, FibWriteSpec, INLINE_PICTURE, LINE_BREAK, LW_OFFSET, NUMBER_FORMAT_BY_NFC, NumberingDefinition, NumberingDefinitions, NumberingLevel, PARAGRAPH_MARK, PapxFkp, PapxLookup, PapxParagraphToWrite, PapxRecord, ParagraphEntry, ParagraphProperties, Piece, PieceTable, Plc, Prl, PropertyBinTable, SECTION_MARK, SGC, STI_USER_DEFINED, STK, SUMMARY_INFORMATION_STREAM, SYMBOL_ANCHOR, SectionProperties, Sprm, Style, StyleSheet, TextRange, WORD_DOCUMENT_STREAM, WriteDocContentOptions, applyCharacterSprms, applyParagraphSprms, applySectionSprms, buildChpxPages, buildEmptyStsh, buildFib, buildFontTable, buildPapxPages, buildPlcfSed, buildPropertyBinTable, buildSepx, buildTextClx, characterOffset, characterSize, decodeSprm, encodeCharacterGrpprl, encodeParagraphGrpprl, encodeSectionGrpprl, endsParagraph, findLargestAtMost, firstFcOfPage, fitsAloneOnPapxPage, headingLevelFromIstd, isAnchorOnly, isDocBytes, layoutMetadataToSummaryInformation, operandSize, parseChpxFkp, parseClx, parseFib, parseFontTable, parsePapxFkp, parsePlc, parseStsh, readDocContent, readDocStreams, readGrpprl, readInt16LE, readInt32LE, readNumberingDefinitions, readSectionProperties, readTextRange, readUint16LE, readUint32LE, readUint8, slice, tableStreamName, writeDocContent };
+export { ANNOTATION_REFERENCE, CELL_MARK, COMPRESSED_CHARACTER_MAP, CharacterProperties, ChpxFkp, ChpxRunToWrite, DRAWN_OBJECT, DocContent, DocFormatError, DocStreams, DocUnsupportedError, FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, FIELD_BEGIN, FIELD_END, FIELD_SEPARATOR, FKP_PAGE_SIZE, FOOTNOTE_REFERENCE, Fib, FibWriteSpec, INLINE_PICTURE, LINE_BREAK, LW_OFFSET, NUMBER_FORMAT_BY_NFC, NumberingDefinition, NumberingDefinitions, NumberingLevel, PARAGRAPH_MARK, PapxFkp, PapxLookup, PapxParagraphToWrite, PapxRecord, ParagraphEntry, ParagraphProperties, Piece, PieceTable, Plc, Prl, PropertyBinTable, ResolvedStyleFormatting, SECTION_MARK, SGC, STI_USER_DEFINED, STK, SUMMARY_INFORMATION_STREAM, SYMBOL_ANCHOR, SectionProperties, Sprm, Style, StyleSheet, TextRange, WORD_DOCUMENT_STREAM, WriteDocContentOptions, applyCharacterSprms, applyParagraphSprms, applySectionSprms, buildChpxPages, buildFib, buildFontTable, buildPapxPages, buildPlcfSed, buildPropertyBinTable, buildSepx, buildStshForStyles, buildTextClx, characterIstdFromGrpprl, characterOffset, characterSize, decodeSprm, encodeCharacterGrpprl, encodeParagraphGrpprl, encodeSectionGrpprl, endsParagraph, findLargestAtMost, firstFcOfPage, fitsAloneOnPapxPage, headingLevelFromIstd, isAnchorOnly, isDocBytes, layoutMetadataToSummaryInformation, operandSize, parseChpxFkp, parseClx, parseFib, parseFontTable, parsePapxFkp, parsePlc, parseStsh, readDocContent, readDocStreams, readGrpprl, readInt16LE, readInt32LE, readNumberingDefinitions, readSectionProperties, readTextRange, readUint16LE, readUint32LE, readUint8, resolveStyleFormatting, slice, tableStreamName, writeDocContent };

package/dist/index.d.ts

@@ -13,15 +13,15 @@ import { ANNOTATION_REFERENCE, CELL_MARK, DRAWN_OBJECT, FIELD_BEGIN, FIELD_END,
 import { a as operandSize, i as decodeSprm, n as SGC, o as readGrpprl, r as Sprm, t as Prl } from "./sprm-DEyvdOo0.js";
 import { ChpxFkp, FKP_PAGE_SIZE, PapxFkp, PapxLookup, PapxRecord, PropertyBinTable, parseChpxFkp, parsePapxFkp } from "./prop/fkp.js";
 import { ChpxRunToWrite, PapxParagraphToWrite, buildChpxPages, buildPapxPages, buildPropertyBinTable, firstFcOfPage, fitsAloneOnPapxPage } from "./prop/fkp-write.js";
-import { CharacterProperties, applyCharacterSprms } from "./prop/chp.js";
+import { CharacterProperties, applyCharacterSprms, characterIstdFromGrpprl } from "./prop/chp.js";
 import { encodeCharacterGrpprl } from "./prop/chp-write.js";
 import { n as applyParagraphSprms, t as ParagraphProperties } from "./pap-DOFLMWcG.js";
 import { encodeParagraphGrpprl } from "./prop/pap-write.js";
 import { SectionProperties, applySectionSprms, readSectionProperties } from "./prop/sep.js";
 import { buildPlcfSed, buildSepx, encodeSectionGrpprl } from "./prop/sep-write.js";
-import { STI_USER_DEFINED, STK, Style, StyleSheet, buildEmptyStsh, headingLevelFromIstd, parseStsh } from "./style/stsh.js";
+import { ResolvedStyleFormatting, STI_USER_DEFINED, STK, Style, StyleSheet, buildStshForStyles, headingLevelFromIstd, parseStsh, resolveStyleFormatting } from "./style/stsh.js";
 import { buildFontTable, parseFontTable } from "./style/fonts.js";
 import { a as readNumberingDefinitions, i as NumberingLevel, n as NumberingDefinition, r as NumberingDefinitions, t as NUMBER_FORMAT_BY_NFC } from "./numbering-Co4jssbG.js";
 import { DocContent, DocStreams, ParagraphEntry, readDocContent, readDocStreams } from "./read.js";
 import { WriteDocContentOptions, writeDocContent } from "./write.js";
-export { ANNOTATION_REFERENCE, CELL_MARK, COMPRESSED_CHARACTER_MAP, CharacterProperties, ChpxFkp, ChpxRunToWrite, DRAWN_OBJECT, DocContent, DocFormatError, DocStreams, DocUnsupportedError, FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, FIELD_BEGIN, FIELD_END, FIELD_SEPARATOR, FKP_PAGE_SIZE, FOOTNOTE_REFERENCE, Fib, FibWriteSpec, INLINE_PICTURE, LINE_BREAK, LW_OFFSET, NUMBER_FORMAT_BY_NFC, NumberingDefinition, NumberingDefinitions, NumberingLevel, PARAGRAPH_MARK, PapxFkp, PapxLookup, PapxParagraphToWrite, PapxRecord, ParagraphEntry, ParagraphProperties, Piece, PieceTable, Plc, Prl, PropertyBinTable, SECTION_MARK, SGC, STI_USER_DEFINED, STK, SUMMARY_INFORMATION_STREAM, SYMBOL_ANCHOR, SectionProperties, Sprm, Style, StyleSheet, TextRange, WORD_DOCUMENT_STREAM, WriteDocContentOptions, applyCharacterSprms, applyParagraphSprms, applySectionSprms, buildChpxPages, buildEmptyStsh, buildFib, buildFontTable, buildPapxPages, buildPlcfSed, buildPropertyBinTable, buildSepx, buildTextClx, characterOffset, characterSize, decodeSprm, encodeCharacterGrpprl, encodeParagraphGrpprl, encodeSectionGrpprl, endsParagraph, findLargestAtMost, firstFcOfPage, fitsAloneOnPapxPage, headingLevelFromIstd, isAnchorOnly, isDocBytes, layoutMetadataToSummaryInformation, operandSize, parseChpxFkp, parseClx, parseFib, parseFontTable, parsePapxFkp, parsePlc, parseStsh, readDocContent, readDocStreams, readGrpprl, readInt16LE, readInt32LE, readNumberingDefinitions, readSectionProperties, readTextRange, readUint16LE, readUint32LE, readUint8, slice, tableStreamName, writeDocContent };
+export { ANNOTATION_REFERENCE, CELL_MARK, COMPRESSED_CHARACTER_MAP, CharacterProperties, ChpxFkp, ChpxRunToWrite, DRAWN_OBJECT, DocContent, DocFormatError, DocStreams, DocUnsupportedError, FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, FIELD_BEGIN, FIELD_END, FIELD_SEPARATOR, FKP_PAGE_SIZE, FOOTNOTE_REFERENCE, Fib, FibWriteSpec, INLINE_PICTURE, LINE_BREAK, LW_OFFSET, NUMBER_FORMAT_BY_NFC, NumberingDefinition, NumberingDefinitions, NumberingLevel, PARAGRAPH_MARK, PapxFkp, PapxLookup, PapxParagraphToWrite, PapxRecord, ParagraphEntry, ParagraphProperties, Piece, PieceTable, Plc, Prl, PropertyBinTable, ResolvedStyleFormatting, SECTION_MARK, SGC, STI_USER_DEFINED, STK, SUMMARY_INFORMATION_STREAM, SYMBOL_ANCHOR, SectionProperties, Sprm, Style, StyleSheet, TextRange, WORD_DOCUMENT_STREAM, WriteDocContentOptions, applyCharacterSprms, applyParagraphSprms, applySectionSprms, buildChpxPages, buildFib, buildFontTable, buildPapxPages, buildPlcfSed, buildPropertyBinTable, buildSepx, buildStshForStyles, buildTextClx, characterIstdFromGrpprl, characterOffset, characterSize, decodeSprm, encodeCharacterGrpprl, encodeParagraphGrpprl, encodeSectionGrpprl, endsParagraph, findLargestAtMost, firstFcOfPage, fitsAloneOnPapxPage, headingLevelFromIstd, isAnchorOnly, isDocBytes, layoutMetadataToSummaryInformation, operandSize, parseChpxFkp, parseClx, parseFib, parseFontTable, parsePapxFkp, parsePlc, parseStsh, readDocContent, readDocStreams, readGrpprl, readInt16LE, readInt32LE, readNumberingDefinitions, readSectionProperties, readTextRange, readUint16LE, readUint32LE, readUint8, resolveStyleFormatting, slice, tableStreamName, writeDocContent };

package/dist/index.js

@@ -13,15 +13,15 @@ import { ANNOTATION_REFERENCE, CELL_MARK, DRAWN_OBJECT, FIELD_BEGIN, FIELD_END,
 import { SGC, decodeSprm, operandSize, readGrpprl } from "./prop/sprm.js";
 import { FKP_PAGE_SIZE, PropertyBinTable, parseChpxFkp, parsePapxFkp } from "./prop/fkp.js";
 import { buildChpxPages, buildPapxPages, buildPropertyBinTable, firstFcOfPage, fitsAloneOnPapxPage } from "./prop/fkp-write.js";
-import { applyCharacterSprms } from "./prop/chp.js";
+import { applyCharacterSprms, characterIstdFromGrpprl } from "./prop/chp.js";
 import { encodeCharacterGrpprl } from "./prop/chp-write.js";
 import { applyParagraphSprms } from "./prop/pap.js";
 import { encodeParagraphGrpprl } from "./prop/pap-write.js";
 import { applySectionSprms, readSectionProperties } from "./prop/sep.js";
 import { buildPlcfSed, buildSepx, encodeSectionGrpprl } from "./prop/sep-write.js";
-import { STI_USER_DEFINED, STK, buildEmptyStsh, headingLevelFromIstd, parseStsh } from "./style/stsh.js";
+import { STI_USER_DEFINED, STK, buildStshForStyles, headingLevelFromIstd, parseStsh, resolveStyleFormatting } from "./style/stsh.js";
 import { buildFontTable, parseFontTable } from "./style/fonts.js";
 import { NUMBER_FORMAT_BY_NFC, readNumberingDefinitions } from "./list/numbering.js";
 import { readDocContent, readDocStreams } from "./read.js";
 import { writeDocContent } from "./write.js";
-export { ANNOTATION_REFERENCE, CELL_MARK, COMPRESSED_CHARACTER_MAP, DRAWN_OBJECT, DocFormatError, DocUnsupportedError, FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, FIELD_BEGIN, FIELD_END, FIELD_SEPARATOR, FKP_PAGE_SIZE, FOOTNOTE_REFERENCE, INLINE_PICTURE, LINE_BREAK, LW_OFFSET, NUMBER_FORMAT_BY_NFC, PARAGRAPH_MARK, PropertyBinTable, SECTION_MARK, SGC, STI_USER_DEFINED, STK, SUMMARY_INFORMATION_STREAM, SYMBOL_ANCHOR, WORD_DOCUMENT_STREAM, applyCharacterSprms, applyParagraphSprms, applySectionSprms, buildChpxPages, buildEmptyStsh, buildFib, buildFontTable, buildPapxPages, buildPlcfSed, buildPropertyBinTable, buildSepx, buildTextClx, characterOffset, characterSize, decodeSprm, encodeCharacterGrpprl, encodeParagraphGrpprl, encodeSectionGrpprl, endsParagraph, findLargestAtMost, firstFcOfPage, fitsAloneOnPapxPage, headingLevelFromIstd, isAnchorOnly, isDocBytes, layoutMetadataToSummaryInformation, operandSize, parseChpxFkp, parseClx, parseFib, parseFontTable, parsePapxFkp, parsePlc, parseStsh, readDocContent, readDocStreams, readGrpprl, readInt16LE, readInt32LE, readNumberingDefinitions, readSectionProperties, readTextRange, readUint16LE, readUint32LE, readUint8, slice, tableStreamName, writeDocContent };
+export { ANNOTATION_REFERENCE, CELL_MARK, COMPRESSED_CHARACTER_MAP, DRAWN_OBJECT, DocFormatError, DocUnsupportedError, FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, FIELD_BEGIN, FIELD_END, FIELD_SEPARATOR, FKP_PAGE_SIZE, FOOTNOTE_REFERENCE, INLINE_PICTURE, LINE_BREAK, LW_OFFSET, NUMBER_FORMAT_BY_NFC, PARAGRAPH_MARK, PropertyBinTable, SECTION_MARK, SGC, STI_USER_DEFINED, STK, SUMMARY_INFORMATION_STREAM, SYMBOL_ANCHOR, WORD_DOCUMENT_STREAM, applyCharacterSprms, applyParagraphSprms, applySectionSprms, buildChpxPages, buildFib, buildFontTable, buildPapxPages, buildPlcfSed, buildPropertyBinTable, buildSepx, buildStshForStyles, buildTextClx, characterIstdFromGrpprl, characterOffset, characterSize, decodeSprm, encodeCharacterGrpprl, encodeParagraphGrpprl, encodeSectionGrpprl, endsParagraph, findLargestAtMost, firstFcOfPage, fitsAloneOnPapxPage, headingLevelFromIstd, isAnchorOnly, isDocBytes, layoutMetadataToSummaryInformation, operandSize, parseChpxFkp, parseClx, parseFib, parseFontTable, parsePapxFkp, parsePlc, parseStsh, readDocContent, readDocStreams, readGrpprl, readInt16LE, readInt32LE, readNumberingDefinitions, readSectionProperties, readTextRange, readUint16LE, readUint32LE, readUint8, resolveStyleFormatting, slice, tableStreamName, writeDocContent };

package/dist/prop/chp.cjs

@@ -76,5 +76,11 @@ function applyCharacterSprms(prls, into, fonts) {
 	}
 	return into;
 }
+function characterIstdFromGrpprl(prls) {
+	let istd;
+	for (const prl of prls) if (prl.sprm.sgc === require_prop_sprm.SGC.character && prl.sprm.value === SPRM_C_ISTD) istd = require_bytes.readUint16LE(prl.operand, 0);
+	return istd;
+}
 //#endregion
 exports.applyCharacterSprms = applyCharacterSprms;
+exports.characterIstdFromGrpprl = characterIstdFromGrpprl;

package/dist/prop/chp.d.cts

@@ -13,5 +13,6 @@ interface CharacterProperties {
   istd?: number;
 }
 declare function applyCharacterSprms(prls: readonly Prl[], into: CharacterProperties, fonts?: readonly string[]): CharacterProperties;
+declare function characterIstdFromGrpprl(prls: readonly Prl[]): number | undefined;
 //#endregion
-export { CharacterProperties, applyCharacterSprms };
+export { CharacterProperties, applyCharacterSprms, characterIstdFromGrpprl };

package/dist/prop/chp.d.ts

@@ -13,5 +13,6 @@ interface CharacterProperties {
   istd?: number;
 }
 declare function applyCharacterSprms(prls: readonly Prl[], into: CharacterProperties, fonts?: readonly string[]): CharacterProperties;
+declare function characterIstdFromGrpprl(prls: readonly Prl[]): number | undefined;
 //#endregion
-export { CharacterProperties, applyCharacterSprms };
+export { CharacterProperties, applyCharacterSprms, characterIstdFromGrpprl };

package/dist/prop/chp.js

@@ -75,5 +75,10 @@ function applyCharacterSprms(prls, into, fonts) {
 	}
 	return into;
 }
+function characterIstdFromGrpprl(prls) {
+	let istd;
+	for (const prl of prls) if (prl.sprm.sgc === SGC.character && prl.sprm.value === SPRM_C_ISTD) istd = readUint16LE(prl.operand, 0);
+	return istd;
+}
 //#endregion
-export { applyCharacterSprms };
+export { applyCharacterSprms, characterIstdFromGrpprl };

package/dist/read.cjs

@@ -105,12 +105,13 @@ function buildParagraph(text, fcs, propertyFc, terminator, context) {
 	const grpprl = papx !== void 0 ? require_prop_sprm.readGrpprl(papx.grpprl) : [];
 	if (papx !== void 0) {
 		properties.istd = papx.istd;
+		if (context.styles !== void 0) require_prop_pap.applyParagraphSprms(require_style_stsh.resolveStyleFormatting(context.styles, papx.istd).paragraphPrls, properties);
 		require_prop_pap.applyParagraphSprms(grpprl, properties);
 	}
 	return {
 		paragraph: {
 			kind: "paragraph",
-			runs: buildRuns(text, fcs, context),
+			runs: buildRuns(text, fcs, context, papx?.istd),
 			...paragraphAttributes(properties, context)
 		},
 		properties,
@@ -142,11 +143,12 @@ function paragraphAttributes(properties, context) {
 	};
 	return attributes;
 }
-function buildRuns(text, fcs, context) {
+function buildRuns(text, fcs, context, paragraphIstd) {
 	const runs = [];
 	let currentKey;
 	let currentText = "";
 	let currentProperties = {};
+	const paragraphStyleCharacterPrls = context.styles !== void 0 && paragraphIstd !== void 0 ? require_style_stsh.resolveStyleFormatting(context.styles, paragraphIstd).characterPrls : [];
 	const enclosingInstruction = [];
 	let inInstruction = false;
 	const flush = () => {
@@ -176,14 +178,21 @@ function buildRuns(text, fcs, context) {
 		const fc = fcs[index];
 		if (fc === void 0) throw new require_errors.DocFormatError(`character ${index} of a paragraph has no byte offset, so its formatting cannot be located`);
 		const grpprl = context.chpxTable.chpxGrpprl(fc);
-		const key = grpprl === void 0 ? "none" : `${grpprl.byteOffset}:${grpprl.byteLength}`;
+		const chpxKey = grpprl === void 0 ? "none" : `${grpprl.byteOffset}:${grpprl.byteLength}`;
+		const key = `${paragraphIstd ?? "none"}:${chpxKey}`;
 		if (key !== currentKey) {
 			flush();
 			currentKey = key;
 			let properties = context.characterProperties.get(key);
 			if (properties === void 0) {
 				properties = {};
-				if (grpprl !== void 0) require_prop_chp.applyCharacterSprms(require_prop_sprm.readGrpprl(grpprl), properties, context.fonts);
+				require_prop_chp.applyCharacterSprms(paragraphStyleCharacterPrls, properties, context.fonts);
+				if (grpprl !== void 0) {
+					const runPrls = require_prop_sprm.readGrpprl(grpprl);
+					const characterIstd = require_prop_chp.characterIstdFromGrpprl(runPrls);
+					if (characterIstd !== void 0 && context.styles !== void 0) require_prop_chp.applyCharacterSprms(require_style_stsh.resolveStyleFormatting(context.styles, characterIstd).characterPrls, properties, context.fonts);
+					require_prop_chp.applyCharacterSprms(runPrls, properties, context.fonts);
+				}
 				context.characterProperties.set(key, properties);
 			}
 			currentProperties = properties;

package/dist/read.js

@@ -7,10 +7,10 @@ import { readTextRange } from "./text/characters.js";
 import { endsParagraph, isAnchorOnly } from "./text/special.js";
 import { readGrpprl } from "./prop/sprm.js";
 import { PropertyBinTable } from "./prop/fkp.js";
-import { applyCharacterSprms } from "./prop/chp.js";
+import { applyCharacterSprms, characterIstdFromGrpprl } from "./prop/chp.js";
 import { applyParagraphSprms } from "./prop/pap.js";
 import { readSectionProperties } from "./prop/sep.js";
-import { headingLevelFromIstd, parseStsh } from "./style/stsh.js";
+import { headingLevelFromIstd, parseStsh, resolveStyleFormatting } from "./style/stsh.js";
 import { parseFontTable } from "./style/fonts.js";
 import { readNumberingDefinitions } from "./list/numbering.js";
 import { assembleBlocks } from "./table/read.js";
@@ -104,12 +104,13 @@ function buildParagraph(text, fcs, propertyFc, terminator, context) {
 	const grpprl = papx !== void 0 ? readGrpprl(papx.grpprl) : [];
 	if (papx !== void 0) {
 		properties.istd = papx.istd;
+		if (context.styles !== void 0) applyParagraphSprms(resolveStyleFormatting(context.styles, papx.istd).paragraphPrls, properties);
 		applyParagraphSprms(grpprl, properties);
 	}
 	return {
 		paragraph: {
 			kind: "paragraph",
-			runs: buildRuns(text, fcs, context),
+			runs: buildRuns(text, fcs, context, papx?.istd),
 			...paragraphAttributes(properties, context)
 		},
 		properties,
@@ -141,11 +142,12 @@ function paragraphAttributes(properties, context) {
 	};
 	return attributes;
 }
-function buildRuns(text, fcs, context) {
+function buildRuns(text, fcs, context, paragraphIstd) {
 	const runs = [];
 	let currentKey;
 	let currentText = "";
 	let currentProperties = {};
+	const paragraphStyleCharacterPrls = context.styles !== void 0 && paragraphIstd !== void 0 ? resolveStyleFormatting(context.styles, paragraphIstd).characterPrls : [];
 	const enclosingInstruction = [];
 	let inInstruction = false;
 	const flush = () => {
@@ -175,14 +177,21 @@ function buildRuns(text, fcs, context) {
 		const fc = fcs[index];
 		if (fc === void 0) throw new DocFormatError(`character ${index} of a paragraph has no byte offset, so its formatting cannot be located`);
 		const grpprl = context.chpxTable.chpxGrpprl(fc);
-		const key = grpprl === void 0 ? "none" : `${grpprl.byteOffset}:${grpprl.byteLength}`;
+		const chpxKey = grpprl === void 0 ? "none" : `${grpprl.byteOffset}:${grpprl.byteLength}`;
+		const key = `${paragraphIstd ?? "none"}:${chpxKey}`;
 		if (key !== currentKey) {
 			flush();
 			currentKey = key;
 			let properties = context.characterProperties.get(key);
 			if (properties === void 0) {
 				properties = {};
-				if (grpprl !== void 0) applyCharacterSprms(readGrpprl(grpprl), properties, context.fonts);
+				applyCharacterSprms(paragraphStyleCharacterPrls, properties, context.fonts);
+				if (grpprl !== void 0) {
+					const runPrls = readGrpprl(grpprl);
+					const characterIstd = characterIstdFromGrpprl(runPrls);
+					if (characterIstd !== void 0 && context.styles !== void 0) applyCharacterSprms(resolveStyleFormatting(context.styles, characterIstd).characterPrls, properties, context.fonts);
+					applyCharacterSprms(runPrls, properties, context.fonts);
+				}
 				context.characterProperties.set(key, properties);
 			}
 			currentProperties = properties;

package/dist/style/stsh.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_errors = require("../errors.cjs");
 const require_bytes = require("../bytes.cjs");
+const require_prop_sprm = require("../prop/sprm.cjs");
 //#region src/style/stsh.ts
 /** Stshif is a fixed 18 bytes: cstd, cbSTDBaseInFile, a bit field, stiMaxWhenSaved, istdMaxFixedWhenSaved, nVerBuiltInNamesWhenSaved, and the three default font indexes. */
 const STSHIF_SIZE = 18;
@@ -40,12 +41,17 @@ function parseStd(std, istd, cbStdBaseInFile) {
 	const word0 = require_bytes.readUint16LE(std, 0);
 	const word1 = require_bytes.readUint16LE(std, 2);
 	const istdBase = word1 >> 4 & 4095;
+	const stk = word1 & 15;
+	const name = readXstz(std, cbStdBaseInFile, `name of the style at istd ${istd}`);
+	const { grpprlPapx, grpprlChpx } = parseGrLPUpxSw(std, cbStdBaseInFile + xstzByteLength(std, cbStdBaseInFile), stk, istd);
 	return {
 		istd,
 		sti: word0 & 4095,
-		stk: word1 & 15,
+		stk,
 		istdBase: istdBase === ISTD_BASE_NONE ? void 0 : istdBase,
-		name: readXstz(std, cbStdBaseInFile, `name of the style at istd ${istd}`)
+		name,
+		grpprlPapx,
+		grpprlChpx
 	};
 }
 function readXstz(bytes, offset, what) {
@@ -55,34 +61,120 @@ function readXstz(bytes, offset, what) {
 	for (let index = 0; index < cch; index += 1) out += String.fromCharCode(require_bytes.readUint16LE(chars, index * 2));
 	return out;
 }
+function xstzByteLength(bytes, offset) {
+	return 2 + require_bytes.readUint16LE(bytes, offset) * 2 + 2;
+}
+function readLpUpx(std, offset, what) {
+	const cbUpx = require_bytes.readUint16LE(std, offset);
+	return {
+		upx: require_bytes.slice(std, offset + 2, cbUpx, what),
+		next: offset + 2 + cbUpx + cbUpx % 2
+	};
+}
+function parseGrLPUpxSw(std, offset, stk, istd) {
+	if (stk === STK.paragraph) {
+		const papx = readLpUpx(std, offset, `UpxPapx for the paragraph style at istd ${istd}`);
+		const chpx = readLpUpx(std, papx.next, `UpxChpx for the paragraph style at istd ${istd}`);
+		const grpprlPapxBytes = require_bytes.slice(papx.upx, 2, papx.upx.length - 2, `grpprlPapx for the paragraph style at istd ${istd}`);
+		return {
+			grpprlPapx: require_prop_sprm.readGrpprl(grpprlPapxBytes),
+			grpprlChpx: require_prop_sprm.readGrpprl(chpx.upx)
+		};
+	}
+	if (stk === STK.character) {
+		const chpx = readLpUpx(std, offset, `UpxChpx for the character style at istd ${istd}`);
+		return {
+			grpprlPapx: void 0,
+			grpprlChpx: require_prop_sprm.readGrpprl(chpx.upx)
+		};
+	}
+	return {
+		grpprlPapx: void 0,
+		grpprlChpx: void 0
+	};
+}
+function resolveStyleFormatting(styleSheet, istd) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = styleSheet.styles[istd];
+	while (current !== void 0) {
+		if (seen.has(current.istd)) throw new require_errors.DocFormatError(`style inheritance chain starting at istd ${istd} loops back to istd ${current.istd}, which [MS-DOC] 2.9.260's own istdBase rule forbids`);
+		seen.add(current.istd);
+		chain.push(current);
+		current = current.istdBase === void 0 ? void 0 : styleSheet.styles[current.istdBase];
+	}
+	const paragraphPrls = [];
+	const characterPrls = [];
+	for (let index = chain.length - 1; index >= 0; index -= 1) {
+		const style = chain[index];
+		if (style === void 0) continue;
+		if (style.grpprlPapx !== void 0) paragraphPrls.push(...style.grpprlPapx);
+		if (style.grpprlChpx !== void 0) characterPrls.push(...style.grpprlChpx);
+	}
+	return {
+		paragraphPrls,
+		characterPrls
+	};
+}
 function headingLevelFromIstd(istd) {
 	return istd >= 1 && istd <= 9 ? istd : void 0;
 }
-function buildEmptyStsh() {
+function buildStshForStyles(names) {
+	const cstd = names.size === 0 ? 0 : Math.max(...names.keys()) + 1;
 	const stshi = [];
-	const push16 = (value) => {
-		stshi.push(value & 255, value >> 8 & 255);
+	const push16 = (target, value) => {
+		target.push(value & 255, value >> 8 & 255);
 	};
-	push16(0);
-	push16(STDF_SIZE_WITHOUT_POST_2000);
-	push16(1);
-	push16(0);
-	push16(15);
-	push16(0);
-	push16(0);
-	push16(0);
-	push16(0);
-	push16(0);
-	push16(4);
-	return new Uint8Array([
+	push16(stshi, cstd);
+	push16(stshi, STDF_SIZE_WITHOUT_POST_2000);
+	push16(stshi, 1);
+	push16(stshi, 0);
+	push16(stshi, 15);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 4);
+	const out = [
 		stshi.length & 255,
 		stshi.length >> 8 & 255,
 		...stshi
-	]);
+	];
+	const pushLpUpx = (target, payload) => {
+		push16(target, payload.length);
+		target.push(...payload);
+		if (payload.length % 2 === 1) target.push(0);
+	};
+	for (let istd = 0; istd < cstd; istd += 1) {
+		const name = names.get(istd);
+		if (name === void 0) {
+			out.push(0, 0);
+			continue;
+		}
+		const std = [];
+		const word0 = 4094;
+		const word1 = STK.paragraph & 15 | 65520;
+		push16(std, word0);
+		push16(std, word1);
+		push16(std, 0);
+		push16(std, 0);
+		push16(std, 0);
+		push16(std, name.length);
+		for (const character of name) push16(std, character.charCodeAt(0));
+		push16(std, 0);
+		pushLpUpx(std, [istd & 255, istd >> 8 & 255]);
+		pushLpUpx(std, []);
+		push16(out, std.length);
+		out.push(...std);
+		if (std.length % 2 === 1) out.push(0);
+	}
+	return new Uint8Array(out);
 }
 //#endregion
 exports.STI_USER_DEFINED = STI_USER_DEFINED;
 exports.STK = STK;
-exports.buildEmptyStsh = buildEmptyStsh;
+exports.buildStshForStyles = buildStshForStyles;
 exports.headingLevelFromIstd = headingLevelFromIstd;
 exports.parseStsh = parseStsh;
+exports.resolveStyleFormatting = resolveStyleFormatting;

package/dist/style/stsh.d.cts

@@ -1,3 +1,4 @@
+import { t as Prl } from "../sprm-DEyvdOo0.cjs";
 //#region src/style/stsh.d.ts
 /** StdfBase.sti's "0x0FFE for user-defined styles"; anything else is an application-defined style whose sti identifies it. */
 declare const STI_USER_DEFINED = 4094;
@@ -18,13 +19,22 @@ interface Style {
   readonly istdBase: number | undefined;
   /** The style's primary name, from the STD's own Xstz. */
   readonly name: string;
+  /** The style's own paragraph formatting -- StkParaGRLPUPX's lpUpxPapx.PAPX.grpprlPapx -- present only for a paragraph style (STK.paragraph). Undefined for every other stk: table and numbering styles carry their own formatting shapes this package does not read (see the README's own scope note). */
+  readonly grpprlPapx: readonly Prl[] | undefined;
+  /** The style's own character formatting -- a paragraph style's StkParaGRLPUPX.lpUpxChpx.CHPX.grpprlChpx (the run-level defaults a heading's own text falls back to) or a character style's StkCharGRLPUPX.lpUpxChpx.CHPX.grpprlChpx -- present for STK.paragraph and STK.character, undefined otherwise. */
+  readonly grpprlChpx: readonly Prl[] | undefined;
 }
 interface StyleSheet {
   /** Indexed by istd; a hole is a slot [MS-DOC] permits to be empty ("A style definition can be empty, in which case cbStd MUST be 0"). */
   readonly styles: readonly (Style | undefined)[];
 }
 declare function parseStsh(stsh: Uint8Array): StyleSheet;
+interface ResolvedStyleFormatting {
+  readonly paragraphPrls: readonly Prl[];
+  readonly characterPrls: readonly Prl[];
+}
+declare function resolveStyleFormatting(styleSheet: StyleSheet, istd: number): ResolvedStyleFormatting;
 declare function headingLevelFromIstd(istd: number): number | undefined;
-declare function buildEmptyStsh(): Uint8Array;
+declare function buildStshForStyles(names: ReadonlyMap<number, string>): Uint8Array;
 //#endregion
-export { STI_USER_DEFINED, STK, Style, StyleSheet, buildEmptyStsh, headingLevelFromIstd, parseStsh };
+export { ResolvedStyleFormatting, STI_USER_DEFINED, STK, Style, StyleSheet, buildStshForStyles, headingLevelFromIstd, parseStsh, resolveStyleFormatting };

package/dist/style/stsh.d.ts

@@ -1,3 +1,4 @@
+import { t as Prl } from "../sprm-DEyvdOo0.js";
 //#region src/style/stsh.d.ts
 /** StdfBase.sti's "0x0FFE for user-defined styles"; anything else is an application-defined style whose sti identifies it. */
 declare const STI_USER_DEFINED = 4094;
@@ -18,13 +19,22 @@ interface Style {
   readonly istdBase: number | undefined;
   /** The style's primary name, from the STD's own Xstz. */
   readonly name: string;
+  /** The style's own paragraph formatting -- StkParaGRLPUPX's lpUpxPapx.PAPX.grpprlPapx -- present only for a paragraph style (STK.paragraph). Undefined for every other stk: table and numbering styles carry their own formatting shapes this package does not read (see the README's own scope note). */
+  readonly grpprlPapx: readonly Prl[] | undefined;
+  /** The style's own character formatting -- a paragraph style's StkParaGRLPUPX.lpUpxChpx.CHPX.grpprlChpx (the run-level defaults a heading's own text falls back to) or a character style's StkCharGRLPUPX.lpUpxChpx.CHPX.grpprlChpx -- present for STK.paragraph and STK.character, undefined otherwise. */
+  readonly grpprlChpx: readonly Prl[] | undefined;
 }
 interface StyleSheet {
   /** Indexed by istd; a hole is a slot [MS-DOC] permits to be empty ("A style definition can be empty, in which case cbStd MUST be 0"). */
   readonly styles: readonly (Style | undefined)[];
 }
 declare function parseStsh(stsh: Uint8Array): StyleSheet;
+interface ResolvedStyleFormatting {
+  readonly paragraphPrls: readonly Prl[];
+  readonly characterPrls: readonly Prl[];
+}
+declare function resolveStyleFormatting(styleSheet: StyleSheet, istd: number): ResolvedStyleFormatting;
 declare function headingLevelFromIstd(istd: number): number | undefined;
-declare function buildEmptyStsh(): Uint8Array;
+declare function buildStshForStyles(names: ReadonlyMap<number, string>): Uint8Array;
 //#endregion
-export { STI_USER_DEFINED, STK, Style, StyleSheet, buildEmptyStsh, headingLevelFromIstd, parseStsh };
+export { ResolvedStyleFormatting, STI_USER_DEFINED, STK, Style, StyleSheet, buildStshForStyles, headingLevelFromIstd, parseStsh, resolveStyleFormatting };

package/dist/style/stsh.js

@@ -1,5 +1,6 @@
 import { DocFormatError } from "../errors.js";
 import { readInt16LE, readUint16LE, slice } from "../bytes.js";
+import { readGrpprl } from "../prop/sprm.js";
 //#region src/style/stsh.ts
 /** Stshif is a fixed 18 bytes: cstd, cbSTDBaseInFile, a bit field, stiMaxWhenSaved, istdMaxFixedWhenSaved, nVerBuiltInNamesWhenSaved, and the three default font indexes. */
 const STSHIF_SIZE = 18;
@@ -39,12 +40,17 @@ function parseStd(std, istd, cbStdBaseInFile) {
 	const word0 = readUint16LE(std, 0);
 	const word1 = readUint16LE(std, 2);
 	const istdBase = word1 >> 4 & 4095;
+	const stk = word1 & 15;
+	const name = readXstz(std, cbStdBaseInFile, `name of the style at istd ${istd}`);
+	const { grpprlPapx, grpprlChpx } = parseGrLPUpxSw(std, cbStdBaseInFile + xstzByteLength(std, cbStdBaseInFile), stk, istd);
 	return {
 		istd,
 		sti: word0 & 4095,
-		stk: word1 & 15,
+		stk,
 		istdBase: istdBase === ISTD_BASE_NONE ? void 0 : istdBase,
-		name: readXstz(std, cbStdBaseInFile, `name of the style at istd ${istd}`)
+		name,
+		grpprlPapx,
+		grpprlChpx
 	};
 }
 function readXstz(bytes, offset, what) {
@@ -54,30 +60,115 @@ function readXstz(bytes, offset, what) {
 	for (let index = 0; index < cch; index += 1) out += String.fromCharCode(readUint16LE(chars, index * 2));
 	return out;
 }
+function xstzByteLength(bytes, offset) {
+	return 2 + readUint16LE(bytes, offset) * 2 + 2;
+}
+function readLpUpx(std, offset, what) {
+	const cbUpx = readUint16LE(std, offset);
+	return {
+		upx: slice(std, offset + 2, cbUpx, what),
+		next: offset + 2 + cbUpx + cbUpx % 2
+	};
+}
+function parseGrLPUpxSw(std, offset, stk, istd) {
+	if (stk === STK.paragraph) {
+		const papx = readLpUpx(std, offset, `UpxPapx for the paragraph style at istd ${istd}`);
+		const chpx = readLpUpx(std, papx.next, `UpxChpx for the paragraph style at istd ${istd}`);
+		const grpprlPapxBytes = slice(papx.upx, 2, papx.upx.length - 2, `grpprlPapx for the paragraph style at istd ${istd}`);
+		return {
+			grpprlPapx: readGrpprl(grpprlPapxBytes),
+			grpprlChpx: readGrpprl(chpx.upx)
+		};
+	}
+	if (stk === STK.character) {
+		const chpx = readLpUpx(std, offset, `UpxChpx for the character style at istd ${istd}`);
+		return {
+			grpprlPapx: void 0,
+			grpprlChpx: readGrpprl(chpx.upx)
+		};
+	}
+	return {
+		grpprlPapx: void 0,
+		grpprlChpx: void 0
+	};
+}
+function resolveStyleFormatting(styleSheet, istd) {
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = styleSheet.styles[istd];
+	while (current !== void 0) {
+		if (seen.has(current.istd)) throw new DocFormatError(`style inheritance chain starting at istd ${istd} loops back to istd ${current.istd}, which [MS-DOC] 2.9.260's own istdBase rule forbids`);
+		seen.add(current.istd);
+		chain.push(current);
+		current = current.istdBase === void 0 ? void 0 : styleSheet.styles[current.istdBase];
+	}
+	const paragraphPrls = [];
+	const characterPrls = [];
+	for (let index = chain.length - 1; index >= 0; index -= 1) {
+		const style = chain[index];
+		if (style === void 0) continue;
+		if (style.grpprlPapx !== void 0) paragraphPrls.push(...style.grpprlPapx);
+		if (style.grpprlChpx !== void 0) characterPrls.push(...style.grpprlChpx);
+	}
+	return {
+		paragraphPrls,
+		characterPrls
+	};
+}
 function headingLevelFromIstd(istd) {
 	return istd >= 1 && istd <= 9 ? istd : void 0;
 }
-function buildEmptyStsh() {
+function buildStshForStyles(names) {
+	const cstd = names.size === 0 ? 0 : Math.max(...names.keys()) + 1;
 	const stshi = [];
-	const push16 = (value) => {
-		stshi.push(value & 255, value >> 8 & 255);
+	const push16 = (target, value) => {
+		target.push(value & 255, value >> 8 & 255);
 	};
-	push16(0);
-	push16(STDF_SIZE_WITHOUT_POST_2000);
-	push16(1);
-	push16(0);
-	push16(15);
-	push16(0);
-	push16(0);
-	push16(0);
-	push16(0);
-	push16(0);
-	push16(4);
-	return new Uint8Array([
+	push16(stshi, cstd);
+	push16(stshi, STDF_SIZE_WITHOUT_POST_2000);
+	push16(stshi, 1);
+	push16(stshi, 0);
+	push16(stshi, 15);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 0);
+	push16(stshi, 4);
+	const out = [
 		stshi.length & 255,
 		stshi.length >> 8 & 255,
 		...stshi
-	]);
+	];
+	const pushLpUpx = (target, payload) => {
+		push16(target, payload.length);
+		target.push(...payload);
+		if (payload.length % 2 === 1) target.push(0);
+	};
+	for (let istd = 0; istd < cstd; istd += 1) {
+		const name = names.get(istd);
+		if (name === void 0) {
+			out.push(0, 0);
+			continue;
+		}
+		const std = [];
+		const word0 = 4094;
+		const word1 = STK.paragraph & 15 | 65520;
+		push16(std, word0);
+		push16(std, word1);
+		push16(std, 0);
+		push16(std, 0);
+		push16(std, 0);
+		push16(std, name.length);
+		for (const character of name) push16(std, character.charCodeAt(0));
+		push16(std, 0);
+		pushLpUpx(std, [istd & 255, istd >> 8 & 255]);
+		pushLpUpx(std, []);
+		push16(out, std.length);
+		out.push(...std);
+		if (std.length % 2 === 1) out.push(0);
+	}
+	return new Uint8Array(out);
 }
 //#endregion
-export { STI_USER_DEFINED, STK, buildEmptyStsh, headingLevelFromIstd, parseStsh };
+export { STI_USER_DEFINED, STK, buildStshForStyles, headingLevelFromIstd, parseStsh, resolveStyleFormatting };

package/dist/table/write.d.cts

@@ -1,2 +1,2 @@
-import { n as WriteWarning, r as flattenSectionBlocks, t as WriteParagraph } from "../write-C9XbykDf.cjs";
+import { n as WriteWarning, r as flattenSectionBlocks, t as WriteParagraph } from "../write-SN_aIwyF.cjs";
 export { WriteParagraph, WriteWarning, flattenSectionBlocks };

package/dist/table/write.d.ts

@@ -1,2 +1,2 @@
-import { n as WriteWarning, r as flattenSectionBlocks, t as WriteParagraph } from "../write-C9XbykDf.js";
+import { n as WriteWarning, r as flattenSectionBlocks, t as WriteParagraph } from "../write-SN_aIwyF.js";
 export { WriteParagraph, WriteWarning, flattenSectionBlocks };

package/dist/{write-C9XbykDf.d.cts → write-SN_aIwyF.d.cts}

@@ -4,7 +4,7 @@ import { ContentBlock, ContentParagraph, ContentRun } from "document-schema.js";
 type WriteWarning = (message: string) => void;
 interface WriteParagraph {
   readonly runs: readonly ContentRun[];
-  readonly properties: Pick<ContentParagraph, "alignment" | "indentLeftPt" | "indentRightPt" | "indentFirstLinePt" | "spacingBeforePt" | "spacingAfterPt" | "lineSpacing" | "pageBreakBefore" | "list">;
+  readonly properties: Pick<ContentParagraph, "alignment" | "indentLeftPt" | "indentRightPt" | "indentFirstLinePt" | "spacingBeforePt" | "spacingAfterPt" | "lineSpacing" | "pageBreakBefore" | "list" | "styleId" | "headingLevel">;
   /** Extra grpprl bytes appended after encodeParagraphGrpprl's own output -- sprmPFInTable on every table paragraph, plus sprmPFTtp and the row's own TAP on a row's trailing mark. */
   readonly extraGrpprl: readonly number[];
   /** The character terminating this paragraph in the text stream: PARAGRAPH_MARK normally, CELL_MARK for a table cell or row mark. */

package/dist/{write-C9XbykDf.d.ts → write-SN_aIwyF.d.ts}

@@ -4,7 +4,7 @@ import { ContentBlock, ContentParagraph, ContentRun } from "document-schema.js";
 type WriteWarning = (message: string) => void;
 interface WriteParagraph {
   readonly runs: readonly ContentRun[];
-  readonly properties: Pick<ContentParagraph, "alignment" | "indentLeftPt" | "indentRightPt" | "indentFirstLinePt" | "spacingBeforePt" | "spacingAfterPt" | "lineSpacing" | "pageBreakBefore" | "list">;
+  readonly properties: Pick<ContentParagraph, "alignment" | "indentLeftPt" | "indentRightPt" | "indentFirstLinePt" | "spacingBeforePt" | "spacingAfterPt" | "lineSpacing" | "pageBreakBefore" | "list" | "styleId" | "headingLevel">;
   /** Extra grpprl bytes appended after encodeParagraphGrpprl's own output -- sprmPFInTable on every table paragraph, plus sprmPFTtp and the row's own TAP on a row's trailing mark. */
   readonly extraGrpprl: readonly number[];
   /** The character terminating this paragraph in the text stream: PARAGRAPH_MARK normally, CELL_MARK for a table cell or row mark. */

package/dist/write.cjs

@@ -32,6 +32,28 @@ function writeDocContent(document, options = {}) {
 		extraGrpprl: [],
 		terminator: 13
 	});
+	const FIRST_NON_HEADING_ISTD = 10;
+	const MAX_HEADING_ISTD = 9;
+	const styleNames = /* @__PURE__ */ new Map();
+	const istdByStyleId = /* @__PURE__ */ new Map();
+	let nextNonHeadingIstd = FIRST_NON_HEADING_ISTD;
+	const istdOf = (properties) => {
+		const heading = properties.headingLevel;
+		if (heading !== void 0 && heading >= 1 && heading <= MAX_HEADING_ISTD) {
+			if (!styleNames.has(heading)) styleNames.set(heading, properties.styleId ?? `Heading ${String(heading)}`);
+			return heading;
+		}
+		const styleId = properties.styleId;
+		if (styleId === void 0) return 0;
+		const existing = istdByStyleId.get(styleId);
+		if (existing !== void 0) return existing;
+		const istd = nextNonHeadingIstd;
+		nextNonHeadingIstd += 1;
+		istdByStyleId.set(styleId, istd);
+		styleNames.set(istd, styleId);
+		return istd;
+	};
+	const istds = writeParagraphs.map((entry) => istdOf(entry.properties));
 	const fontNames = [];
 	const fontIndexByName = /* @__PURE__ */ new Map();
 	const fontIndexOf = (name) => {
@@ -101,9 +123,11 @@ function writeDocContent(document, options = {}) {
 	const papxParagraphSpecs = formatted.map((paragraph, index) => {
 		const start = paragraphStarts[index];
 		if (start === void 0) throw new require_errors.DocFormatError("internal defect: writeDocContent lost a paragraph's own start position");
+		const istd = istds[index];
+		if (istd === void 0) throw new require_errors.DocFormatError("internal defect: writeDocContent lost a paragraph's own minted istd");
 		return {
 			fc: characterFc(start),
-			istd: 0,
+			istd,
 			grpprl: paragraph.grpprl
 		};
 	});
@@ -123,7 +147,7 @@ function writeDocContent(document, options = {}) {
 	const clx = require_text_piece_table_write.buildTextClx(text.length, TEXT_FC);
 	const chpxBinTable = require_prop_fkp_write.buildPropertyBinTable([...chpxPages.map(require_prop_fkp_write.firstFcOfPage), textFcLim], chpxPages.map((_, index) => chpxPageStart + index));
 	const papxBinTable = require_prop_fkp_write.buildPropertyBinTable([...papxPages.map(require_prop_fkp_write.firstFcOfPage), textFcLim], papxPages.map((_, index) => papxPageStart + index));
-	const stsh = require_style_stsh.buildEmptyStsh();
+	const stsh = require_style_stsh.buildStshForStyles(styleNames);
 	const fontTable = fontNames.length > 0 ? require_style_fonts.buildFontTable(fontNames) : void 0;
 	const plcfSed = require_prop_sep_write.buildPlcfSed(text.length, fcSepx);
 	let cursor = 0;

package/dist/write.d.cts

@@ -1,4 +1,4 @@
-import { n as WriteWarning } from "./write-C9XbykDf.cjs";
+import { n as WriteWarning } from "./write-SN_aIwyF.cjs";
 import { ContentDocument } from "document-schema.js";
 //#region src/write.d.ts
 interface WriteDocContentOptions {

package/dist/write.d.ts

@@ -1,4 +1,4 @@
-import { n as WriteWarning } from "./write-C9XbykDf.js";
+import { n as WriteWarning } from "./write-SN_aIwyF.js";
 import { ContentDocument } from "document-schema.js";
 //#region src/write.d.ts
 interface WriteDocContentOptions {

package/dist/write.js

@@ -9,7 +9,7 @@ import { buildChpxPages, buildPapxPages, buildPropertyBinTable, firstFcOfPage }
 import { encodeCharacterGrpprl } from "./prop/chp-write.js";
 import { encodeParagraphGrpprl } from "./prop/pap-write.js";
 import { buildPlcfSed, buildSepx, encodeSectionGrpprl } from "./prop/sep-write.js";
-import { buildEmptyStsh } from "./style/stsh.js";
+import { buildStshForStyles } from "./style/stsh.js";
 import { buildFontTable } from "./style/fonts.js";
 import { buildNumberingTables, gatherListUsage } from "./list/numbering-write.js";
 import { flattenSectionBlocks } from "./table/write.js";
@@ -31,6 +31,28 @@ function writeDocContent(document, options = {}) {
 		extraGrpprl: [],
 		terminator: 13
 	});
+	const FIRST_NON_HEADING_ISTD = 10;
+	const MAX_HEADING_ISTD = 9;
+	const styleNames = /* @__PURE__ */ new Map();
+	const istdByStyleId = /* @__PURE__ */ new Map();
+	let nextNonHeadingIstd = FIRST_NON_HEADING_ISTD;
+	const istdOf = (properties) => {
+		const heading = properties.headingLevel;
+		if (heading !== void 0 && heading >= 1 && heading <= MAX_HEADING_ISTD) {
+			if (!styleNames.has(heading)) styleNames.set(heading, properties.styleId ?? `Heading ${String(heading)}`);
+			return heading;
+		}
+		const styleId = properties.styleId;
+		if (styleId === void 0) return 0;
+		const existing = istdByStyleId.get(styleId);
+		if (existing !== void 0) return existing;
+		const istd = nextNonHeadingIstd;
+		nextNonHeadingIstd += 1;
+		istdByStyleId.set(styleId, istd);
+		styleNames.set(istd, styleId);
+		return istd;
+	};
+	const istds = writeParagraphs.map((entry) => istdOf(entry.properties));
 	const fontNames = [];
 	const fontIndexByName = /* @__PURE__ */ new Map();
 	const fontIndexOf = (name) => {
@@ -100,9 +122,11 @@ function writeDocContent(document, options = {}) {
 	const papxParagraphSpecs = formatted.map((paragraph, index) => {
 		const start = paragraphStarts[index];
 		if (start === void 0) throw new DocFormatError("internal defect: writeDocContent lost a paragraph's own start position");
+		const istd = istds[index];
+		if (istd === void 0) throw new DocFormatError("internal defect: writeDocContent lost a paragraph's own minted istd");
 		return {
 			fc: characterFc(start),
-			istd: 0,
+			istd,
 			grpprl: paragraph.grpprl
 		};
 	});
@@ -122,7 +146,7 @@ function writeDocContent(document, options = {}) {
 	const clx = buildTextClx(text.length, TEXT_FC);
 	const chpxBinTable = buildPropertyBinTable([...chpxPages.map(firstFcOfPage), textFcLim], chpxPages.map((_, index) => chpxPageStart + index));
 	const papxBinTable = buildPropertyBinTable([...papxPages.map(firstFcOfPage), textFcLim], papxPages.map((_, index) => papxPageStart + index));
-	const stsh = buildEmptyStsh();
+	const stsh = buildStshForStyles(styleNames);
 	const fontTable = fontNames.length > 0 ? buildFontTable(fontNames) : void 0;
 	const plcfSed = buildPlcfSed(text.length, fcSepx);
 	let cursor = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doc-codec",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "description": "A hand-written reader for the Word Binary File Format ([MS-DOC], .doc) against the shared document-schema.js content pivot: FIB parsing, piece-table text reconstruction, and CHPX/PAPX formatting exceptions.",
   "type": "module",
   "repository": {