xls-codec 4.8.0 → 4.10.0

package/README.md

@@ -39,7 +39,7 @@ What `writeXlsContent`/`writeXls` cover: every `ContentCellValue` kind a real `.
 | 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`)                                                        | The reader now recovers a sheet's own base `cellIs` rules and `CF12`'s colour scale/data bar/icon set rules (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.                                                                                                                                                                                                                                                                                                                                                                                              |
+| 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.                                                                                                                                                                                                                                                                                                                                                                                      |
 | Cell comments (`Note`/`Txo`)                                                                                       | The reader now recovers a cell's comment (see Read-side gaps below), but writing one back out is its own separate mechanism -- a `Note`/`Obj`/`Txo` triple with its own object-id bookkeeping, distinct from every other cell record this writer already emits -- 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. A `ContentSheetCell.comment` is silently ignored on write.                                                                                                                                                                                                                                                                                                      |
 | 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. |
@@ -57,11 +57,12 @@ Each deliberate rather than overlooked:
 - **Cell comments, resolved for real (ExaDev/documents.js#949).** A legacy BIFF8 comment is split across three record kinds a single self-contained xlsx `<comment>` element never needs: a `Note` record ([MS-XLS] 2.4.179, wrapping a `NoteSh` structure) anchors the comment to a cell and names its author, but carries no text of its own; the text lives in a `Txo` record ([MS-XLS] 2.4.329), its characters carried across trailing `Continue` records; the two are joined through an `Obj` record ([MS-XLS] 2.4.181) whose `FtCmo` names an object id and type, the `Note`'s own `idObj` field naming that same id, and a `Txo` always immediately following the `Obj` record whose shape it belongs to (`src/workbook/comments.ts`). Read in one independent pass over the whole worksheet substream rather than assuming stream order between a `Note` and the `Obj`+`Txo` pair it names -- both are resolved regardless of which comes first. Legacy BIFF8 has no threading and no per-comment timestamp at all (unlike xlsx's own `[MS-XLSX]` threaded-comments extension), so `ContentSheetCellComment.replies` and `.createdAt` are never populated from an `.xls` source; rich per-character formatting within a comment (`TxORuns`) is skipped rather than modelled, the same scope limit this reader already applies to the shared string table's own rich runs, since `ContentSheetCellComment.text` is a plain string with nowhere to carry them.
 - **Data validation, resolved for real (ExaDev/documents.js#1098).** `Dv` ([MS-XLS] 2.4.95) is a fixed, published binary structure -- a bit-packed flags `DWORD` (`valType`/`errStyle`/`fAllowBlank`/`fShowInputMsg`/`fShowErrorMsg`/`typOperator`), four `XLUnicodeString`s (prompt/error titles and messages), one or two `DVParsedFormula` structures, and a trailing `SqRefU` range list -- read directly against that spec (`src/workbook/data-validation.ts`), unlike `calcext:condition`'s own LibreOffice-source-transcribed mini-language odf.js's equivalent reader needed. A `DVParsedFormula`'s own `rgce` is the identical `Ptg` token grammar a cell's `Formula` record carries, so its formula text is recovered with the same `parseFormulaText` this reader already uses for ordinary cell formulas. `DVal` ([MS-XLS] 2.4.96), the record that precedes a sheet's own `Dv` collection, carries only input-window UI state (position, drop-down `Obj` reference) with no counterpart in `ContentSheetDataValidationSchema` and is not read for its own fields.
 - **Charts, drawings, and images, resolved for real (ExaDev/documents.js#924).** A worksheet's own `MsoDrawing` records ([MS-XLS] 2.1.7.20.3-adjacent, `RECORD_MSODRAWING`) carry MS-ODRAW (Escher) bytes that split across as many records as the drawing needs and simply concatenate, in stream order, into one continuous Escher record tree (`src/drawing/escher.ts`, reading [MS-ODRAW]'s own `OfficeArtRecordHeader`/container-vs-atom framing directly against its spec rather than from memory). Within that tree, `src/drawing/shapes.ts` walks the `DgContainer`/`SpgrContainer`/`SpContainer` hierarchy for each real top-level shape's own type, id, and cell anchor (`ClientAnchorSheet`, [MS-XLS] 2.5.163 — one `Sp` atom's `recInstance` and `ClientAnchor`'s corner-cell-plus-fractional-offset pair, 1/1024ths of a cell's width and 1/256ths of its height), skipping the invisible "patriarch" group root every drawing wraps its real shapes in. A picture shape's own `Opt` property table names a `pib` — a 1-based index into the **workbook-wide** Blip Store (`OfficeArtBstoreContainer`, read once from the globals substream's own `MsoDrawingGroup` stream, `src/drawing/blips.ts`) — resolved to real image bytes for a PNG or JPEG blip (`OfficeArtBlipPNG`/`OfficeArtBlipJPEG`'s own literal file bytes, past their `rgbUid` header); a DIB/EMF/WMF/PICT/TIFF blip is recognised but produces no image, since `ContentImageBlockSchema.format` has no lossless slot for any of them. Since neither an Escher shape nor a `MsoDrawing` record names what kind of object it actually holds, each shape is paired 1:1, in document order, with the worksheet substream's own `Obj` records (skipping any Note-type `Obj` `src/workbook/comments.ts` already accounts for) — the same positional correlation every other real BIFF8 reader relies on. An `Obj` naming a **chart** locates the chart's own nested `BOF`(dt=`0x0020`)/`EOF` substream — which sits INSIDE the worksheet substream, immediately after the shape that anchors it ([MS-XLS] "Chart Area") — via `src/biff/substreams.ts`'s own stack-based substream nesting (a genuinely new capability this issue needed: `splitSubstreams` previously treated any BOF met mid-substream as ending it outright, which would have silently dropped every worksheet record written after an embedded chart). `src/workbook/chart.ts` reads that substream's `Series`/`AI` (`BRAI`)/`SeriesText` records — a series' own name and its category/value data links — resolving each link's value either from the chart's own on-disk `SERIESDATA` cache (`Dimensions`/`SIIndex`/`Number`/`BoolErr`/`Blank`/`Label`, present when the chart's data lives on another sheet or is genuinely external) or, for the common case of a chart plotting its own sheet's cells, by resolving the `AI`'s `PtgArea3d`/`PtgRef3d` reference token directly against that sheet's own already-mapped cells — and lands as a `ContentEmbeddedObject` with `objectKind: 'chart'`, its cached series/category table flattened into a small one-sheet spreadsheet `ContentDocument`, the identical shape `ooxml.js`'s own xlsx/pptx chart reading already produces (ExaDev/documents.js#719): `document-schema.js` has no richer, chart-type-aware object model yet, so this reader targets the fallback that exists rather than inventing one. Every other recognised shape (an autoshape, a text box, a line, a group) lands as `objectKind: 'drawing'`, a single-page `ContentDocument` holding one sized-and-positioned `ContentShape` with no text content modelled. Not modelled at all: a shape's own rotation, fill/line formatting, or text runs; a group's own nested transform (a nested nested group's shapes are still recovered, cell-anchored, but a group's own rotation/scale is not composed into its children's positions); and a chart's own type, axes, and legend, which `document-schema.js`'s flattened-table representation has no field for regardless of what this reader could recover.
-- **Conditional formatting, base rules resolved for real (ExaDev/documents.js#1102).** A `CondFmt` record ([MS-XLS] 2.4.56) marks the start of one to three `CF` records ([MS-XLS] 2.4.42) sharing one cell-range list, read together as a group (`src/workbook/conditional-format.ts`) since a `CF`'s own ranges live on its parent `CondFmt`, not on itself. Base BIFF8 (Excel 97) conditional formatting has exactly two rule shapes: a comparison ("Cell Value Is") condition, promoted to `ContentSheetConditionalFormat`'s `cellIs` variant with its formula(s) recovered through the same `parseFormulaText` this reader already uses for cell formulas and `Dv`; and a formula condition, left unpromoted for the same "no closed-form structure without a general formula engine" reason `data-validation.ts` and `ooxml.js`'s own xlsx `cfRule` reading already draw. A rule's resulting style -- font colour and fill background -- comes from its `CF`'s own `DXFN` structure, resolved through the identical `icv`/`Palette` colour machinery a regular cell's fill and border already use ([Cell decoration](#cell-decoration)); a `DXFN` naming a user-defined number format (`DXFNumUsr`) degrades that one rule's style to absent rather than risk misreading the font/fill fields that follow it, since [MS-XLS]'s own prose for `DXFNumUsr`'s length field does not settle whether it counts itself. Every richer rule type Excel 2007+ added has no representation in the base `CF` record at all; it rides a `CF12` record instead, linked to its own `CondFmt` through a `CFEx` extension record.
+- **Conditional formatting, base rules resolved for real (ExaDev/documents.js#1102).** A `CondFmt` record ([MS-XLS] 2.4.56) marks the start of one to three `CF` records ([MS-XLS] 2.4.42) sharing one cell-range list, read together as a group (`src/workbook/conditional-format.ts`) since a `CF`'s own ranges live on its parent `CondFmt`, not on itself. Base BIFF8 (Excel 97) conditional formatting has exactly two rule shapes: a comparison ("Cell Value Is") condition, promoted to `ContentSheetConditionalFormat`'s `cellIs` variant with its formula(s) recovered through the same `parseFormulaText` this reader already uses for cell formulas and `Dv`; and a formula condition, left unpromoted for the same "no closed-form structure without a general formula engine" reason `data-validation.ts` and `ooxml.js`'s own xlsx `cfRule` reading already draw. A rule's resulting style -- font colour and fill background -- comes from its `CF`'s own `DXFN` structure, resolved through the identical `icv`/`Palette` colour machinery a regular cell's fill and border already use ([Cell decoration](#cell-decoration)); a `DXFN` naming a user-defined number format (`DXFNumUsr`) degrades that one rule's style to absent rather than risk misreading the font/fill fields that follow it, since [MS-XLS]'s own prose for `DXFNumUsr`'s length field does not settle whether it counts itself. Every richer rule type Excel 2007+ added has no representation in the base `CF` record at all; it rides a `CF12` record instead, or, for a rule Excel keeps expressible as a legacy formula condition for pre-2007 readers, a `CFEx` extension record that attaches richer metadata to an ordinary `CondFmt`-owned `CF` without promoting it into a `CF12` record at all.
 - **Conditional formatting, CF12's colour scale/data bar/icon set rules resolved for real (ExaDev/documents.js#1104).** `CF12`'s own `ct` field picks one of six rule shapes ([MS-XLS] 2.4.43); this reader promotes the three that share a genuine array-of-thresholds building block already modelled in `document-schema.js` -- colour scale, data bar, and icon set (`src/workbook/conditional-format-12.ts`) -- each reading an array of `CFVO` threshold objects (the identical `num`/`percent`/`max`/`min`/`formula`/`percentile` vocabulary `ContentSheetConditionalFormatValueSchema` already carries for `ooxml.js`'s xlsx reader and `odf.js`'s ods reader) paired with `CFColor` values. A `CFColor` naming an indexed colour resolves through the same `icv`/`Palette` machinery as base `CF`'s own `DXFN`, then Excel's own TintAndShade model applies the colour's own tint/shade Xnum (`xf-colors.ts`'s `applyTint`); one naming a plain RGB triple resolves directly, tint included; one naming an automatic or theme colour degrades the whole rule to absent, since this package has no BIFF8 `Theme` reader to resolve a theme reference against. Icon set's own `iIconSet` byte maps to the identical ECMA-376 `ST_IconSetType` vocabulary (`3Arrows`, `3TrafficLights1`, `5Quarters`, and the rest of the seventeen built-in sets) `ooxml.js`'s xlsx `cfRule` reading already carries as a plain string. A record longer than the 8224-byte single-record ceiling continues onto `ContinueFrt12` rather than the plain `Continue` every other record in this package joins against; `groupRecords` (`src/biff/substreams.ts`) strips its own restated `FrtRefHeader` before joining it.
-- **Conditional formatting, CF12's filter-dispatched template rules resolved for real (ExaDev/documents.js#1106).** `ct` 0x05 ("filter") dispatches further through `icfTemplate`, alongside a 16-byte `CFExTemplateParams` block always present regardless of `ct`. Of that block's five variants, only two need real parsing -- `CFExFilterParams` (top10's own `fTop`/`fPercent`/`iParam`) and `CFExAveragesTemplateParams` (the aboveAverage family's own standard-deviation count) -- since `CFExDefaultTemplateParams` (duplicateValues/uniqueValues/the four blank/error conditions) is 16 reserved bytes and `CFExDateTemplateParams`'s own `dateOp` field is a fixed restatement of `icfTemplate` for all ten date/time periods, so both dispatch directly off `icfTemplate` with no further byte reading. Unlike colour scale/data bar/icon set, [MS-XLS] does not force a `ct` 0x05 rule's own `cbDxf` to zero, so its `DXFN12` can carry a genuine font/fill override; that structure resolves through the identical `parseDxfStyle` base `CF`'s own `DXFN` already uses. A malformed `iParam` of zero degrades a top10 rule to absent rather than promoting a `rank` `ContentSheetConditionalFormatSchema` itself requires to be positive. Comparison/formula rules re-expressed in this newer record shape, `containsText`'s own four sub-types (`CFExTextTemplateParams` names which one a rule is but not its actual search string, and CF12's own formula fields are spec'd to be zero for every `ct` 0x05 rule -- where the literal text operand lives is a genuine open question), and `CFEx`'s own extension of a legacy `CF` record all remain unread (ExaDev/documents.js#1100).
-- **Not read at all:** `CF12`'s `containsText` filter rules, and `CFEx`'s own `CF`-record extension (ExaDev/documents.js#1100). 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 workbooks, decrypted for real (ExaDev/documents.js#1108).** A `FilePass` record ([MS-XLS] 2.4.117) means every record after it is ciphertext under one of three schemes; this reader implements exactly one, the [MS-OFFCRYPTO] 2.3.6.1 "RC4 encryption header" -- `readXlsContent`/`readXls` take an optional `password`, verify it against the header's own `EncryptedVerifier`/`EncryptedVerifierHash` pair, then decrypt every subsequent record's data (`src/workbook/encryption.ts`) using the RC4/MD5 primitives [`archive-codec`](../archive-codec/README.md#legacy-office-encryption) shares with `doc-codec`/`ppt-codec`'s own eventual integration. [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, 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 and XOR obfuscation are explicitly out of scope, tracked separately on [#922](https://github.com/ExaDev/documents.js/issues/922).
+- **Conditional formatting, CF12's filter-dispatched template rules resolved for real (ExaDev/documents.js#1106).** `ct` 0x05 ("filter") dispatches further through `icfTemplate`, alongside a 16-byte `CFExTemplateParams` block always present regardless of `ct`. Of that block's five variants, only two need real parsing -- `CFExFilterParams` (top10's own `fTop`/`fPercent`/`iParam`) and `CFExAveragesTemplateParams` (the aboveAverage family's own standard-deviation count) -- since `CFExDefaultTemplateParams` (duplicateValues/uniqueValues/the four blank/error conditions) is 16 reserved bytes and `CFExDateTemplateParams`'s own `dateOp` field is a fixed restatement of `icfTemplate` for all ten date/time periods, so both dispatch directly off `icfTemplate` with no further byte reading. Unlike colour scale/data bar/icon set, [MS-XLS] does not force a `ct` 0x05 rule's own `cbDxf` to zero, so its `DXFN12` can carry a genuine font/fill override; that structure resolves through the identical `parseDxfStyle` base `CF`'s own `DXFN` already uses. A malformed `iParam` of zero degrades a top10 rule to absent rather than promoting a `rank` `ContentSheetConditionalFormatSchema` itself requires to be positive.
+- **Conditional formatting, `containsText`/`notContainsText`/`beginsWith`/`endsWith` and `CFEx`'s own legacy-`CF` extension resolved for real (ExaDev/documents.js#1100).** `icfTemplate` 0x0008 ("Contains text") is the one filter-dispatched template that is NOT actually a `ct` 0x05 rule: `CFExTextTemplateParams` carries only `ctp`, naming which of the four text sub-types a rule is, and neither it nor `ct` 0x05's own `CFFilter` `rgbCT` has anywhere to carry the literal search text (confirmed against a second, independent transcription of both structures -- [kinkou/unxls](https://github.com/kinkou/unxls)'s own `cfextexttemplateparams`/`cffilter` readers, which read `CFFilter` as an unconditional fixed six bytes with no variable trailer). Excel instead expresses these four rule kinds as a genuine `ct` 0x02 formula condition -- either directly on a `CF12` record, or (to stay evaluable by pre-2007 Excel, which silently skips an unrecognised `CF12`/`CondFmt12` "future record" wholesale) via a `CFEx` record ([MS-XLS] 2.4.63) extending an ordinary legacy `CF` -- with the literal text present as a string-constant (`PtgStr`) operand somewhere in the formula's own token stream, matching Excel's real, independently-confirmed generated formula for each sub-type (`NOT(ISERROR(SEARCH("text",cell)))` for `containsText`, and the `ISERROR`/`LEFT`+`LEN`/`RIGHT`+`LEN` equivalents for the other three -- LibreOffice's own `xecontent.cxx` `GetFixedFormula` emits exactly these shapes for its xlsx compatibility formula). `readCfTextFilterRule` (`src/workbook/conditional-format-12.ts`) extracts that operand via `ptg.ts`'s `extractFirstStringLiteral`, reached from both `readCf12`'s own `ct` 0x02 branch and `readCfEx` (`src/workbook/conditional-format-ex.ts`). A `CFEx` record with `fIsCF12` set (extending a genuine `CF12` record rather than a legacy `CF`) stays unread: that `CF12` carries no ranges of its own -- a `CondFmt12` normally supplies them -- and this reader has no established link back to one for it. `CFEx`'s own `nID` cross-references the `nID` field [MS-XLS] 2.1.7.20.6's own worksheet-substream grammar places on every `CondFmt` record (every `CFEx` on a sheet follows every `CondFmt`/`CondFmt12` group, per that same grammar), so `workbook/sheet.ts` keeps a per-`nID` map of each group's own resolved ranges and raw `CF` operands as it walks the substream, for a later `CFEx` to resolve its own `icf` index against.
+- **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. Remaining read+write scope gaps (formula writing and per-cell font) are tracked on [#815](https://github.com/ExaDev/documents.js/issues/815).
 

package/dist/biff/cursor.cjs

@@ -62,8 +62,19 @@ var BlockCursor = class {
 		const raw = this.take(8);
 		return new DataView(raw.buffer, raw.byteOffset, raw.byteLength).getFloat64(0, true);
 	}
-	/** The next `count` bytes, copied out. Spans block boundaries. */
+	/** Total unread bytes across the current block and every block after it -- what a length-prefixed field's own prefix must be checked against before that many bytes are allocated, so a record cannot claim a length far larger than the data actually behind it. */
+	remainingTotal() {
+		this.settle();
+		let total = 0;
+		for (let index = this.blockIndex; index < this.blocks.length; index += 1) {
+			const block = this.blocks[index];
+			total += (index === this.blockIndex ? this.remainingInBlock() : block?.length) ?? 0;
+		}
+		return total;
+	}
+	/** The next `count` bytes, copied out. Spans block boundaries. Rejects a `count` larger than the data actually remaining before allocating, so a length-prefixed field taken from untrusted input (e.g. CFEx's own `cbDxf`) cannot force a multi-gigabyte allocation from a tiny record. */
 	take(count) {
+		if (count > this.remainingTotal()) throw new require_biff_records.BiffFormatError(`${count}-byte run requests more data than remains in the record`);
 		const out = new Uint8Array(count);
 		for (let index = 0; index < count; index += 1) out[index] = this.nextByte(`${count}-byte run`);
 		return out;

package/dist/biff/cursor.d.cts

@@ -1,2 +1,2 @@
-import { t as BlockCursor } from "../cursor-VMtw9uVP.cjs";
+import { t as BlockCursor } from "../cursor-CnEuX5qE.cjs";
 export { BlockCursor };

package/dist/biff/cursor.d.ts

@@ -1,2 +1,2 @@
-import { t as BlockCursor } from "../cursor-VMtw9uVP.js";
+import { t as BlockCursor } from "../cursor-CnEuX5qE.js";
 export { BlockCursor };

package/dist/biff/cursor.js

@@ -61,8 +61,19 @@ var BlockCursor = class {
 		const raw = this.take(8);
 		return new DataView(raw.buffer, raw.byteOffset, raw.byteLength).getFloat64(0, true);
 	}
-	/** The next `count` bytes, copied out. Spans block boundaries. */
+	/** Total unread bytes across the current block and every block after it -- what a length-prefixed field's own prefix must be checked against before that many bytes are allocated, so a record cannot claim a length far larger than the data actually behind it. */
+	remainingTotal() {
+		this.settle();
+		let total = 0;
+		for (let index = this.blockIndex; index < this.blocks.length; index += 1) {
+			const block = this.blocks[index];
+			total += (index === this.blockIndex ? this.remainingInBlock() : block?.length) ?? 0;
+		}
+		return total;
+	}
+	/** The next `count` bytes, copied out. Spans block boundaries. Rejects a `count` larger than the data actually remaining before allocating, so a length-prefixed field taken from untrusted input (e.g. CFEx's own `cbDxf`) cannot force a multi-gigabyte allocation from a tiny record. */
 	take(count) {
+		if (count > this.remainingTotal()) throw new BiffFormatError(`${count}-byte run requests more data than remains in the record`);
 		const out = new Uint8Array(count);
 		for (let index = 0; index < count; index += 1) out[index] = this.nextByte(`${count}-byte run`);
 		return out;

package/dist/biff/ptg.cjs

@@ -336,9 +336,12 @@ function parseFormulaText(rgce, context, options = {}) {
 		case PTG_MISSARG:
 			pushAtomic(stack, "");
 			break;
-		case PTG_STR:
-			pushAtomic(stack, quoteStringLiteral(require_biff_strings.readShortXLUnicodeString(cursor)));
+		case PTG_STR: {
+			const value = require_biff_strings.readShortXLUnicodeString(cursor);
+			options.onStringLiteral?.(value);
+			pushAtomic(stack, quoteStringLiteral(value));
 			break;
+		}
 		case PTG_ERR: {
 			const text = require_biff_errors.errorTextOf(cursor.u8());
 			if (text === void 0) return void 0;
@@ -449,6 +452,16 @@ function parseFormulaText(rgce, context, options = {}) {
 	}
 	return stack.length === 1 ? stack[0]?.text : void 0;
 }
+/**
+* Returns the raw text of the first PtgStr operand `rgce` contains, or undefined if it contains none -- a narrower question than parseFormulaText's own "render the whole formula", answerable even when the formula wraps that operand in functions this reader has no other reason to understand. Exists for conditional-format-12.ts's own readCfTextFilterRule: a CF12/CFExNonCF12 containsText-family rule states which of the four text-comparison sub-types it is via CFExTextTemplateParams.ctp, but carries the literal search text nowhere else but as this operand in its own formula (Excel's real generated shape being e.g. NOT(ISERROR(SEARCH("text",A1))) for containsText -- see conditional-format-ex.ts's own top comment for the full citation). Walks the whole token stream via parseFormulaText's own onStringLiteral hook rather than scanning for the PtgStr opcode directly, since a raw byte scan cannot tell an opcode byte from a length or count belonging to some other token's own payload.
+*/
+function extractFirstStringLiteral(rgce, context) {
+	let literal;
+	parseFormulaText(rgce, context, { onStringLiteral: (value) => {
+		literal ??= value;
+	} });
+	return literal;
+}
 /** PtgExp's own opcode ([MS-XLS] f9aa266f): 0x01, a reserved bit, then the row/col of the Formula record that carries the shared or array formula's real expression -- see readPtgExpBase. */
 const PTG_EXP_OPCODE = 1;
 /** PtgExp's own fixed size: the opcode byte plus a Rw (2 bytes) and a Col (2 bytes), [MS-XLS] f9aa266f. */
@@ -468,5 +481,6 @@ function readPtgExpBase(rgce) {
 	};
 }
 //#endregion
+exports.extractFirstStringLiteral = extractFirstStringLiteral;
 exports.parseFormulaText = parseFormulaText;
 exports.readPtgExpBase = readPtgExpBase;

package/dist/biff/ptg.d.cts

@@ -1,2 +1,2 @@
-import { a as SheetRange, i as ParseFormulaOptions, n as FormulaOrigin, o as parseFormulaText, r as FormulaSheetContext, s as readPtgExpBase, t as ExternalSheetLabel } from "../ptg-CCBbJLZJ.cjs";
-export { ExternalSheetLabel, FormulaOrigin, FormulaSheetContext, ParseFormulaOptions, SheetRange, parseFormulaText, readPtgExpBase };
+import { a as SheetRange, c as readPtgExpBase, i as ParseFormulaOptions, n as FormulaOrigin, o as extractFirstStringLiteral, r as FormulaSheetContext, s as parseFormulaText, t as ExternalSheetLabel } from "../ptg-75v7MhaA.cjs";
+export { ExternalSheetLabel, FormulaOrigin, FormulaSheetContext, ParseFormulaOptions, SheetRange, extractFirstStringLiteral, parseFormulaText, readPtgExpBase };

package/dist/biff/ptg.d.ts

@@ -1,2 +1,2 @@
-import { a as SheetRange, i as ParseFormulaOptions, n as FormulaOrigin, o as parseFormulaText, r as FormulaSheetContext, s as readPtgExpBase, t as ExternalSheetLabel } from "../ptg-CCBbJLZJ.js";
-export { ExternalSheetLabel, FormulaOrigin, FormulaSheetContext, ParseFormulaOptions, SheetRange, parseFormulaText, readPtgExpBase };
+import { a as SheetRange, c as readPtgExpBase, i as ParseFormulaOptions, n as FormulaOrigin, o as extractFirstStringLiteral, r as FormulaSheetContext, s as parseFormulaText, t as ExternalSheetLabel } from "../ptg-75v7MhaA.js";
+export { ExternalSheetLabel, FormulaOrigin, FormulaSheetContext, ParseFormulaOptions, SheetRange, extractFirstStringLiteral, parseFormulaText, readPtgExpBase };

package/dist/biff/ptg.js

@@ -335,9 +335,12 @@ function parseFormulaText(rgce, context, options = {}) {
 		case PTG_MISSARG:
 			pushAtomic(stack, "");
 			break;
-		case PTG_STR:
-			pushAtomic(stack, quoteStringLiteral(readShortXLUnicodeString(cursor)));
+		case PTG_STR: {
+			const value = readShortXLUnicodeString(cursor);
+			options.onStringLiteral?.(value);
+			pushAtomic(stack, quoteStringLiteral(value));
 			break;
+		}
 		case PTG_ERR: {
 			const text = errorTextOf(cursor.u8());
 			if (text === void 0) return void 0;
@@ -448,6 +451,16 @@ function parseFormulaText(rgce, context, options = {}) {
 	}
 	return stack.length === 1 ? stack[0]?.text : void 0;
 }
+/**
+* Returns the raw text of the first PtgStr operand `rgce` contains, or undefined if it contains none -- a narrower question than parseFormulaText's own "render the whole formula", answerable even when the formula wraps that operand in functions this reader has no other reason to understand. Exists for conditional-format-12.ts's own readCfTextFilterRule: a CF12/CFExNonCF12 containsText-family rule states which of the four text-comparison sub-types it is via CFExTextTemplateParams.ctp, but carries the literal search text nowhere else but as this operand in its own formula (Excel's real generated shape being e.g. NOT(ISERROR(SEARCH("text",A1))) for containsText -- see conditional-format-ex.ts's own top comment for the full citation). Walks the whole token stream via parseFormulaText's own onStringLiteral hook rather than scanning for the PtgStr opcode directly, since a raw byte scan cannot tell an opcode byte from a length or count belonging to some other token's own payload.
+*/
+function extractFirstStringLiteral(rgce, context) {
+	let literal;
+	parseFormulaText(rgce, context, { onStringLiteral: (value) => {
+		literal ??= value;
+	} });
+	return literal;
+}
 /** PtgExp's own opcode ([MS-XLS] f9aa266f): 0x01, a reserved bit, then the row/col of the Formula record that carries the shared or array formula's real expression -- see readPtgExpBase. */
 const PTG_EXP_OPCODE = 1;
 /** PtgExp's own fixed size: the opcode byte plus a Rw (2 bytes) and a Col (2 bytes), [MS-XLS] f9aa266f. */
@@ -467,4 +480,4 @@ function readPtgExpBase(rgce) {
 	};
 }
 //#endregion
-export { parseFormulaText, readPtgExpBase };
+export { extractFirstStringLiteral, parseFormulaText, readPtgExpBase };

package/dist/biff/record-types.cjs

@@ -64,8 +64,10 @@ const RECORD_CONDFMT = 432;
 const RECORD_CF = 433;
 /** Marks the start of a collection of CF12 records, the "future record" (FRT) equivalent of CondFmt for the rule types Excel 97's own CF record cannot express ([MS-XLS] 2.4.57). Wraps a CondFmtStructure -- the same ccf/flags/refBound/sqref shape CondFmt's own body carries, just prefixed by a 12-byte FrtRefHeaderU this reader never needs to read. */
 const RECORD_CONDFMT12 = 2169;
-/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). This reader only promotes the three rule types with a genuine array-of-thresholds shape already shared with ooxml.js's xlsx cfRule reading -- colour scale, data bar, icon set (ExaDev/documents.js#1104); the filter-template family stays unread (ExaDev/documents.js#1100). */
+/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). */
 const RECORD_CF12 = 2170;
+/** Extends an existing CondFmt-owned rule with icfTemplate/priority metadata a legacy (Excel 97) CF record has no field for -- CF12's counterpart for a rule Excel keeps expressible as a plain formula condition for pre-2007 readers, most notably the containsText family ([MS-XLS] 2.4.63). Read by workbook/conditional-format-ex.ts. */
+const RECORD_CFEX = 2171;
 /** A cell comment's anchor -- row, column, and its own author, linking to the Obj record that names its text ([MS-XLS] 2.4.179). */
 const RECORD_NOTE = 28;
 /** A drawing object's common properties (id, type) and, for a comment, its FtNts sub-structure ([MS-XLS] 2.4.181). */
@@ -175,6 +177,7 @@ exports.RECORD_CALCREFMODE = RECORD_CALCREFMODE;
 exports.RECORD_CALCSAVERECALC = RECORD_CALCSAVERECALC;
 exports.RECORD_CF = RECORD_CF;
 exports.RECORD_CF12 = RECORD_CF12;
+exports.RECORD_CFEX = RECORD_CFEX;
 exports.RECORD_COLINFO = RECORD_COLINFO;
 exports.RECORD_CONDFMT = RECORD_CONDFMT;
 exports.RECORD_CONDFMT12 = RECORD_CONDFMT12;

package/dist/biff/record-types.d.cts

@@ -63,8 +63,10 @@ declare const RECORD_CONDFMT = 432;
 declare const RECORD_CF = 433;
 /** Marks the start of a collection of CF12 records, the "future record" (FRT) equivalent of CondFmt for the rule types Excel 97's own CF record cannot express ([MS-XLS] 2.4.57). Wraps a CondFmtStructure -- the same ccf/flags/refBound/sqref shape CondFmt's own body carries, just prefixed by a 12-byte FrtRefHeaderU this reader never needs to read. */
 declare const RECORD_CONDFMT12 = 2169;
-/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). This reader only promotes the three rule types with a genuine array-of-thresholds shape already shared with ooxml.js's xlsx cfRule reading -- colour scale, data bar, icon set (ExaDev/documents.js#1104); the filter-template family stays unread (ExaDev/documents.js#1100). */
+/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). */
 declare const RECORD_CF12 = 2170;
+/** Extends an existing CondFmt-owned rule with icfTemplate/priority metadata a legacy (Excel 97) CF record has no field for -- CF12's counterpart for a rule Excel keeps expressible as a plain formula condition for pre-2007 readers, most notably the containsText family ([MS-XLS] 2.4.63). Read by workbook/conditional-format-ex.ts. */
+declare const RECORD_CFEX = 2171;
 /** A cell comment's anchor -- row, column, and its own author, linking to the Obj record that names its text ([MS-XLS] 2.4.179). */
 declare const RECORD_NOTE = 28;
 /** A drawing object's common properties (id, type) and, for a comment, its FtNts sub-structure ([MS-XLS] 2.4.181). */
@@ -154,4 +156,4 @@ declare const BIFF8_VERSION = 1536;
 /** [MS-XLS] 2.1.4: "The record size ... MUST be less than or equal to 8224." The ceiling a writer splits a record at, and the bound a reader can sanity-check a declared size against. */
 declare const MAX_RECORD_DATA_SIZE = 8224;
 //#endregion
-export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_AI, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOTTOMMARGIN, RECORD_BOUNDSHEET8, RECORD_CALCCOUNT, RECORD_CALCDELTA, RECORD_CALCITER, RECORD_CALCREFMODE, RECORD_CALCSAVERECALC, RECORD_CF, RECORD_CF12, RECORD_COLINFO, RECORD_CONDFMT, RECORD_CONDFMT12, RECORD_CONTINUE, RECORD_CONTINUEFRT12, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_DV, RECORD_DVAL, RECORD_EOF, RECORD_EXTERNSHEET, RECORD_FILELOCK, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_HORIZONTALPAGEBREAKS, RECORD_INTERFACEHDR, RECORD_LABEL, RECORD_LABELSST, RECORD_LBL, RECORD_LEFTMARGIN, RECORD_MERGECELLS, RECORD_MSODRAWING, RECORD_MSODRAWINGGROUP, RECORD_MSODRAWINGSELECTION, RECORD_MULBLANK, RECORD_MULRK, RECORD_NOTE, RECORD_NUMBER, RECORD_OBJ, RECORD_PALETTE, RECORD_PRINTGRID, RECORD_PRINTROWCOL, RECORD_RIGHTMARGIN, RECORD_RK, RECORD_ROW, RECORD_RRDHEAD, RECORD_RRDINFO, RECORD_SERIES, RECORD_SERIESTEXT, RECORD_SETUP, RECORD_SHRFMLA, RECORD_SIINDEX, RECORD_SST, RECORD_STRING, RECORD_STYLE, RECORD_SUPBOOK, RECORD_TABLE, RECORD_TOPMARGIN, RECORD_TXO, RECORD_USREXCL, RECORD_VERTICALPAGEBREAKS, RECORD_WSBOOL, RECORD_XF };
+export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_AI, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOTTOMMARGIN, RECORD_BOUNDSHEET8, RECORD_CALCCOUNT, RECORD_CALCDELTA, RECORD_CALCITER, RECORD_CALCREFMODE, RECORD_CALCSAVERECALC, RECORD_CF, RECORD_CF12, RECORD_CFEX, RECORD_COLINFO, RECORD_CONDFMT, RECORD_CONDFMT12, RECORD_CONTINUE, RECORD_CONTINUEFRT12, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_DV, RECORD_DVAL, RECORD_EOF, RECORD_EXTERNSHEET, RECORD_FILELOCK, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_HORIZONTALPAGEBREAKS, RECORD_INTERFACEHDR, RECORD_LABEL, RECORD_LABELSST, RECORD_LBL, RECORD_LEFTMARGIN, RECORD_MERGECELLS, RECORD_MSODRAWING, RECORD_MSODRAWINGGROUP, RECORD_MSODRAWINGSELECTION, RECORD_MULBLANK, RECORD_MULRK, RECORD_NOTE, RECORD_NUMBER, RECORD_OBJ, RECORD_PALETTE, RECORD_PRINTGRID, RECORD_PRINTROWCOL, RECORD_RIGHTMARGIN, RECORD_RK, RECORD_ROW, RECORD_RRDHEAD, RECORD_RRDINFO, RECORD_SERIES, RECORD_SERIESTEXT, RECORD_SETUP, RECORD_SHRFMLA, RECORD_SIINDEX, RECORD_SST, RECORD_STRING, RECORD_STYLE, RECORD_SUPBOOK, RECORD_TABLE, RECORD_TOPMARGIN, RECORD_TXO, RECORD_USREXCL, RECORD_VERTICALPAGEBREAKS, RECORD_WSBOOL, RECORD_XF };

package/dist/biff/record-types.d.ts

@@ -63,8 +63,10 @@ declare const RECORD_CONDFMT = 432;
 declare const RECORD_CF = 433;
 /** Marks the start of a collection of CF12 records, the "future record" (FRT) equivalent of CondFmt for the rule types Excel 97's own CF record cannot express ([MS-XLS] 2.4.57). Wraps a CondFmtStructure -- the same ccf/flags/refBound/sqref shape CondFmt's own body carries, just prefixed by a 12-byte FrtRefHeaderU this reader never needs to read. */
 declare const RECORD_CONDFMT12 = 2169;
-/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). This reader only promotes the three rule types with a genuine array-of-thresholds shape already shared with ooxml.js's xlsx cfRule reading -- colour scale, data bar, icon set (ExaDev/documents.js#1104); the filter-template family stays unread (ExaDev/documents.js#1100). */
+/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). */
 declare const RECORD_CF12 = 2170;
+/** Extends an existing CondFmt-owned rule with icfTemplate/priority metadata a legacy (Excel 97) CF record has no field for -- CF12's counterpart for a rule Excel keeps expressible as a plain formula condition for pre-2007 readers, most notably the containsText family ([MS-XLS] 2.4.63). Read by workbook/conditional-format-ex.ts. */
+declare const RECORD_CFEX = 2171;
 /** A cell comment's anchor -- row, column, and its own author, linking to the Obj record that names its text ([MS-XLS] 2.4.179). */
 declare const RECORD_NOTE = 28;
 /** A drawing object's common properties (id, type) and, for a comment, its FtNts sub-structure ([MS-XLS] 2.4.181). */
@@ -154,4 +156,4 @@ declare const BIFF8_VERSION = 1536;
 /** [MS-XLS] 2.1.4: "The record size ... MUST be less than or equal to 8224." The ceiling a writer splits a record at, and the bound a reader can sanity-check a declared size against. */
 declare const MAX_RECORD_DATA_SIZE = 8224;
 //#endregion
-export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_AI, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOTTOMMARGIN, RECORD_BOUNDSHEET8, RECORD_CALCCOUNT, RECORD_CALCDELTA, RECORD_CALCITER, RECORD_CALCREFMODE, RECORD_CALCSAVERECALC, RECORD_CF, RECORD_CF12, RECORD_COLINFO, RECORD_CONDFMT, RECORD_CONDFMT12, RECORD_CONTINUE, RECORD_CONTINUEFRT12, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_DV, RECORD_DVAL, RECORD_EOF, RECORD_EXTERNSHEET, RECORD_FILELOCK, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_HORIZONTALPAGEBREAKS, RECORD_INTERFACEHDR, RECORD_LABEL, RECORD_LABELSST, RECORD_LBL, RECORD_LEFTMARGIN, RECORD_MERGECELLS, RECORD_MSODRAWING, RECORD_MSODRAWINGGROUP, RECORD_MSODRAWINGSELECTION, RECORD_MULBLANK, RECORD_MULRK, RECORD_NOTE, RECORD_NUMBER, RECORD_OBJ, RECORD_PALETTE, RECORD_PRINTGRID, RECORD_PRINTROWCOL, RECORD_RIGHTMARGIN, RECORD_RK, RECORD_ROW, RECORD_RRDHEAD, RECORD_RRDINFO, RECORD_SERIES, RECORD_SERIESTEXT, RECORD_SETUP, RECORD_SHRFMLA, RECORD_SIINDEX, RECORD_SST, RECORD_STRING, RECORD_STYLE, RECORD_SUPBOOK, RECORD_TABLE, RECORD_TOPMARGIN, RECORD_TXO, RECORD_USREXCL, RECORD_VERTICALPAGEBREAKS, RECORD_WSBOOL, RECORD_XF };
+export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_AI, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOTTOMMARGIN, RECORD_BOUNDSHEET8, RECORD_CALCCOUNT, RECORD_CALCDELTA, RECORD_CALCITER, RECORD_CALCREFMODE, RECORD_CALCSAVERECALC, RECORD_CF, RECORD_CF12, RECORD_CFEX, RECORD_COLINFO, RECORD_CONDFMT, RECORD_CONDFMT12, RECORD_CONTINUE, RECORD_CONTINUEFRT12, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_DV, RECORD_DVAL, RECORD_EOF, RECORD_EXTERNSHEET, RECORD_FILELOCK, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_HORIZONTALPAGEBREAKS, RECORD_INTERFACEHDR, RECORD_LABEL, RECORD_LABELSST, RECORD_LBL, RECORD_LEFTMARGIN, RECORD_MERGECELLS, RECORD_MSODRAWING, RECORD_MSODRAWINGGROUP, RECORD_MSODRAWINGSELECTION, RECORD_MULBLANK, RECORD_MULRK, RECORD_NOTE, RECORD_NUMBER, RECORD_OBJ, RECORD_PALETTE, RECORD_PRINTGRID, RECORD_PRINTROWCOL, RECORD_RIGHTMARGIN, RECORD_RK, RECORD_ROW, RECORD_RRDHEAD, RECORD_RRDINFO, RECORD_SERIES, RECORD_SERIESTEXT, RECORD_SETUP, RECORD_SHRFMLA, RECORD_SIINDEX, RECORD_SST, RECORD_STRING, RECORD_STYLE, RECORD_SUPBOOK, RECORD_TABLE, RECORD_TOPMARGIN, RECORD_TXO, RECORD_USREXCL, RECORD_VERTICALPAGEBREAKS, RECORD_WSBOOL, RECORD_XF };

package/dist/biff/record-types.js

@@ -63,8 +63,10 @@ const RECORD_CONDFMT = 432;
 const RECORD_CF = 433;
 /** Marks the start of a collection of CF12 records, the "future record" (FRT) equivalent of CondFmt for the rule types Excel 97's own CF record cannot express ([MS-XLS] 2.4.57). Wraps a CondFmtStructure -- the same ccf/flags/refBound/sqref shape CondFmt's own body carries, just prefixed by a 12-byte FrtRefHeaderU this reader never needs to read. */
 const RECORD_CONDFMT12 = 2169;
-/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). This reader only promotes the three rule types with a genuine array-of-thresholds shape already shared with ooxml.js's xlsx cfRule reading -- colour scale, data bar, icon set (ExaDev/documents.js#1104); the filter-template family stays unread (ExaDev/documents.js#1100). */
+/** One extended conditional-formatting rule: colour scale, data bar, icon set, a filter-dispatched template (top10, aboveAverage, contains-text, a date/time period, …), or a plain comparison/formula rule re-expressed in the newer record shape ([MS-XLS] 2.4.43). */
 const RECORD_CF12 = 2170;
