archive-codec 1.6.8 → 1.7.1

package/README.md

@@ -2,7 +2,7 @@
 
 [![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/documents.js/tree/main/packages/archive-codec) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/archive-codec) [![npm version](https://img.shields.io/npm/v/archive-codec)](https://www.npmjs.com/package/archive-codec) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/documents.js/ci.yml?branch=main)](https://github.com/ExaDev/documents.js/actions)
 
-> ZIP-in-ZIP recursive walking under depth and cumulative decompressed-size guards, classic OLE compound-file ([MS-CFB]) reading and writing, and [MS-OLEPS] Property Set Stream reading and writing — zero document-format knowledge, the archive and container utility package for the [documents.js family](../../README.md). Worker-isomorphic: the same code runs under Node and inside a Cloudflare Workers isolate.
+> ZIP-in-ZIP recursive walking under depth and cumulative decompressed-size guards, classic OLE compound-file ([MS-CFB]) reading and writing, [MS-OLEPS] Property Set Stream reading and writing, and the RC4/MD5 primitives the legacy OLE-based binary formats share for their own password-to-open encryption — zero document-format knowledge, the archive and container utility package for the [documents.js family](../../README.md). Worker-isomorphic: the same code runs under Node and inside a Cloudflare Workers isolate.
 
 Created for [documents.js#564](https://github.com/ExaDev/documents.js/issues/564): nothing in the ecosystem recursed into a nested archive. Most concretely, OOXML's embedded-object model — a docx/pptx carrying a genuinely separate ZIP blob at `word/embeddings/oleObject1.xlsx` — had no safe handling anywhere, and no package guarded against recursive-archive inputs at all (`byte-codec`'s 512 MiB per-stream inflate cap does not compose across recursion). A new sibling was chosen over extending `byte-codec` (whose charter is byte/image primitives, zero container-format knowledge) or doing it inline in `documents.js` (which would repeat the duplication `byte-codec`'s own extraction was meant to avoid). Its first family consumer is `ooxml.js`'s OLE embedded-object recovery — [documents.js#733](https://github.com/ExaDev/documents.js/issues/733) (pptx, `p:oleObj`) and [documents.js#734](https://github.com/ExaDev/documents.js/issues/734) (docx, `o:OLEObject`): an OLE payload part's bytes are checked through `isZipArchive` and, when they are a ZIP, decoded as a nested OOXML package behind this package's guarded walk — the bounded inflate that populates `document-schema.js`'s `ContentEmbeddedObject`/`ContentEmbeddedObjectBlock` (the same vocabulary odf.js embeds formula sub-documents through) with a genuinely recovered sub-document.
 
@@ -14,7 +14,9 @@ Created for [documents.js#564](https://github.com/ExaDev/documents.js/issues/564
 
 [documents.js#815](https://github.com/ExaDev/documents.js/issues/815), [#816](https://github.com/ExaDev/documents.js/issues/816), and [#817](https://github.com/ExaDev/documents.js/issues/817) also each named the same remaining gap: `doc-codec`, `xls-codec`, and `ppt-codec` all hard-coded document metadata (title, author, dates) to an empty object, because that metadata lives in a genuinely different structure from the one each format's own reader already parses -- a [MS-OLEPS] Property Set Stream, conventionally stored as a "\x05SummaryInformation" stream beside `WordDocument`/`Workbook`/`PowerPoint Document` in the identical [MS-CFB] container all three already read through this package. `oleps/read` and `oleps/write` are the generic property-set codec (the stream header, the PropertySet packet's dictionary, and VT_I2/VT_I4/VT_LPSTR/VT_LPWSTR/VT_FILETIME typed values), and `oleps/summary-information` is the SummaryInformation-specific mapping on top of it -- the same two-layer split `cfb/read.ts` and `cfb/ole-package.ts` already establish for the OLE Package stream, container structure below, one named stream's own field layout above.
 
-Scope: **ZIP containers** (read and write over [`fflate`](https://github.com/101arrowz/fflate), recursive walking of ZIP-in-ZIP entries), **classic OLE compound files** (bounded [MS-CFB] reading and conformant [MS-CFB] writing, plus OLE Package stream reading and writing), and **[MS-OLEPS] Property Set Streams** (generic read/write of a single-property-set stream, plus SummaryInformation's own title/subject/author/keywords/comments/created/last-saved/last-printed fields). **tar and gzip, DocumentSummaryInformation's extended and user-defined property sets, and writing VT_LPSTR (ANSI-codepage) string properties are explicitly out of scope.**
+[documents.js#1108](https://github.com/ExaDev/documents.js/issues/1108) added the RC4/MD5 primitives `xls-codec` needs to decrypt a legacy-encrypted `.xls` workbook: the [MS-OFFCRYPTO] 2.3.6.1 "RC4 encryption header" scheme every BIFF8 `FilePass` record protected this way shares with the same header shape in `.doc` and `.ppt`. RC4 and MD5 are trivial and completely unavailable from any platform crypto API this package can portably reach (WebCrypto has never offered either; `node:crypto` dropped RC4 from its default provider with OpenSSL 3), so hand-writing them here — once, shared — is the only option that keeps `xls-codec`, `doc-codec`, and `ppt-codec` (already this package's only consumers) from each carrying their own copy. The newer "RC4 CryptoAPI encryption header" scheme (2.3.5.1, a different header shape and derivation) and the older XOR obfuscation scheme are explicitly out of scope for now — tracked separately in [documents.js#922](https://github.com/ExaDev/documents.js/issues/922).
+
+Scope: **ZIP containers** (read and write over [`fflate`](https://github.com/101arrowz/fflate), recursive walking of ZIP-in-ZIP entries), **classic OLE compound files** (bounded [MS-CFB] reading and conformant [MS-CFB] writing, plus OLE Package stream reading and writing), **[MS-OLEPS] Property Set Streams** (generic read/write of a single-property-set stream, plus SummaryInformation's own title/subject/author/keywords/comments/created/last-saved/last-printed fields), and the **RC4/MD5 primitives** the legacy OLE-based binary formats share for password-to-open encryption. **tar and gzip, DocumentSummaryInformation's extended and user-defined property sets, writing VT_LPSTR (ANSI-codepage) string properties, RC4 CryptoAPI encryption, and XOR obfuscation are explicitly out of scope.**
 
 ## Getting started
 
@@ -57,6 +59,9 @@ The smoke suite (`test/smoke.test.mjs`) is the guard on that advertisement: it l
 | `oleps/write`               | `writePropertySetStream` (generic [MS-OLEPS] property-set encoding), `PropertySetWriteError` — takes the `PropertySet` shape `oleps/read` returns                                                                                                                                       |
 | `oleps/summary-information` | `readSummaryInformation`, `writeSummaryInformationStream`, `SummaryInformationProperties`, `FMTID_SUMMARY_INFORMATION`                                                                                                                                                                  |
 | `oleps/layout-metadata`     | `summaryInformationToLayoutMetadata`, `layoutMetadataToSummaryInformation`, `hasSummaryInformationFields` — the `SummaryInformationProperties` <-> `document-schema.js`'s `LayoutMetadata` mapping, shared by `doc-codec`/`xls-codec`/`ppt-codec` (see [Property sets](#property-sets)) |
+| `crypto/md5`                | `md5` — RFC 1321 MD5, hand-written (see [Legacy Office encryption](#legacy-office-encryption))                                                                                                                                                                                          |
+| `crypto/rc4`                | `rc4` — the RC4 stream cipher, hand-written; symmetric, so also the decrypt operation                                                                                                                                                                                                   |
+| `crypto/office-rc4`         | `deriveOfficeRc4BaseHash`, `deriveOfficeRc4BlockKey`, `decryptOfficeRc4`, `OFFICE_RC4_VERIFIER_LENGTH`, `OFFICE_RC4_BLOCK_SIZE` — [MS-OFFCRYPTO] 2.3.6.2's own key derivation and the block-keyed stream decryption built on it                                                         |
 
 ### Recursive walking
 
@@ -168,6 +173,21 @@ A property whose type this reader does not decode — an unsupported `PropertyTy
 
 `oleps/layout-metadata`'s `summaryInformationToLayoutMetadata`/`layoutMetadataToSummaryInformation`/`hasSummaryInformationFields` map `SummaryInformationProperties` to and from `document-schema.js`'s own `LayoutMetadata` — the shared metadata shape every codec's `ContentDocument` carries, format-agnostic rather than specific to any one legacy binary format. `doc-codec`, `xls-codec`, and `ppt-codec` each import these directly rather than maintaining their own copy, wrapping `layoutMetadataToSummaryInformation` with their own `createdIso`/`modifiedIso` date validation so a malformed date is reported through that package's own error vocabulary rather than an opaque `RangeError` out of the FILETIME conversion.
 
+### Legacy Office encryption
+
+```ts
+import { deriveOfficeRc4BaseHash, decryptOfficeRc4 } from "archive-codec";
+
+// salt and streamOffset come from the caller's own FilePass-record reading
+// (xls-codec's own [MS-XLS] 2.4.117 handling, not this package's concern).
+const baseHash = deriveOfficeRc4BaseHash(password, salt);
+const plaintext = decryptOfficeRc4(baseHash, streamOffset, ciphertext);
+```
+
+`deriveOfficeRc4BaseHash`/`deriveOfficeRc4BlockKey`/`decryptOfficeRc4` implement [MS-OFFCRYPTO] 2.3.6.1/2.3.6.2's RC4 encryption header scheme: a per-workbook base hash derived once from the password and the header's own salt, then a real 40-bit RC4 key re-derived from that base hash at every 1024-byte boundary of the underlying decrypted stream. Both the key length and the block-reset interval come from Apache POI's own `Biff8EncryptionKey`, a mature independent implementation, rather than the published spec's own more generic prose — see each constant's own doc comment for the discrepancy. `decryptOfficeRc4` takes the byte offset a chunk starts at within the whole encrypted stream (not within the chunk itself), so a stream can be decrypted in arbitrary pieces, not only from its own start, and still land on the correct per-block key throughout.
+
+This is exactly the piece `xls-codec`'s `FilePass`-record reader needs and nothing more: locating the `FilePass` record, reading its own encryption-header bytes, and verifying the password against `EncryptedVerifier`/`EncryptedVerifierHash` are `xls-codec`'s own concern, not this package's — `archive-codec` carries only the format-agnostic cryptography, never a `.xls`-specific byte layout. `md5`/`rc4` are exported individually too, for `doc-codec`/`ppt-codec`'s own eventual integration against the identical header scheme.
+
 ### ZIP container
 
 `zipPackage` takes an _ordered_ array of `[path, entry]` tuples, not a `Record`, so the caller controls the exact emission order deterministically (the property formats with a fixed-offset first entry — ODF's `mimetype` — depend on), and any entry can be written stored-uncompressed via `stored: true`. `unzipPackage` is the read side; the returned `Record` makes no ordering promise and collapses duplicate paths.
@@ -176,7 +196,7 @@ A property whose type this reader does not decode — an unsupported `PropertyTy
 
 - Worker-isomorphic (see the [family-wide convention](../../README.md#conventions)): runtime `src/` must not import `node:*`, a bare Node builtin, or use the `Buffer` global — enforced by a `no-restricted-imports`/`no-restricted-globals` ESLint rule and exercised in CI by running the test suite inside an actual `workerd` isolate (`pnpm test:workers`). Test files under `src/**/*.test.ts` and `src/test-support/` are exempt and may use Node APIs for fixtures.
 - Only `src/index.ts` may be named `index.*` — a custom ESLint rule (`local/no-non-barrel-index`) rejects any other module using an `index` basename, since that would be a hidden entry point the `exports` map in `package.json` doesn't advertise.
-- Zero document-format knowledge: this package knows bytes and container structure — ZIP entries, compound-file sectors and directory entries, the OLE packaging wrapper, [MS-OLEPS] property identifiers and typed values — never that any entry or stream is a document, or that PID 2 means a title. It depends only on `fflate` — not on `byte-codec`, `ooxml.js`, or `odf.js` (whose ZIP wrappers it deliberately mirrors rather than imports, keeping their branding and release cadences decoupled).
+- Zero document-format knowledge: this package knows bytes and container structure — ZIP entries, compound-file sectors and directory entries, the OLE packaging wrapper, [MS-OLEPS] property identifiers and typed values, and the one shared RC4/MD5 cryptography scheme the legacy OLE-based binary formats happen to encrypt themselves with — never that any entry or stream is a document, or that PID 2 means a title. It depends only on `fflate` — not on `byte-codec`, `ooxml.js`, or `odf.js` (whose ZIP wrappers it deliberately mirrors rather than imports, keeping their branding and release cadences decoupled).
 
 ## Install
 

package/dist/crypto/md5.cjs

@@ -0,0 +1,221 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/md5.ts
+const BLOCK_BYTES = 64;
+const DIGEST_BYTES = 16;
+const ROUNDS = 64;
+const WORDS_PER_BLOCK = 16;
+const T_VALUES = [
+	3614090360,
+	3905402710,
+	606105819,
+	3250441966,
+	4118548399,
+	1200080426,
+	2821735955,
+	4249261313,
+	1770035416,
+	2336552879,
+	4294925233,
+	2304563134,
+	1804603682,
+	4254626195,
+	2792965006,
+	1236535329,
+	4129170786,
+	3225465664,
+	643717713,
+	3921069994,
+	3593408605,
+	38016083,
+	3634488961,
+	3889429448,
+	568446438,
+	3275163606,
+	4107603335,
+	1163531501,
+	2850285829,
+	4243563512,
+	1735328473,
+	2368359562,
+	4294588738,
+	2272392833,
+	1839030562,
+	4259657740,
+	2763975236,
+	1272893353,
+	4139469664,
+	3200236656,
+	681279174,
+	3936430074,
+	3572445317,
+	76029189,
+	3654602809,
+	3873151461,
+	530742520,
+	3299628645,
+	4096336452,
+	1126891415,
+	2878612391,
+	4237533241,
+	1700485571,
+	2399980690,
+	4293915773,
+	2240044497,
+	1873313359,
+	4264355552,
+	2734768916,
+	1309151649,
+	4149444226,
+	3174756917,
+	718787259,
+	3951481745
+];
+const T = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(T_VALUES.length * 4));
+T_VALUES.forEach((value, index) => {
+	T.setUint32(index * 4, value, true);
+});
+const SHIFT_VALUES = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
+];
+const SHIFT = new DataView(new ArrayBuffer(SHIFT_VALUES.length));
+SHIFT_VALUES.forEach((value, index) => {
+	SHIFT.setUint8(index, value);
+});
+const INITIAL_A = 1732584193;
+const INITIAL_B = 4023233417;
+const INITIAL_C = 2562383102;
+const INITIAL_D = 271733878;
+function rotl32(value, bits) {
+	return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function padMessage(bytes) {
+	const paddedLength = (Math.floor((bytes.length + 8) / BLOCK_BYTES) + 1) * BLOCK_BYTES;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	const bitLength = bytes.length * 8;
+	let low = bitLength % 4294967296;
+	let high = Math.floor(bitLength / 4294967296);
+	for (let i = 0; i < 4; i++) {
+		view.setUint8(paddedLength - 8 + i, low & 255);
+		low = Math.floor(low / 256);
+		view.setUint8(paddedLength - 4 + i, high & 255);
+		high = Math.floor(high / 256);
+	}
+	return padded;
+}
+function md5(bytes) {
+	const padded = padMessage(bytes);
+	const paddedView = new DataView(padded.buffer);
+	let stateA = INITIAL_A;
+	let stateB = INITIAL_B;
+	let stateC = INITIAL_C;
+	let stateD = INITIAL_D;
+	const block = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(64));
+	for (let offset = 0; offset < padded.length; offset += BLOCK_BYTES) {
+		for (let i = 0; i < WORDS_PER_BLOCK; i++) block.setUint32(i * 4, paddedView.getUint32(offset + i * 4, true), true);
+		let a = stateA;
+		let b = stateB;
+		let c = stateC;
+		let d = stateD;
+		for (let i = 0; i < ROUNDS; i++) {
+			let f;
+			let g;
+			if (i < 16) {
+				f = b & c | ~b & d;
+				g = i;
+			} else if (i < 32) {
+				f = d & b | ~d & c;
+				g = (5 * i + 1) % WORDS_PER_BLOCK;
+			} else if (i < 48) {
+				f = b ^ c ^ d;
+				g = (3 * i + 5) % WORDS_PER_BLOCK;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * i % WORDS_PER_BLOCK;
+			}
+			const rotated = rotl32(a + (f >>> 0) + T.getUint32(i * 4, true) + block.getUint32(g * 4, true) >>> 0, SHIFT.getUint8(i));
+			a = d;
+			d = c;
+			c = b;
+			b = b + rotated >>> 0;
+		}
+		stateA = stateA + a | 0;
+		stateB = stateB + b | 0;
+		stateC = stateC + c | 0;
+		stateD = stateD + d | 0;
+	}
+	const digest = new Uint8Array(DIGEST_BYTES);
+	const digestView = new DataView(digest.buffer);
+	digestView.setInt32(0, stateA, true);
+	digestView.setInt32(4, stateB, true);
+	digestView.setInt32(8, stateC, true);
+	digestView.setInt32(12, stateD, true);
+	return digest;
+}
+//#endregion
+exports.md5 = md5;

package/dist/crypto/md5.d.cts

@@ -0,0 +1,4 @@
+//#region src/crypto/md5.d.ts
+declare function md5(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { md5 };

package/dist/crypto/md5.d.ts

@@ -0,0 +1,4 @@
+//#region src/crypto/md5.d.ts
+declare function md5(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { md5 };

package/dist/crypto/md5.js

@@ -0,0 +1,220 @@
+//#region src/crypto/md5.ts
+const BLOCK_BYTES = 64;
+const DIGEST_BYTES = 16;
+const ROUNDS = 64;
+const WORDS_PER_BLOCK = 16;
+const T_VALUES = [
+	3614090360,
+	3905402710,
+	606105819,
+	3250441966,
+	4118548399,
+	1200080426,
+	2821735955,
+	4249261313,
+	1770035416,
+	2336552879,
+	4294925233,
+	2304563134,
+	1804603682,
+	4254626195,
+	2792965006,
+	1236535329,
+	4129170786,
+	3225465664,
+	643717713,
+	3921069994,
+	3593408605,
+	38016083,
+	3634488961,
+	3889429448,
+	568446438,
+	3275163606,
+	4107603335,
+	1163531501,
+	2850285829,
+	4243563512,
+	1735328473,
+	2368359562,
+	4294588738,
+	2272392833,
+	1839030562,
+	4259657740,
+	2763975236,
+	1272893353,
+	4139469664,
+	3200236656,
+	681279174,
+	3936430074,
+	3572445317,
+	76029189,
+	3654602809,
+	3873151461,
+	530742520,
+	3299628645,
+	4096336452,
+	1126891415,
+	2878612391,
+	4237533241,
+	1700485571,
+	2399980690,
+	4293915773,
+	2240044497,
+	1873313359,
+	4264355552,
+	2734768916,
+	1309151649,
+	4149444226,
+	3174756917,
+	718787259,
+	3951481745
+];
+const T = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(T_VALUES.length * 4));
+T_VALUES.forEach((value, index) => {
+	T.setUint32(index * 4, value, true);
+});
+const SHIFT_VALUES = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
+];
+const SHIFT = new DataView(new ArrayBuffer(SHIFT_VALUES.length));
+SHIFT_VALUES.forEach((value, index) => {
+	SHIFT.setUint8(index, value);
+});
+const INITIAL_A = 1732584193;
+const INITIAL_B = 4023233417;
+const INITIAL_C = 2562383102;
+const INITIAL_D = 271733878;
+function rotl32(value, bits) {
+	return (value << bits | value >>> 32 - bits) >>> 0;
+}
+function padMessage(bytes) {
+	const paddedLength = (Math.floor((bytes.length + 8) / BLOCK_BYTES) + 1) * BLOCK_BYTES;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	const bitLength = bytes.length * 8;
+	let low = bitLength % 4294967296;
+	let high = Math.floor(bitLength / 4294967296);
+	for (let i = 0; i < 4; i++) {
+		view.setUint8(paddedLength - 8 + i, low & 255);
+		low = Math.floor(low / 256);
+		view.setUint8(paddedLength - 4 + i, high & 255);
+		high = Math.floor(high / 256);
+	}
+	return padded;
+}
+function md5(bytes) {
+	const padded = padMessage(bytes);
+	const paddedView = new DataView(padded.buffer);
+	let stateA = INITIAL_A;
+	let stateB = INITIAL_B;
+	let stateC = INITIAL_C;
+	let stateD = INITIAL_D;
+	const block = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(64));
+	for (let offset = 0; offset < padded.length; offset += BLOCK_BYTES) {
+		for (let i = 0; i < WORDS_PER_BLOCK; i++) block.setUint32(i * 4, paddedView.getUint32(offset + i * 4, true), true);
+		let a = stateA;
+		let b = stateB;
+		let c = stateC;
+		let d = stateD;
+		for (let i = 0; i < ROUNDS; i++) {
+			let f;
+			let g;
+			if (i < 16) {
+				f = b & c | ~b & d;
+				g = i;
+			} else if (i < 32) {
+				f = d & b | ~d & c;
+				g = (5 * i + 1) % WORDS_PER_BLOCK;
+			} else if (i < 48) {
+				f = b ^ c ^ d;
+				g = (3 * i + 5) % WORDS_PER_BLOCK;
+			} else {
+				f = c ^ (b | ~d);
+				g = 7 * i % WORDS_PER_BLOCK;
+			}
+			const rotated = rotl32(a + (f >>> 0) + T.getUint32(i * 4, true) + block.getUint32(g * 4, true) >>> 0, SHIFT.getUint8(i));
+			a = d;
+			d = c;
+			c = b;
+			b = b + rotated >>> 0;
+		}
+		stateA = stateA + a | 0;
+		stateB = stateB + b | 0;
+		stateC = stateC + c | 0;
+		stateD = stateD + d | 0;
+	}
+	const digest = new Uint8Array(DIGEST_BYTES);
+	const digestView = new DataView(digest.buffer);
+	digestView.setInt32(0, stateA, true);
+	digestView.setInt32(4, stateB, true);
+	digestView.setInt32(8, stateC, true);
+	digestView.setInt32(12, stateD, true);
+	return digest;
+}
+//#endregion
+export { md5 };

package/dist/crypto/office-rc4.cjs

@@ -0,0 +1,69 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_crypto_md5 = require("./md5.cjs");
+const require_crypto_rc4 = require("./rc4.cjs");
+//#region src/crypto/office-rc4.ts
+/** [MS-OFFCRYPTO] 2.3.6.1's own EncryptedVerifier/EncryptedVerifierHash length, and the salt length the same header carries. */
+const OFFICE_RC4_VERIFIER_LENGTH = 16;
+/** The span of the underlying decrypted stream one derived RC4 key covers before the next block's key takes over -- confirmed against Apache POI's Biff8EncryptionKey, since [MS-OFFCRYPTO] 2.3.6.2's own prose does not state it. */
+const OFFICE_RC4_BLOCK_SIZE = 1024;
+/** The real derived RC4 key length for this scheme (40 bits) -- confirmed against Apache POI's Biff8EncryptionKey, since [MS-OFFCRYPTO] 2.3.6.2's own generic prose ("the first 128 bits of Hfinal") describes a different, longer-key variant this header shape does not use. */
+const KEY_LENGTH_BYTES = 5;
+function passwordToUtf16LeBytes(password) {
+	const bytes = new Uint8Array(password.length * 2);
+	for (let i = 0; i < password.length; i += 1) {
+		const code = password.charCodeAt(i);
+		bytes[i * 2] = code & 255;
+		bytes[i * 2 + 1] = code >>> 8 & 255;
+	}
+	return bytes;
+}
+/** The per-workbook intermediate hash (H1's own first 5 bytes) every block's key derives from -- computed once per password+salt pair, then reused across every block via deriveOfficeRc4BlockKey, since recomputing H0/H1 per block would be needless repeated work over the identical 336-byte buffer. */
+function deriveOfficeRc4BaseHash(password, salt) {
+	const truncated = require_crypto_md5.md5(passwordToUtf16LeBytes(password)).subarray(0, KEY_LENGTH_BYTES);
+	const unit = /* @__PURE__ */ new Uint8Array(21);
+	unit.set(truncated, 0);
+	unit.set(salt, KEY_LENGTH_BYTES);
+	const buffer336 = new Uint8Array(unit.length * 16);
+	for (let i = 0; i < 16; i += 1) buffer336.set(unit, i * unit.length);
+	return require_crypto_md5.md5(buffer336).subarray(0, KEY_LENGTH_BYTES);
+}
+/** The real, block-specific 40-bit RC4 key: MD5(baseHash + the block number as 4 little-endian bytes), truncated to 5 bytes. */
+function deriveOfficeRc4BlockKey(baseHash, blockNumber) {
+	const input = new Uint8Array(baseHash.length + 4);
+	input.set(baseHash, 0);
+	input[baseHash.length] = blockNumber & 255;
+	input[baseHash.length + 1] = blockNumber >>> 8 & 255;
+	input[baseHash.length + 2] = blockNumber >>> 16 & 255;
+	input[baseHash.length + 3] = blockNumber >>> 24 & 255;
+	return require_crypto_md5.md5(input).subarray(0, KEY_LENGTH_BYTES);
+}
+/**
+* Decrypts `data` -- a byte range of the underlying OLE stream starting at `streamOffset` bytes from the very start of that stream -- against the RC4 encryption header scheme, re-deriving the block key at every 1024-byte boundary `data` crosses. RC4 is symmetric, so this same function also encrypts; nothing in this package uses it that way, since nothing in this family writes an encrypted legacy binary document.
+*
+* `streamOffset` matters because the block number is the byte's own absolute position in the stream divided by 1024, not its position within whatever slice `data` happens to be -- decrypting a stream in arbitrary chunks (not just from offset 0) still lands on the correct per-block key this way.
+*/
+function decryptOfficeRc4(baseHash, streamOffset, data) {
+	const out = new Uint8Array(data.length);
+	let position = 0;
+	while (position < data.length) {
+		const absolute = streamOffset + position;
+		const blockNumber = Math.floor(absolute / OFFICE_RC4_BLOCK_SIZE);
+		const offsetWithinBlock = absolute - blockNumber * OFFICE_RC4_BLOCK_SIZE;
+		const bytesLeftInBlock = OFFICE_RC4_BLOCK_SIZE - offsetWithinBlock;
+		const chunkLength = Math.min(bytesLeftInBlock, data.length - position);
+		const key = deriveOfficeRc4BlockKey(baseHash, blockNumber);
+		const keystreamPrefixAndChunk = require_crypto_rc4.rc4(key, new Uint8Array(offsetWithinBlock + chunkLength));
+		const chunk = data.subarray(position, position + chunkLength);
+		const chunkView = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+		const keystreamView = new DataView(keystreamPrefixAndChunk.buffer, keystreamPrefixAndChunk.byteOffset, keystreamPrefixAndChunk.byteLength);
+		for (let i = 0; i < chunkLength; i += 1) out[position + i] = chunkView.getUint8(i) ^ keystreamView.getUint8(offsetWithinBlock + i);
+		position += chunkLength;
+	}
+	return out;
+}
+//#endregion
+exports.OFFICE_RC4_BLOCK_SIZE = OFFICE_RC4_BLOCK_SIZE;
+exports.OFFICE_RC4_VERIFIER_LENGTH = OFFICE_RC4_VERIFIER_LENGTH;
+exports.decryptOfficeRc4 = decryptOfficeRc4;
+exports.deriveOfficeRc4BaseHash = deriveOfficeRc4BaseHash;
+exports.deriveOfficeRc4BlockKey = deriveOfficeRc4BlockKey;

package/dist/crypto/office-rc4.d.cts

@@ -0,0 +1,17 @@
+//#region src/crypto/office-rc4.d.ts
+/** [MS-OFFCRYPTO] 2.3.6.1's own EncryptedVerifier/EncryptedVerifierHash length, and the salt length the same header carries. */
+declare const OFFICE_RC4_VERIFIER_LENGTH = 16;
+/** The span of the underlying decrypted stream one derived RC4 key covers before the next block's key takes over -- confirmed against Apache POI's Biff8EncryptionKey, since [MS-OFFCRYPTO] 2.3.6.2's own prose does not state it. */
+declare const OFFICE_RC4_BLOCK_SIZE = 1024;
+/** The per-workbook intermediate hash (H1's own first 5 bytes) every block's key derives from -- computed once per password+salt pair, then reused across every block via deriveOfficeRc4BlockKey, since recomputing H0/H1 per block would be needless repeated work over the identical 336-byte buffer. */
+declare function deriveOfficeRc4BaseHash(password: string, salt: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+/** The real, block-specific 40-bit RC4 key: MD5(baseHash + the block number as 4 little-endian bytes), truncated to 5 bytes. */
+declare function deriveOfficeRc4BlockKey(baseHash: Uint8Array<ArrayBuffer>, blockNumber: number): Uint8Array<ArrayBuffer>;
+/**
+ * Decrypts `data` -- a byte range of the underlying OLE stream starting at `streamOffset` bytes from the very start of that stream -- against the RC4 encryption header scheme, re-deriving the block key at every 1024-byte boundary `data` crosses. RC4 is symmetric, so this same function also encrypts; nothing in this package uses it that way, since nothing in this family writes an encrypted legacy binary document.
+ *
+ * `streamOffset` matters because the block number is the byte's own absolute position in the stream divided by 1024, not its position within whatever slice `data` happens to be -- decrypting a stream in arbitrary chunks (not just from offset 0) still lands on the correct per-block key this way.
+ */
+declare function decryptOfficeRc4(baseHash: Uint8Array<ArrayBuffer>, streamOffset: number, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey };

package/dist/crypto/office-rc4.d.ts

@@ -0,0 +1,17 @@
+//#region src/crypto/office-rc4.d.ts
+/** [MS-OFFCRYPTO] 2.3.6.1's own EncryptedVerifier/EncryptedVerifierHash length, and the salt length the same header carries. */
+declare const OFFICE_RC4_VERIFIER_LENGTH = 16;
+/** The span of the underlying decrypted stream one derived RC4 key covers before the next block's key takes over -- confirmed against Apache POI's Biff8EncryptionKey, since [MS-OFFCRYPTO] 2.3.6.2's own prose does not state it. */
+declare const OFFICE_RC4_BLOCK_SIZE = 1024;
+/** The per-workbook intermediate hash (H1's own first 5 bytes) every block's key derives from -- computed once per password+salt pair, then reused across every block via deriveOfficeRc4BlockKey, since recomputing H0/H1 per block would be needless repeated work over the identical 336-byte buffer. */
+declare function deriveOfficeRc4BaseHash(password: string, salt: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+/** The real, block-specific 40-bit RC4 key: MD5(baseHash + the block number as 4 little-endian bytes), truncated to 5 bytes. */
+declare function deriveOfficeRc4BlockKey(baseHash: Uint8Array<ArrayBuffer>, blockNumber: number): Uint8Array<ArrayBuffer>;
+/**
+ * Decrypts `data` -- a byte range of the underlying OLE stream starting at `streamOffset` bytes from the very start of that stream -- against the RC4 encryption header scheme, re-deriving the block key at every 1024-byte boundary `data` crosses. RC4 is symmetric, so this same function also encrypts; nothing in this package uses it that way, since nothing in this family writes an encrypted legacy binary document.
+ *
+ * `streamOffset` matters because the block number is the byte's own absolute position in the stream divided by 1024, not its position within whatever slice `data` happens to be -- decrypting a stream in arbitrary chunks (not just from offset 0) still lands on the correct per-block key this way.
+ */
+declare function decryptOfficeRc4(baseHash: Uint8Array<ArrayBuffer>, streamOffset: number, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey };

package/dist/crypto/office-rc4.js

@@ -0,0 +1,64 @@
+import { md5 } from "./md5.js";
+import { rc4 } from "./rc4.js";
+//#region src/crypto/office-rc4.ts
+/** [MS-OFFCRYPTO] 2.3.6.1's own EncryptedVerifier/EncryptedVerifierHash length, and the salt length the same header carries. */
+const OFFICE_RC4_VERIFIER_LENGTH = 16;
+/** The span of the underlying decrypted stream one derived RC4 key covers before the next block's key takes over -- confirmed against Apache POI's Biff8EncryptionKey, since [MS-OFFCRYPTO] 2.3.6.2's own prose does not state it. */
+const OFFICE_RC4_BLOCK_SIZE = 1024;
+/** The real derived RC4 key length for this scheme (40 bits) -- confirmed against Apache POI's Biff8EncryptionKey, since [MS-OFFCRYPTO] 2.3.6.2's own generic prose ("the first 128 bits of Hfinal") describes a different, longer-key variant this header shape does not use. */
+const KEY_LENGTH_BYTES = 5;
+function passwordToUtf16LeBytes(password) {
+	const bytes = new Uint8Array(password.length * 2);
+	for (let i = 0; i < password.length; i += 1) {
+		const code = password.charCodeAt(i);
+		bytes[i * 2] = code & 255;
+		bytes[i * 2 + 1] = code >>> 8 & 255;
+	}
+	return bytes;
+}
+/** The per-workbook intermediate hash (H1's own first 5 bytes) every block's key derives from -- computed once per password+salt pair, then reused across every block via deriveOfficeRc4BlockKey, since recomputing H0/H1 per block would be needless repeated work over the identical 336-byte buffer. */
+function deriveOfficeRc4BaseHash(password, salt) {
+	const truncated = md5(passwordToUtf16LeBytes(password)).subarray(0, KEY_LENGTH_BYTES);
+	const unit = /* @__PURE__ */ new Uint8Array(21);
+	unit.set(truncated, 0);
+	unit.set(salt, KEY_LENGTH_BYTES);
+	const buffer336 = new Uint8Array(unit.length * 16);
+	for (let i = 0; i < 16; i += 1) buffer336.set(unit, i * unit.length);
+	return md5(buffer336).subarray(0, KEY_LENGTH_BYTES);
+}
+/** The real, block-specific 40-bit RC4 key: MD5(baseHash + the block number as 4 little-endian bytes), truncated to 5 bytes. */
+function deriveOfficeRc4BlockKey(baseHash, blockNumber) {
+	const input = new Uint8Array(baseHash.length + 4);
+	input.set(baseHash, 0);
+	input[baseHash.length] = blockNumber & 255;
+	input[baseHash.length + 1] = blockNumber >>> 8 & 255;
+	input[baseHash.length + 2] = blockNumber >>> 16 & 255;
+	input[baseHash.length + 3] = blockNumber >>> 24 & 255;
+	return md5(input).subarray(0, KEY_LENGTH_BYTES);
+}
+/**
+* Decrypts `data` -- a byte range of the underlying OLE stream starting at `streamOffset` bytes from the very start of that stream -- against the RC4 encryption header scheme, re-deriving the block key at every 1024-byte boundary `data` crosses. RC4 is symmetric, so this same function also encrypts; nothing in this package uses it that way, since nothing in this family writes an encrypted legacy binary document.
+*
+* `streamOffset` matters because the block number is the byte's own absolute position in the stream divided by 1024, not its position within whatever slice `data` happens to be -- decrypting a stream in arbitrary chunks (not just from offset 0) still lands on the correct per-block key this way.
+*/
+function decryptOfficeRc4(baseHash, streamOffset, data) {
+	const out = new Uint8Array(data.length);
+	let position = 0;
+	while (position < data.length) {
+		const absolute = streamOffset + position;
+		const blockNumber = Math.floor(absolute / OFFICE_RC4_BLOCK_SIZE);
+		const offsetWithinBlock = absolute - blockNumber * OFFICE_RC4_BLOCK_SIZE;
+		const bytesLeftInBlock = OFFICE_RC4_BLOCK_SIZE - offsetWithinBlock;
+		const chunkLength = Math.min(bytesLeftInBlock, data.length - position);
+		const key = deriveOfficeRc4BlockKey(baseHash, blockNumber);
+		const keystreamPrefixAndChunk = rc4(key, new Uint8Array(offsetWithinBlock + chunkLength));
+		const chunk = data.subarray(position, position + chunkLength);
+		const chunkView = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+		const keystreamView = new DataView(keystreamPrefixAndChunk.buffer, keystreamPrefixAndChunk.byteOffset, keystreamPrefixAndChunk.byteLength);
+		for (let i = 0; i < chunkLength; i += 1) out[position + i] = chunkView.getUint8(i) ^ keystreamView.getUint8(offsetWithinBlock + i);
+		position += chunkLength;
+	}
+	return out;
+}
+//#endregion
+export { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey };

package/dist/crypto/rc4.cjs

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/rc4.ts
+const STATE_SIZE = 256;
+function rc4(key, data) {
+	if (key.length === 0) return Uint8Array.from(data);
+	const keyView = new DataView(key.buffer, key.byteOffset, key.byteLength);
+	const state = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(STATE_SIZE));
+	for (let i = 0; i < STATE_SIZE; i++) state.setUint8(i, i);
+	let j = 0;
+	for (let i = 0; i < STATE_SIZE; i++) {
+		j = j + state.getUint8(i) + keyView.getUint8(i % key.length) & 255;
+		const swap = state.getUint8(i);
+		state.setUint8(i, state.getUint8(j));
+		state.setUint8(j, swap);
+	}
+	const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const out = new Uint8Array(data.length);
+	let x = 0;
+	let y = 0;
+	for (let n = 0; n < data.length; n++) {
+		x = x + 1 & 255;
+		y = y + state.getUint8(x) & 255;
+		const swap = state.getUint8(x);
+		state.setUint8(x, state.getUint8(y));
+		state.setUint8(y, swap);
+		out[n] = dataView.getUint8(n) ^ state.getUint8(state.getUint8(x) + state.getUint8(y) & 255);
+	}
+	return out;
+}
+//#endregion
+exports.rc4 = rc4;

package/dist/crypto/rc4.d.cts

@@ -0,0 +1,4 @@
+//#region src/crypto/rc4.d.ts
+declare function rc4(key: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { rc4 };

package/dist/crypto/rc4.d.ts

@@ -0,0 +1,4 @@
+//#region src/crypto/rc4.d.ts
+declare function rc4(key: Uint8Array<ArrayBuffer>, data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { rc4 };

package/dist/crypto/rc4.js

@@ -0,0 +1,30 @@
+//#region src/crypto/rc4.ts
+const STATE_SIZE = 256;
+function rc4(key, data) {
+	if (key.length === 0) return Uint8Array.from(data);
+	const keyView = new DataView(key.buffer, key.byteOffset, key.byteLength);
+	const state = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(STATE_SIZE));
+	for (let i = 0; i < STATE_SIZE; i++) state.setUint8(i, i);
+	let j = 0;
+	for (let i = 0; i < STATE_SIZE; i++) {
+		j = j + state.getUint8(i) + keyView.getUint8(i % key.length) & 255;
+		const swap = state.getUint8(i);
+		state.setUint8(i, state.getUint8(j));
+		state.setUint8(j, swap);
+	}
+	const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const out = new Uint8Array(data.length);
+	let x = 0;
+	let y = 0;
+	for (let n = 0; n < data.length; n++) {
+		x = x + 1 & 255;
+		y = y + state.getUint8(x) & 255;
+		const swap = state.getUint8(x);
+		state.setUint8(x, state.getUint8(y));
+		state.setUint8(y, swap);
+		out[n] = dataView.getUint8(n) ^ state.getUint8(state.getUint8(x) + state.getUint8(y) & 255);
+	}
+	return out;
+}
+//#endregion
+export { rc4 };

package/dist/index.cjs

@@ -3,6 +3,9 @@ const require_cfb_detect = require("./cfb/detect.cjs");
 const require_cfb_ole_package = require("./cfb/ole-package.cjs");
 const require_cfb_read = require("./cfb/read.cjs");
 const require_cfb_write = require("./cfb/write.cjs");
+const require_crypto_md5 = require("./crypto/md5.cjs");
+const require_crypto_rc4 = require("./crypto/rc4.cjs");
+const require_crypto_office_rc4 = require("./crypto/office-rc4.cjs");
 const require_oleps_layout_metadata = require("./oleps/layout-metadata.cjs");
 const require_oleps_read = require("./oleps/read.cjs");
 const require_oleps_write = require("./oleps/write.cjs");
@@ -17,15 +20,22 @@ exports.FMTID_SUMMARY_INFORMATION = require_oleps_summary_information.FMTID_SUMM
 exports.MAX_CFB_TOTAL_STREAM_BYTES = require_cfb_read.MAX_CFB_TOTAL_STREAM_BYTES;
 exports.MAX_WALK_DEPTH = require_zip_walk.MAX_WALK_DEPTH;
 exports.MAX_WALK_TOTAL_BYTES = require_zip_walk.MAX_WALK_TOTAL_BYTES;
+exports.OFFICE_RC4_BLOCK_SIZE = require_crypto_office_rc4.OFFICE_RC4_BLOCK_SIZE;
+exports.OFFICE_RC4_VERIFIER_LENGTH = require_crypto_office_rc4.OFFICE_RC4_VERIFIER_LENGTH;
 exports.OlePackageFormatError = require_cfb_ole_package.OlePackageFormatError;
 exports.OlePackageWriteError = require_cfb_ole_package.OlePackageWriteError;
 exports.PropertySetFormatError = require_oleps_read.PropertySetFormatError;
 exports.PropertySetWriteError = require_oleps_write.PropertySetWriteError;
+exports.decryptOfficeRc4 = require_crypto_office_rc4.decryptOfficeRc4;
+exports.deriveOfficeRc4BaseHash = require_crypto_office_rc4.deriveOfficeRc4BaseHash;
+exports.deriveOfficeRc4BlockKey = require_crypto_office_rc4.deriveOfficeRc4BlockKey;
 exports.detectArchiveFormat = require_zip_detect.detectArchiveFormat;
 exports.hasSummaryInformationFields = require_oleps_layout_metadata.hasSummaryInformationFields;
 exports.isCompoundFile = require_cfb_detect.isCompoundFile;
 exports.isZipArchive = require_zip_detect.isZipArchive;
 exports.layoutMetadataToSummaryInformation = require_oleps_layout_metadata.layoutMetadataToSummaryInformation;
+exports.md5 = require_crypto_md5.md5;
+exports.rc4 = require_crypto_rc4.rc4;
 exports.readCompoundFile = require_cfb_read.readCompoundFile;
 exports.readOlePackage = require_cfb_ole_package.readOlePackage;
 exports.readPropertySetStream = require_oleps_read.readPropertySetStream;

package/dist/index.d.cts

@@ -2,6 +2,9 @@ import { isCompoundFile } from "./cfb/detect.cjs";
 import { OlePackage, OlePackageFormatError, OlePackageWriteError, readOlePackage, writeOlePackage } from "./cfb/ole-package.cjs";
 import { CompoundFileFormatError, CompoundFileStream, MAX_CFB_TOTAL_STREAM_BYTES, ReadCompoundFileOptions, readCompoundFile } from "./cfb/read.cjs";
 import { CompoundFileWriteError, WriteCompoundFileOptions, writeCompoundFile } from "./cfb/write.cjs";
+import { md5 } from "./crypto/md5.cjs";
+import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey } from "./crypto/office-rc4.cjs";
+import { rc4 } from "./crypto/rc4.cjs";
 import { FMTID_SUMMARY_INFORMATION, SummaryInformationProperties, readSummaryInformation, writeSummaryInformationStream } from "./oleps/summary-information.cjs";
 import { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata } from "./oleps/layout-metadata.cjs";
 import { PropertySet, PropertyValue } from "./oleps/wire.cjs";
@@ -10,4 +13,4 @@ import { PropertySetWriteError, writePropertySetStream } from "./oleps/write.cjs
 import { ZipEntry, unzipPackage, zipPackage } from "./zip/container.cjs";
 import { ArchiveFormat, detectArchiveFormat, isZipArchive } from "./zip/detect.cjs";
 import { ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, WalkArchiveOptions, walkArchive } from "./zip/walk.cjs";
-export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };
+export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/dist/index.d.ts

@@ -2,6 +2,9 @@ import { isCompoundFile } from "./cfb/detect.js";
 import { OlePackage, OlePackageFormatError, OlePackageWriteError, readOlePackage, writeOlePackage } from "./cfb/ole-package.js";
 import { CompoundFileFormatError, CompoundFileStream, MAX_CFB_TOTAL_STREAM_BYTES, ReadCompoundFileOptions, readCompoundFile } from "./cfb/read.js";
 import { CompoundFileWriteError, WriteCompoundFileOptions, writeCompoundFile } from "./cfb/write.js";
+import { md5 } from "./crypto/md5.js";
+import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey } from "./crypto/office-rc4.js";
+import { rc4 } from "./crypto/rc4.js";
 import { FMTID_SUMMARY_INFORMATION, SummaryInformationProperties, readSummaryInformation, writeSummaryInformationStream } from "./oleps/summary-information.js";
 import { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata } from "./oleps/layout-metadata.js";
 import { PropertySet, PropertyValue } from "./oleps/wire.js";
@@ -10,4 +13,4 @@ import { PropertySetWriteError, writePropertySetStream } from "./oleps/write.js"
 import { ZipEntry, unzipPackage, zipPackage } from "./zip/container.js";
 import { ArchiveFormat, detectArchiveFormat, isZipArchive } from "./zip/detect.js";
 import { ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, WalkArchiveOptions, walkArchive } from "./zip/walk.js";
-export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };
+export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackage, OlePackageFormatError, OlePackageWriteError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/dist/index.js

@@ -2,6 +2,9 @@ import { isCompoundFile } from "./cfb/detect.js";
 import { OlePackageFormatError, OlePackageWriteError, readOlePackage, writeOlePackage } from "./cfb/ole-package.js";
 import { CompoundFileFormatError, MAX_CFB_TOTAL_STREAM_BYTES, readCompoundFile } from "./cfb/read.js";
 import { CompoundFileWriteError, writeCompoundFile } from "./cfb/write.js";
+import { md5 } from "./crypto/md5.js";
+import { rc4 } from "./crypto/rc4.js";
+import { OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey } from "./crypto/office-rc4.js";
 import { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata } from "./oleps/layout-metadata.js";
 import { PropertySetFormatError, readPropertySetStream } from "./oleps/read.js";
 import { PropertySetWriteError, writePropertySetStream } from "./oleps/write.js";
@@ -9,4 +12,4 @@ import { FMTID_SUMMARY_INFORMATION, readSummaryInformation, writeSummaryInformat
 import { unzipPackage, zipPackage } from "./zip/container.js";
 import { detectArchiveFormat, isZipArchive } from "./zip/detect.js";
 import { ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, walkArchive } from "./zip/walk.js";
-export { ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackageFormatError, OlePackageWriteError, PropertySetFormatError, PropertySetWriteError, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };
+export { ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileWriteError, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OFFICE_RC4_BLOCK_SIZE, OFFICE_RC4_VERIFIER_LENGTH, OlePackageFormatError, OlePackageWriteError, PropertySetFormatError, PropertySetWriteError, decryptOfficeRc4, deriveOfficeRc4BaseHash, deriveOfficeRc4BlockKey, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, md5, rc4, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writeOlePackage, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archive-codec",
-  "version": "1.6.8",
+  "version": "1.7.1",
   "description": "ZIP-in-ZIP recursive walking with depth and cumulative decompressed-size guards, bounded classic OLE compound-file ([MS-CFB]) reading and writing, and [MS-OLEPS] Property Set Stream reading and writing - zero document-format knowledge, the archive and container utility package for the documents.js family.",
   "type": "module",
   "repository": {
@@ -70,26 +70,23 @@
   },
   "packageManager": "pnpm@11.6.0",
   "dependencies": {
-    "document-schema.js": "^7.3.0",
-    "fflate": "^0.8.2"
+    "document-schema.js": "7.3.1",
+    "fflate": "0.8.3"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.18.5",
-    "@cloudflare/vitest-pool-workers": "^0.20.1",
-    "@stryker-mutator/core": "^10.0.0",
-    "@stryker-mutator/typescript-checker": "^10.0.0",
-    "@stryker-mutator/vitest-runner": "^10.0.0",
-    "@types/node": "^26.1.2",
-    "eslint": "^10.8.0",
-    "husky": "^9.1.7",
+    "@arethetypeswrong/cli": "0.18.5",
+    "@cloudflare/vitest-pool-workers": "0.21.2",
+    "@stryker-mutator/core": "10.0.0",
+    "@stryker-mutator/typescript-checker": "10.0.0",
+    "@stryker-mutator/vitest-runner": "10.0.0",
+    "@types/node": "26.2.0",
+    "eslint": "10.8.1",
+    "husky": "9.1.7",
     "jiti": "2.7.0",
-    "publint": "^0.3.21",
-    "tsdown": "^0.22.13",
-    "turbo": "^2.10.8",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.10"
-  },
-  "lint-staged": {
-    "*.ts": "eslint --fix"
+    "publint": "0.3.22",
+    "tsdown": "0.22.14",
+    "turbo": "2.10.8",
+    "typescript": "6.0.3",
+    "vitest": "4.1.11"
   }
 }