doc-codec 2.3.7 → 2.4.0

package/README.md

@@ -22,6 +22,7 @@ Built and shipped, on the read side:
 - **`readDocContent`** — the whole chain, producing a `'wordprocessing'` `ContentDocument` of paragraphs, runs and tables.
 - **`isDocBytes`** — distinguishes a `.doc` from the `.xls`, `.ppt` and OLE embeddings that share its container, by looking for a `WordDocument` stream carrying `FibBase.wIdent`.
 - **Document metadata** — `title`/`subject`/`author`/`keywords`/`createdIso`/`modifiedIso` read from a `"\x05SummaryInformation"` stream when one is present (see [Metadata](#metadata)); `comments` and `lastPrintedIso` remain unread, since `LayoutMetadata` has no field for either.
+- **RC4-encrypted documents, decrypted for real (ExaDev/documents.js#1113)** — `readDocContent`/`readDocStreams` take an optional `password`, verified against the Table stream's own `EncryptionHeader` before anything is trusted (see [Encryption](#encryption)). XOR obfuscation and RC4 CryptoAPI stay refused, tracked on [ExaDev/documents.js#922](https://github.com/ExaDev/documents.js/issues/922).
 - **Numbering definitions** — `readDocContent`'s own `numbering` field: every list's glyph/format, level-text template, and start-at value, resolved from `PlfLst`/`PlfLfo` and keyed by the same `listId` a paragraph's `ContentParagraph.list.numId` already carries. See [Numbering definitions](#numbering-definitions), which also covers `writeDocContent`'s own inverse.
 - **The one section's own page size and margins** — `prop/sep.ts`'s `readSectionProperties` resolves `PlcfSed`/`Sepx` (`sprmSXaPage`/`sprmSYaPage`/`sprmSDxaLeft`/`sprmSDxaRight`/`sprmSDyaTop`/`sprmSDyaBottom`) into `ContentSection.pageSize`/`.margins`, falling back field by field to Word's own new-document default (US Letter, one-inch margins) for a document carrying no `PlcfSed` at all, or for any one sprm it leaves unstated. This reader only ever resolves the section spanning the whole main document — the "Section boundaries" row below states what "one section" still means.
 
@@ -41,7 +42,7 @@ Built and shipped, on the write side — see [Writing](#writing) for the full sc
 | **Subdocuments**                                                | Only the main document (character positions 0 to `ccpText`) is converted. Footnotes, endnotes, headers, footers, comments and text boxes are not, in either direction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | **Section boundaries**                                          | Section boundaries themselves are not read — the whole document is always treated as one section, spanning the entire main document — so a multi-section `.doc`'s later sections' own page size and margins are never consulted, only the first's (see the read-side page-size/margins bullet above for what is now read of that one section). `writeDocContent` refuses a `ContentDocument` with more than one section, rather than silently merging their content into what would read back as one.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 | **Extended and user-defined document properties**               | `title`/`subject`/`author`/`keywords`/`createdIso`/`modifiedIso` are read from and written to a `"\x05SummaryInformation"` stream when present (see [Metadata](#metadata)); the sibling `"\x05DocumentSummaryInformation"` stream (company, manager, and custom user-defined properties) is not read or written at all.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| **Encryption**                                                  | An encrypted or XOR-obfuscated document is refused with a `DocUnsupportedError` rather than read as plaintext. `writeDocContent` never encrypts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| **Encryption**                                                  | RC4-encrypted documents ([MS-DOC] 2.2.6.2, ExaDev/documents.js#1113) are decrypted given a password -- `readDocContent`/`readDocStreams` take an optional `password`, verified against the Table stream's own EncryptionHeader before anything is trusted (see [Encryption](#encryption) below). XOR obfuscation and RC4 CryptoAPI (a different, newer EncryptionHeader shape) still refuse with a `DocUnsupportedError` rather than being read as plaintext or misread as the wrong scheme. `writeDocContent` never encrypts.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | **`sprmPHugePapx` / `sprmPTableProps`**                         | Paragraph properties stored indirectly in the Data stream are not followed, so such a paragraph reads with fewer properties than it states. [MS-DOC] 2.4.3's own Overview of Tables text names `sprmPTableProps` as a real, legal alternative to `sprmTDefTable` some applications process — but a real producer's row mark is not shown to prefer it: a genuine LibreOffice-authored `.doc` table's own row mark states its TAP through the identical direct `sprmTDefTable` this package's reader and writer already use (confirmed by parsing a LibreOffice 26.2.5.2-authored table's raw `PapxFkp` bytes; see [ExaDev/documents.js#892](https://github.com/ExaDev/documents.js/issues/892)), matching 2.4.3's own compatibility guidance ("An application SHOULD use sprmTDefTable to define table cells for applications that do not process sprmPTableProps"). `writeDocContent` never writes an indirect Papx.                                                                                                                                                          |
 | **Hyperlinks and fields**                                       | `ContentRun.hyperlink`, footnote/comment/annotation references, and every other field or anchor character are read as plain text or dropped (see [What is converted](#what-is-converted)) and are not written.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | **Every FIB field beyond what this package's own reader needs** | `writeDocContent` populates only the fc/lcb pairs its own reader consults (the style sheet, the two property bin tables, the Clx, the font table). Roughly 140 other `FibRgFcLcb97` pairs — `SttbfAssoc`, `Dop`, the printer-driver structures among them — are left zero, which is the format's own "undefined, MUST be ignored" contract for most of them, but not a certification that every third-party [MS-DOC] reader accepts the result; see `fib/write.ts`'s own note.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -170,6 +171,24 @@ The mapping is not 1:1, and each gap is permanent rather than a remaining TODO:
 
 Only the fixed SummaryInformation property set is read or written — the sibling `"\x05DocumentSummaryInformation"` stream (company, manager, and custom user-defined properties, [MS-OLEPS]'s two-property-set spelling) is not attempted at all, an explicit scope boundary `archive-codec`'s own `oleps` support shares.
 
+## Encryption
+
+A `.doc` protected with a password to open uses one of three schemes [MS-DOC] 2.2.6 names, selected by `FibBase`'s own `fEncrypted`/`fObfuscated` flags: RC4 encryption ([MS-DOC] 2.2.6.2, this reader), XOR obfuscation (2.2.6.1), or RC4 CryptoAPI (2.2.6.3, a different, newer `EncryptionHeader` shape). `readDocContent`/`readDocStreams` take an optional `password`, ignored for an unencrypted document; a missing or incorrect password against an RC4-encrypted one throws `DocUnsupportedError` rather than returning a partial or garbled document, and so does an XOR-obfuscated or RC4-CryptoAPI-encrypted one regardless of password, since neither is implemented.
+
+```ts
+import { readDocContent } from "doc-codec";
+
+const document = readDocContent(bytes, "correct horse battery staple");
+```
+
+[MS-DOC] 2.2.6.2's own `EncryptionHeader` _is_ [MS-OFFCRYPTO] 2.3.6.1's RC4 encryption header — byte-identical to what `xls-codec`'s own `FilePass` record carries (ExaDev/documents.js#1108), so `src/encryption.ts` needs no new cryptography, only `archive-codec`'s shared `deriveOfficeRc4BaseHash`/`decryptOfficeRc4` primitives and the doc-specific container layout, which differs from BIFF8's in three real ways rather than being a copy of xls-codec's own scheme:
+
+- **Location.** The `EncryptionHeader` sits unencrypted at the very start of the Table stream (`0Table`/`1Table`, whichever `FibBase.fWhichTblStm` selects), its own byte length given by `FibBase.lKey` — unlike `FilePass`, an inline record within the Workbook stream.
+- **Re-keying interval.** 512 bytes, not `xls-codec`'s 1024 (`archive-codec`'s `OFFICE_RC4_DOC_BLOCK_SIZE`) — a real [MS-DOC]-specific value, confirmed against Apache POI's `BinaryRC4Decryptor` independently of `xls-codec`'s own `Biff8DecryptingStream`.
+- **Per-stream block-zero origin.** WordDocument and Table are each encrypted independently, each with its own block-number counter starting at zero at that stream's own byte 0 — unlike `xls-codec`'s single continuous Workbook-stream offset. WordDocument's own unencrypted prefix is a fixed 68 bytes ([MS-DOC] 2.2.6.1/2.2.6.2's own stated literal); Table's is `FibBase.lKey`, since the `EncryptionHeader` occupying it has to be readable before any key can be derived at all. The Data stream is also encrypted in full per the spec, but this reader does not read the Data stream at all today, so decrypting it is out of scope until something needs to.
+
+`writeDocContent` never encrypts.
+
 ## Writing
 
 `writeDocContent` takes a `'wordprocessing'` `ContentDocument` with exactly one section, an optional `WriteDocContentOptions`, and produces real [MS-DOC] bytes wrapped in a real [MS-CFB] compound file, inverting every read-side structure listed above: a real piece table (`text/piece-table-write.ts`, always one uncompressed 16-bit piece — see [Why always uncompressed](#why-the-writer-always-writes-uncompressed-text)), `Sprm`-encoded grpprls for each run's and paragraph's own direct formatting (`prop/chp-write.ts`, `prop/pap-write.ts`), `ChpxFkp`/`PapxFkp` pages packed and split across as many 512-byte pages as the content needs (`prop/fkp-write.ts`), a real style sheet minting one entry per distinct `styleId`/`headingLevel` a document's paragraphs actually use (`style/stsh.ts`'s `buildStshForStyles`, [ExaDev/documents.js#1059](https://github.com/ExaDev/documents.js/issues/1059) — identity only, no formatting of a style's own; `FibRgFcLcb97.lcbStshf` "MUST be a nonzero value", so a document is never written without one, even one carrying zero styles, though this package's own reader tolerates a missing one), and a font table when at least one run names a font (`style/fonts.ts`). `WriteDocContentOptions.onWarning`, when given, is called for a non-fatal write-time degradation this writer chooses over throwing — today, only the lost-boundary fallback's own per-row budget check (see [Tables](#tables)'s own note on [ExaDev/documents.js#1013](https://github.com/ExaDev/documents.js/issues/1013)) — but that is not a guarantee the write itself goes on to succeed: a row whose own assigned lost boundaries cannot be trimmed down to a split that fits at all still reports one warning, describing its boundaries as unrecoverable and its fully-unsplit encoding as the fallback being attempted — and, should that unsplit encoding also overflow the row's own byte budget once `buildPapxPages` actually packs it, `writeDocContent` can still throw further down the same pipeline, after any rows still to come have had their own chance to report a warning: a caller can genuinely see this warning followed by a hard failure, but not necessarily right away, and not necessarily for the row whose warning it just read, since `buildPapxPages` packs paragraphs in document order and can fail first on an earlier row that also overflowed. Every genuine refusal this writer makes outright — the kinds named in the table below — still throws `DocFormatError`/`DocUnsupportedError` directly, with no warning first.
@@ -274,7 +293,7 @@ const written = writeDocContent({
 });
 ```
 
-`readDocContent` throws a `DocFormatError` when the bytes do not conform to [MS-DOC], and a `DocUnsupportedError` when they conform but use a feature this package deliberately refuses rather than approximates (encryption, or the `sprmPChgTabs` sentinel above). `writeDocContent` throws a `DocUnsupportedError` for a document, section count, or block kind outside its own scope (see [Writing](#writing)) and a `DocFormatError` for a value that would need a property out of a sprm's own operand range (a font size or indent too large to fit its 2-byte operand, for instance).
+`readDocContent` throws a `DocFormatError` when the bytes do not conform to [MS-DOC], and a `DocUnsupportedError` when they conform but use a feature this package deliberately refuses rather than approximates (XOR obfuscation or RC4 CryptoAPI encryption, an RC4-encrypted document given no password or the wrong one, or the `sprmPChgTabs` sentinel above). `writeDocContent` throws a `DocUnsupportedError` for a document, section count, or block kind outside its own scope (see [Writing](#writing)) and a `DocFormatError` for a value that would need a property out of a sprm's own operand range (a font size or indent too large to fit its 2-byte operand, for instance).
 
 ## Worker-isomorphic
 

package/dist/encryption.cjs

@@ -0,0 +1,70 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("./errors.cjs");
+const require_bytes = require("./bytes.cjs");
+require("./fib/offsets.cjs");
+let archive_codec = require("archive-codec");
+//#region src/encryption.ts
+/** [MS-DOC] 2.2.6.2's own EncryptionHeader field layout, byte offsets within the Table stream's own first FibBase.lKey bytes: EncryptionVersionInfo (vMajor/vMinor, 2 bytes each) at 0, then Salt/EncryptedVerifier/EncryptedVerifierHash, each OFFICE_RC4_VERIFIER_LENGTH (16) bytes, back to back. */
+const HEADER_OFFSET = {
+	versionMajor: 0,
+	versionMinor: 2,
+	salt: 4,
+	encryptedVerifier: 4 + archive_codec.OFFICE_RC4_VERIFIER_LENGTH,
+	encryptedVerifierHash: 4 + archive_codec.OFFICE_RC4_VERIFIER_LENGTH * 2
+};
+/** The RC4 (non-CryptoAPI) EncryptionHeader's own total size -- EncryptionVersionInfo(4) + Salt(16) + EncryptedVerifier(16) + EncryptedVerifierHash(16). Used only to slice the header's own fields out of the Table stream; the actual unencrypted-prefix boundary for decrypting the rest of the Table stream is FibBase.lKey itself (see this file's own top comment), not this constant. */
+const RC4_HEADER_SIZE = 4 + archive_codec.OFFICE_RC4_VERIFIER_LENGTH * 3;
+/** [MS-DOC] 2.2.6.2/2.2.6.1's own literal, stated identically in both sections: the WordDocument stream's initial 68 bytes are never encrypted regardless of scheme. Not further decomposed by the spec into named sub-fields covering exactly this span, so it is carried here as the constant the spec itself states rather than derived from FibBase's own field sizes (which do not sum to 68). */
+const WORD_DOCUMENT_UNENCRYPTED_PREFIX = 68;
+/** [MS-OFFCRYPTO] 2.3.6.1's own EncryptionVersionInfo values naming the plain "RC4 encryption header" this module implements; vMajor 2-4 with vMinor 2 names RC4 CryptoAPI (2.2.6.3) instead, a different header shape this module rejects rather than misreads. */
+const RC4_HEADER_VERSION_MAJOR = 1;
+const RC4_HEADER_VERSION_MINOR = 1;
+/** A bounds-checked subarray that keeps the `Uint8Array<ArrayBuffer>` generic parameter archive-codec's own crypto functions require -- bytes.ts's own `slice` returns a bare `Uint8Array`, which is doc-codec's own convention everywhere else but too wide here, since `md5`/`rc4` construct a `DataView` directly over the buffer and need to know it genuinely is one, not just ArrayBufferLike. */
+function checkedSubarray(bytes, offset, length, what) {
+	if (offset + length > bytes.length) throw new require_errors.DocFormatError(`${what} read of ${length} bytes at offset ${offset} runs past the end of a ${bytes.length}-byte stream`);
+	return bytes.subarray(offset, offset + length);
+}
+/** Reads the EncryptionHeader from the Table stream's own first RC4_HEADER_SIZE bytes, rejecting RC4 CryptoAPI by its own EncryptionVersionInfo rather than misreading it as the plain RC4 header. */
+function readRc4Header(table) {
+	const header = checkedSubarray(table, 0, RC4_HEADER_SIZE, "EncryptionHeader");
+	const versionMajor = require_bytes.readUint16LE(header, HEADER_OFFSET.versionMajor);
+	const versionMinor = require_bytes.readUint16LE(header, HEADER_OFFSET.versionMinor);
+	if (versionMajor !== RC4_HEADER_VERSION_MAJOR || versionMinor !== RC4_HEADER_VERSION_MINOR) throw new require_errors.DocUnsupportedError(`this document uses RC4 CryptoAPI encryption (EncryptionVersionInfo ${versionMajor}.${versionMinor}, [MS-DOC] 2.2.6.3), which this reader does not decrypt`);
+	return {
+		salt: checkedSubarray(header, HEADER_OFFSET.salt, archive_codec.OFFICE_RC4_VERIFIER_LENGTH, "EncryptionHeader.Salt"),
+		encryptedVerifier: checkedSubarray(header, HEADER_OFFSET.encryptedVerifier, archive_codec.OFFICE_RC4_VERIFIER_LENGTH, "EncryptionHeader.EncryptedVerifier"),
+		encryptedVerifierHash: checkedSubarray(header, HEADER_OFFSET.encryptedVerifierHash, archive_codec.OFFICE_RC4_VERIFIER_LENGTH, "EncryptionHeader.EncryptedVerifierHash")
+	};
+}
+/** [MS-OFFCRYPTO] 2.3.6.4's own password verification, identical to xls-codec's own workbook/encryption.ts: block 0's key decrypts EncryptedVerifier, then EncryptedVerifierHash continuing the same keystream, and MD5 of the decrypted verifier must equal the decrypted hash. */
+function verifyPassword(baseHash, header) {
+	const decryptedVerifier = (0, archive_codec.decryptOfficeRc4)(baseHash, 0, header.encryptedVerifier, archive_codec.OFFICE_RC4_DOC_BLOCK_SIZE);
+	const decryptedVerifierHash = (0, archive_codec.decryptOfficeRc4)(baseHash, archive_codec.OFFICE_RC4_VERIFIER_LENGTH, header.encryptedVerifierHash, archive_codec.OFFICE_RC4_DOC_BLOCK_SIZE);
+	const computedHash = (0, archive_codec.md5)(decryptedVerifier);
+	if (!(computedHash.length === decryptedVerifierHash.length && computedHash.every((byte, index) => byte === decryptedVerifierHash[index]))) throw new require_errors.DocUnsupportedError("incorrect password for RC4-encrypted document");
+}
+/** Decrypts everything after `prefixLength` bytes of `stream`, leaving the prefix itself untouched -- WORD_DOCUMENT_UNENCRYPTED_PREFIX for WordDocument, FibBase.lKey for Table, each stream's own block-number counter starting fresh at its own byte 0 (this file's own top comment, point 3). */
+function decryptStream(baseHash, stream, prefixLength) {
+	const decrypted = new Uint8Array(stream.length);
+	decrypted.set(stream.subarray(0, prefixLength), 0);
+	decrypted.set((0, archive_codec.decryptOfficeRc4)(baseHash, prefixLength, stream.subarray(prefixLength), archive_codec.OFFICE_RC4_DOC_BLOCK_SIZE), prefixLength);
+	return decrypted;
+}
+/**
+* Decrypts an RC4-encrypted (fEncrypted=1, fObfuscated=0) document's WordDocument and Table streams given the password, verifying it first against the Table stream's own EncryptionHeader.
+*
+* Throws `DocUnsupportedError` for a missing password, an incorrect one, or an encryption scheme this module does not implement (RC4 CryptoAPI) -- there is no partial or best-effort result to return in any of those cases.
+*/
+function decryptDocStreams(wordDocument, table, password) {
+	if (password === void 0) throw new require_errors.DocUnsupportedError("this document is RC4-encrypted ([MS-DOC] 2.2.6.2); call readDocContent with a password to decrypt it");
+	const header = readRc4Header(table);
+	const baseHash = (0, archive_codec.deriveOfficeRc4BaseHash)(password, header.salt);
+	verifyPassword(baseHash, header);
+	const lKey = require_bytes.readUint32LE(wordDocument, 14);
+	return {
+		wordDocument: decryptStream(baseHash, wordDocument, WORD_DOCUMENT_UNENCRYPTED_PREFIX),
+		table: decryptStream(baseHash, table, lKey)
+	};
+}
+//#endregion
+exports.decryptDocStreams = decryptDocStreams;

package/dist/encryption.d.cts

@@ -0,0 +1,13 @@
+//#region src/encryption.d.ts
+interface DecryptedDocStreams {
+  readonly wordDocument: Uint8Array<ArrayBuffer>;
+  readonly table: Uint8Array<ArrayBuffer>;
+}
+/**
+ * Decrypts an RC4-encrypted (fEncrypted=1, fObfuscated=0) document's WordDocument and Table streams given the password, verifying it first against the Table stream's own EncryptionHeader.
+ *
+ * Throws `DocUnsupportedError` for a missing password, an incorrect one, or an encryption scheme this module does not implement (RC4 CryptoAPI) -- there is no partial or best-effort result to return in any of those cases.
+ */
+declare function decryptDocStreams(wordDocument: Uint8Array<ArrayBuffer>, table: Uint8Array<ArrayBuffer>, password: string | undefined): DecryptedDocStreams;
+//#endregion
+export { DecryptedDocStreams, decryptDocStreams };

package/dist/encryption.d.ts

@@ -0,0 +1,13 @@
+//#region src/encryption.d.ts
+interface DecryptedDocStreams {
+  readonly wordDocument: Uint8Array<ArrayBuffer>;
+  readonly table: Uint8Array<ArrayBuffer>;
+}
+/**
+ * Decrypts an RC4-encrypted (fEncrypted=1, fObfuscated=0) document's WordDocument and Table streams given the password, verifying it first against the Table stream's own EncryptionHeader.
+ *
+ * Throws `DocUnsupportedError` for a missing password, an incorrect one, or an encryption scheme this module does not implement (RC4 CryptoAPI) -- there is no partial or best-effort result to return in any of those cases.
+ */
+declare function decryptDocStreams(wordDocument: Uint8Array<ArrayBuffer>, table: Uint8Array<ArrayBuffer>, password: string | undefined): DecryptedDocStreams;
+//#endregion
+export { DecryptedDocStreams, decryptDocStreams };

package/dist/encryption.js

@@ -0,0 +1,69 @@
+import { DocFormatError, DocUnsupportedError } from "./errors.js";
+import { readUint16LE, readUint32LE } from "./bytes.js";
+import "./fib/offsets.js";
+import { OFFICE_RC4_DOC_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, md5 } from "archive-codec";
+//#region src/encryption.ts
+/** [MS-DOC] 2.2.6.2's own EncryptionHeader field layout, byte offsets within the Table stream's own first FibBase.lKey bytes: EncryptionVersionInfo (vMajor/vMinor, 2 bytes each) at 0, then Salt/EncryptedVerifier/EncryptedVerifierHash, each OFFICE_RC4_VERIFIER_LENGTH (16) bytes, back to back. */
+const HEADER_OFFSET = {
+	versionMajor: 0,
+	versionMinor: 2,
+	salt: 4,
+	encryptedVerifier: 4 + OFFICE_RC4_VERIFIER_LENGTH,
+	encryptedVerifierHash: 4 + OFFICE_RC4_VERIFIER_LENGTH * 2
+};
+/** The RC4 (non-CryptoAPI) EncryptionHeader's own total size -- EncryptionVersionInfo(4) + Salt(16) + EncryptedVerifier(16) + EncryptedVerifierHash(16). Used only to slice the header's own fields out of the Table stream; the actual unencrypted-prefix boundary for decrypting the rest of the Table stream is FibBase.lKey itself (see this file's own top comment), not this constant. */
+const RC4_HEADER_SIZE = 4 + OFFICE_RC4_VERIFIER_LENGTH * 3;
+/** [MS-DOC] 2.2.6.2/2.2.6.1's own literal, stated identically in both sections: the WordDocument stream's initial 68 bytes are never encrypted regardless of scheme. Not further decomposed by the spec into named sub-fields covering exactly this span, so it is carried here as the constant the spec itself states rather than derived from FibBase's own field sizes (which do not sum to 68). */
+const WORD_DOCUMENT_UNENCRYPTED_PREFIX = 68;
+/** [MS-OFFCRYPTO] 2.3.6.1's own EncryptionVersionInfo values naming the plain "RC4 encryption header" this module implements; vMajor 2-4 with vMinor 2 names RC4 CryptoAPI (2.2.6.3) instead, a different header shape this module rejects rather than misreads. */
+const RC4_HEADER_VERSION_MAJOR = 1;
+const RC4_HEADER_VERSION_MINOR = 1;
+/** A bounds-checked subarray that keeps the `Uint8Array<ArrayBuffer>` generic parameter archive-codec's own crypto functions require -- bytes.ts's own `slice` returns a bare `Uint8Array`, which is doc-codec's own convention everywhere else but too wide here, since `md5`/`rc4` construct a `DataView` directly over the buffer and need to know it genuinely is one, not just ArrayBufferLike. */
+function checkedSubarray(bytes, offset, length, what) {
+	if (offset + length > bytes.length) throw new DocFormatError(`${what} read of ${length} bytes at offset ${offset} runs past the end of a ${bytes.length}-byte stream`);
+	return bytes.subarray(offset, offset + length);
+}
+/** Reads the EncryptionHeader from the Table stream's own first RC4_HEADER_SIZE bytes, rejecting RC4 CryptoAPI by its own EncryptionVersionInfo rather than misreading it as the plain RC4 header. */
+function readRc4Header(table) {
+	const header = checkedSubarray(table, 0, RC4_HEADER_SIZE, "EncryptionHeader");
+	const versionMajor = readUint16LE(header, HEADER_OFFSET.versionMajor);
+	const versionMinor = readUint16LE(header, HEADER_OFFSET.versionMinor);
+	if (versionMajor !== RC4_HEADER_VERSION_MAJOR || versionMinor !== RC4_HEADER_VERSION_MINOR) throw new DocUnsupportedError(`this document uses RC4 CryptoAPI encryption (EncryptionVersionInfo ${versionMajor}.${versionMinor}, [MS-DOC] 2.2.6.3), which this reader does not decrypt`);
+	return {
+		salt: checkedSubarray(header, HEADER_OFFSET.salt, OFFICE_RC4_VERIFIER_LENGTH, "EncryptionHeader.Salt"),
+		encryptedVerifier: checkedSubarray(header, HEADER_OFFSET.encryptedVerifier, OFFICE_RC4_VERIFIER_LENGTH, "EncryptionHeader.EncryptedVerifier"),
+		encryptedVerifierHash: checkedSubarray(header, HEADER_OFFSET.encryptedVerifierHash, OFFICE_RC4_VERIFIER_LENGTH, "EncryptionHeader.EncryptedVerifierHash")
+	};
+}
+/** [MS-OFFCRYPTO] 2.3.6.4's own password verification, identical to xls-codec's own workbook/encryption.ts: block 0's key decrypts EncryptedVerifier, then EncryptedVerifierHash continuing the same keystream, and MD5 of the decrypted verifier must equal the decrypted hash. */
+function verifyPassword(baseHash, header) {
+	const decryptedVerifier = decryptOfficeRc4(baseHash, 0, header.encryptedVerifier, OFFICE_RC4_DOC_BLOCK_SIZE);
+	const decryptedVerifierHash = decryptOfficeRc4(baseHash, OFFICE_RC4_VERIFIER_LENGTH, header.encryptedVerifierHash, OFFICE_RC4_DOC_BLOCK_SIZE);
+	const computedHash = md5(decryptedVerifier);
+	if (!(computedHash.length === decryptedVerifierHash.length && computedHash.every((byte, index) => byte === decryptedVerifierHash[index]))) throw new DocUnsupportedError("incorrect password for RC4-encrypted document");
+}
+/** Decrypts everything after `prefixLength` bytes of `stream`, leaving the prefix itself untouched -- WORD_DOCUMENT_UNENCRYPTED_PREFIX for WordDocument, FibBase.lKey for Table, each stream's own block-number counter starting fresh at its own byte 0 (this file's own top comment, point 3). */
+function decryptStream(baseHash, stream, prefixLength) {
+	const decrypted = new Uint8Array(stream.length);
+	decrypted.set(stream.subarray(0, prefixLength), 0);
+	decrypted.set(decryptOfficeRc4(baseHash, prefixLength, stream.subarray(prefixLength), OFFICE_RC4_DOC_BLOCK_SIZE), prefixLength);
+	return decrypted;
+}
+/**
+* Decrypts an RC4-encrypted (fEncrypted=1, fObfuscated=0) document's WordDocument and Table streams given the password, verifying it first against the Table stream's own EncryptionHeader.
+*
+* Throws `DocUnsupportedError` for a missing password, an incorrect one, or an encryption scheme this module does not implement (RC4 CryptoAPI) -- there is no partial or best-effort result to return in any of those cases.
+*/
+function decryptDocStreams(wordDocument, table, password) {
+	if (password === void 0) throw new DocUnsupportedError("this document is RC4-encrypted ([MS-DOC] 2.2.6.2); call readDocContent with a password to decrypt it");
+	const header = readRc4Header(table);
+	const baseHash = deriveOfficeRc4BaseHash(password, header.salt);
+	verifyPassword(baseHash, header);
+	const lKey = readUint32LE(wordDocument, 14);
+	return {
+		wordDocument: decryptStream(baseHash, wordDocument, WORD_DOCUMENT_UNENCRYPTED_PREFIX),
+		table: decryptStream(baseHash, table, lKey)
+	};
+}
+//#endregion
+export { decryptDocStreams };

package/dist/fib/fib.cjs

@@ -3,12 +3,20 @@ const require_errors = require("../errors.cjs");
 const require_bytes = require("../bytes.cjs");
 const require_fib_offsets = require("./offsets.cjs");
 //#region src/fib/fib.ts
+/** FibBase's own encryption-related flags and stream selector, [MS-DOC] 2.5.2 -- every one of them sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so this is always safely readable regardless of whether the document is actually encrypted, unlike parseFib's own later reads. read.ts calls this before choosing whether to decrypt and which Table stream to read, since both decisions have to be made before parseFib can run on a genuinely encrypted document -- parseFib itself no longer checks fEncrypted at all; a caller reading raw, still-encrypted bytes into it is a caller bug read.ts's own orchestration exists to prevent. */
+function peekFibBaseFlags(wordDocument) {
+	const flags = require_bytes.readUint16LE(wordDocument, 10);
+	return {
+		fEncrypted: (flags & require_fib_offsets.FIB_BASE_FLAG.fEncrypted) !== 0,
+		fObfuscated: (flags & require_fib_offsets.FIB_BASE_FLAG.fObfuscated) !== 0,
+		fWhichTblStm: (flags & require_fib_offsets.FIB_BASE_FLAG.fWhichTblStm) !== 0 ? 1 : 0
+	};
+}
 function parseFib(wordDocument) {
 	const wIdent = require_bytes.readUint16LE(wordDocument, 0);
 	if (wIdent !== 42476) throw new require_errors.DocFormatError(`the WordDocument stream begins with 0x${wIdent.toString(16).toUpperCase().padStart(4, "0")} rather than the 0xA5EC every Word Binary File's FibBase.wIdent must carry`);
 	const nFib = require_bytes.readUint16LE(wordDocument, 2);
 	const flags = require_bytes.readUint16LE(wordDocument, 10);
-	if ((flags & require_fib_offsets.FIB_BASE_FLAG.fEncrypted) !== 0) throw new require_errors.DocUnsupportedError((flags & require_fib_offsets.FIB_BASE_FLAG.fObfuscated) !== 0 ? "this document is XOR-obfuscated ([MS-DOC] 2.2.6.1); doc-codec cannot decrypt it, and reading its streams as plaintext would produce arbitrary text rather than the document's own" : "this document is encrypted ([MS-DOC] 2.2.6); doc-codec cannot decrypt it, and reading its streams as plaintext would produce arbitrary text rather than the document's own");
 	const csw = require_bytes.readUint16LE(wordDocument, 32);
 	if (csw !== 14) throw new require_errors.DocFormatError(`Fib.csw is 0x${csw.toString(16)} rather than the mandated 0x${14 .toString(16)}, so FibRgW97 is not the size every later offset assumes`);
 	const cslw = require_bytes.readUint16LE(wordDocument, 62);
@@ -55,4 +63,5 @@ function tableStreamName(fib) {
 }
 //#endregion
 exports.parseFib = parseFib;
+exports.peekFibBaseFlags = peekFibBaseFlags;
 exports.tableStreamName = tableStreamName;

package/dist/fib/fib.d.cts

@@ -1,2 +1,2 @@
-import { n as parseFib, r as tableStreamName, t as Fib } from "../fib-CtsLtF96.cjs";
-export { Fib, parseFib, tableStreamName };
+import { i as tableStreamName, n as parseFib, r as peekFibBaseFlags, t as Fib } from "../fib-DWFta19r.cjs";
+export { Fib, parseFib, peekFibBaseFlags, tableStreamName };

package/dist/fib/fib.d.ts

@@ -1,2 +1,2 @@
-import { n as parseFib, r as tableStreamName, t as Fib } from "../fib-CtsLtF96.js";
-export { Fib, parseFib, tableStreamName };
+import { i as tableStreamName, n as parseFib, r as peekFibBaseFlags, t as Fib } from "../fib-DWFta19r.js";
+export { Fib, parseFib, peekFibBaseFlags, tableStreamName };

package/dist/fib/fib.js

@@ -1,13 +1,21 @@
-import { DocFormatError, DocUnsupportedError } from "../errors.js";
+import { DocFormatError } from "../errors.js";
 import { readInt32LE, readUint16LE, readUint32LE } from "../bytes.js";
 import { FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, LW_OFFSET } from "./offsets.js";
 //#region src/fib/fib.ts
+/** FibBase's own encryption-related flags and stream selector, [MS-DOC] 2.5.2 -- every one of them sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so this is always safely readable regardless of whether the document is actually encrypted, unlike parseFib's own later reads. read.ts calls this before choosing whether to decrypt and which Table stream to read, since both decisions have to be made before parseFib can run on a genuinely encrypted document -- parseFib itself no longer checks fEncrypted at all; a caller reading raw, still-encrypted bytes into it is a caller bug read.ts's own orchestration exists to prevent. */
+function peekFibBaseFlags(wordDocument) {
+	const flags = readUint16LE(wordDocument, 10);
+	return {
+		fEncrypted: (flags & FIB_BASE_FLAG.fEncrypted) !== 0,
+		fObfuscated: (flags & FIB_BASE_FLAG.fObfuscated) !== 0,
+		fWhichTblStm: (flags & FIB_BASE_FLAG.fWhichTblStm) !== 0 ? 1 : 0
+	};
+}
 function parseFib(wordDocument) {
 	const wIdent = readUint16LE(wordDocument, 0);
 	if (wIdent !== 42476) throw new DocFormatError(`the WordDocument stream begins with 0x${wIdent.toString(16).toUpperCase().padStart(4, "0")} rather than the 0xA5EC every Word Binary File's FibBase.wIdent must carry`);
 	const nFib = readUint16LE(wordDocument, 2);
 	const flags = readUint16LE(wordDocument, 10);
-	if ((flags & FIB_BASE_FLAG.fEncrypted) !== 0) throw new DocUnsupportedError((flags & FIB_BASE_FLAG.fObfuscated) !== 0 ? "this document is XOR-obfuscated ([MS-DOC] 2.2.6.1); doc-codec cannot decrypt it, and reading its streams as plaintext would produce arbitrary text rather than the document's own" : "this document is encrypted ([MS-DOC] 2.2.6); doc-codec cannot decrypt it, and reading its streams as plaintext would produce arbitrary text rather than the document's own");
 	const csw = readUint16LE(wordDocument, 32);
 	if (csw !== 14) throw new DocFormatError(`Fib.csw is 0x${csw.toString(16)} rather than the mandated 0x${14 .toString(16)}, so FibRgW97 is not the size every later offset assumes`);
 	const cslw = readUint16LE(wordDocument, 62);
@@ -53,4 +61,4 @@ function tableStreamName(fib) {
 	return fib.fWhichTblStm === 1 ? "1Table" : "0Table";
 }
 //#endregion
-export { parseFib, tableStreamName };
+export { parseFib, peekFibBaseFlags, tableStreamName };

package/dist/fib/offsets.cjs

@@ -2,6 +2,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/fib/offsets.ts
 /** FibBase, [MS-DOC] 2.5.2 -- the fixed 32-byte head of every Fib. csw, the count of 16-bit values in FibRgW97, sits immediately after it, so this doubles as csw's own offset. */
 const FIB_BASE_SIZE = 32;
+/** FibBase.lKey, [MS-DOC] 2.5.2 -- a 4-byte field at offset 14 (after wIdent, nFib, unused, lid, pnNext, and the flags word), meaningful only when fEncrypted is 1: the XOR obfuscation password verifier when fObfuscated is also 1, or the byte size of the EncryptionHeader stored at the start of the Table stream when fObfuscated is 0 ([MS-DOC] 2.2.6.2/encryption.ts). Otherwise MUST be 0. Sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so it is always safely readable regardless of the document's own encryption status. */
+const FIB_LKEY_OFFSET = 14;
 /** csw MUST be 0x000E, fixing FibRgW97 at 28 bytes and every offset after it. */
 const FIB_CSW_REQUIRED = 14;
 /** FibRgW97, [MS-DOC] 2.5.3 -- 14 16-bit values, none of which this reader needs. */
@@ -61,6 +63,7 @@ exports.FIB_CSLW_OFFSET = FIB_CSLW_OFFSET;
 exports.FIB_CSLW_REQUIRED = FIB_CSLW_REQUIRED;
 exports.FIB_CSW_REQUIRED = FIB_CSW_REQUIRED;
 exports.FIB_FC_LCB_BLOB_OFFSET = FIB_FC_LCB_BLOB_OFFSET;
+exports.FIB_LKEY_OFFSET = FIB_LKEY_OFFSET;
 exports.FIB_RG_LW_OFFSET = FIB_RG_LW_OFFSET;
 exports.FIB_RG_LW_SIZE = FIB_RG_LW_SIZE;
 exports.FIB_RG_W_OFFSET = FIB_RG_W_OFFSET;

package/dist/fib/offsets.d.cts

@@ -1,6 +1,8 @@
 //#region src/fib/offsets.d.ts
 /** FibBase, [MS-DOC] 2.5.2 -- the fixed 32-byte head of every Fib. csw, the count of 16-bit values in FibRgW97, sits immediately after it, so this doubles as csw's own offset. */
 declare const FIB_BASE_SIZE = 32;
+/** FibBase.lKey, [MS-DOC] 2.5.2 -- a 4-byte field at offset 14 (after wIdent, nFib, unused, lid, pnNext, and the flags word), meaningful only when fEncrypted is 1: the XOR obfuscation password verifier when fObfuscated is also 1, or the byte size of the EncryptionHeader stored at the start of the Table stream when fObfuscated is 0 ([MS-DOC] 2.2.6.2/encryption.ts). Otherwise MUST be 0. Sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so it is always safely readable regardless of the document's own encryption status. */
+declare const FIB_LKEY_OFFSET = 14;
 /** csw MUST be 0x000E, fixing FibRgW97 at 28 bytes and every offset after it. */
 declare const FIB_CSW_REQUIRED = 14;
 /** FibRgW97, [MS-DOC] 2.5.3 -- 14 16-bit values, none of which this reader needs. */
@@ -52,4 +54,4 @@ declare const FIB_BASE_FLAG: {
 };
 declare const FIB_W_IDENT = 42476;
 //#endregion
-export { FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, LW_OFFSET };
+export { FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_LKEY_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, LW_OFFSET };

package/dist/fib/offsets.d.ts

@@ -1,6 +1,8 @@
 //#region src/fib/offsets.d.ts
 /** FibBase, [MS-DOC] 2.5.2 -- the fixed 32-byte head of every Fib. csw, the count of 16-bit values in FibRgW97, sits immediately after it, so this doubles as csw's own offset. */
 declare const FIB_BASE_SIZE = 32;
+/** FibBase.lKey, [MS-DOC] 2.5.2 -- a 4-byte field at offset 14 (after wIdent, nFib, unused, lid, pnNext, and the flags word), meaningful only when fEncrypted is 1: the XOR obfuscation password verifier when fObfuscated is also 1, or the byte size of the EncryptionHeader stored at the start of the Table stream when fObfuscated is 0 ([MS-DOC] 2.2.6.2/encryption.ts). Otherwise MUST be 0. Sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so it is always safely readable regardless of the document's own encryption status. */
+declare const FIB_LKEY_OFFSET = 14;
 /** csw MUST be 0x000E, fixing FibRgW97 at 28 bytes and every offset after it. */
 declare const FIB_CSW_REQUIRED = 14;
 /** FibRgW97, [MS-DOC] 2.5.3 -- 14 16-bit values, none of which this reader needs. */
@@ -52,4 +54,4 @@ declare const FIB_BASE_FLAG: {
 };
 declare const FIB_W_IDENT = 42476;
 //#endregion
-export { FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, LW_OFFSET };
+export { FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_LKEY_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, LW_OFFSET };

package/dist/fib/offsets.js

@@ -1,6 +1,8 @@
 //#region src/fib/offsets.ts
 /** FibBase, [MS-DOC] 2.5.2 -- the fixed 32-byte head of every Fib. csw, the count of 16-bit values in FibRgW97, sits immediately after it, so this doubles as csw's own offset. */
 const FIB_BASE_SIZE = 32;
+/** FibBase.lKey, [MS-DOC] 2.5.2 -- a 4-byte field at offset 14 (after wIdent, nFib, unused, lid, pnNext, and the flags word), meaningful only when fEncrypted is 1: the XOR obfuscation password verifier when fObfuscated is also 1, or the byte size of the EncryptionHeader stored at the start of the Table stream when fObfuscated is 0 ([MS-DOC] 2.2.6.2/encryption.ts). Otherwise MUST be 0. Sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so it is always safely readable regardless of the document's own encryption status. */
+const FIB_LKEY_OFFSET = 14;
 /** csw MUST be 0x000E, fixing FibRgW97 at 28 bytes and every offset after it. */
 const FIB_CSW_REQUIRED = 14;
 /** FibRgW97, [MS-DOC] 2.5.3 -- 14 16-bit values, none of which this reader needs. */
@@ -52,4 +54,4 @@ const FIB_BASE_FLAG = {
 };
 const FIB_W_IDENT = 42476;
 //#endregion
-export { FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, LW_OFFSET };
+export { FC_LCB_VALUE_INDEX, FIB_BASE_FLAG, FIB_BASE_SIZE, FIB_CB_RG_FC_LCB_OFFSET, FIB_CSLW_OFFSET, FIB_CSLW_REQUIRED, FIB_CSW_REQUIRED, FIB_FC_LCB_BLOB_OFFSET, FIB_LKEY_OFFSET, FIB_RG_LW_OFFSET, FIB_RG_LW_SIZE, FIB_RG_W_OFFSET, FIB_RG_W_SIZE, FIB_W_IDENT, LW_OFFSET };

package/dist/{fib-CtsLtF96.d.cts → fib-DWFta19r.d.cts}

@@ -30,8 +30,14 @@ interface Fib {
   readonly fcPlfLfo: number;
   readonly lcbPlfLfo: number;
 }
+/** FibBase's own encryption-related flags and stream selector, [MS-DOC] 2.5.2 -- every one of them sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so this is always safely readable regardless of whether the document is actually encrypted, unlike parseFib's own later reads. read.ts calls this before choosing whether to decrypt and which Table stream to read, since both decisions have to be made before parseFib can run on a genuinely encrypted document -- parseFib itself no longer checks fEncrypted at all; a caller reading raw, still-encrypted bytes into it is a caller bug read.ts's own orchestration exists to prevent. */
+declare function peekFibBaseFlags(wordDocument: Uint8Array): {
+  readonly fEncrypted: boolean;
+  readonly fObfuscated: boolean;
+  readonly fWhichTblStm: 0 | 1;
+};
 declare function parseFib(wordDocument: Uint8Array): Fib;
 /** The name of the compound-file stream every `fc` offset in the Fib is relative to, selected by FibBase.fWhichTblStm. */
 declare function tableStreamName(fib: Fib): "0Table" | "1Table";
 //#endregion
-export { parseFib as n, tableStreamName as r, Fib as t };
+export { tableStreamName as i, parseFib as n, peekFibBaseFlags as r, Fib as t };

package/dist/{fib-CtsLtF96.d.ts → fib-DWFta19r.d.ts}

@@ -30,8 +30,14 @@ interface Fib {
   readonly fcPlfLfo: number;
   readonly lcbPlfLfo: number;
 }
+/** FibBase's own encryption-related flags and stream selector, [MS-DOC] 2.5.2 -- every one of them sits within the 68-byte prefix [MS-DOC] 2.2.6.2 leaves unencrypted, so this is always safely readable regardless of whether the document is actually encrypted, unlike parseFib's own later reads. read.ts calls this before choosing whether to decrypt and which Table stream to read, since both decisions have to be made before parseFib can run on a genuinely encrypted document -- parseFib itself no longer checks fEncrypted at all; a caller reading raw, still-encrypted bytes into it is a caller bug read.ts's own orchestration exists to prevent. */
+declare function peekFibBaseFlags(wordDocument: Uint8Array): {
+  readonly fEncrypted: boolean;
+  readonly fObfuscated: boolean;
+  readonly fWhichTblStm: 0 | 1;
+};
 declare function parseFib(wordDocument: Uint8Array): Fib;
 /** The name of the compound-file stream every `fc` offset in the Fib is relative to, selected by FibBase.fWhichTblStm. */
 declare function tableStreamName(fib: Fib): "0Table" | "1Table";
 //#endregion
-export { parseFib as n, tableStreamName as r, Fib as t };
+export { tableStreamName as i, parseFib as n, peekFibBaseFlags as r, Fib as t };

package/dist/index.cjs

@@ -39,6 +39,7 @@ exports.FIB_CSLW_OFFSET = require_fib_offsets.FIB_CSLW_OFFSET;
 exports.FIB_CSLW_REQUIRED = require_fib_offsets.FIB_CSLW_REQUIRED;
 exports.FIB_CSW_REQUIRED = require_fib_offsets.FIB_CSW_REQUIRED;
 exports.FIB_FC_LCB_BLOB_OFFSET = require_fib_offsets.FIB_FC_LCB_BLOB_OFFSET;
+exports.FIB_LKEY_OFFSET = require_fib_offsets.FIB_LKEY_OFFSET;
 exports.FIB_RG_LW_OFFSET = require_fib_offsets.FIB_RG_LW_OFFSET;
 exports.FIB_RG_LW_SIZE = require_fib_offsets.FIB_RG_LW_SIZE;
 exports.FIB_RG_W_OFFSET = require_fib_offsets.FIB_RG_W_OFFSET;
@@ -97,6 +98,7 @@ exports.parseFontTable = require_style_fonts.parseFontTable;
 exports.parsePapxFkp = require_prop_fkp.parsePapxFkp;
 exports.parsePlc = require_plc.parsePlc;
 exports.parseStsh = require_style_stsh.parseStsh;
+exports.peekFibBaseFlags = require_fib_fib.peekFibBaseFlags;
 exports.readDocContent = require_read.readDocContent;
 exports.readDocStreams = require_read.readDocStreams;
 exports.readGrpprl = require_prop_sprm.readGrpprl;

package/dist/index.d.cts

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/list/numbering-write.d.cts

@@ -1,4 +1,4 @@
-import { r as NumberingDefinitions } from "../numbering-Bivayss4.cjs";
+import { r as NumberingDefinitions } from "../numbering-DSpm9w6y.cjs";
 import { ContentListMembership } from "document-schema.js";
 //#region src/list/numbering-write.d.ts
 /** One document's own numbering, gathered from every paragraph's list membership (the caller passes the already-flattened sequence, table cells included, so a list used only inside a table cell is still resolved). */

package/dist/list/numbering-write.d.ts

@@ -1,4 +1,4 @@
-import { r as NumberingDefinitions } from "../numbering-Co4jssbG.js";
+import { r as NumberingDefinitions } from "../numbering-DayjnHXY.js";
 import { ContentListMembership } from "document-schema.js";
 //#region src/list/numbering-write.d.ts
 /** One document's own numbering, gathered from every paragraph's list membership (the caller passes the already-flattened sequence, table cells included, so a list used only inside a table cell is still resolved). */

package/dist/list/numbering.d.cts

@@ -1,2 +1,2 @@
-import { a as readNumberingDefinitions, i as NumberingLevel, n as NumberingDefinition, r as NumberingDefinitions, t as NUMBER_FORMAT_BY_NFC } from "../numbering-Bivayss4.cjs";
+import { a as readNumberingDefinitions, i as NumberingLevel, n as NumberingDefinition, r as NumberingDefinitions, t as NUMBER_FORMAT_BY_NFC } from "../numbering-DSpm9w6y.cjs";
 export { NUMBER_FORMAT_BY_NFC, NumberingDefinition, NumberingDefinitions, NumberingLevel, readNumberingDefinitions };

package/dist/list/numbering.d.ts

@@ -1,2 +1,2 @@
-import { a as readNumberingDefinitions, i as NumberingLevel, n as NumberingDefinition, r as NumberingDefinitions, t as NUMBER_FORMAT_BY_NFC } from "../numbering-Co4jssbG.js";
+import { a as readNumberingDefinitions, i as NumberingLevel, n as NumberingDefinition, r as NumberingDefinitions, t as NUMBER_FORMAT_BY_NFC } from "../numbering-DayjnHXY.js";
 export { NUMBER_FORMAT_BY_NFC, NumberingDefinition, NumberingDefinitions, NumberingLevel, readNumberingDefinitions };

package/dist/{numbering-Bivayss4.d.cts → numbering-DSpm9w6y.d.cts}

@@ -1,4 +1,4 @@
-import { t as Fib } from "./fib-CtsLtF96.cjs";
+import { t as Fib } from "./fib-DWFta19r.cjs";
 //#region src/list/numbering.d.ts
 /** MSONFC ([MS-OSHARED] 2.2.1.3), mapped to its own documented ST_NumberFormat equivalent -- the identical vocabulary ooxml.js's NumberingLevel.format carries verbatim from word/numbering.xml's own w:numFmt/@w:val. Every member through msonfcUCRus (0x3B) is a real numbered/lettered/ideograph format; 0x17 (msonfcBullet) is handled separately below since PlfLfo also treats it as the "no number sequence, but has bullets" case LVLF's own field text calls out by name. */
 declare const NUMBER_FORMAT_BY_NFC: Readonly<Record<number, string>>;

package/dist/{numbering-Co4jssbG.d.ts → numbering-DayjnHXY.d.ts}

@@ -1,4 +1,4 @@
-import { t as Fib } from "./fib-CtsLtF96.js";
+import { t as Fib } from "./fib-DWFta19r.js";
 //#region src/list/numbering.d.ts
 /** MSONFC ([MS-OSHARED] 2.2.1.3), mapped to its own documented ST_NumberFormat equivalent -- the identical vocabulary ooxml.js's NumberingLevel.format carries verbatim from word/numbering.xml's own w:numFmt/@w:val. Every member through msonfcUCRus (0x3B) is a real numbered/lettered/ideograph format; 0x17 (msonfcBullet) is handled separately below since PlfLfo also treats it as the "no number sequence, but has bullets" case LVLF's own field text calls out by name. */
 declare const NUMBER_FORMAT_BY_NFC: Readonly<Record<number, string>>;

package/dist/prop/sep.d.cts

@@ -1,4 +1,4 @@
-import { t as Fib } from "../fib-CtsLtF96.cjs";
+import { t as Fib } from "../fib-DWFta19r.cjs";
 import { t as Prl } from "../sprm-DEyvdOo0.cjs";
 //#region src/prop/sep.d.ts
 interface SectionProperties {

package/dist/prop/sep.d.ts

@@ -1,4 +1,4 @@
-import { t as Fib } from "../fib-CtsLtF96.js";
+import { t as Fib } from "../fib-DWFta19r.js";
 import { t as Prl } from "../sprm-DEyvdOo0.js";
 //#region src/prop/sep.d.ts
 interface SectionProperties {

package/dist/read.cjs

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_errors = require("./errors.cjs");
 const require_bytes = require("./bytes.cjs");
 const require_detect = require("./detect.cjs");
+const require_encryption = require("./encryption.cjs");
 const require_fib_fib = require("./fib/fib.cjs");
 const require_text_piece_table = require("./text/piece-table.cjs");
 const require_text_characters = require("./text/characters.cjs");
@@ -28,24 +29,33 @@ const DEFAULT_MARGINS = {
 	bottomPt: 72,
 	leftPt: 72
 };
-function readDocStreams(bytes) {
+function readDocStreams(bytes, password) {
 	const streams = (0, archive_codec.readCompoundFile)(bytes);
-	const wordDocument = streams.find((stream) => stream.path === require_detect.WORD_DOCUMENT_STREAM);
-	if (wordDocument === void 0) throw new require_errors.DocFormatError(`this compound file has no "${require_detect.WORD_DOCUMENT_STREAM}" stream, so it is not a Word Binary File (it holds: ${streams.map((stream) => stream.path).join(", ")})`);
-	const fib = require_fib_fib.parseFib(wordDocument.bytes);
-	const wanted = require_fib_fib.tableStreamName(fib);
-	const table = streams.find((stream) => stream.path === wanted);
-	if (table === void 0) throw new require_errors.DocFormatError(`FibBase.fWhichTblStm selects the "${wanted}" stream, which this compound file does not contain`);
+	const wordDocumentStream = streams.find((stream) => stream.path === require_detect.WORD_DOCUMENT_STREAM);
+	if (wordDocumentStream === void 0) throw new require_errors.DocFormatError(`this compound file has no "${require_detect.WORD_DOCUMENT_STREAM}" stream, so it is not a Word Binary File (it holds: ${streams.map((stream) => stream.path).join(", ")})`);
+	const flags = require_fib_fib.peekFibBaseFlags(wordDocumentStream.bytes);
+	const wanted = flags.fWhichTblStm === 1 ? "1Table" : "0Table";
+	const tableStream = streams.find((stream) => stream.path === wanted);
+	if (tableStream === void 0) throw new require_errors.DocFormatError(`FibBase.fWhichTblStm selects the "${wanted}" stream, which this compound file does not contain`);
+	let wordDocument = wordDocumentStream.bytes;
+	let table = tableStream.bytes;
+	if (flags.fEncrypted) {
+		if (flags.fObfuscated) throw new require_errors.DocUnsupportedError("this document is XOR-obfuscated ([MS-DOC] 2.2.6.1); doc-codec cannot decrypt it, and reading its streams as plaintext would produce arbitrary text rather than the document's own");
+		const decrypted = require_encryption.decryptDocStreams(wordDocument, table, password);
+		wordDocument = decrypted.wordDocument;
+		table = decrypted.table;
+	}
+	const fib = require_fib_fib.parseFib(wordDocument);
 	const metadata = streams.find((stream) => stream.path === require_detect.SUMMARY_INFORMATION_STREAM);
 	return {
-		wordDocument: wordDocument.bytes,
-		table: table.bytes,
+		wordDocument,
+		table,
 		fib,
 		metadata: metadata?.bytes
 	};
 }
-function readDocContent(bytes) {
-	const { wordDocument, table, fib, metadata } = readDocStreams(bytes);
+function readDocContent(bytes, password) {
+	const { wordDocument, table, fib, metadata } = readDocStreams(bytes, password);
 	const pieceTable = require_text_piece_table.parseClx(require_bytes.slice(table, fib.fcClx, fib.lcbClx, "Clx in the Table stream"));
 	const styles = fib.lcbStshf > 0 ? require_style_stsh.parseStsh(require_bytes.slice(table, fib.fcStshf, fib.lcbStshf, "STSH in the Table stream")) : void 0;
 	const chpxTable = new require_prop_fkp.PropertyBinTable(wordDocument, require_bytes.slice(table, fib.fcPlcfBteChpx, fib.lcbPlcfBteChpx, "PlcBteChpx in the Table stream"), "PlcBteChpx");

package/dist/read.d.cts

@@ -1,7 +1,7 @@
-import { t as Fib } from "./fib-CtsLtF96.cjs";
+import { t as Fib } from "./fib-DWFta19r.cjs";
 import { t as Prl } from "./sprm-DEyvdOo0.cjs";
 import { t as ParagraphProperties } from "./pap-BT1p0uzu.cjs";
-import { r as NumberingDefinitions } from "./numbering-Bivayss4.cjs";
+import { r as NumberingDefinitions } from "./numbering-DSpm9w6y.cjs";
 import { ContentDocument, ContentParagraph } from "document-schema.js";
 //#region src/read.d.ts
 interface DocStreams {
@@ -11,12 +11,12 @@ interface DocStreams {
   /** The raw "\x05SummaryInformation" stream bytes, or undefined when the container carries none -- a valid, spec-conformant Word Binary File need not carry document properties at all. */
   readonly metadata: Uint8Array<ArrayBuffer> | undefined;
 }
-declare function readDocStreams(bytes: Uint8Array<ArrayBuffer>): DocStreams;
+declare function readDocStreams(bytes: Uint8Array<ArrayBuffer>, password?: string): DocStreams;
 /** readDocContent's own return type: a ContentDocument (kind 'wordprocessing') plus numbering -- the list-level formatting (glyph/format, level-text template, start-at value) PlfLst/PlfLfo carry, which ContentListMembership has nowhere to hold. Mirrors ooxml.js's own DocxDocument.numbering exactly in field name and NumberingDefinitions' own shape (see list/numbering.ts's top comment for why it sits outside the shared schema rather than inside ContentListMembership); unlike DocxDocument, DocContent stays a genuine ContentDocument subtype (an intersection, not a fresh shape) since readDocContent already had one return type to widen rather than two to reconcile. */
 type DocContent = ContentDocument & {
   readonly numbering: NumberingDefinitions;
 };
-declare function readDocContent(bytes: Uint8Array<ArrayBuffer>): DocContent;
+declare function readDocContent(bytes: Uint8Array<ArrayBuffer>, password?: string): DocContent;
 /** One paragraph/cell/row-ending mark, still flat -- table/read.ts's assembleBlocks is what folds a run of these into a real ContentTable. `properties` and `grpprl` are carried alongside the already-built `paragraph` because table grouping needs sprmPFInTable/sprmPFTtp/sprmPItap (properties) and, on a row's own mark, its table-defining sgc-5 sprms (grpprl) -- neither of which survives onto a plain ContentParagraph. */
 interface ParagraphEntry {
   readonly paragraph: ContentParagraph;

package/dist/read.d.ts

@@ -1,7 +1,7 @@
-import { t as Fib } from "./fib-CtsLtF96.js";
+import { t as Fib } from "./fib-DWFta19r.js";
 import { t as Prl } from "./sprm-DEyvdOo0.js";
 import { t as ParagraphProperties } from "./pap-DOFLMWcG.js";
-import { r as NumberingDefinitions } from "./numbering-Co4jssbG.js";
+import { r as NumberingDefinitions } from "./numbering-DayjnHXY.js";
 import { ContentDocument, ContentParagraph } from "document-schema.js";
 //#region src/read.d.ts
 interface DocStreams {
@@ -11,12 +11,12 @@ interface DocStreams {
   /** The raw "\x05SummaryInformation" stream bytes, or undefined when the container carries none -- a valid, spec-conformant Word Binary File need not carry document properties at all. */
   readonly metadata: Uint8Array<ArrayBuffer> | undefined;
 }
-declare function readDocStreams(bytes: Uint8Array<ArrayBuffer>): DocStreams;
+declare function readDocStreams(bytes: Uint8Array<ArrayBuffer>, password?: string): DocStreams;
 /** readDocContent's own return type: a ContentDocument (kind 'wordprocessing') plus numbering -- the list-level formatting (glyph/format, level-text template, start-at value) PlfLst/PlfLfo carry, which ContentListMembership has nowhere to hold. Mirrors ooxml.js's own DocxDocument.numbering exactly in field name and NumberingDefinitions' own shape (see list/numbering.ts's top comment for why it sits outside the shared schema rather than inside ContentListMembership); unlike DocxDocument, DocContent stays a genuine ContentDocument subtype (an intersection, not a fresh shape) since readDocContent already had one return type to widen rather than two to reconcile. */
 type DocContent = ContentDocument & {
   readonly numbering: NumberingDefinitions;
 };
-declare function readDocContent(bytes: Uint8Array<ArrayBuffer>): DocContent;
+declare function readDocContent(bytes: Uint8Array<ArrayBuffer>, password?: string): DocContent;
 /** One paragraph/cell/row-ending mark, still flat -- table/read.ts's assembleBlocks is what folds a run of these into a real ContentTable. `properties` and `grpprl` are carried alongside the already-built `paragraph` because table grouping needs sprmPFInTable/sprmPFTtp/sprmPItap (properties) and, on a row's own mark, its table-defining sgc-5 sprms (grpprl) -- neither of which survives onto a plain ContentParagraph. */
 interface ParagraphEntry {
   readonly paragraph: ContentParagraph;

package/dist/read.js

@@ -1,7 +1,8 @@
-import { DocFormatError } from "./errors.js";
+import { DocFormatError, DocUnsupportedError } from "./errors.js";
 import { slice } from "./bytes.js";
 import { SUMMARY_INFORMATION_STREAM, WORD_DOCUMENT_STREAM } from "./detect.js";
-import { parseFib, tableStreamName } from "./fib/fib.js";
+import { decryptDocStreams } from "./encryption.js";
+import { parseFib, peekFibBaseFlags } from "./fib/fib.js";
 import { parseClx } from "./text/piece-table.js";
 import { readTextRange } from "./text/characters.js";
 import { endsParagraph, isAnchorOnly } from "./text/special.js";
@@ -27,24 +28,33 @@ const DEFAULT_MARGINS = {
 	bottomPt: 72,
 	leftPt: 72
 };
-function readDocStreams(bytes) {
+function readDocStreams(bytes, password) {
 	const streams = readCompoundFile(bytes);
-	const wordDocument = streams.find((stream) => stream.path === WORD_DOCUMENT_STREAM);
-	if (wordDocument === void 0) throw new DocFormatError(`this compound file has no "${WORD_DOCUMENT_STREAM}" stream, so it is not a Word Binary File (it holds: ${streams.map((stream) => stream.path).join(", ")})`);
-	const fib = parseFib(wordDocument.bytes);
-	const wanted = tableStreamName(fib);
-	const table = streams.find((stream) => stream.path === wanted);
-	if (table === void 0) throw new DocFormatError(`FibBase.fWhichTblStm selects the "${wanted}" stream, which this compound file does not contain`);
+	const wordDocumentStream = streams.find((stream) => stream.path === WORD_DOCUMENT_STREAM);
+	if (wordDocumentStream === void 0) throw new DocFormatError(`this compound file has no "${WORD_DOCUMENT_STREAM}" stream, so it is not a Word Binary File (it holds: ${streams.map((stream) => stream.path).join(", ")})`);
+	const flags = peekFibBaseFlags(wordDocumentStream.bytes);
+	const wanted = flags.fWhichTblStm === 1 ? "1Table" : "0Table";
+	const tableStream = streams.find((stream) => stream.path === wanted);
+	if (tableStream === void 0) throw new DocFormatError(`FibBase.fWhichTblStm selects the "${wanted}" stream, which this compound file does not contain`);
+	let wordDocument = wordDocumentStream.bytes;
+	let table = tableStream.bytes;
+	if (flags.fEncrypted) {
+		if (flags.fObfuscated) throw new DocUnsupportedError("this document is XOR-obfuscated ([MS-DOC] 2.2.6.1); doc-codec cannot decrypt it, and reading its streams as plaintext would produce arbitrary text rather than the document's own");
+		const decrypted = decryptDocStreams(wordDocument, table, password);
+		wordDocument = decrypted.wordDocument;
+		table = decrypted.table;
+	}
+	const fib = parseFib(wordDocument);
 	const metadata = streams.find((stream) => stream.path === SUMMARY_INFORMATION_STREAM);
 	return {
-		wordDocument: wordDocument.bytes,
-		table: table.bytes,
+		wordDocument,
+		table,
 		fib,
 		metadata: metadata?.bytes
 	};
 }
-function readDocContent(bytes) {
-	const { wordDocument, table, fib, metadata } = readDocStreams(bytes);
+function readDocContent(bytes, password) {
+	const { wordDocument, table, fib, metadata } = readDocStreams(bytes, password);
 	const pieceTable = parseClx(slice(table, fib.fcClx, fib.lcbClx, "Clx in the Table stream"));
 	const styles = fib.lcbStshf > 0 ? parseStsh(slice(table, fib.fcStshf, fib.lcbStshf, "STSH in the Table stream")) : void 0;
 	const chpxTable = new PropertyBinTable(wordDocument, slice(table, fib.fcPlcfBteChpx, fib.lcbPlcfBteChpx, "PlcBteChpx in the Table stream"), "PlcBteChpx");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doc-codec",
-  "version": "2.3.7",
+  "version": "2.4.0",
   "description": "A hand-written reader for the Word Binary File Format ([MS-DOC], .doc) against the shared document-schema.js content pivot: FIB parsing, piece-table text reconstruction, and CHPX/PAPX formatting exceptions.",
   "type": "module",
   "repository": {
@@ -78,7 +78,7 @@
   "license": "MIT",
   "packageManager": "pnpm@11.6.0",
   "dependencies": {
-    "archive-codec": "1.7.2",
+    "archive-codec": "1.8.0",
     "document-schema.js": "7.3.1"
   },
   "devDependencies": {