+/** Extends an existing CondFmt-owned rule with icfTemplate/priority metadata a legacy (Excel 97) CF record has no field for -- CF12's counterpart for a rule Excel keeps expressible as a plain formula condition for pre-2007 readers, most notably the containsText family ([MS-XLS] 2.4.63). Read by workbook/conditional-format-ex.ts. */
+const RECORD_CFEX = 2171;
 /** A cell comment's anchor -- row, column, and its own author, linking to the Obj record that names its text ([MS-XLS] 2.4.179). */
 const RECORD_NOTE = 28;
 /** A drawing object's common properties (id, type) and, for a comment, its FtNts sub-structure ([MS-XLS] 2.4.181). */
@@ -154,4 +156,4 @@ const BIFF8_VERSION = 1536;
 /** [MS-XLS] 2.1.4: "The record size ... MUST be less than or equal to 8224." The ceiling a writer splits a record at, and the bound a reader can sanity-check a declared size against. */
 const MAX_RECORD_DATA_SIZE = 8224;
 //#endregion
-export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_AI, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOTTOMMARGIN, RECORD_BOUNDSHEET8, RECORD_CALCCOUNT, RECORD_CALCDELTA, RECORD_CALCITER, RECORD_CALCREFMODE, RECORD_CALCSAVERECALC, RECORD_CF, RECORD_CF12, RECORD_COLINFO, RECORD_CONDFMT, RECORD_CONDFMT12, RECORD_CONTINUE, RECORD_CONTINUEFRT12, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_DV, RECORD_DVAL, RECORD_EOF, RECORD_EXTERNSHEET, RECORD_FILELOCK, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_HORIZONTALPAGEBREAKS, RECORD_INTERFACEHDR, RECORD_LABEL, RECORD_LABELSST, RECORD_LBL, RECORD_LEFTMARGIN, RECORD_MERGECELLS, RECORD_MSODRAWING, RECORD_MSODRAWINGGROUP, RECORD_MSODRAWINGSELECTION, RECORD_MULBLANK, RECORD_MULRK, RECORD_NOTE, RECORD_NUMBER, RECORD_OBJ, RECORD_PALETTE, RECORD_PRINTGRID, RECORD_PRINTROWCOL, RECORD_RIGHTMARGIN, RECORD_RK, RECORD_ROW, RECORD_RRDHEAD, RECORD_RRDINFO, RECORD_SERIES, RECORD_SERIESTEXT, RECORD_SETUP, RECORD_SHRFMLA, RECORD_SIINDEX, RECORD_SST, RECORD_STRING, RECORD_STYLE, RECORD_SUPBOOK, RECORD_TABLE, RECORD_TOPMARGIN, RECORD_TXO, RECORD_USREXCL, RECORD_VERTICALPAGEBREAKS, RECORD_WSBOOL, RECORD_XF };
+export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_AI, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOTTOMMARGIN, RECORD_BOUNDSHEET8, RECORD_CALCCOUNT, RECORD_CALCDELTA, RECORD_CALCITER, RECORD_CALCREFMODE, RECORD_CALCSAVERECALC, RECORD_CF, RECORD_CF12, RECORD_CFEX, RECORD_COLINFO, RECORD_CONDFMT, RECORD_CONDFMT12, RECORD_CONTINUE, RECORD_CONTINUEFRT12, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_DV, RECORD_DVAL, RECORD_EOF, RECORD_EXTERNSHEET, RECORD_FILELOCK, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_HORIZONTALPAGEBREAKS, RECORD_INTERFACEHDR, RECORD_LABEL, RECORD_LABELSST, RECORD_LBL, RECORD_LEFTMARGIN, RECORD_MERGECELLS, RECORD_MSODRAWING, RECORD_MSODRAWINGGROUP, RECORD_MSODRAWINGSELECTION, RECORD_MULBLANK, RECORD_MULRK, RECORD_NOTE, RECORD_NUMBER, RECORD_OBJ, RECORD_PALETTE, RECORD_PRINTGRID, RECORD_PRINTROWCOL, RECORD_RIGHTMARGIN, RECORD_RK, RECORD_ROW, RECORD_RRDHEAD, RECORD_RRDINFO, RECORD_SERIES, RECORD_SERIESTEXT, RECORD_SETUP, RECORD_SHRFMLA, RECORD_SIINDEX, RECORD_SST, RECORD_STRING, RECORD_STYLE, RECORD_SUPBOOK, RECORD_TABLE, RECORD_TOPMARGIN, RECORD_TXO, RECORD_USREXCL, RECORD_VERTICALPAGEBREAKS, RECORD_WSBOOL, RECORD_XF };

