xls-codec 4.11.0 → 4.12.0

package/README.md

@@ -30,22 +30,22 @@ Verified primarily by round trip (`src/write.test.ts`, plus a dedicated `test/wo
 
 ### Writer scope
 
-What `writeXlsContent`/`writeXls` cover: every `ContentCellValue` kind a real `.xls` can hold (`number`, `percentage`, `currency`, `boolean`, `date`, `time`, `dateTime`, `string`, `error`; an `empty` cell is written as a `Blank` record when it carries formatting and as nothing at all when it does not — see below), merged ranges (`colSpan`/`rowSpan`), row heights and hidden rows, column widths and hidden columns, multiple sheets, explicit and default number formats, a shared string table deduplicated across the whole workbook, every field of a sheet's own [print settings](#print-settings), a cell's own [alignment](#cell-alignment), a cell's own background fill and per-side borders (see [Cell decoration](#cell-decoration)), a same-sheet formula (see [Formula writing](#formula-writing)), and a cell's own comment text and author (see [Cell comments, written](#cell-comments-written)). What it deliberately does not:
-
-| Not written                                                                                                                                                                                      | Why                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Formula` records for a 3D (cross-sheet or external-workbook) reference, an array-constant literal or CSE array formula, a defined name, or a call to a function outside `Ftab`'s own vocabulary | Same-sheet formulas write (see [Formula writing](#formula-writing)); these four constructs each throw a `BiffWriteError` naming the construct instead, rather than emit a token stream the writer cannot prove round-trips. A 3D reference needs a `SupBook`/`ExternSheet` pair this writer only ever mints today for the two built-in print-settings names (see [Print settings](#print-settings)), not for an arbitrary formula; an array constant/CSE formula needs a `PtgExtraArray`/`Array`-record trailer this writer does not build; a defined name has nowhere to resolve against, the same gap the `Lbl` row below describes; and Excel 2007+ added many worksheet functions BIFF8's own `Ftab` enumeration never named, resolved through a `PtgNameX`/add-in mechanism this writer does not implement. |
-| Per-cell font                                                                                                                                                                                    | The reader does not read one back: `ContentSheetCell` has no cell-level font field at all (`ooxml.js`'s xlsx reader makes the identical font-scope choice), so writing a real value here would be unverifiable by round trip. Every `XF` this writer emits still references the same single font.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `MulBlank`/`RK`/`MulRk`                                                                                                                                                                          | Pure compaction optimisations over information a plain `Blank`/`Number`/`LabelSst`/`BoolErr` record already carries losslessly. (`Blank` itself _is_ written, for a formatted empty cell — see the `empty` row below.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| An `empty`-kind cell carrying no formatting                                                                                                                                                      | Written as nothing at all, which is what round-trips: `content.ts`'s reader drops an unformatted blank cell it reads, and a merged range's empty anchor is independently reconstructed from `MergeCells` alone. A formatted one (a fill, a border, or a non-default alignment) is the opposite case — its formatting exists only in the `XF` a cell record names, so it gets a real `Blank` record ([MS-XLS] 2.4.20) and round-trips with that formatting intact.                                                                                                                                                                                                                                                                                                                                                |
-| Images, embedded objects (charts/drawings)                                                                                                                                                       | The reader now recovers a sheet's own pictures, charts, and generic drawing shapes (see Read-side gaps below), but writing them back out is its own separate mechanism — a shape's own MS-ODRAW (Escher) container tree, a workbook-wide Blip Store, and (for a chart) a whole nested `BOF`/`EOF` substream, none of which this writer's existing per-record emission has any machinery for — scoped as its own piece of work rather than folded into recovering the read side, the same split this table already draws for `Formula` records. `ContentSheet.images` and `ContentSheet.embeddedObjects` are silently ignored on write.                                                                                                                                                                           |
-| Defined names (`Lbl`)                                                                                                                                                                            | Read only for the two built-in ones a sheet's print range and repeated header bands live in ([Print settings](#print-settings)); a user-defined name has nowhere to land in `document-schema.js`'s spreadsheet model, so there is no round trip to verify a writer for it against.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| Data validation (`Dv`/`DVal`)                                                                                                                                                                    | The reader now recovers a sheet's own validation rules (see Read-side gaps below), but writing them back out is its own separate mechanism -- re-encoding a formula's own text back into `Ptg` tokens for `Dv`'s two `DVParsedFormula` fields, the same "not folded into recovering the read side" split this table already draws for `Formula` records. A `ContentSheet.dataValidations` is silently ignored on write.                                                                                                                                                                                                                                                                                                                                                                                          |
-| Conditional formatting (`CondFmt`/`CF`, `CondFmt12`/`CF12`, `CFEx`)                                                                                                                              | The reader now recovers a sheet's own base `cellIs` rules and every `CF12`/`CFEx` rule this package's schema models (see Read-side gaps below), but writing them back out is its own separate mechanism, the same "not folded into recovering the read side" split this table already draws for `Formula` records and `Dv`. A `ContentSheet.conditionalFormats` is silently ignored on write.                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| A comment's `replies` or `createdAt`                                                                                                                                                             | A cell's `text` and `author` write (see the Status list above); legacy BIFF8's `Note`/`Obj`/`Txo` triple has no threading and no per-comment timestamp at all, the same gap `src/workbook/comments.ts`'s own read side already documents, so there is nothing for these two fields to round-trip against.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| A page size no `iPaperSize` code names                                                                                                                                                           | Written as [MS-XLS] 2.4.257's own custom-paper value rather than as a named paper it is not — the dimensions themselves are unwritable, since `Setup` addresses paper only by code. See [Print settings](#print-settings).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `Window1`/`Window2`, `CodePage`, `Index`/`DBCell`, the legacy interface records (`InterfaceHdr`, `WriteAccess`, …)                                                                               | UI and interoperability bookkeeping [MS-XLS]'s own grammar names in the globals/worksheet substreams alongside the content-carrying records above, not data. `Index`/`DBCell` specifically is a pure cell-lookup performance optimisation (see [MS-XLS]'s own "Retrieval of Last-Calculated Cell Values Without Loading Cell Table") that this reader — and Excel's own reader — does not require to find a cell; real, well-established minimal BIFF8 writers (e.g. Python's `xlwt`) omit the same set and produce files Excel opens correctly. The calculation-state records (`CalcCount`, `CalcRefMode`, `CalcIter`, `CalcDelta`, `CalcSaveRecalc`) sat in this row until print settings needed them — see [Print settings](#print-settings) for why the writer emits them now.                               |
-| `Continue`-chain splitting                                                                                                                                                                       | A record whose data would exceed the 8224-byte single-record ceiling ([MS-XLS] 2.1.4) — an extremely long shared string, an enormous shared string table, or thousands of merged ranges in one sheet — is refused with a thrown `BiffWriteError` rather than silently split across `Continue` records.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+What `writeXlsContent`/`writeXls` cover: every `ContentCellValue` kind a real `.xls` can hold (`number`, `percentage`, `currency`, `boolean`, `date`, `time`, `dateTime`, `string`, `error`; an `empty` cell is written as a `Blank` record when it carries formatting and as nothing at all when it does not — see below), merged ranges (`colSpan`/`rowSpan`), row heights and hidden rows, column widths and hidden columns, multiple sheets, explicit and default number formats, a shared string table deduplicated across the whole workbook, every field of a sheet's own [print settings](#print-settings), a cell's own [alignment](#cell-alignment), a cell's own background fill and per-side borders (see [Cell decoration](#cell-decoration)), a same-sheet formula (see [Formula writing](#formula-writing)), and a cell's own comment text and author (see [Cell comments, written](#cell-comments-written)), a sheet's own data validations (one Dval wrapper plus one Dv record per rule, every schema field through the same `compileFormulaText` formula compiler cell formulas use), and a sheet's own `cellIs` conditional formats (one CondFmt plus one CF record per rule, its style's text colour and solid background encoded as a DXFN through the workbook's own palette). What it deliberately does not:
+
+| Not written                                                                                                                                                                                      | Why                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Formula` records for a 3D (cross-sheet or external-workbook) reference, an array-constant literal or CSE array formula, a defined name, or a call to a function outside `Ftab`'s own vocabulary | Same-sheet formulas write (see [Formula writing](#formula-writing)); these four constructs each throw a `BiffWriteError` naming the construct instead, rather than emit a token stream the writer cannot prove round-trips. A 3D reference needs a `SupBook`/`ExternSheet` pair this writer only ever mints today for the two built-in print-settings names (see [Print settings](#print-settings)), not for an arbitrary formula; an array constant/CSE formula needs a `PtgExtraArray`/`Array`-record trailer this writer does not build; a defined name has nowhere to resolve against, the same gap the `Lbl` row below describes; and Excel 2007+ added many worksheet functions BIFF8's own `Ftab` enumeration never named, resolved through a `PtgNameX`/add-in mechanism this writer does not implement.                                          |
+| Per-cell font                                                                                                                                                                                    | The reader does not read one back: `ContentSheetCell` has no cell-level font field at all (`ooxml.js`'s xlsx reader makes the identical font-scope choice), so writing a real value here would be unverifiable by round trip. Every `XF` this writer emits still references the same single font.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `MulBlank`/`RK`/`MulRk`                                                                                                                                                                          | Pure compaction optimisations over information a plain `Blank`/`Number`/`LabelSst`/`BoolErr` record already carries losslessly. (`Blank` itself _is_ written, for a formatted empty cell — see the `empty` row below.)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| An `empty`-kind cell carrying no formatting                                                                                                                                                      | Written as nothing at all, which is what round-trips: `content.ts`'s reader drops an unformatted blank cell it reads, and a merged range's empty anchor is independently reconstructed from `MergeCells` alone. A formatted one (a fill, a border, or a non-default alignment) is the opposite case — its formatting exists only in the `XF` a cell record names, so it gets a real `Blank` record ([MS-XLS] 2.4.20) and round-trips with that formatting intact.                                                                                                                                                                                                                                                                                                                                                                                         |
+| Images, embedded objects (charts/drawings)                                                                                                                                                       | The reader now recovers a sheet's own pictures, charts, and generic drawing shapes (see Read-side gaps below), but writing them back out is its own separate mechanism — a shape's own MS-ODRAW (Escher) container tree, a workbook-wide Blip Store, and (for a chart) a whole nested `BOF`/`EOF` substream, none of which this writer's existing per-record emission has any machinery for — scoped as its own piece of work rather than folded into recovering the read side, the same split this table already draws for `Formula` records. `ContentSheet.images` and `ContentSheet.embeddedObjects` are silently ignored on write.                                                                                                                                                                                                                    |
+| Defined names (`Lbl`)                                                                                                                                                                            | Read only for the two built-in ones a sheet's print range and repeated header bands live in ([Print settings](#print-settings)); a user-defined name has nowhere to land in `document-schema.js`'s spreadsheet model, so there is no round trip to verify a writer for it against.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| A data validation whose formula text `compileFormulaText` cannot encode                                                                                                                          | Every other rule shape writes (see the lead paragraph); a formula naming a construct outside the same-sheet `Ptg` vocabulary the cell-formula writer supports throws the identical `BiffWriteError` that cell formula already does, rather than emit a token stream this writer cannot prove round-trips. A comparison-typed rule carrying no operator, or a two-operand operator (`between`/`notBetween`) carrying fewer or more than its two formulas, is a malformed model and throws naming it.                                                                                                                                                                                                                                                                                                                                                       |
+| Conditional formatting beyond the base `cellIs` comparison (`CondFmt12`/`CF12`/`CFEx`)                                                                                                           | A `cellIs` rule writes as one `CondFmt` plus one `CF` record -- its operator, both formula operands through `compileFormulaText`, and its style's text colour and solid background as a `DXFN` resolved through the workbook's own palette (`workbook/conditional-format-write.ts`, the write-side inverse of `readCondFmtGroup`/`readCf`/`parseDxfStyle`). Every other variant the schema models (colour scale, data bar, icon set, the text family, `top10`, ...) is a CF12-era rule with no base-CF spelling, and CF12 writing is its own mechanism this writer does not build -- such a rule throws a `BiffWriteError` naming its type rather than being silently dropped, the identical refusal the four out-of-scope formula constructs already draw. A `cellIs` rule's `priority`/`stopIfTrue`/`source` have no base-CF field and are not written. |
+| A comment's `replies` or `createdAt`                                                                                                                                                             | A cell's `text` and `author` write (see the Status list above); legacy BIFF8's `Note`/`Obj`/`Txo` triple has no threading and no per-comment timestamp at all, the same gap `src/workbook/comments.ts`'s own read side already documents, so there is nothing for these two fields to round-trip against.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| A page size no `iPaperSize` code names                                                                                                                                                           | Written as [MS-XLS] 2.4.257's own custom-paper value rather than as a named paper it is not — the dimensions themselves are unwritable, since `Setup` addresses paper only by code. See [Print settings](#print-settings).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `Window1`/`Window2`, `CodePage`, `Index`/`DBCell`, the legacy interface records (`InterfaceHdr`, `WriteAccess`, …)                                                                               | UI and interoperability bookkeeping [MS-XLS]'s own grammar names in the globals/worksheet substreams alongside the content-carrying records above, not data. `Index`/`DBCell` specifically is a pure cell-lookup performance optimisation (see [MS-XLS]'s own "Retrieval of Last-Calculated Cell Values Without Loading Cell Table") that this reader — and Excel's own reader — does not require to find a cell; real, well-established minimal BIFF8 writers (e.g. Python's `xlwt`) omit the same set and produce files Excel opens correctly. The calculation-state records (`CalcCount`, `CalcRefMode`, `CalcIter`, `CalcDelta`, `CalcSaveRecalc`) sat in this row until print settings needed them — see [Print settings](#print-settings) for why the writer emits them now.                                                                        |
+| `Continue`-chain splitting                                                                                                                                                                       | A record whose data would exceed the 8224-byte single-record ceiling ([MS-XLS] 2.1.4) — an extremely long shared string, an enormous shared string table, or thousands of merged ranges in one sheet — is refused with a thrown `BiffWriteError` rather than silently split across `Continue` records.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
 Column widths round-trip to the nearest pixel Excel's own integer-pixel-grid quantization allows (matching the read direction's own "honestly approximate" contract, `units.ts`), never narrower than requested. A `.xls` cell outside BIFF8's own grid (65536 rows, 256 columns) is refused rather than silently wrapped or truncated.
 
@@ -66,7 +66,7 @@ Each deliberate rather than overlooked:
 - **Not read at all:** a `CFEx` record that extends a genuine `CF12` record rather than a legacy `CF` (see above). Defined names (`Lbl`) are read only for the two built-in ones a sheet's print range and repeated header bands live in ([Print settings](#print-settings)); a user-defined name has nowhere to land in `document-schema.js`'s spreadsheet model, so it is skipped.
 - **RC4-encrypted and XOR-obfuscated workbooks, decrypted for real (ExaDev/documents.js#1108, #922).** A `FilePass` record ([MS-XLS] 2.4.117) means every record after it is ciphertext under one of three schemes; this reader implements two of them, dispatching on the record's own `wEncryptionType` -- the [MS-OFFCRYPTO] 2.3.6.1 "RC4 encryption header" and 2.3.7's own XOR obfuscation (Method 1) -- `readXlsContent`/`readXls` take an optional `password`, verify it against the header's own fields (RC4's `EncryptedVerifier`/`EncryptedVerifierHash`, decrypted then compared; XOR obfuscation's `key`/`verificationBytes`, plain unencrypted checksums compared directly), then decrypt every subsequent record's data (`src/workbook/encryption.ts`) using the RC4/MD5 and XOR-obfuscation primitives [`archive-codec`](../archive-codec/README.md#xor-obfuscation-xlsdoc) shares with `doc-codec`. XOR obfuscation's own per-record `XorArrayIndex` -- `(streamOffset + recordDataLength) % 16`, `recordDataLength` always the record's own full declared size regardless of how much of a given span is actually being decrypted -- is confirmed against a genuine Excel-generated fixture, not just the published spec text (see `archive-codec`'s own account of why that spec text alone is not trustworthy here). [MS-XLS] 2.2.10's own exclusion list -- `BOF`, `FilePass`, and four shared-workbook revision-tracking records this package otherwise never reads, plus `BoundSheet8`'s own `lbPlyPos` field specifically -- is honoured exactly for both schemes, re-derived independently in this package's own tests rather than trusted by construction. A missing or incorrect password throws rather than returning a garbled document; the newer "RC4 CryptoAPI encryption header" scheme remains explicitly out of scope (ppt-codec's own encryption, tracked separately on [#1116](https://github.com/ExaDev/documents.js/issues/1116)).
 
-This package is wired into `documents.js`'s conversion registry (`xlsToPdf`/`pdfToXls`, `convertDocument("xls", ...)`, and every same-variant spreadsheet bridge) — see that package's own README Fidelity table for exactly which pairs route and which don't. Per-cell font is the one remaining read+write scope gap that is genuinely permanent rather than pending (see the Writer scope table below); formula writing and cell comments are covered as of [Formula writing](#formula-writing) and [Cell comments, written](#cell-comments-written), each within the boundary those sections describe. Images/embedded objects, data validation, conditional formatting, and defined names remain read-only — tracked on [#971](https://github.com/ExaDev/documents.js/issues/971).
+This package is wired into `documents.js`'s conversion registry (`xlsToPdf`/`pdfToXls`, `convertDocument("xls", ...)`, and every same-variant spreadsheet bridge) — see that package's own README Fidelity table for exactly which pairs route and which don't. Per-cell font is the one remaining read+write scope gap that is genuinely permanent rather than pending (see the Writer scope table below); formula writing, cell comments, data validation writing, and `cellIs` conditional-format writing are covered, each within the boundary the sections and the Writer scope table describe. Images/embedded objects (their MS-ODRAW/Escher container trees and Blip Store) and defined names remain read-only — the remaining [#971](https://github.com/ExaDev/documents.js/issues/971) scope.
 
 ## Cell decoration
 

package/dist/workbook/conditional-format-write.cjs

@@ -0,0 +1,93 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../biff/record-types.cjs");
+const require_biff_write_errors = require("../biff/write-errors.cjs");
+const require_biff_builder = require("../biff/builder.cjs");
+const require_biff_record_writer = require("../biff/record-writer.cjs");
+const require_biff_ptg_writer = require("../biff/ptg-writer.cjs");
+//#region src/workbook/conditional-format-write.ts
+const CP_BY_OPERATOR = /* @__PURE__ */ new Map([
+	["between", 1],
+	["notBetween", 2],
+	["equal", 3],
+	["notEqual", 4],
+	["greaterThan", 5],
+	["lessThan", 6],
+	["greaterThanOrEqual", 7],
+	["lessThanOrEqual", 8]
+]);
+const DXFFNTD_LENGTH = 122;
+const DXFFNTD_ICV_FORE_OFFSET = 80;
+function writeDxfn(style, icvOf) {
+	const textColor = style?.textColor;
+	const background = style?.background;
+	if (textColor === void 0 && background === void 0) return /* @__PURE__ */ new Uint8Array(0);
+	const flags = new require_biff_builder.RecordBuilder();
+	let flagsWord = 0;
+	if (textColor !== void 0) flagsWord |= 1 << 26;
+	if (background !== void 0) flagsWord |= 1 << 29;
+	flags.u32(flagsWord);
+	flags.u16(0);
+	if (textColor !== void 0) {
+		const fontBlock = new Uint8Array(DXFFNTD_LENGTH);
+		new DataView(fontBlock.buffer, fontBlock.byteOffset, fontBlock.byteLength).setInt32(DXFFNTD_ICV_FORE_OFFSET, icvOf(textColor), true);
+		flags.bytes(fontBlock);
+	}
+	if (background !== void 0) {
+		const patWord = 1024 | icvOf(background) << 16;
+		flags.u32(patWord >>> 0);
+	}
+	return flags.build();
+}
+function writeCfRecord(rule, icvOf) {
+	const cp = CP_BY_OPERATOR.get(rule.operator);
+	if (cp === void 0) throw new require_biff_write_errors.BiffWriteError(`conditional-format operator "${rule.operator}" has no CF cp value`);
+	const rgce1 = require_biff_ptg_writer.compileFormulaText(rule.formula1);
+	const rgce2 = rule.formula2 !== void 0 ? require_biff_ptg_writer.compileFormulaText(rule.formula2) : void 0;
+	const dxf = writeDxfn(rule.style, icvOf);
+	const writer = new require_biff_builder.RecordBuilder().u8(1).u8(cp).u16(rgce1.length).u16(rgce2?.length ?? 0).bytes(dxf).bytes(rgce1);
+	if (rgce2 !== void 0) writer.bytes(rgce2);
+	return require_biff_record_writer.writeRecord(433, writer.build());
+}
+function boundingBoxOf(rule) {
+	let startRow = Number.MAX_SAFE_INTEGER;
+	let endRow = 0;
+	let startColumn = Number.MAX_SAFE_INTEGER;
+	let endColumn = 0;
+	for (const range of rule.ranges) {
+		startRow = Math.min(startRow, range.startRow);
+		endRow = Math.max(endRow, range.endRow);
+		startColumn = Math.min(startColumn, range.startColumn);
+		endColumn = Math.max(endColumn, range.endColumn);
+	}
+	return {
+		startRow,
+		endRow,
+		startColumn,
+		endColumn
+	};
+}
+function writeSheetConditionalFormats(sheet, icvOf) {
+	const rules = sheet.conditionalFormats ?? [];
+	if (rules.length === 0) return [];
+	const pieces = [];
+	for (const [index, rule] of rules.entries()) {
+		if (rule.type !== "cellIs") throw new require_biff_write_errors.BiffWriteError(`a conditional-format rule of type "${rule.type}" has no base BIFF8 CF spelling; this writer states cellIs comparisons only (CF12 writing is out of scope), so the rule cannot be written rather than silently dropped`);
+		if (rule.ranges.length === 0) throw new require_biff_write_errors.BiffWriteError("a conditional-format rule carrying no range states nothing; the schema requires at least one");
+		for (const range of rule.ranges) if (range.startRow > 65535 || range.endRow > 65535 || range.startColumn > 255 || range.endColumn > 255) throw new require_biff_write_errors.BiffWriteError(`a conditional-format range (rows ${range.startRow}-${range.endRow}, columns ${range.startColumn}-${range.endColumn}) is outside BIFF8's own grid; a .xls workbook cannot address it`);
+		const nID = index + 1;
+		if (nID > 32767) throw new require_biff_write_errors.BiffWriteError(`this sheet's ${rules.length} conditional-format rules exceed CondFmt's own 15-bit nID field`);
+		const box = boundingBoxOf(rule);
+		const header = new require_biff_builder.RecordBuilder().u16(1).u16(nID << 1).u16(box.startRow).u16(box.endRow).u16(box.startColumn).u16(box.endColumn).u16(rule.ranges.length);
+		for (const range of rule.ranges) {
+			header.u16(range.startRow);
+			header.u16(range.endRow);
+			header.u16(range.startColumn);
+			header.u16(range.endColumn);
+		}
+		pieces.push(require_biff_record_writer.writeRecord(432, header.build()));
+		pieces.push(writeCfRecord(rule, icvOf));
+	}
+	return pieces;
+}
+//#endregion
+exports.writeSheetConditionalFormats = writeSheetConditionalFormats;

package/dist/workbook/conditional-format-write.d.cts

@@ -0,0 +1,5 @@
+import { Color, ContentSheet } from "document-schema.js";
+//#region src/workbook/conditional-format-write.d.ts
+declare function writeSheetConditionalFormats(sheet: ContentSheet, icvOf: (color: Color) => number): Uint8Array<ArrayBuffer>[];
+//#endregion
+export { writeSheetConditionalFormats };

package/dist/workbook/conditional-format-write.d.ts

@@ -0,0 +1,5 @@
+import { Color, ContentSheet } from "document-schema.js";
+//#region src/workbook/conditional-format-write.d.ts
+declare function writeSheetConditionalFormats(sheet: ContentSheet, icvOf: (color: Color) => number): Uint8Array<ArrayBuffer>[];
+//#endregion
+export { writeSheetConditionalFormats };

package/dist/workbook/conditional-format-write.js

@@ -0,0 +1,92 @@
+import "../biff/record-types.js";
+import { BiffWriteError } from "../biff/write-errors.js";
+import { RecordBuilder } from "../biff/builder.js";
+import { writeRecord } from "../biff/record-writer.js";
+import { compileFormulaText } from "../biff/ptg-writer.js";
+//#region src/workbook/conditional-format-write.ts
+const CP_BY_OPERATOR = /* @__PURE__ */ new Map([
+	["between", 1],
+	["notBetween", 2],
+	["equal", 3],
+	["notEqual", 4],
+	["greaterThan", 5],
+	["lessThan", 6],
+	["greaterThanOrEqual", 7],
+	["lessThanOrEqual", 8]
+]);
+const DXFFNTD_LENGTH = 122;
+const DXFFNTD_ICV_FORE_OFFSET = 80;
+function writeDxfn(style, icvOf) {
+	const textColor = style?.textColor;
+	const background = style?.background;
+	if (textColor === void 0 && background === void 0) return /* @__PURE__ */ new Uint8Array(0);
+	const flags = new RecordBuilder();
+	let flagsWord = 0;
+	if (textColor !== void 0) flagsWord |= 1 << 26;
+	if (background !== void 0) flagsWord |= 1 << 29;
+	flags.u32(flagsWord);
+	flags.u16(0);
+	if (textColor !== void 0) {
+		const fontBlock = new Uint8Array(DXFFNTD_LENGTH);
+		new DataView(fontBlock.buffer, fontBlock.byteOffset, fontBlock.byteLength).setInt32(DXFFNTD_ICV_FORE_OFFSET, icvOf(textColor), true);
+		flags.bytes(fontBlock);
+	}
+	if (background !== void 0) {
+		const patWord = 1024 | icvOf(background) << 16;
+		flags.u32(patWord >>> 0);
+	}
+	return flags.build();
+}
+function writeCfRecord(rule, icvOf) {
+	const cp = CP_BY_OPERATOR.get(rule.operator);
+	if (cp === void 0) throw new BiffWriteError(`conditional-format operator "${rule.operator}" has no CF cp value`);
+	const rgce1 = compileFormulaText(rule.formula1);
+	const rgce2 = rule.formula2 !== void 0 ? compileFormulaText(rule.formula2) : void 0;
+	const dxf = writeDxfn(rule.style, icvOf);
+	const writer = new RecordBuilder().u8(1).u8(cp).u16(rgce1.length).u16(rgce2?.length ?? 0).bytes(dxf).bytes(rgce1);
+	if (rgce2 !== void 0) writer.bytes(rgce2);
+	return writeRecord(433, writer.build());
+}
+function boundingBoxOf(rule) {
+	let startRow = Number.MAX_SAFE_INTEGER;
+	let endRow = 0;
+	let startColumn = Number.MAX_SAFE_INTEGER;
+	let endColumn = 0;
+	for (const range of rule.ranges) {
+		startRow = Math.min(startRow, range.startRow);
+		endRow = Math.max(endRow, range.endRow);
+		startColumn = Math.min(startColumn, range.startColumn);
+		endColumn = Math.max(endColumn, range.endColumn);
+	}
+	return {
+		startRow,
+		endRow,
+		startColumn,
+		endColumn
+	};
+}
+function writeSheetConditionalFormats(sheet, icvOf) {
+	const rules = sheet.conditionalFormats ?? [];
+	if (rules.length === 0) return [];
+	const pieces = [];
+	for (const [index, rule] of rules.entries()) {
+		if (rule.type !== "cellIs") throw new BiffWriteError(`a conditional-format rule of type "${rule.type}" has no base BIFF8 CF spelling; this writer states cellIs comparisons only (CF12 writing is out of scope), so the rule cannot be written rather than silently dropped`);
+		if (rule.ranges.length === 0) throw new BiffWriteError("a conditional-format rule carrying no range states nothing; the schema requires at least one");
+		for (const range of rule.ranges) if (range.startRow > 65535 || range.endRow > 65535 || range.startColumn > 255 || range.endColumn > 255) throw new BiffWriteError(`a conditional-format range (rows ${range.startRow}-${range.endRow}, columns ${range.startColumn}-${range.endColumn}) is outside BIFF8's own grid; a .xls workbook cannot address it`);
+		const nID = index + 1;
+		if (nID > 32767) throw new BiffWriteError(`this sheet's ${rules.length} conditional-format rules exceed CondFmt's own 15-bit nID field`);
+		const box = boundingBoxOf(rule);
+		const header = new RecordBuilder().u16(1).u16(nID << 1).u16(box.startRow).u16(box.endRow).u16(box.startColumn).u16(box.endColumn).u16(rule.ranges.length);
+		for (const range of rule.ranges) {
+			header.u16(range.startRow);
+			header.u16(range.endRow);
+			header.u16(range.startColumn);
+			header.u16(range.endColumn);
+		}
+		pieces.push(writeRecord(432, header.build()));
+		pieces.push(writeCfRecord(rule, icvOf));
+	}
+	return pieces;
+}
+//#endregion
+export { writeSheetConditionalFormats };

package/dist/workbook/data-validation-write.cjs

@@ -0,0 +1,85 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../biff/record-types.cjs");
+const require_biff_write_errors = require("../biff/write-errors.cjs");
+const require_biff_builder = require("../biff/builder.cjs");
+const require_biff_record_writer = require("../biff/record-writer.cjs");
+const require_biff_string_writer = require("../biff/string-writer.cjs");
+const require_biff_ptg_writer = require("../biff/ptg-writer.cjs");
+//#region src/workbook/data-validation-write.ts
+const VAL_TYPE_BY_TYPE = /* @__PURE__ */ new Map([
+	["whole", 1],
+	["decimal", 2],
+	["list", 3],
+	["date", 4],
+	["time", 5],
+	["textLength", 6],
+	["custom", 7]
+]);
+const TYP_OPERATOR_BY_OPERATOR = /* @__PURE__ */ new Map([
+	["between", 0],
+	["notBetween", 1],
+	["equal", 2],
+	["notEqual", 3],
+	["greaterThan", 4],
+	["lessThan", 5],
+	["greaterThanOrEqual", 6],
+	["lessThanOrEqual", 7]
+]);
+const ERR_STYLE_CODE = /* @__PURE__ */ new Map([
+	["stop", 0],
+	["warning", 1],
+	["information", 2]
+]);
+function writeDvParsedFormula(text) {
+	const rgce = text === void 0 ? /* @__PURE__ */ new Uint8Array(0) : require_biff_ptg_writer.compileFormulaText(text);
+	return [new require_biff_builder.RecordBuilder().u16(rgce.length).u16(0).build(), rgce];
+}
+function writeDvRecord(validation) {
+	const valType = VAL_TYPE_BY_TYPE.get(validation.type);
+	if (valType === void 0) throw new require_biff_write_errors.BiffWriteError(`data validation type "${validation.type}" has no Dv valType value`);
+	let flags = valType;
+	flags |= (ERR_STYLE_CODE.get(validation.errorStyle ?? "stop") ?? 0) << 4;
+	if (validation.allowBlank === true) flags |= 256;
+	if (validation.showInputMessage === true) flags |= 1 << 18;
+	if (validation.showErrorMessage === true) flags |= 1 << 19;
+	if (validation.type !== "list" && validation.type !== "custom") {
+		if (validation.operator === void 0) throw new require_biff_write_errors.BiffWriteError(`a ${validation.type} data validation over ${validation.ranges.length} range(s) carries no operator; the schema requires one for every type but 'list' and 'custom'`);
+		const typOperator = TYP_OPERATOR_BY_OPERATOR.get(validation.operator);
+		if (typOperator === void 0) throw new require_biff_write_errors.BiffWriteError(`data validation operator "${validation.operator}" has no Dv typOperator value`);
+		flags |= typOperator << 20;
+	}
+	const isTwoOperand = validation.operator === "between" || validation.operator === "notBetween";
+	if (!isTwoOperand && validation.formula2 !== void 0) throw new require_biff_write_errors.BiffWriteError(`a data validation with operator "${validation.operator}" carries a second formula; only 'between' and 'notBetween' state two operands`);
+	if (isTwoOperand && validation.formula2 === void 0) throw new require_biff_write_errors.BiffWriteError(`a data validation with operator "${validation.operator}" carries no second formula; 'between' and 'notBetween' require two operands`);
+	if (validation.ranges.length === 0) throw new require_biff_write_errors.BiffWriteError("a data validation carrying no range states nothing; the schema requires at least one");
+	const writer = new require_biff_builder.RecordBuilder();
+	writer.u32(flags);
+	writer.bytes(require_biff_string_writer.writeXLUnicodeString(validation.promptTitle ?? ""));
+	writer.bytes(require_biff_string_writer.writeXLUnicodeString(validation.errorTitle ?? ""));
+	writer.bytes(require_biff_string_writer.writeXLUnicodeString(validation.prompt ?? ""));
+	writer.bytes(require_biff_string_writer.writeXLUnicodeString(validation.error ?? ""));
+	const [f1Header, f1Rgce] = writeDvParsedFormula(validation.formula1);
+	writer.bytes(f1Header).bytes(f1Rgce);
+	const [f2Header, f2Rgce] = writeDvParsedFormula(validation.formula2);
+	writer.bytes(f2Header).bytes(f2Rgce);
+	writer.u16(validation.ranges.length);
+	for (const range of validation.ranges) {
+		writer.u16(range.startRow);
+		writer.u16(range.endRow);
+		writer.u16(range.startColumn);
+		writer.u16(range.endColumn);
+	}
+	return require_biff_record_writer.writeRecord(446, writer.build());
+}
+function writeDvalRecord(ruleCount) {
+	const writer = new require_biff_builder.RecordBuilder().u16(0).u32(0).u32(0).u32(4294967295).u32(ruleCount);
+	return require_biff_record_writer.writeRecord(434, writer.build());
+}
+function writeSheetDataValidations(sheet) {
+	const validations = sheet.dataValidations ?? [];
+	if (validations.length === 0) return [];
+	for (const validation of validations) for (const range of validation.ranges) if (range.startRow > 65535 || range.endRow > 65535 || range.startColumn > 255 || range.endColumn > 255) throw new require_biff_write_errors.BiffWriteError(`a data validation range (rows ${range.startRow}-${range.endRow}, columns ${range.startColumn}-${range.endColumn}) is outside BIFF8's own grid; a .xls workbook cannot address it`);
+	return [writeDvalRecord(validations.length), ...validations.map((validation) => writeDvRecord(validation))];
+}
+//#endregion
+exports.writeSheetDataValidations = writeSheetDataValidations;

package/dist/workbook/data-validation-write.d.cts

@@ -0,0 +1,5 @@
+import { ContentSheet } from "document-schema.js";
+//#region src/workbook/data-validation-write.d.ts
+declare function writeSheetDataValidations(sheet: ContentSheet): Uint8Array<ArrayBuffer>[];
+//#endregion
+export { writeSheetDataValidations };

package/dist/workbook/data-validation-write.d.ts

@@ -0,0 +1,5 @@
+import { ContentSheet } from "document-schema.js";
+//#region src/workbook/data-validation-write.d.ts
+declare function writeSheetDataValidations(sheet: ContentSheet): Uint8Array<ArrayBuffer>[];
+//#endregion
+export { writeSheetDataValidations };

package/dist/workbook/data-validation-write.js

@@ -0,0 +1,84 @@
+import "../biff/record-types.js";
+import { BiffWriteError } from "../biff/write-errors.js";
+import { RecordBuilder } from "../biff/builder.js";
+import { writeRecord } from "../biff/record-writer.js";
+import { writeXLUnicodeString } from "../biff/string-writer.js";
+import { compileFormulaText } from "../biff/ptg-writer.js";
+//#region src/workbook/data-validation-write.ts
+const VAL_TYPE_BY_TYPE = /* @__PURE__ */ new Map([
+	["whole", 1],
+	["decimal", 2],
+	["list", 3],
+	["date", 4],
+	["time", 5],
+	["textLength", 6],
+	["custom", 7]
+]);
+const TYP_OPERATOR_BY_OPERATOR = /* @__PURE__ */ new Map([
+	["between", 0],
+	["notBetween", 1],
+	["equal", 2],
+	["notEqual", 3],
+	["greaterThan", 4],
+	["lessThan", 5],
+	["greaterThanOrEqual", 6],
+	["lessThanOrEqual", 7]
+]);
+const ERR_STYLE_CODE = /* @__PURE__ */ new Map([
+	["stop", 0],
+	["warning", 1],
+	["information", 2]
+]);
+function writeDvParsedFormula(text) {
+	const rgce = text === void 0 ? /* @__PURE__ */ new Uint8Array(0) : compileFormulaText(text);
+	return [new RecordBuilder().u16(rgce.length).u16(0).build(), rgce];
+}
+function writeDvRecord(validation) {
+	const valType = VAL_TYPE_BY_TYPE.get(validation.type);
+	if (valType === void 0) throw new BiffWriteError(`data validation type "${validation.type}" has no Dv valType value`);
+	let flags = valType;
+	flags |= (ERR_STYLE_CODE.get(validation.errorStyle ?? "stop") ?? 0) << 4;
+	if (validation.allowBlank === true) flags |= 256;
+	if (validation.showInputMessage === true) flags |= 1 << 18;
+	if (validation.showErrorMessage === true) flags |= 1 << 19;
+	if (validation.type !== "list" && validation.type !== "custom") {
+		if (validation.operator === void 0) throw new BiffWriteError(`a ${validation.type} data validation over ${validation.ranges.length} range(s) carries no operator; the schema requires one for every type but 'list' and 'custom'`);
+		const typOperator = TYP_OPERATOR_BY_OPERATOR.get(validation.operator);
+		if (typOperator === void 0) throw new BiffWriteError(`data validation operator "${validation.operator}" has no Dv typOperator value`);
+		flags |= typOperator << 20;
+	}
+	const isTwoOperand = validation.operator === "between" || validation.operator === "notBetween";
+	if (!isTwoOperand && validation.formula2 !== void 0) throw new BiffWriteError(`a data validation with operator "${validation.operator}" carries a second formula; only 'between' and 'notBetween' state two operands`);
+	if (isTwoOperand && validation.formula2 === void 0) throw new BiffWriteError(`a data validation with operator "${validation.operator}" carries no second formula; 'between' and 'notBetween' require two operands`);
+	if (validation.ranges.length === 0) throw new BiffWriteError("a data validation carrying no range states nothing; the schema requires at least one");
+	const writer = new RecordBuilder();
+	writer.u32(flags);
+	writer.bytes(writeXLUnicodeString(validation.promptTitle ?? ""));
+	writer.bytes(writeXLUnicodeString(validation.errorTitle ?? ""));
+	writer.bytes(writeXLUnicodeString(validation.prompt ?? ""));
+	writer.bytes(writeXLUnicodeString(validation.error ?? ""));
+	const [f1Header, f1Rgce] = writeDvParsedFormula(validation.formula1);
+	writer.bytes(f1Header).bytes(f1Rgce);
+	const [f2Header, f2Rgce] = writeDvParsedFormula(validation.formula2);
+	writer.bytes(f2Header).bytes(f2Rgce);
+	writer.u16(validation.ranges.length);
+	for (const range of validation.ranges) {
+		writer.u16(range.startRow);
+		writer.u16(range.endRow);
+		writer.u16(range.startColumn);
+		writer.u16(range.endColumn);
+	}
+	return writeRecord(446, writer.build());
+}
+function writeDvalRecord(ruleCount) {
+	const writer = new RecordBuilder().u16(0).u32(0).u32(0).u32(4294967295).u32(ruleCount);
+	return writeRecord(434, writer.build());
+}
+function writeSheetDataValidations(sheet) {
+	const validations = sheet.dataValidations ?? [];
+	if (validations.length === 0) return [];
+	for (const validation of validations) for (const range of validation.ranges) if (range.startRow > 65535 || range.endRow > 65535 || range.startColumn > 255 || range.endColumn > 255) throw new BiffWriteError(`a data validation range (rows ${range.startRow}-${range.endRow}, columns ${range.startColumn}-${range.endColumn}) is outside BIFF8's own grid; a .xls workbook cannot address it`);
+	return [writeDvalRecord(validations.length), ...validations.map((validation) => writeDvRecord(validation))];
+}
+//#endregion
+export { writeSheetDataValidations };

package/dist/workbook/sheet-writer.cjs

@@ -12,6 +12,8 @@ const require_biff_string_writer = require("../biff/string-writer.cjs");
 const require_workbook_globals_writer = require("./globals-writer.cjs");
 const require_biff_ptg_writer = require("../biff/ptg-writer.cjs");
 const require_written_cells = require("../written-cells.cjs");
+const require_workbook_conditional_format_write = require("./conditional-format-write.cjs");
+const require_workbook_data_validation_write = require("./data-validation-write.cjs");
 const require_workbook_comment_writer = require("./comment-writer.cjs");
 //#region src/workbook/sheet-writer.ts
 /** BIFF8's own 16-bit row index and 8-bit column index ceilings ([MS-XLS] 2.4.221's Rw structure and 2.4.53's Col256U structure): 65536 rows (0-65535), 256 columns (0-255) -- unlike xlsx's much larger grid. A cell outside this range cannot be expressed in BIFF8 at all, so it is refused rather than silently truncated into a wrapped index. */
@@ -318,6 +320,8 @@ function buildWorksheetSubstream(sheet, ctx) {
 	if (merges.length > 0) pieces.push(writeMergeCellsRecord(merges));
 	const commentedCells = sheet.cells.filter((cell) => cell.comment !== void 0);
 	if (commentedCells.length > 0) pieces.push(...require_workbook_comment_writer.writeSheetComments(commentedCells));
+	pieces.push(...require_workbook_data_validation_write.writeSheetDataValidations(sheet));
+	pieces.push(...require_workbook_conditional_format_write.writeSheetConditionalFormats(sheet, ctx.icvOf));
 	pieces.push(require_biff_record_writer.writeRecord(10, /* @__PURE__ */ new Uint8Array(0)));
 	return require_biff_record_writer.concatRecords(...pieces);
 }

package/dist/workbook/sheet-writer.d.cts

@@ -1,6 +1,8 @@
-import { ContentSheet, ContentSheetCell } from "document-schema.js";
+import { Color, ContentSheet, ContentSheetCell } from "document-schema.js";
 //#region src/workbook/sheet-writer.d.ts
 interface SheetWriteContext {
+  /** The icv a colour resolves to through the workbook's own palette plan (write.ts's buildPalettePlan) -- the same colour-table resolution a cell decoration's own fill already draws, offered to the conditional-format writer whose DXFN style colours are palette references too. Every colour this is called with must already have been registered during that plan's own workbook-wide scan. */
+  icvOf: (color: Color) => number;
   /** The XF index ([MS-XLS] 2.5.168 IXFCell) a cell's own (number format, alignment, decoration) combination resolves to -- GENERAL_CELL_XF_INDEX for a cell with General formatting, general/bottom alignment, and no background/borders, one of the workbook's other cell XFs otherwise. write.ts's own cell-format interning pass is what assigns and deduplicates these. */
   xfIndexForCell(cell: ContentSheetCell): number;
   /** The shared string table index for a string cell's own text; every string a sheet writes must already be registered in the workbook-wide table before this is called. */

package/dist/workbook/sheet-writer.d.ts

@@ -1,6 +1,8 @@
-import { ContentSheet, ContentSheetCell } from "document-schema.js";
+import { Color, ContentSheet, ContentSheetCell } from "document-schema.js";
 //#region src/workbook/sheet-writer.d.ts
 interface SheetWriteContext {
+  /** The icv a colour resolves to through the workbook's own palette plan (write.ts's buildPalettePlan) -- the same colour-table resolution a cell decoration's own fill already draws, offered to the conditional-format writer whose DXFN style colours are palette references too. Every colour this is called with must already have been registered during that plan's own workbook-wide scan. */
+  icvOf: (color: Color) => number;
   /** The XF index ([MS-XLS] 2.5.168 IXFCell) a cell's own (number format, alignment, decoration) combination resolves to -- GENERAL_CELL_XF_INDEX for a cell with General formatting, general/bottom alignment, and no background/borders, one of the workbook's other cell XFs otherwise. write.ts's own cell-format interning pass is what assigns and deduplicates these. */
   xfIndexForCell(cell: ContentSheetCell): number;
   /** The shared string table index for a string cell's own text; every string a sheet writes must already be registered in the workbook-wide table before this is called. */

package/dist/workbook/sheet-writer.js

@@ -11,6 +11,8 @@ import { writeXLUnicodeString } from "../biff/string-writer.js";
 import { GENERAL_CELL_XF_INDEX } from "./globals-writer.js";
 import { compileFormulaText } from "../biff/ptg-writer.js";
 import { cellCarriesFormatting, writesCellRecord } from "../written-cells.js";
+import { writeSheetConditionalFormats } from "./conditional-format-write.js";
+import { writeSheetDataValidations } from "./data-validation-write.js";
 import { writeSheetComments } from "./comment-writer.js";
 //#region src/workbook/sheet-writer.ts
 /** BIFF8's own 16-bit row index and 8-bit column index ceilings ([MS-XLS] 2.4.221's Rw structure and 2.4.53's Col256U structure): 65536 rows (0-65535), 256 columns (0-255) -- unlike xlsx's much larger grid. A cell outside this range cannot be expressed in BIFF8 at all, so it is refused rather than silently truncated into a wrapped index. */
@@ -317,6 +319,8 @@ function buildWorksheetSubstream(sheet, ctx) {
 	if (merges.length > 0) pieces.push(writeMergeCellsRecord(merges));
 	const commentedCells = sheet.cells.filter((cell) => cell.comment !== void 0);
 	if (commentedCells.length > 0) pieces.push(...writeSheetComments(commentedCells));
+	pieces.push(...writeSheetDataValidations(sheet));
+	pieces.push(...writeSheetConditionalFormats(sheet, ctx.icvOf));
 	pieces.push(writeRecord(10, /* @__PURE__ */ new Uint8Array(0)));
 	return concatRecords(...pieces);
 }

package/dist/write.cjs

@@ -99,13 +99,20 @@ function buildPalettePlan(sheets) {
 		record(fill.foregroundColor);
 		record(fill.backgroundColor);
 	};
-	for (const sheet of sheets) for (const cell of sheet.cells) {
-		if (!require_written_cells.writesCellRecord(cell)) continue;
-		recordFill(cell.background);
-		record(cell.borders?.left?.color);
-		record(cell.borders?.right?.color);
-		record(cell.borders?.top?.color);
-		record(cell.borders?.bottom?.color);
+	for (const sheet of sheets) {
+		for (const cell of sheet.cells) {
+			if (!require_written_cells.writesCellRecord(cell)) continue;
+			recordFill(cell.background);
+			record(cell.borders?.left?.color);
+			record(cell.borders?.right?.color);
+			record(cell.borders?.top?.color);
+			record(cell.borders?.bottom?.color);
+		}
+		for (const rule of sheet.conditionalFormats ?? []) {
+			if (rule.type !== "cellIs") continue;
+			record(rule.style?.textColor);
+			record(rule.style?.background);
+		}
 	}
 	const missing = (hex) => {
 		throw new require_biff_write_errors.BiffWriteError(`internal error: colour ${hex} was not registered during the workbook-wide palette scan`);
@@ -303,7 +310,8 @@ function buildWorkbookStream(content) {
 	const globals = require_workbook_globals_writer.buildWorkbookGlobals(globalsPlan);
 	const sheetContext = {
 		xfIndexForCell: cellXfPlan.xfIndexForCell,
-		sstIndexFor: (text) => sstPlan.indexOf(text)
+		sstIndexFor: (text) => sstPlan.indexOf(text),
+		icvOf: palettePlan.icvOf
 	};
 	const sheetStreams = content.sheets.map((sheet) => require_workbook_sheet_writer.buildWorksheetSubstream(sheet, sheetContext));
 	const sheetOffsets = [];

package/dist/write.js

@@ -98,13 +98,20 @@ function buildPalettePlan(sheets) {
 		record(fill.foregroundColor);
 		record(fill.backgroundColor);
 	};
-	for (const sheet of sheets) for (const cell of sheet.cells) {
-		if (!writesCellRecord(cell)) continue;
-		recordFill(cell.background);
-		record(cell.borders?.left?.color);
-		record(cell.borders?.right?.color);
-		record(cell.borders?.top?.color);
-		record(cell.borders?.bottom?.color);
+	for (const sheet of sheets) {
+		for (const cell of sheet.cells) {
+			if (!writesCellRecord(cell)) continue;
+			recordFill(cell.background);
+			record(cell.borders?.left?.color);
+			record(cell.borders?.right?.color);
+			record(cell.borders?.top?.color);
+			record(cell.borders?.bottom?.color);
+		}
+		for (const rule of sheet.conditionalFormats ?? []) {
+			if (rule.type !== "cellIs") continue;
+			record(rule.style?.textColor);
+			record(rule.style?.background);
+		}
 	}
 	const missing = (hex) => {
 		throw new BiffWriteError(`internal error: colour ${hex} was not registered during the workbook-wide palette scan`);
@@ -302,7 +309,8 @@ function buildWorkbookStream(content) {
 	const globals = buildWorkbookGlobals(globalsPlan);
 	const sheetContext = {
 		xfIndexForCell: cellXfPlan.xfIndexForCell,
-		sstIndexFor: (text) => sstPlan.indexOf(text)
+		sstIndexFor: (text) => sstPlan.indexOf(text),
+		icvOf: palettePlan.icvOf
 	};
 	const sheetStreams = content.sheets.map((sheet) => buildWorksheetSubstream(sheet, sheetContext));
 	const sheetOffsets = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xls-codec",
-  "version": "4.11.0",
+  "version": "4.12.0",
   "description": "Hand-written reader for the legacy Excel Binary File Format (.xls, BIFF8) as specified by [MS-XLS], mapping a workbook's record stream onto the shared document-schema.js spreadsheet model - the .xls codec for the documents.js family.",
   "type": "module",
   "repository": {
@@ -70,8 +70,8 @@
   },
   "packageManager": "pnpm@11.6.0",
   "dependencies": {
-    "archive-codec": "1.10.0",
-    "document-schema.js": "7.5.0",
+    "archive-codec": "1.10.1",
+    "document-schema.js": "7.5.1",
     "excel-number-format": "1.1.1"
   },
   "devDependencies": {