archive-codec 1.1.2 → 1.3.0

package/README.md

@@ -2,13 +2,15 @@
 
 [![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, and bounded classic OLE compound-file ([MS-CFB]) reading — 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, and classic OLE compound-file ([MS-CFB]) 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.
 
 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.
 
 [documents.js#739](https://github.com/ExaDev/documents.js/issues/739) widened the charter from that ZIP-only v1 scope to the classic OLE compound file, recording the decision explicitly rather than by accident (mirroring the #564 reasoning): real-world Word and PowerPoint files frequently store the embeddee as a `.bin` compound file at `word|ppt/embeddings/oleObject1.bin`, and a CFB reader is container knowledge exactly the way ZIP structure is — sectors, FAT chains, and directory entries, never that any stream is a document. The same recovery now unwraps such a payload's `Package` stream ([MS-OLEDS]'s OLE packaging of the real file) through this package and feeds the packaged ZIP to the unchanged nested decode.
 
-Scope: **ZIP containers** (read and write over [`fflate`](https://github.com/101arrowz/fflate), recursive walking of ZIP-in-ZIP entries) and **classic OLE compound files** (bounded [MS-CFB] reading, plus the OLE Package stream unwrapping). **tar and gzip are explicitly out of scope.**
+[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) then needed the other direction. `xls-codec`, `doc-codec`, `ppt-codec`, and `wpd-codec` each read a legacy Office binary format out of an [MS-CFB] container, and none of them can write one back, because there was no container to put their streams into: a `.xls` writer producing a `Workbook` stream, or a `.doc` writer producing `WordDocument` and `1Table`, needs a conformant compound file to hold them. That container is structural knowledge exactly as the reader's is, so `writeCompoundFile` is the mirror of `readCompoundFile` here rather than four hand-rolled emitters in four codecs.
+
+Scope: **ZIP containers** (read and write over [`fflate`](https://github.com/101arrowz/fflate), recursive walking of ZIP-in-ZIP entries) and **classic OLE compound files** (bounded [MS-CFB] reading and conformant [MS-CFB] writing, plus the OLE Package stream unwrapping). **tar and gzip are explicitly out of scope.**
 
 ## Getting started
 
@@ -32,33 +34,34 @@ To run a single test file, pass its path to vitest directly, e.g. `pnpm exec vit
 Every module is importable by package-relative path as well as through the barrel — `tsdown` builds one dist file per src module (`root: 'src'`, the same layout ooxml.js ships), and `package.json`'s `./*` exports wildcard maps each subpath onto it:
 
 ```ts
-import { readCompoundFile } from 'archive-codec/cfb/read';
-import { walkArchive } from 'archive-codec/zip/walk';
+import { readCompoundFile } from "archive-codec/cfb/read";
+import { walkArchive } from "archive-codec/zip/walk";
 ```
 
 The smoke suite (`test/smoke.test.mjs`) is the guard on that advertisement: it loads each module below from the built `dist/` in both module systems, so a build config that stops serving an advertised subpath fails the suite — neither publint nor `attw` catches a wildcard whose targets are missing.
 
-| Module | Exports |
-|---|---|
-| `zip/container` | `zipPackage` (ordered-entries ZIP write with stored-uncompressed support), `unzipPackage`, `ZipEntry` |
-| `zip/detect` | `detectArchiveFormat` (`'zip' \| 'cfb' \| 'unknown'`), `isZipArchive`, `ArchiveFormat` |
-| `zip/walk` | `walkArchive` (recursive ZIP-in-ZIP walking), `ArchiveWalkEntry`, `ArchiveWalkLimitError`, `MAX_WALK_DEPTH`, `MAX_WALK_TOTAL_BYTES`, `WalkArchiveOptions` |
-| `cfb/detect` | `isCompoundFile` (the `D0 CF 11 E0 …` magic-byte check) |
-| `cfb/read` | `readCompoundFile` (bounded [MS-CFB] stream extraction), `CompoundFileStream`, `CompoundFileFormatError`, `MAX_CFB_TOTAL_STREAM_BYTES`, `ReadCompoundFileOptions` |
-| `cfb/ole-package` | `readOlePackage` (OLE Package stream unwrapping), `OlePackage`, `OlePackageFormatError` |
+| Module            | Exports                                                                                                                                                             |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `zip/container`   | `zipPackage` (ordered-entries ZIP write with stored-uncompressed support), `unzipPackage`, `ZipEntry`                                                               |
+| `zip/detect`      | `detectArchiveFormat` (`'zip' \| 'cfb' \| 'unknown'`), `isZipArchive`, `ArchiveFormat`                                                                              |
+| `zip/walk`        | `walkArchive` (recursive ZIP-in-ZIP walking), `ArchiveWalkEntry`, `ArchiveWalkLimitError`, `MAX_WALK_DEPTH`, `MAX_WALK_TOTAL_BYTES`, `WalkArchiveOptions`           |
+| `cfb/detect`      | `isCompoundFile` (the `D0 CF 11 E0 …` magic-byte check)                                                                                                             |
+| `cfb/read`        | `readCompoundFile` (bounded [MS-CFB] stream extraction), `CompoundFileStream`, `CompoundFileFormatError`, `MAX_CFB_TOTAL_STREAM_BYTES`, `ReadCompoundFileOptions`   |
+| `cfb/write`       | `writeCompoundFile` ([MS-CFB] container generation), `CompoundFileWriteError`, `WriteCompoundFileOptions` — takes the `CompoundFileStream` array `cfb/read` returns |
+| `cfb/ole-package` | `readOlePackage` (OLE Package stream unwrapping), `OlePackage`, `OlePackageFormatError`                                                                             |
 
 ### Recursive walking
 
 ```ts
-import { walkArchive } from 'archive-codec';
+import { walkArchive } from "archive-codec";
 
 // Every entry of every nested ZIP, flattened. Throws ArchiveWalkLimitError if
 // the walk exceeds the depth cap or the cumulative decompressed-bytes budget.
 for (const entry of walkArchive(docxBytes)) {
-  entry.path;      // e.g. 'xl/workbook.xml', the path within its own archive
+  entry.path; // e.g. 'xl/workbook.xml', the path within its own archive
   entry.ancestors; // e.g. ['word/embeddings/oleObject1.xlsx'] -- the nested
-                   // ZIP entries descended through to reach this one
-  entry.bytes;     // decompressed content
+  // ZIP entries descended through to reach this one
+  entry.bytes; // decompressed content
 }
 ```
 
@@ -67,18 +70,20 @@ Both guards throw rather than truncate: an input outside the contract must fail
 ### Compound files
 
 ```ts
-import { readCompoundFile, readOlePackage } from 'archive-codec';
+import { readCompoundFile, readOlePackage } from "archive-codec";
 
 // Every stream of a classic OLE compound file, with its storage path.
 // Throws CompoundFileFormatError on any structural nonconformance.
 for (const stream of readCompoundFile(oleBinBytes)) {
-  stream.path;  // e.g. 'Package' -- root-level, or 'ObjectStorage/Package'
+  stream.path; // e.g. 'Package' -- root-level, or 'ObjectStorage/Package'
   stream.bytes; // the stream's content
 }
 
 // The OLE packaging a Word/PowerPoint embed wraps the real file in before
 // storing it as the 'Package' stream: label, paths, and the file's bytes.
-const packageStream = readCompoundFile(oleBinBytes).find((s) => s.path === 'Package');
+const packageStream = readCompoundFile(oleBinBytes).find(
+  (s) => s.path === "Package",
+);
 if (packageStream !== undefined) {
   readOlePackage(packageStream.bytes).fileBytes; // often a ZIP for a modern embed
 }
@@ -86,9 +91,31 @@ if (packageStream !== undefined) {
 
 Reading is bounded the same way walking is: chain cycles and out-of-range sectors fail against bounds derived from the file's own sector count, and one cumulative extracted-bytes budget (`MAX_CFB_TOTAL_STREAM_BYTES`, 512 MiB — the same figure the family grants one decompressed stream) bounds the multiplication a hostile FAT gains by aliasing one sector into many streams. Every structural failure throws rather than truncating — a malformed compound file fails whole, never a partial stream listing that looks complete. Version 3 (512-byte sectors) and version 4 (4096-byte) files both read; the mini-FAT path every stream shorter than the header's cutoff takes is first-class, because a small real-world embed genuinely lands there.
 
+Writing is the mirror image, taking the same `CompoundFileStream` array reading returns:
+
+```ts
+import { readCompoundFile, writeCompoundFile } from "archive-codec";
+
+const bytes = writeCompoundFile([
+  { path: "WordDocument", bytes: mainStream },
+  { path: "1Table", bytes: tableStream },
+  { path: "SummaryInformation", bytes: summaryStream },
+  { path: "ObjectPool/_1234/Package", bytes: embeddedFile }, // a nested storage
+]);
+
+// ... so re-writing what was read is a round trip, not a translation.
+writeCompoundFile(readCompoundFile(bytes));
+```
+
+Slash-separated paths name the enclosing storages exactly as reading reports them, so nested storages are written as well as read; a request that cannot be expressed as a conformant file throws `CompoundFileWriteError` rather than producing bytes that only look valid — an over-long or illegally named entry (`\`, `:`, and `!` are the characters [MS-CFB] forbids), an empty path segment, two siblings whose names collide under the format's case-insensitive ordering, or a version 3 stream past the 2 GB the format allows one. Both allocation paths are written: a stream at or above the 4096-byte cutoff takes FAT-chained sectors, one below it a run of 64-byte mini sectors in the root entry's own mini stream. Files past the 6.875 MiB that the header's own 109-entry DIFAT array can address spill into chained DIFAT sectors rather than failing, which matters because a real `.doc` or `.xls` reaches that size routinely.
+
+Two details are deliberate rather than incidental. The directory's sibling trees are genuine red-black trees — balanced by construction and coloured so that every [MS-CFB] 2.6.4 constraint holds, including the black-height property — because the sibling tree exists to be binary-searched by name, and the degenerate right-sibling chain that a purely structural reader would still accept is not a search tree. And the output depends only on the set of paths, never on the order they were supplied in, since the directory's order is the format's own name ordering: two callers building the same file from differently ordered lists get identical bytes.
+
+Correctness is checked against independent parsers, not only against this package's own reader: the written files are accepted by [`olefile`](https://github.com/decalage2/olefile) in its strict `DEFECT_INCORRECT` mode and by 7-Zip's Compound handler, both of which return byte-identical stream content, and a real LibreOffice-authored `.doc` read through `readCompoundFile` and re-emitted through `writeCompoundFile` still opens in LibreOffice Writer.
+
 ### 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.
+`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.
 
 ## Conventions
 

package/dist/cfb/read.cjs

@@ -113,7 +113,7 @@ function readCompoundFile(bytes, options = {}) {
 		});
 	}
 	const root = entries[0];
-	if (root === void 0 || root.objectType !== OBJECT_TYPE_ROOT) throw new CompoundFileFormatError("the first directory entry is not the root storage entry (object type 5), as [MS-CFB] 2.6.1 requires");
+	if (root?.objectType !== OBJECT_TYPE_ROOT) throw new CompoundFileFormatError("the first directory entry is not the root storage entry (object type 5), as [MS-CFB] 2.6.1 requires");
 	const miniStream = chainBytes(root.startSector).subarray(0, root.size);
 	const miniSectorCount = Math.floor(miniStream.length / miniSectorSize);
 	const miniFatBytes = chainBytes(firstMiniFatSector);

package/dist/cfb/read.js

@@ -112,7 +112,7 @@ function readCompoundFile(bytes, options = {}) {
 		});
 	}
 	const root = entries[0];
-	if (root === void 0 || root.objectType !== OBJECT_TYPE_ROOT) throw new CompoundFileFormatError("the first directory entry is not the root storage entry (object type 5), as [MS-CFB] 2.6.1 requires");
+	if (root?.objectType !== OBJECT_TYPE_ROOT) throw new CompoundFileFormatError("the first directory entry is not the root storage entry (object type 5), as [MS-CFB] 2.6.1 requires");
 	const miniStream = chainBytes(root.startSector).subarray(0, root.size);
 	const miniSectorCount = Math.floor(miniStream.length / miniSectorSize);
 	const miniFatBytes = chainBytes(firstMiniFatSector);

package/dist/cfb/write.cjs

@@ -0,0 +1,297 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/cfb/write.ts
+const ENDOFCHAIN = 4294967294;
+const FATSECT = 4294967293;
+const DIFSECT = 4294967292;
+const NOSTREAM = 4294967295;
+const FREESECT_FILL_BYTE = 255;
+const HEADER_DIFAT_ENTRIES = 109;
+const HEADER_DIFAT_OFFSET = 76;
+const DIRECTORY_ENTRY_SIZE = 128;
+const MAX_NAME_CODE_UNITS = 31;
+const MINI_SECTOR_SHIFT = 6;
+const MINI_SECTOR_SIZE = 64;
+const MINI_STREAM_CUTOFF = 4096;
+const OBJECT_TYPE_STORAGE = 1;
+const OBJECT_TYPE_STREAM = 2;
+const OBJECT_TYPE_ROOT = 5;
+const COLOUR_RED = 0;
+const COLOUR_BLACK = 1;
+const ROOT_ENTRY_NAME = "Root Entry";
+const MAX_VERSION_3_STREAM_BYTES = 2147483648;
+const ILLEGAL_NAME_CHARACTERS = [
+	"\\",
+	":",
+	"!"
+];
+var CompoundFileWriteError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CompoundFileWriteError";
+	}
+};
+function isStorage(node) {
+	return "children" in node;
+}
+function objectTypeOf(entry) {
+	if (entry.id === 0) return OBJECT_TYPE_ROOT;
+	return isStorage(entry.node) ? OBJECT_TYPE_STORAGE : OBJECT_TYPE_STREAM;
+}
+function upperCodeUnit(value, index) {
+	const unit = value.charCodeAt(index);
+	if (unit >= 55296 && unit <= 57343) return unit;
+	const upper = String.fromCharCode(unit).toUpperCase();
+	return upper.length === 1 ? upper.charCodeAt(0) : unit;
+}
+function compareEntryNames(left, right) {
+	if (left.length !== right.length) return left.length - right.length;
+	for (let i = 0; i < left.length; i++) {
+		const difference = upperCodeUnit(left, i) - upperCodeUnit(right, i);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+function checkedSegment(name, path) {
+	if (name.length === 0) throw new CompoundFileWriteError(`stream path ${JSON.stringify(path)} has an empty name segment; every segment must name a storage, and the last must name the stream`);
+	if (name.length > MAX_NAME_CODE_UNITS) throw new CompoundFileWriteError(`'${name}' is ${name.length} UTF-16 code points, more than the ${MAX_NAME_CODE_UNITS} a directory entry's name field holds alongside its terminating null (in stream path ${JSON.stringify(path)})`);
+	for (const illegal of ILLEGAL_NAME_CHARACTERS) if (name.includes(illegal)) throw new CompoundFileWriteError(`'${name}' holds '${illegal}', which [MS-CFB] 2.6.1 forbids in a storage or stream name (in stream path ${JSON.stringify(path)})`);
+	return name;
+}
+function addStream(root, path, bytes) {
+	const segments = path.split("/");
+	let storage = root;
+	let depth = 0;
+	for (const segment of segments) {
+		depth += 1;
+		const name = checkedSegment(segment, path);
+		const existing = storage.children.find((child) => compareEntryNames(child.name, name) === 0);
+		if (depth === segments.length) {
+			if (existing !== void 0) throw new CompoundFileWriteError(`stream path ${JSON.stringify(path)} collides with '${existing.name}', which the file already holds in the same storage ([MS-CFB] 2.6.4 requires siblings to have unique names)`);
+			storage.children.push({
+				name,
+				bytes
+			});
+		} else if (existing === void 0) {
+			const created = {
+				name,
+				children: []
+			};
+			storage.children.push(created);
+			storage = created;
+		} else if (isStorage(existing)) storage = existing;
+		else throw new CompoundFileWriteError(`stream path ${JSON.stringify(path)} needs '${existing.name}' to be a storage, but the file already holds a stream by that name`);
+	}
+}
+function deepestDepth(count) {
+	return count === 0 ? 0 : 31 - Math.clz32(count);
+}
+function linkSiblings(siblings, depth, deepest) {
+	const midpoint = siblings.length >> 1;
+	const before = siblings.slice(0, midpoint);
+	const [node, ...after] = siblings.slice(midpoint);
+	if (node === void 0) return;
+	node.colour = depth === deepest && deepest > 0 ? COLOUR_RED : COLOUR_BLACK;
+	const left = linkSiblings(before, depth + 1, deepest);
+	const right = linkSiblings(after, depth + 1, deepest);
+	node.left = left === void 0 ? NOSTREAM : left.id;
+	node.right = right === void 0 ? NOSTREAM : right.id;
+	return node;
+}
+function planDirectory(root) {
+	const plans = [];
+	const plan = (node) => {
+		const created = {
+			id: plans.length,
+			node,
+			left: NOSTREAM,
+			right: NOSTREAM,
+			child: NOSTREAM,
+			colour: COLOUR_BLACK,
+			startSector: 0,
+			size: 0
+		};
+		plans.push(created);
+		return created;
+	};
+	const rootPlan = plan(root);
+	let frontier = [rootPlan];
+	while (frontier.length > 0) {
+		const next = [];
+		for (const parent of frontier) {
+			const node = parent.node;
+			if (!isStorage(node)) continue;
+			node.children.sort((left, right) => compareEntryNames(left.name, right.name));
+			const children = [];
+			for (const child of node.children) {
+				const childPlan = plan(child);
+				children.push(childPlan);
+				next.push(childPlan);
+			}
+			const subtree = linkSiblings(children, 0, deepestDepth(children.length));
+			parent.child = subtree === void 0 ? NOSTREAM : subtree.id;
+		}
+		frontier = next;
+	}
+	return {
+		rootPlan,
+		plans
+	};
+}
+function writeCompoundFile(streams, options = {}) {
+	const majorVersion = options.majorVersion ?? 3;
+	const sectorShift = majorVersion === 4 ? 12 : 9;
+	const sectorSize = 1 << sectorShift;
+	const entriesPerFatSector = sectorSize / 4;
+	const entriesPerDirectorySector = sectorSize / DIRECTORY_ENTRY_SIZE;
+	const difatEntriesPerSector = entriesPerFatSector - 1;
+	const root = {
+		name: ROOT_ENTRY_NAME,
+		children: []
+	};
+	for (const { path, bytes } of streams) {
+		if (majorVersion === 3 && bytes.length > MAX_VERSION_3_STREAM_BYTES) throw new CompoundFileWriteError(`stream ${JSON.stringify(path)} is ${bytes.length} bytes, past the ${MAX_VERSION_3_STREAM_BYTES}-byte ceiling [MS-CFB] 2.6.1 puts on a version 3 stream; write the file as version 4 instead`);
+		addStream(root, path, bytes);
+	}
+	const { rootPlan, plans } = planDirectory(root);
+	const miniResident = [];
+	const fatResident = [];
+	for (const entry of plans) {
+		const node = entry.node;
+		if (isStorage(node)) continue;
+		entry.size = node.bytes.length;
+		if (node.bytes.length === 0) entry.startSector = ENDOFCHAIN;
+		else if (node.bytes.length < MINI_STREAM_CUTOFF) miniResident.push({
+			entry,
+			bytes: node.bytes
+		});
+		else fatResident.push({
+			entry,
+			bytes: node.bytes
+		});
+	}
+	let miniSectorCount = 0;
+	for (const { entry, bytes } of miniResident) {
+		entry.startSector = miniSectorCount;
+		miniSectorCount += Math.ceil(bytes.length / MINI_SECTOR_SIZE);
+	}
+	const miniStreamBytes = miniSectorCount * MINI_SECTOR_SIZE;
+	const directorySectorCount = Math.ceil(plans.length / entriesPerDirectorySector);
+	const miniStreamSectorCount = Math.ceil(miniStreamBytes / sectorSize);
+	const miniFatSectorCount = Math.ceil(miniSectorCount / entriesPerFatSector);
+	let fatStreamSectorCount = 0;
+	for (const { bytes } of fatResident) fatStreamSectorCount += Math.ceil(bytes.length / sectorSize);
+	const totalSectorsGiven = (fat, difat) => fat + difat + directorySectorCount + fatStreamSectorCount + miniStreamSectorCount + miniFatSectorCount;
+	let fatSectorCount = 1;
+	let difatSectorCount = 0;
+	for (;;) {
+		const neededFat = Math.max(1, Math.ceil(totalSectorsGiven(fatSectorCount, difatSectorCount) / entriesPerFatSector));
+		const neededDifat = neededFat <= HEADER_DIFAT_ENTRIES ? 0 : Math.ceil((neededFat - HEADER_DIFAT_ENTRIES) / difatEntriesPerSector);
+		if (neededFat === fatSectorCount && neededDifat === difatSectorCount) break;
+		fatSectorCount = neededFat;
+		difatSectorCount = neededDifat;
+	}
+	const totalSectors = totalSectorsGiven(fatSectorCount, difatSectorCount);
+	const difatStart = fatSectorCount;
+	const directoryStart = difatStart + difatSectorCount;
+	let nextSector = directoryStart + directorySectorCount;
+	for (const { entry, bytes } of fatResident) {
+		entry.startSector = nextSector;
+		nextSector += Math.ceil(bytes.length / sectorSize);
+	}
+	const miniStreamStart = nextSector;
+	nextSector += miniStreamSectorCount;
+	const miniFatStart = nextSector;
+	rootPlan.startSector = miniSectorCount === 0 ? ENDOFCHAIN : miniStreamStart;
+	rootPlan.size = miniStreamBytes;
+	const file = new Uint8Array(sectorSize * (1 + totalSectors));
+	const view = new DataView(file.buffer);
+	const putU16 = (offset, value) => {
+		view.setUint16(offset, value, true);
+	};
+	const putU32 = (offset, value) => {
+		view.setUint32(offset, value, true);
+	};
+	const sectorOffset = (sector) => (sector + 1) * sectorSize;
+	file.fill(FREESECT_FILL_BYTE, sectorOffset(0), sectorOffset(0) + fatSectorCount * sectorSize);
+	file.fill(FREESECT_FILL_BYTE, sectorOffset(miniFatStart), sectorOffset(miniFatStart) + miniFatSectorCount * sectorSize);
+	file.fill(FREESECT_FILL_BYTE, sectorOffset(difatStart), sectorOffset(difatStart) + difatSectorCount * sectorSize);
+	file.fill(FREESECT_FILL_BYTE, HEADER_DIFAT_OFFSET, 512);
+	const setFat = (sector, value) => {
+		putU32(sectorOffset(Math.floor(sector / entriesPerFatSector)) + sector % entriesPerFatSector * 4, value);
+	};
+	const chainSectors = (start, count) => {
+		for (let i = 0; i < count; i++) setFat(start + i, i === count - 1 ? ENDOFCHAIN : start + i + 1);
+	};
+	for (let i = 0; i < fatSectorCount; i++) setFat(i, FATSECT);
+	for (let i = 0; i < difatSectorCount; i++) setFat(difatStart + i, DIFSECT);
+	chainSectors(directoryStart, directorySectorCount);
+	for (const { entry, bytes } of fatResident) chainSectors(entry.startSector, Math.ceil(bytes.length / sectorSize));
+	chainSectors(miniStreamStart, miniStreamSectorCount);
+	chainSectors(miniFatStart, miniFatSectorCount);
+	for (let i = 0; i < Math.min(fatSectorCount, HEADER_DIFAT_ENTRIES); i++) putU32(HEADER_DIFAT_OFFSET + i * 4, i);
+	for (let sector = 0; sector < difatSectorCount; sector++) {
+		const base = sectorOffset(difatStart + sector);
+		for (let i = 0; i < difatEntriesPerSector; i++) {
+			const fatIndex = HEADER_DIFAT_ENTRIES + sector * difatEntriesPerSector + i;
+			if (fatIndex < fatSectorCount) putU32(base + i * 4, fatIndex);
+		}
+		putU32(base + difatEntriesPerSector * 4, sector === difatSectorCount - 1 ? ENDOFCHAIN : difatStart + sector + 1);
+	}
+	const setMiniFat = (miniSector, value) => {
+		putU32(sectorOffset(miniFatStart + Math.floor(miniSector / entriesPerFatSector)) + miniSector % entriesPerFatSector * 4, value);
+	};
+	for (const { entry, bytes } of miniResident) {
+		const count = Math.ceil(bytes.length / MINI_SECTOR_SIZE);
+		for (let i = 0; i < count; i++) setMiniFat(entry.startSector + i, i === count - 1 ? ENDOFCHAIN : entry.startSector + i + 1);
+	}
+	for (const { entry, bytes } of fatResident) file.set(bytes, sectorOffset(entry.startSector));
+	for (const { entry, bytes } of miniResident) file.set(bytes, sectorOffset(miniStreamStart) + entry.startSector * MINI_SECTOR_SIZE);
+	const entryOffset = (id) => sectorOffset(directoryStart + Math.floor(id / entriesPerDirectorySector)) + id % entriesPerDirectorySector * DIRECTORY_ENTRY_SIZE;
+	for (const entry of plans) {
+		const base = entryOffset(entry.id);
+		const name = entry.node.name;
+		for (let i = 0; i < name.length; i++) putU16(base + i * 2, name.charCodeAt(i));
+		putU16(base + 64, (name.length + 1) * 2);
+		view.setUint8(base + 66, objectTypeOf(entry));
+		view.setUint8(base + 67, entry.colour);
+		putU32(base + 68, entry.left);
+		putU32(base + 72, entry.right);
+		putU32(base + 76, entry.child);
+		putU32(base + 116, entry.startSector);
+		putU32(base + 120, entry.size >>> 0);
+		putU32(base + 124, Math.floor(entry.size / 4294967296));
+	}
+	for (let id = plans.length; id < directorySectorCount * entriesPerDirectorySector; id++) {
+		const base = entryOffset(id);
+		putU32(base + 68, NOSTREAM);
+		putU32(base + 72, NOSTREAM);
+		putU32(base + 76, NOSTREAM);
+	}
+	file.set([
+		208,
+		207,
+		17,
+		224,
+		161,
+		177,
+		26,
+		225
+	], 0);
+	putU16(24, 62);
+	putU16(26, majorVersion);
+	putU16(28, 65534);
+	putU16(30, sectorShift);
+	putU16(32, MINI_SECTOR_SHIFT);
+	putU32(40, majorVersion === 3 ? 0 : directorySectorCount);
+	putU32(44, fatSectorCount);
+	putU32(48, directoryStart);
+	putU32(56, MINI_STREAM_CUTOFF);
+	putU32(60, miniFatSectorCount === 0 ? ENDOFCHAIN : miniFatStart);
+	putU32(64, miniFatSectorCount);
+	putU32(68, difatSectorCount === 0 ? ENDOFCHAIN : difatStart);
+	putU32(72, difatSectorCount);
+	return file;
+}
+//#endregion
+exports.CompoundFileWriteError = CompoundFileWriteError;
+exports.writeCompoundFile = writeCompoundFile;

package/dist/cfb/write.d.cts

@@ -0,0 +1,11 @@
+import { CompoundFileStream } from "./read.cjs";
+//#region src/cfb/write.d.ts
+declare class CompoundFileWriteError extends Error {
+  constructor(message: string);
+}
+interface WriteCompoundFileOptions {
+  readonly majorVersion?: 3 | 4;
+}
+declare function writeCompoundFile(streams: readonly CompoundFileStream[], options?: WriteCompoundFileOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { CompoundFileWriteError, WriteCompoundFileOptions, writeCompoundFile };

package/dist/cfb/write.d.ts

@@ -0,0 +1,11 @@
+import { CompoundFileStream } from "./read.js";
+//#region src/cfb/write.d.ts
+declare class CompoundFileWriteError extends Error {
+  constructor(message: string);
+}
+interface WriteCompoundFileOptions {
+  readonly majorVersion?: 3 | 4;
+}
+declare function writeCompoundFile(streams: readonly CompoundFileStream[], options?: WriteCompoundFileOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { CompoundFileWriteError, WriteCompoundFileOptions, writeCompoundFile };

package/dist/cfb/write.js

@@ -0,0 +1,295 @@
+//#region src/cfb/write.ts
+const ENDOFCHAIN = 4294967294;
+const FATSECT = 4294967293;
+const DIFSECT = 4294967292;
+const NOSTREAM = 4294967295;
+const FREESECT_FILL_BYTE = 255;
+const HEADER_DIFAT_ENTRIES = 109;
+const HEADER_DIFAT_OFFSET = 76;
+const DIRECTORY_ENTRY_SIZE = 128;
+const MAX_NAME_CODE_UNITS = 31;
+const MINI_SECTOR_SHIFT = 6;
+const MINI_SECTOR_SIZE = 64;
+const MINI_STREAM_CUTOFF = 4096;
+const OBJECT_TYPE_STORAGE = 1;
+const OBJECT_TYPE_STREAM = 2;
+const OBJECT_TYPE_ROOT = 5;
+const COLOUR_RED = 0;
+const COLOUR_BLACK = 1;
+const ROOT_ENTRY_NAME = "Root Entry";
+const MAX_VERSION_3_STREAM_BYTES = 2147483648;
+const ILLEGAL_NAME_CHARACTERS = [
+	"\\",
+	":",
+	"!"
+];
+var CompoundFileWriteError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CompoundFileWriteError";
+	}
+};
+function isStorage(node) {
+	return "children" in node;
+}
+function objectTypeOf(entry) {
+	if (entry.id === 0) return OBJECT_TYPE_ROOT;
+	return isStorage(entry.node) ? OBJECT_TYPE_STORAGE : OBJECT_TYPE_STREAM;
+}
+function upperCodeUnit(value, index) {
+	const unit = value.charCodeAt(index);
+	if (unit >= 55296 && unit <= 57343) return unit;
+	const upper = String.fromCharCode(unit).toUpperCase();
+	return upper.length === 1 ? upper.charCodeAt(0) : unit;
+}
+function compareEntryNames(left, right) {
+	if (left.length !== right.length) return left.length - right.length;
+	for (let i = 0; i < left.length; i++) {
+		const difference = upperCodeUnit(left, i) - upperCodeUnit(right, i);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+function checkedSegment(name, path) {
+	if (name.length === 0) throw new CompoundFileWriteError(`stream path ${JSON.stringify(path)} has an empty name segment; every segment must name a storage, and the last must name the stream`);
+	if (name.length > MAX_NAME_CODE_UNITS) throw new CompoundFileWriteError(`'${name}' is ${name.length} UTF-16 code points, more than the ${MAX_NAME_CODE_UNITS} a directory entry's name field holds alongside its terminating null (in stream path ${JSON.stringify(path)})`);
+	for (const illegal of ILLEGAL_NAME_CHARACTERS) if (name.includes(illegal)) throw new CompoundFileWriteError(`'${name}' holds '${illegal}', which [MS-CFB] 2.6.1 forbids in a storage or stream name (in stream path ${JSON.stringify(path)})`);
+	return name;
+}
+function addStream(root, path, bytes) {
+	const segments = path.split("/");
+	let storage = root;
+	let depth = 0;
+	for (const segment of segments) {
+		depth += 1;
+		const name = checkedSegment(segment, path);
+		const existing = storage.children.find((child) => compareEntryNames(child.name, name) === 0);
+		if (depth === segments.length) {
+			if (existing !== void 0) throw new CompoundFileWriteError(`stream path ${JSON.stringify(path)} collides with '${existing.name}', which the file already holds in the same storage ([MS-CFB] 2.6.4 requires siblings to have unique names)`);
+			storage.children.push({
+				name,
+				bytes
+			});
+		} else if (existing === void 0) {
+			const created = {
+				name,
+				children: []
+			};
+			storage.children.push(created);
+			storage = created;
+		} else if (isStorage(existing)) storage = existing;
+		else throw new CompoundFileWriteError(`stream path ${JSON.stringify(path)} needs '${existing.name}' to be a storage, but the file already holds a stream by that name`);
+	}
+}
+function deepestDepth(count) {
+	return count === 0 ? 0 : 31 - Math.clz32(count);
+}
+function linkSiblings(siblings, depth, deepest) {
+	const midpoint = siblings.length >> 1;
+	const before = siblings.slice(0, midpoint);
+	const [node, ...after] = siblings.slice(midpoint);
+	if (node === void 0) return;
+	node.colour = depth === deepest && deepest > 0 ? COLOUR_RED : COLOUR_BLACK;
+	const left = linkSiblings(before, depth + 1, deepest);
+	const right = linkSiblings(after, depth + 1, deepest);
+	node.left = left === void 0 ? NOSTREAM : left.id;
+	node.right = right === void 0 ? NOSTREAM : right.id;
+	return node;
+}
+function planDirectory(root) {
+	const plans = [];
+	const plan = (node) => {
+		const created = {
+			id: plans.length,
+			node,
+			left: NOSTREAM,
+			right: NOSTREAM,
+			child: NOSTREAM,
+			colour: COLOUR_BLACK,
+			startSector: 0,
+			size: 0
+		};
+		plans.push(created);
+		return created;
+	};
+	const rootPlan = plan(root);
+	let frontier = [rootPlan];
+	while (frontier.length > 0) {
+		const next = [];
+		for (const parent of frontier) {
+			const node = parent.node;
+			if (!isStorage(node)) continue;
+			node.children.sort((left, right) => compareEntryNames(left.name, right.name));
+			const children = [];
+			for (const child of node.children) {
+				const childPlan = plan(child);
+				children.push(childPlan);
+				next.push(childPlan);
+			}
+			const subtree = linkSiblings(children, 0, deepestDepth(children.length));
+			parent.child = subtree === void 0 ? NOSTREAM : subtree.id;
+		}
+		frontier = next;
+	}
+	return {
+		rootPlan,
+		plans
+	};
+}
+function writeCompoundFile(streams, options = {}) {
+	const majorVersion = options.majorVersion ?? 3;
+	const sectorShift = majorVersion === 4 ? 12 : 9;
+	const sectorSize = 1 << sectorShift;
+	const entriesPerFatSector = sectorSize / 4;
+	const entriesPerDirectorySector = sectorSize / DIRECTORY_ENTRY_SIZE;
+	const difatEntriesPerSector = entriesPerFatSector - 1;
+	const root = {
+		name: ROOT_ENTRY_NAME,
+		children: []
+	};
+	for (const { path, bytes } of streams) {
+		if (majorVersion === 3 && bytes.length > MAX_VERSION_3_STREAM_BYTES) throw new CompoundFileWriteError(`stream ${JSON.stringify(path)} is ${bytes.length} bytes, past the ${MAX_VERSION_3_STREAM_BYTES}-byte ceiling [MS-CFB] 2.6.1 puts on a version 3 stream; write the file as version 4 instead`);
+		addStream(root, path, bytes);
+	}
+	const { rootPlan, plans } = planDirectory(root);
+	const miniResident = [];
+	const fatResident = [];
+	for (const entry of plans) {
+		const node = entry.node;
+		if (isStorage(node)) continue;
+		entry.size = node.bytes.length;
+		if (node.bytes.length === 0) entry.startSector = ENDOFCHAIN;
+		else if (node.bytes.length < MINI_STREAM_CUTOFF) miniResident.push({
+			entry,
+			bytes: node.bytes
+		});
+		else fatResident.push({
+			entry,
+			bytes: node.bytes
+		});
+	}
+	let miniSectorCount = 0;
+	for (const { entry, bytes } of miniResident) {
+		entry.startSector = miniSectorCount;
+		miniSectorCount += Math.ceil(bytes.length / MINI_SECTOR_SIZE);
+	}
+	const miniStreamBytes = miniSectorCount * MINI_SECTOR_SIZE;
+	const directorySectorCount = Math.ceil(plans.length / entriesPerDirectorySector);
+	const miniStreamSectorCount = Math.ceil(miniStreamBytes / sectorSize);
+	const miniFatSectorCount = Math.ceil(miniSectorCount / entriesPerFatSector);
+	let fatStreamSectorCount = 0;
+	for (const { bytes } of fatResident) fatStreamSectorCount += Math.ceil(bytes.length / sectorSize);
+	const totalSectorsGiven = (fat, difat) => fat + difat + directorySectorCount + fatStreamSectorCount + miniStreamSectorCount + miniFatSectorCount;
+	let fatSectorCount = 1;
+	let difatSectorCount = 0;
+	for (;;) {
+		const neededFat = Math.max(1, Math.ceil(totalSectorsGiven(fatSectorCount, difatSectorCount) / entriesPerFatSector));
+		const neededDifat = neededFat <= HEADER_DIFAT_ENTRIES ? 0 : Math.ceil((neededFat - HEADER_DIFAT_ENTRIES) / difatEntriesPerSector);
+		if (neededFat === fatSectorCount && neededDifat === difatSectorCount) break;
+		fatSectorCount = neededFat;
+		difatSectorCount = neededDifat;
+	}
+	const totalSectors = totalSectorsGiven(fatSectorCount, difatSectorCount);
+	const difatStart = fatSectorCount;
+	const directoryStart = difatStart + difatSectorCount;
+	let nextSector = directoryStart + directorySectorCount;
+	for (const { entry, bytes } of fatResident) {
+		entry.startSector = nextSector;
+		nextSector += Math.ceil(bytes.length / sectorSize);
+	}
+	const miniStreamStart = nextSector;
+	nextSector += miniStreamSectorCount;
+	const miniFatStart = nextSector;
+	rootPlan.startSector = miniSectorCount === 0 ? ENDOFCHAIN : miniStreamStart;
+	rootPlan.size = miniStreamBytes;
+	const file = new Uint8Array(sectorSize * (1 + totalSectors));
+	const view = new DataView(file.buffer);
+	const putU16 = (offset, value) => {
+		view.setUint16(offset, value, true);
+	};
+	const putU32 = (offset, value) => {
+		view.setUint32(offset, value, true);
+	};
+	const sectorOffset = (sector) => (sector + 1) * sectorSize;
+	file.fill(FREESECT_FILL_BYTE, sectorOffset(0), sectorOffset(0) + fatSectorCount * sectorSize);
+	file.fill(FREESECT_FILL_BYTE, sectorOffset(miniFatStart), sectorOffset(miniFatStart) + miniFatSectorCount * sectorSize);
+	file.fill(FREESECT_FILL_BYTE, sectorOffset(difatStart), sectorOffset(difatStart) + difatSectorCount * sectorSize);
+	file.fill(FREESECT_FILL_BYTE, HEADER_DIFAT_OFFSET, 512);
+	const setFat = (sector, value) => {
+		putU32(sectorOffset(Math.floor(sector / entriesPerFatSector)) + sector % entriesPerFatSector * 4, value);
+	};
+	const chainSectors = (start, count) => {
+		for (let i = 0; i < count; i++) setFat(start + i, i === count - 1 ? ENDOFCHAIN : start + i + 1);
+	};
+	for (let i = 0; i < fatSectorCount; i++) setFat(i, FATSECT);
+	for (let i = 0; i < difatSectorCount; i++) setFat(difatStart + i, DIFSECT);
+	chainSectors(directoryStart, directorySectorCount);
+	for (const { entry, bytes } of fatResident) chainSectors(entry.startSector, Math.ceil(bytes.length / sectorSize));
+	chainSectors(miniStreamStart, miniStreamSectorCount);
+	chainSectors(miniFatStart, miniFatSectorCount);
+	for (let i = 0; i < Math.min(fatSectorCount, HEADER_DIFAT_ENTRIES); i++) putU32(HEADER_DIFAT_OFFSET + i * 4, i);
+	for (let sector = 0; sector < difatSectorCount; sector++) {
+		const base = sectorOffset(difatStart + sector);
+		for (let i = 0; i < difatEntriesPerSector; i++) {
+			const fatIndex = HEADER_DIFAT_ENTRIES + sector * difatEntriesPerSector + i;
+			if (fatIndex < fatSectorCount) putU32(base + i * 4, fatIndex);
+		}
+		putU32(base + difatEntriesPerSector * 4, sector === difatSectorCount - 1 ? ENDOFCHAIN : difatStart + sector + 1);
+	}
+	const setMiniFat = (miniSector, value) => {
+		putU32(sectorOffset(miniFatStart + Math.floor(miniSector / entriesPerFatSector)) + miniSector % entriesPerFatSector * 4, value);
+	};
+	for (const { entry, bytes } of miniResident) {
+		const count = Math.ceil(bytes.length / MINI_SECTOR_SIZE);
+		for (let i = 0; i < count; i++) setMiniFat(entry.startSector + i, i === count - 1 ? ENDOFCHAIN : entry.startSector + i + 1);
+	}
+	for (const { entry, bytes } of fatResident) file.set(bytes, sectorOffset(entry.startSector));
+	for (const { entry, bytes } of miniResident) file.set(bytes, sectorOffset(miniStreamStart) + entry.startSector * MINI_SECTOR_SIZE);
+	const entryOffset = (id) => sectorOffset(directoryStart + Math.floor(id / entriesPerDirectorySector)) + id % entriesPerDirectorySector * DIRECTORY_ENTRY_SIZE;
+	for (const entry of plans) {
+		const base = entryOffset(entry.id);
+		const name = entry.node.name;
+		for (let i = 0; i < name.length; i++) putU16(base + i * 2, name.charCodeAt(i));
+		putU16(base + 64, (name.length + 1) * 2);
+		view.setUint8(base + 66, objectTypeOf(entry));
+		view.setUint8(base + 67, entry.colour);
+		putU32(base + 68, entry.left);
+		putU32(base + 72, entry.right);
+		putU32(base + 76, entry.child);
+		putU32(base + 116, entry.startSector);
+		putU32(base + 120, entry.size >>> 0);
+		putU32(base + 124, Math.floor(entry.size / 4294967296));
+	}
+	for (let id = plans.length; id < directorySectorCount * entriesPerDirectorySector; id++) {
+		const base = entryOffset(id);
+		putU32(base + 68, NOSTREAM);
+		putU32(base + 72, NOSTREAM);
+		putU32(base + 76, NOSTREAM);
+	}
+	file.set([
+		208,
+		207,
+		17,
+		224,
+		161,
+		177,
+		26,
+		225
+	], 0);
+	putU16(24, 62);
+	putU16(26, majorVersion);
+	putU16(28, 65534);
+	putU16(30, sectorShift);
+	putU16(32, MINI_SECTOR_SHIFT);
+	putU32(40, majorVersion === 3 ? 0 : directorySectorCount);
+	putU32(44, fatSectorCount);
+	putU32(48, directoryStart);
+	putU32(56, MINI_STREAM_CUTOFF);
+	putU32(60, miniFatSectorCount === 0 ? ENDOFCHAIN : miniFatStart);
+	putU32(64, miniFatSectorCount);
+	putU32(68, difatSectorCount === 0 ? ENDOFCHAIN : difatStart);
+	putU32(72, difatSectorCount);
+	return file;
+}
+//#endregion
+export { CompoundFileWriteError, writeCompoundFile };

package/dist/index.cjs

@@ -2,11 +2,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 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_zip_container = require("./zip/container.cjs");
 const require_zip_detect = require("./zip/detect.cjs");
 const require_zip_walk = require("./zip/walk.cjs");
 exports.ArchiveWalkLimitError = require_zip_walk.ArchiveWalkLimitError;
 exports.CompoundFileFormatError = require_cfb_read.CompoundFileFormatError;
+exports.CompoundFileWriteError = require_cfb_write.CompoundFileWriteError;
 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;
@@ -18,4 +20,5 @@ exports.readCompoundFile = require_cfb_read.readCompoundFile;
 exports.readOlePackage = require_cfb_ole_package.readOlePackage;
 exports.unzipPackage = require_zip_container.unzipPackage;
 exports.walkArchive = require_zip_walk.walkArchive;
+exports.writeCompoundFile = require_cfb_write.writeCompoundFile;
 exports.zipPackage = require_zip_container.zipPackage;

package/dist/index.d.cts

@@ -1,7 +1,8 @@
 import { isCompoundFile } from "./cfb/detect.cjs";
 import { OlePackage, OlePackageFormatError, readOlePackage } 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 { 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, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, ReadCompoundFileOptions, WalkArchiveOptions, ZipEntry, detectArchiveFormat, isCompoundFile, isZipArchive, readCompoundFile, readOlePackage, unzipPackage, walkArchive, zipPackage };
+export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, ReadCompoundFileOptions, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, detectArchiveFormat, isCompoundFile, isZipArchive, readCompoundFile, readOlePackage, unzipPackage, walkArchive, writeCompoundFile, zipPackage };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { isCompoundFile } from "./cfb/detect.js";
 import { OlePackage, OlePackageFormatError, readOlePackage } 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 { 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, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, ReadCompoundFileOptions, WalkArchiveOptions, ZipEntry, detectArchiveFormat, isCompoundFile, isZipArchive, readCompoundFile, readOlePackage, unzipPackage, walkArchive, zipPackage };
+export { ArchiveFormat, ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileStream, CompoundFileWriteError, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, ReadCompoundFileOptions, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, detectArchiveFormat, isCompoundFile, isZipArchive, readCompoundFile, readOlePackage, unzipPackage, walkArchive, writeCompoundFile, zipPackage };

package/dist/index.js

@@ -1,7 +1,8 @@
 import { isCompoundFile } from "./cfb/detect.js";
 import { OlePackageFormatError, readOlePackage } 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 { 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, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackageFormatError, detectArchiveFormat, isCompoundFile, isZipArchive, readCompoundFile, readOlePackage, unzipPackage, walkArchive, zipPackage };
+export { ArchiveWalkLimitError, CompoundFileFormatError, CompoundFileWriteError, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackageFormatError, detectArchiveFormat, isCompoundFile, isZipArchive, readCompoundFile, readOlePackage, unzipPackage, walkArchive, writeCompoundFile, zipPackage };

package/dist/zip/detect.d.cts

@@ -1,5 +1,5 @@
 //#region src/zip/detect.d.ts
-type ArchiveFormat = 'zip' | 'cfb' | 'unknown';
+type ArchiveFormat = "zip" | "cfb" | "unknown";
 declare function isZipArchive(bytes: Uint8Array): boolean;
 declare function detectArchiveFormat(bytes: Uint8Array): ArchiveFormat;
 //#endregion

package/dist/zip/detect.d.ts

@@ -1,5 +1,5 @@
 //#region src/zip/detect.d.ts
-type ArchiveFormat = 'zip' | 'cfb' | 'unknown';
+type ArchiveFormat = "zip" | "cfb" | "unknown";
 declare function isZipArchive(bytes: Uint8Array): boolean;
 declare function detectArchiveFormat(bytes: Uint8Array): ArchiveFormat;
 //#endregion

package/dist/zip/walk.d.cts

@@ -6,7 +6,7 @@ interface ArchiveWalkEntry {
   readonly ancestors: readonly string[];
   readonly bytes: Uint8Array<ArrayBuffer>;
 }
-type ArchiveWalkLimit = 'depth' | 'total-bytes';
+type ArchiveWalkLimit = "depth" | "total-bytes";
 declare class ArchiveWalkLimitError extends Error {
   readonly limit: ArchiveWalkLimit;
   constructor(limit: ArchiveWalkLimit, message: string);

package/dist/zip/walk.d.ts

@@ -6,7 +6,7 @@ interface ArchiveWalkEntry {
   readonly ancestors: readonly string[];
   readonly bytes: Uint8Array<ArrayBuffer>;
 }
-type ArchiveWalkLimit = 'depth' | 'total-bytes';
+type ArchiveWalkLimit = "depth" | "total-bytes";
 declare class ArchiveWalkLimitError extends Error {
   readonly limit: ArchiveWalkLimit;
   constructor(limit: ArchiveWalkLimit, message: string);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archive-codec",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "ZIP-in-ZIP recursive walking with depth and cumulative decompressed-size guards, plus bounded classic OLE compound-file ([MS-CFB]) reading - zero document-format knowledge, the archive and container utility package for the documents.js family.",
   "type": "module",
   "repository": {
@@ -72,22 +72,13 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
     "@cloudflare/vitest-pool-workers": "^0.20.1",
-    "@commitlint/cli": "^21.2.1",
-    "@commitlint/config-conventional": "^21.2.0",
-    "@eslint/js": "^10.0.1",
-    "@semantic-release/changelog": "^7.0.0",
-    "@semantic-release/git": "^11.0.1",
     "@types/node": "^26.1.2",
     "eslint": "^10.8.0",
-    "globals": "^17.8.0",
     "husky": "^9.1.7",
-    "lint-staged": "^17.2.0",
     "publint": "^0.3.21",
-    "semantic-release": "^25.0.8",
     "tsdown": "^0.22.13",
     "turbo": "^2.10.8",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.65.0",
     "vitest": "^4.1.10"
   },
   "lint-staged": {