package/dist/biff/strings.d.cts

@@ -1,4 +1,4 @@
-import { t as BlockCursor } from "../cursor-VMtw9uVP.cjs";
+import { t as BlockCursor } from "../cursor-CnEuX5qE.cjs";
 //#region src/biff/strings.d.ts
 /** An XLUnicodeString ([MS-XLS] 2.5.294): a two-byte character count, a flags byte, then the characters. Continuable, since the String record ([MS-XLS] 2.4.268) carrying a formula's string result is one of these and its own production admits trailing Continues. */
 declare function readXLUnicodeString(cursor: BlockCursor): string;

package/dist/biff/strings.d.ts

@@ -1,4 +1,4 @@
-import { t as BlockCursor } from "../cursor-VMtw9uVP.js";
+import { t as BlockCursor } from "../cursor-CnEuX5qE.js";
 //#region src/biff/strings.d.ts
 /** An XLUnicodeString ([MS-XLS] 2.5.294): a two-byte character count, a flags byte, then the characters. Continuable, since the String record ([MS-XLS] 2.4.268) carrying a formula's string result is one of these and its own production admits trailing Continues. */
 declare function readXLUnicodeString(cursor: BlockCursor): string;

package/dist/biff/xf-colors.d.cts

@@ -1,2 +1,2 @@
-import { A as longRgbBytesOf, B as vertAlignTokenFor, C as UNDECORATED_XF_FIELDS, D as applyTint, E as XfDecorationFields, F as resolveHorizontalAlignment, I as resolveIcvColor, L as resolveVerticalAlignment, M as readLongRgbColor, N as resolveBorderEdge, O as borderStyleTokenFor, P as resolveFillBackground, R as unpackXfAlignment, S as PATTERN_TYPE_TO_FILL_PATTERN, T as XfBorderEdge, _ as FILL_PATTERN_SOLID, a as BORDER_STYLE_DOUBLE, b as PALETTE_BASE_ICV, c as BORDER_STYLE_MEDIUM_DASHDOT, d as BORDER_STYLE_NONE, f as BORDER_STYLE_SLANT_DASHDOT, g as FILL_PATTERN_NONE, h as DEFAULT_PALETTE_HEX_TO_ICV, i as BORDER_STYLE_DOTTED, j as packXfDecorationWords, k as horizAlignTokenFor, l as BORDER_STYLE_MEDIUM_DASHDOTDOT, m as BORDER_STYLE_THIN, n as BORDER_STYLE_DASHDOTDOT, o as BORDER_STYLE_HAIR, p as BORDER_STYLE_THICK, r as BORDER_STYLE_DASHED, s as BORDER_STYLE_MEDIUM, t as BORDER_STYLE_DASHDOT, u as BORDER_STYLE_MEDIUM_DASHED, v as ICV_AUTOMATIC_BACKGROUND, w as XfAlignmentFields, x as PALETTE_ENTRY_COUNT, y as ICV_AUTOMATIC_FOREGROUND, z as unpackXfDecoration } from "../xf-colors-mqerVt2O.cjs";
+import { A as longRgbBytesOf, B as vertAlignTokenFor, C as UNDECORATED_XF_FIELDS, D as applyTint, E as XfDecorationFields, F as resolveHorizontalAlignment, I as resolveIcvColor, L as resolveVerticalAlignment, M as readLongRgbColor, N as resolveBorderEdge, O as borderStyleTokenFor, P as resolveFillBackground, R as unpackXfAlignment, S as PATTERN_TYPE_TO_FILL_PATTERN, T as XfBorderEdge, _ as FILL_PATTERN_SOLID, a as BORDER_STYLE_DOUBLE, b as PALETTE_BASE_ICV, c as BORDER_STYLE_MEDIUM_DASHDOT, d as BORDER_STYLE_NONE, f as BORDER_STYLE_SLANT_DASHDOT, g as FILL_PATTERN_NONE, h as DEFAULT_PALETTE_HEX_TO_ICV, i as BORDER_STYLE_DOTTED, j as packXfDecorationWords, k as horizAlignTokenFor, l as BORDER_STYLE_MEDIUM_DASHDOTDOT, m as BORDER_STYLE_THIN, n as BORDER_STYLE_DASHDOTDOT, o as BORDER_STYLE_HAIR, p as BORDER_STYLE_THICK, r as BORDER_STYLE_DASHED, s as BORDER_STYLE_MEDIUM, t as BORDER_STYLE_DASHDOT, u as BORDER_STYLE_MEDIUM_DASHED, v as ICV_AUTOMATIC_BACKGROUND, w as XfAlignmentFields, x as PALETTE_ENTRY_COUNT, y as ICV_AUTOMATIC_FOREGROUND, z as unpackXfDecoration } from "../xf-colors-aeH9Ax3Q.cjs";
 export { BORDER_STYLE_DASHDOT, BORDER_STYLE_DASHDOTDOT, BORDER_STYLE_DASHED, BORDER_STYLE_DOTTED, BORDER_STYLE_DOUBLE, BORDER_STYLE_HAIR, BORDER_STYLE_MEDIUM, BORDER_STYLE_MEDIUM_DASHDOT, BORDER_STYLE_MEDIUM_DASHDOTDOT, BORDER_STYLE_MEDIUM_DASHED, BORDER_STYLE_NONE, BORDER_STYLE_SLANT_DASHDOT, BORDER_STYLE_THICK, BORDER_STYLE_THIN, DEFAULT_PALETTE_HEX_TO_ICV, FILL_PATTERN_NONE, FILL_PATTERN_SOLID, ICV_AUTOMATIC_BACKGROUND, ICV_AUTOMATIC_FOREGROUND, PALETTE_BASE_ICV, PALETTE_ENTRY_COUNT, PATTERN_TYPE_TO_FILL_PATTERN, UNDECORATED_XF_FIELDS, XfAlignmentFields, XfBorderEdge, XfDecorationFields, applyTint, borderStyleTokenFor, horizAlignTokenFor, longRgbBytesOf, packXfDecorationWords, readLongRgbColor, resolveBorderEdge, resolveFillBackground, resolveHorizontalAlignment, resolveIcvColor, resolveVerticalAlignment, unpackXfAlignment, unpackXfDecoration, vertAlignTokenFor };

package/dist/biff/xf-colors.d.ts

@@ -1,2 +1,2 @@
-import { A as longRgbBytesOf, B as vertAlignTokenFor, C as UNDECORATED_XF_FIELDS, D as applyTint, E as XfDecorationFields, F as resolveHorizontalAlignment, I as resolveIcvColor, L as resolveVerticalAlignment, M as readLongRgbColor, N as resolveBorderEdge, O as borderStyleTokenFor, P as resolveFillBackground, R as unpackXfAlignment, S as PATTERN_TYPE_TO_FILL_PATTERN, T as XfBorderEdge, _ as FILL_PATTERN_SOLID, a as BORDER_STYLE_DOUBLE, b as PALETTE_BASE_ICV, c as BORDER_STYLE_MEDIUM_DASHDOT, d as BORDER_STYLE_NONE, f as BORDER_STYLE_SLANT_DASHDOT, g as FILL_PATTERN_NONE, h as DEFAULT_PALETTE_HEX_TO_ICV, i as BORDER_STYLE_DOTTED, j as packXfDecorationWords, k as horizAlignTokenFor, l as BORDER_STYLE_MEDIUM_DASHDOTDOT, m as BORDER_STYLE_THIN, n as BORDER_STYLE_DASHDOTDOT, o as BORDER_STYLE_HAIR, p as BORDER_STYLE_THICK, r as BORDER_STYLE_DASHED, s as BORDER_STYLE_MEDIUM, t as BORDER_STYLE_DASHDOT, u as BORDER_STYLE_MEDIUM_DASHED, v as ICV_AUTOMATIC_BACKGROUND, w as XfAlignmentFields, x as PALETTE_ENTRY_COUNT, y as ICV_AUTOMATIC_FOREGROUND, z as unpackXfDecoration } from "../xf-colors-d3OvRw76.js";
+import { A as longRgbBytesOf, B as vertAlignTokenFor, C as UNDECORATED_XF_FIELDS, D as applyTint, E as XfDecorationFields, F as resolveHorizontalAlignment, I as resolveIcvColor, L as resolveVerticalAlignment, M as readLongRgbColor, N as resolveBorderEdge, O as borderStyleTokenFor, P as resolveFillBackground, R as unpackXfAlignment, S as PATTERN_TYPE_TO_FILL_PATTERN, T as XfBorderEdge, _ as FILL_PATTERN_SOLID, a as BORDER_STYLE_DOUBLE, b as PALETTE_BASE_ICV, c as BORDER_STYLE_MEDIUM_DASHDOT, d as BORDER_STYLE_NONE, f as BORDER_STYLE_SLANT_DASHDOT, g as FILL_PATTERN_NONE, h as DEFAULT_PALETTE_HEX_TO_ICV, i as BORDER_STYLE_DOTTED, j as packXfDecorationWords, k as horizAlignTokenFor, l as BORDER_STYLE_MEDIUM_DASHDOTDOT, m as BORDER_STYLE_THIN, n as BORDER_STYLE_DASHDOTDOT, o as BORDER_STYLE_HAIR, p as BORDER_STYLE_THICK, r as BORDER_STYLE_DASHED, s as BORDER_STYLE_MEDIUM, t as BORDER_STYLE_DASHDOT, u as BORDER_STYLE_MEDIUM_DASHED, v as ICV_AUTOMATIC_BACKGROUND, w as XfAlignmentFields, x as PALETTE_ENTRY_COUNT, y as ICV_AUTOMATIC_FOREGROUND, z as unpackXfDecoration } from "../xf-colors-kdNsiNYt.js";
 export { BORDER_STYLE_DASHDOT, BORDER_STYLE_DASHDOTDOT, BORDER_STYLE_DASHED, BORDER_STYLE_DOTTED, BORDER_STYLE_DOUBLE, BORDER_STYLE_HAIR, BORDER_STYLE_MEDIUM, BORDER_STYLE_MEDIUM_DASHDOT, BORDER_STYLE_MEDIUM_DASHDOTDOT, BORDER_STYLE_MEDIUM_DASHED, BORDER_STYLE_NONE, BORDER_STYLE_SLANT_DASHDOT, BORDER_STYLE_THICK, BORDER_STYLE_THIN, DEFAULT_PALETTE_HEX_TO_ICV, FILL_PATTERN_NONE, FILL_PATTERN_SOLID, ICV_AUTOMATIC_BACKGROUND, ICV_AUTOMATIC_FOREGROUND, PALETTE_BASE_ICV, PALETTE_ENTRY_COUNT, PATTERN_TYPE_TO_FILL_PATTERN, UNDECORATED_XF_FIELDS, XfAlignmentFields, XfBorderEdge, XfDecorationFields, applyTint, borderStyleTokenFor, horizAlignTokenFor, longRgbBytesOf, packXfDecorationWords, readLongRgbColor, resolveBorderEdge, resolveFillBackground, resolveHorizontalAlignment, resolveIcvColor, resolveVerticalAlignment, unpackXfAlignment, unpackXfDecoration, vertAlignTokenFor };

package/dist/biff/xf-writer.d.cts

@@ -1,4 +1,4 @@
-import { E as XfDecorationFields } from "../xf-colors-mqerVt2O.cjs";
+import { E as XfDecorationFields } from "../xf-colors-aeH9Ax3Q.cjs";
 import { Alignment, Color } from "document-schema.js";
 //#region src/biff/xf-writer.d.ts
 /** Writes one cell-format XF record (fStyle=0): ifnt/ifmt as given, ixfParent pointing at the Normal cell-style XF (index 0), a CellXF payload carrying `alignment`/`verticalAlignment`/`decoration`'s own fields -- general alignment, bottom vertical alignment, and no fill/border (the same bytes this always wrote before either existed) for whatever is omitted. Twenty bytes total ([MS-XLS] 2.4.353). */

package/dist/biff/xf-writer.d.ts

@@ -1,4 +1,4 @@
-import { E as XfDecorationFields } from "../xf-colors-d3OvRw76.js";
+import { E as XfDecorationFields } from "../xf-colors-kdNsiNYt.js";
 import { Alignment, Color } from "document-schema.js";
 //#region src/biff/xf-writer.d.ts
 /** Writes one cell-format XF record (fStyle=0): ifnt/ifmt as given, ixfParent pointing at the Normal cell-style XF (index 0), a CellXF payload carrying `alignment`/`verticalAlignment`/`decoration`'s own fields -- general alignment, bottom vertical alignment, and no fill/border (the same bytes this always wrote before either existed) for whatever is omitted. Twenty bytes total ([MS-XLS] 2.4.353). */

package/dist/{conditional-format-12-Xl52VBCj.d.ts → conditional-format-12-C3nwy1f8.d.ts}

@@ -1,6 +1,6 @@
-import { r as FormulaSheetContext } from "./ptg-CCBbJLZJ.js";
+import { r as FormulaSheetContext } from "./ptg-75v7MhaA.js";
 import { t as RecordGroup } from "./substreams-CgTHx5kX.js";
-import { i as RawConditionalFormatStyle } from "./conditional-format-Cqcjnm7O.js";
+import { a as RawConditionalFormatStyle } from "./conditional-format-BRMUTRP1.js";
 import { Color, ContentSheetConditionalFormat, ContentSheetConditionalFormatValue, ContentSheetRange } from "document-schema.js";
 //#region src/workbook/conditional-format-12.d.ts
 type RawCfColor = {
@@ -65,7 +65,12 @@ interface RawTimePeriodFormat extends RawFilterFormatCommon {
 interface RawSimpleFilterFormat extends RawFilterFormatCommon {
   readonly kind: "containsBlanks" | "notContainsBlanks" | "containsErrors" | "notContainsErrors" | "uniqueValues" | "duplicateValues";
 }
-type RawConditionalFormat12 = RawColorScaleFormat | RawDataBarFormat | RawIconSetFormat | RawTop10Format | RawAboveAverageFormat | RawTimePeriodFormat | RawSimpleFilterFormat;
+interface RawTextFilterFormat extends RawFilterFormatCommon {
+  readonly kind: "containsText" | "notContainsText" | "beginsWith" | "endsWith";
+  readonly text: string;
+}
+type RawConditionalFormat12 = RawColorScaleFormat | RawDataBarFormat | RawIconSetFormat | RawTop10Format | RawAboveAverageFormat | RawTimePeriodFormat | RawSimpleFilterFormat | RawTextFilterFormat;
+declare function readCfTextFilterRule(icfTemplate: number, templateParams: Uint8Array<ArrayBuffer>, rgce1: Uint8Array<ArrayBuffer>, formulaSheets: FormulaSheetContext): Omit<RawTextFilterFormat, keyof RawFilterFormatCommon> | undefined;
 interface CondFmt12GroupResult {
   readonly formats: RawConditionalFormat12[];
   /** How many records (the CondFmt12 itself plus every CF12 it claimed) the caller should advance past, regardless of how many rules actually promoted. */
@@ -73,4 +78,4 @@ interface CondFmt12GroupResult {
 }
 declare function readCondFmt12Group(records: readonly RecordGroup[], startIndex: number, formulaSheets: FormulaSheetContext): CondFmt12GroupResult;
 //#endregion
-export { RawConditionalFormat12 as a, RawSimpleFilterFormat as c, RawTop10Format as d, readCondFmt12Group as f, RawColorScaleFormat as i, RawTimePeriod as l, RawAboveAverageFormat as n, RawDataBarFormat as o, RawCfColor as r, RawIconSetFormat as s, CondFmt12GroupResult as t, RawTimePeriodFormat as u };
+export { RawConditionalFormat12 as a, RawIconSetFormat as c, RawTimePeriod as d, RawTimePeriodFormat as f, readCondFmt12Group as h, RawColorScaleFormat as i, RawSimpleFilterFormat as l, readCfTextFilterRule as m, RawAboveAverageFormat as n, RawConditionalFormat12Common as o, RawTop10Format as p, RawCfColor as r, RawDataBarFormat as s, CondFmt12GroupResult as t, RawTextFilterFormat as u };

package/dist/{conditional-format-12-CZ43-CR4.d.cts → conditional-format-12-D65-ruTq.d.cts}

@@ -1,6 +1,6 @@
-import { r as FormulaSheetContext } from "./ptg-CCBbJLZJ.cjs";
+import { r as FormulaSheetContext } from "./ptg-75v7MhaA.cjs";
 import { t as RecordGroup } from "./substreams-XDNgDvRJ.cjs";
-import { i as RawConditionalFormatStyle } from "./conditional-format-Bt1vRWgc.cjs";
+import { a as RawConditionalFormatStyle } from "./conditional-format-Cth_afMy.cjs";
 import { Color, ContentSheetConditionalFormat, ContentSheetConditionalFormatValue, ContentSheetRange } from "document-schema.js";
 //#region src/workbook/conditional-format-12.d.ts
 type RawCfColor = {
@@ -65,7 +65,12 @@ interface RawTimePeriodFormat extends RawFilterFormatCommon {
 interface RawSimpleFilterFormat extends RawFilterFormatCommon {
   readonly kind: "containsBlanks" | "notContainsBlanks" | "containsErrors" | "notContainsErrors" | "uniqueValues" | "duplicateValues";
 }
-type RawConditionalFormat12 = RawColorScaleFormat | RawDataBarFormat | RawIconSetFormat | RawTop10Format | RawAboveAverageFormat | RawTimePeriodFormat | RawSimpleFilterFormat;
+interface RawTextFilterFormat extends RawFilterFormatCommon {
+  readonly kind: "containsText" | "notContainsText" | "beginsWith" | "endsWith";
+  readonly text: string;
+}
+type RawConditionalFormat12 = RawColorScaleFormat | RawDataBarFormat | RawIconSetFormat | RawTop10Format | RawAboveAverageFormat | RawTimePeriodFormat | RawSimpleFilterFormat | RawTextFilterFormat;
+declare function readCfTextFilterRule(icfTemplate: number, templateParams: Uint8Array<ArrayBuffer>, rgce1: Uint8Array<ArrayBuffer>, formulaSheets: FormulaSheetContext): Omit<RawTextFilterFormat, keyof RawFilterFormatCommon> | undefined;
 interface CondFmt12GroupResult {
   readonly formats: RawConditionalFormat12[];
   /** How many records (the CondFmt12 itself plus every CF12 it claimed) the caller should advance past, regardless of how many rules actually promoted. */
@@ -73,4 +78,4 @@ interface CondFmt12GroupResult {
 }
 declare function readCondFmt12Group(records: readonly RecordGroup[], startIndex: number, formulaSheets: FormulaSheetContext): CondFmt12GroupResult;
 //#endregion
-export { RawConditionalFormat12 as a, RawSimpleFilterFormat as c, RawTop10Format as d, readCondFmt12Group as f, RawColorScaleFormat as i, RawTimePeriod as l, RawAboveAverageFormat as n, RawDataBarFormat as o, RawCfColor as r, RawIconSetFormat as s, CondFmt12GroupResult as t, RawTimePeriodFormat as u };
+export { RawConditionalFormat12 as a, RawIconSetFormat as c, RawTimePeriod as d, RawTimePeriodFormat as f, readCondFmt12Group as h, RawColorScaleFormat as i, RawSimpleFilterFormat as l, readCfTextFilterRule as m, RawAboveAverageFormat as n, RawConditionalFormat12Common as o, RawTop10Format as p, RawCfColor as r, RawDataBarFormat as s, CondFmt12GroupResult as t, RawTextFilterFormat as u };

package/dist/conditional-format-BRMUTRP1.d.ts

@@ -0,0 +1,41 @@
+import { r as FormulaSheetContext } from "./ptg-75v7MhaA.js";
+import { t as RecordGroup } from "./substreams-CgTHx5kX.js";
+import { ContentSheetRange, SheetRuleOperator } from "document-schema.js";
+//#region src/workbook/conditional-format.d.ts
+interface RawConditionalFormatFill {
+  readonly fillPattern: number;
+  readonly fillForegroundIcv: number;
+  readonly fillBackgroundIcv: number;
+}
+interface RawConditionalFormatStyle {
+  readonly fontColorIcv: number | undefined;
+  readonly fill: RawConditionalFormatFill | undefined;
+}
+interface RawConditionalFormat {
+  readonly operator: SheetRuleOperator;
+  readonly formula1: string;
+  readonly formula2: string | undefined;
+  readonly style: RawConditionalFormatStyle | undefined;
+  readonly ranges: ContentSheetRange[];
+}
+declare function parseDxfStyle(dxfBytes: Uint8Array<ArrayBuffer>): RawConditionalFormatStyle | undefined;
+/** A CF record's own operand, in its rawest usable form -- the pieces conditional-format-ex.ts needs to resolve a CFEx that extends this specific CF (by icf, a positional index into a CondFmt's own CF children), independent of whether readCf below can promote this CF into a 'cellIs' rule at all. A ct 0x02 formula condition, exactly the kind readCf itself never promotes, is the one CFEx actually cares about (see conditional-format-ex.ts's own top comment for why). */
+interface RawCfOperand {
+  readonly ct: number;
+  readonly cp: number;
+  readonly rgce1: Uint8Array<ArrayBuffer>;
+}
+interface CondFmtGroupResult {
+  readonly formats: RawConditionalFormat[];
+  /** How many records (the CondFmt itself plus every CF it claimed) the caller should advance past, regardless of how many rules actually promoted. */
+  readonly recordsConsumed: number;
+  /** CondFmt's own nID ([MS-XLS] 2.5.56's own CondFmtStructure) -- the identifier a later CFEx record's own nID field cross-references to extend one specific CF child of this group (conditional-format-ex.ts). 0 on a malformed group, alongside an empty rawCfs -- a real CFEx can legitimately name nID 0, but never resolves anything through an empty rawCfs, so the two degraded groups can never be confused for one another by a lookup. */
+  readonly nID: number;
+  /** This group's own shared ranges, exposed independently of `formats` since a CFEx-promoted rule needs them too and a CF this reader could not promote into `formats` still shares them. */
+  readonly ranges: ContentSheetRange[];
+  /** Every one of this group's CF children, in declared (icf) order, each parsed to its raw operand or undefined for one this reader could not even parse -- CFExNonCF12's own icf field indexes into exactly this collection, regardless of which entries readCf itself went on to promote into `formats`. */
+  readonly rawCfs: readonly (RawCfOperand | undefined)[];
+}
+declare function readCondFmtGroup(records: readonly RecordGroup[], startIndex: number, formulaSheets: FormulaSheetContext): CondFmtGroupResult;
+//#endregion
+export { RawConditionalFormatStyle as a, RawConditionalFormatFill as i, RawCfOperand as n, parseDxfStyle as o, RawConditionalFormat as r, readCondFmtGroup as s, CondFmtGroupResult as t };

package/dist/conditional-format-Cth_afMy.d.cts

@@ -0,0 +1,41 @@
+import { r as FormulaSheetContext } from "./ptg-75v7MhaA.cjs";
+import { t as RecordGroup } from "./substreams-XDNgDvRJ.cjs";
+import { ContentSheetRange, SheetRuleOperator } from "document-schema.js";
+//#region src/workbook/conditional-format.d.ts
+interface RawConditionalFormatFill {
+  readonly fillPattern: number;
+  readonly fillForegroundIcv: number;
+  readonly fillBackgroundIcv: number;
+}
+interface RawConditionalFormatStyle {
+  readonly fontColorIcv: number | undefined;
+  readonly fill: RawConditionalFormatFill | undefined;
+}
+interface RawConditionalFormat {
+  readonly operator: SheetRuleOperator;
+  readonly formula1: string;
+  readonly formula2: string | undefined;
+  readonly style: RawConditionalFormatStyle | undefined;
+  readonly ranges: ContentSheetRange[];
+}
+declare function parseDxfStyle(dxfBytes: Uint8Array<ArrayBuffer>): RawConditionalFormatStyle | undefined;
+/** A CF record's own operand, in its rawest usable form -- the pieces conditional-format-ex.ts needs to resolve a CFEx that extends this specific CF (by icf, a positional index into a CondFmt's own CF children), independent of whether readCf below can promote this CF into a 'cellIs' rule at all. A ct 0x02 formula condition, exactly the kind readCf itself never promotes, is the one CFEx actually cares about (see conditional-format-ex.ts's own top comment for why). */
+interface RawCfOperand {
+  readonly ct: number;
+  readonly cp: number;
+  readonly rgce1: Uint8Array<ArrayBuffer>;
+}
+interface CondFmtGroupResult {
+  readonly formats: RawConditionalFormat[];
+  /** How many records (the CondFmt itself plus every CF it claimed) the caller should advance past, regardless of how many rules actually promoted. */
+  readonly recordsConsumed: number;
+  /** CondFmt's own nID ([MS-XLS] 2.5.56's own CondFmtStructure) -- the identifier a later CFEx record's own nID field cross-references to extend one specific CF child of this group (conditional-format-ex.ts). 0 on a malformed group, alongside an empty rawCfs -- a real CFEx can legitimately name nID 0, but never resolves anything through an empty rawCfs, so the two degraded groups can never be confused for one another by a lookup. */
+  readonly nID: number;
+  /** This group's own shared ranges, exposed independently of `formats` since a CFEx-promoted rule needs them too and a CF this reader could not promote into `formats` still shares them. */
+  readonly ranges: ContentSheetRange[];
+  /** Every one of this group's CF children, in declared (icf) order, each parsed to its raw operand or undefined for one this reader could not even parse -- CFExNonCF12's own icf field indexes into exactly this collection, regardless of which entries readCf itself went on to promote into `formats`. */
+  readonly rawCfs: readonly (RawCfOperand | undefined)[];
+}
+declare function readCondFmtGroup(records: readonly RecordGroup[], startIndex: number, formulaSheets: FormulaSheetContext): CondFmtGroupResult;
+//#endregion
+export { RawConditionalFormatStyle as a, RawConditionalFormatFill as i, RawCfOperand as n, parseDxfStyle as o, RawConditionalFormat as r, readCondFmtGroup as s, CondFmtGroupResult as t };

package/dist/content.cjs

@@ -83,7 +83,7 @@ function mapPrintSettings(raw, names) {
 /**
 * Reads a .xls file's bytes into a ContentDocument.
 *
-* The counterpart of ooxml.js's readXlsxContent, producing the same shape from the older format. `password` decrypts a workbook protected by [MS-XLS] 2.4.117's FilePass record under the [MS-OFFCRYPTO] 2.3.6.1 RC4 encryption header scheme -- see workbook/encryption.ts. It is ignored for an unencrypted workbook, and a missing or incorrect password against an encrypted one throws rather than returning a partial or garbled document.
+* The counterpart of ooxml.js's readXlsxContent, producing the same shape from the older format. `password` decrypts a workbook protected by [MS-XLS] 2.4.117's FilePass record, under either the [MS-OFFCRYPTO] 2.3.6.1 RC4 encryption header scheme or 2.3.7's XOR obfuscation -- see workbook/encryption.ts. It is ignored for an unencrypted workbook, and a missing or incorrect password against an encrypted one throws rather than returning a partial or garbled document.
 */
 function readXlsContent(bytes, password) {
 	const { workbook, metadata } = require_container.readWorkbookStreams(bytes);
@@ -256,6 +256,16 @@ function mapConditionalFormats12(raw, palette) {
 			});
 			continue;
 		}
+		if (format.kind === "containsText" || format.kind === "notContainsText" || format.kind === "beginsWith" || format.kind === "endsWith") {
+			const style = mapConditionalFormatStyle(format.style, palette);
+			results.push({
+				type: format.kind,
+				text: format.text,
+				...style !== void 0 ? { style } : {},
+				...common
+			});
+			continue;
+		}
 		const style = mapConditionalFormatStyle(format.style, palette);
 		results.push({
 			type: format.kind,

package/dist/content.d.cts

@@ -11,7 +11,7 @@ type XlsContentDocument = Extract<ContentDocument, {
 /**
  * Reads a .xls file's bytes into a ContentDocument.
  *
- * The counterpart of ooxml.js's readXlsxContent, producing the same shape from the older format. `password` decrypts a workbook protected by [MS-XLS] 2.4.117's FilePass record under the [MS-OFFCRYPTO] 2.3.6.1 RC4 encryption header scheme -- see workbook/encryption.ts. It is ignored for an unencrypted workbook, and a missing or incorrect password against an encrypted one throws rather than returning a partial or garbled document.
+ * The counterpart of ooxml.js's readXlsxContent, producing the same shape from the older format. `password` decrypts a workbook protected by [MS-XLS] 2.4.117's FilePass record, under either the [MS-OFFCRYPTO] 2.3.6.1 RC4 encryption header scheme or 2.3.7's XOR obfuscation -- see workbook/encryption.ts. It is ignored for an unencrypted workbook, and a missing or incorrect password against an encrypted one throws rather than returning a partial or garbled document.
  */
 declare function readXlsContent(bytes: Uint8Array<ArrayBuffer>, password?: string): XlsContentDocument;
 /** The tree-form read: readXlsContent composed with the schema's own structural transform, exactly as ooxml.js's readXlsx wraps readXlsxContent. */

package/dist/content.d.ts

@@ -11,7 +11,7 @@ type XlsContentDocument = Extract<ContentDocument, {
 /**
  * Reads a .xls file's bytes into a ContentDocument.
  *
- * The counterpart of ooxml.js's readXlsxContent, producing the same shape from the older format. `password` decrypts a workbook protected by [MS-XLS] 2.4.117's FilePass record under the [MS-OFFCRYPTO] 2.3.6.1 RC4 encryption header scheme -- see workbook/encryption.ts. It is ignored for an unencrypted workbook, and a missing or incorrect password against an encrypted one throws rather than returning a partial or garbled document.
+ * The counterpart of ooxml.js's readXlsxContent, producing the same shape from the older format. `password` decrypts a workbook protected by [MS-XLS] 2.4.117's FilePass record, under either the [MS-OFFCRYPTO] 2.3.6.1 RC4 encryption header scheme or 2.3.7's XOR obfuscation -- see workbook/encryption.ts. It is ignored for an unencrypted workbook, and a missing or incorrect password against an encrypted one throws rather than returning a partial or garbled document.
  */
 declare function readXlsContent(bytes: Uint8Array<ArrayBuffer>, password?: string): XlsContentDocument;
 /** The tree-form read: readXlsContent composed with the schema's own structural transform, exactly as ooxml.js's readXlsx wraps readXlsxContent. */