archive-codec 1.2.0 → 1.4.0

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,20 +2,37 @@ 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_oleps_layout_metadata = require("./oleps/layout-metadata.cjs");
+const require_oleps_read = require("./oleps/read.cjs");
+const require_oleps_write = require("./oleps/write.cjs");
+const require_oleps_summary_information = require("./oleps/summary-information.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.FMTID_SUMMARY_INFORMATION = require_oleps_summary_information.FMTID_SUMMARY_INFORMATION;
 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.OlePackageFormatError = require_cfb_ole_package.OlePackageFormatError;
+exports.PropertySetFormatError = require_oleps_read.PropertySetFormatError;
+exports.PropertySetWriteError = require_oleps_write.PropertySetWriteError;
 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.readCompoundFile = require_cfb_read.readCompoundFile;
 exports.readOlePackage = require_cfb_ole_package.readOlePackage;
+exports.readPropertySetStream = require_oleps_read.readPropertySetStream;
+exports.readSummaryInformation = require_oleps_summary_information.readSummaryInformation;
+exports.summaryInformationToLayoutMetadata = require_oleps_layout_metadata.summaryInformationToLayoutMetadata;
 exports.unzipPackage = require_zip_container.unzipPackage;
 exports.walkArchive = require_zip_walk.walkArchive;
+exports.writeCompoundFile = require_cfb_write.writeCompoundFile;
+exports.writePropertySetStream = require_oleps_write.writePropertySetStream;
+exports.writeSummaryInformationStream = require_oleps_summary_information.writeSummaryInformationStream;
 exports.zipPackage = require_zip_container.zipPackage;

package/dist/index.d.cts

@@ -1,7 +1,13 @@
 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 { 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";
+import { PropertySetFormatError, readPropertySetStream } from "./oleps/read.cjs";
+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, 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, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/dist/index.d.ts

@@ -1,7 +1,13 @@
 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 { 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";
+import { PropertySetFormatError, readPropertySetStream } from "./oleps/read.js";
+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, 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, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackage, OlePackageFormatError, type PropertySet, PropertySetFormatError, PropertySetWriteError, type PropertyValue, ReadCompoundFileOptions, SummaryInformationProperties, WalkArchiveOptions, WriteCompoundFileOptions, ZipEntry, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/dist/index.js

@@ -1,7 +1,12 @@
 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 { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata } from "./oleps/layout-metadata.js";
+import { PropertySetFormatError, readPropertySetStream } from "./oleps/read.js";
+import { PropertySetWriteError, writePropertySetStream } from "./oleps/write.js";
+import { FMTID_SUMMARY_INFORMATION, readSummaryInformation, writeSummaryInformationStream } from "./oleps/summary-information.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, FMTID_SUMMARY_INFORMATION, MAX_CFB_TOTAL_STREAM_BYTES, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, OlePackageFormatError, PropertySetFormatError, PropertySetWriteError, detectArchiveFormat, hasSummaryInformationFields, isCompoundFile, isZipArchive, layoutMetadataToSummaryInformation, readCompoundFile, readOlePackage, readPropertySetStream, readSummaryInformation, summaryInformationToLayoutMetadata, unzipPackage, walkArchive, writeCompoundFile, writePropertySetStream, writeSummaryInformationStream, zipPackage };

package/dist/oleps/layout-metadata.cjs

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/oleps/layout-metadata.ts
+function summaryInformationToLayoutMetadata(info) {
+	return {
+		title: info.title,
+		subject: info.subject,
+		author: info.author,
+		keywords: info.keywords === void 0 ? void 0 : [...info.keywords],
+		createdIso: info.createdIso,
+		modifiedIso: info.lastSavedIso
+	};
+}
+function layoutMetadataToSummaryInformation(metadata) {
+	return {
+		title: metadata.title,
+		subject: metadata.subject,
+		author: metadata.author,
+		keywords: metadata.keywords,
+		createdIso: metadata.createdIso,
+		lastSavedIso: metadata.modifiedIso
+	};
+}
+/** Whether a LayoutMetadata carries anything SummaryInformation can actually represent -- `creator`/`producer`/`language` alone should not force a stream carrying nothing but the CodePage property into existence, since a reader would see that back as `{}` regardless (see each caller's own write-side entry point). */
+function hasSummaryInformationFields(metadata) {
+	return metadata.title !== void 0 || metadata.subject !== void 0 || metadata.author !== void 0 || metadata.keywords !== void 0 && metadata.keywords.length > 0 || metadata.createdIso !== void 0 || metadata.modifiedIso !== void 0;
+}
+//#endregion
+exports.hasSummaryInformationFields = hasSummaryInformationFields;
+exports.layoutMetadataToSummaryInformation = layoutMetadataToSummaryInformation;
+exports.summaryInformationToLayoutMetadata = summaryInformationToLayoutMetadata;

package/dist/oleps/layout-metadata.d.cts

@@ -0,0 +1,9 @@
+import { SummaryInformationProperties } from "./summary-information.cjs";
+import { LayoutMetadata } from "document-schema.js";
+//#region src/oleps/layout-metadata.d.ts
+declare function summaryInformationToLayoutMetadata(info: SummaryInformationProperties): LayoutMetadata;
+declare function layoutMetadataToSummaryInformation(metadata: LayoutMetadata): SummaryInformationProperties;
+/** Whether a LayoutMetadata carries anything SummaryInformation can actually represent -- `creator`/`producer`/`language` alone should not force a stream carrying nothing but the CodePage property into existence, since a reader would see that back as `{}` regardless (see each caller's own write-side entry point). */
+declare function hasSummaryInformationFields(metadata: LayoutMetadata): boolean;
+//#endregion
+export { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata };

package/dist/oleps/layout-metadata.d.ts

@@ -0,0 +1,9 @@
+import { SummaryInformationProperties } from "./summary-information.js";
+import { LayoutMetadata } from "document-schema.js";
+//#region src/oleps/layout-metadata.d.ts
+declare function summaryInformationToLayoutMetadata(info: SummaryInformationProperties): LayoutMetadata;
+declare function layoutMetadataToSummaryInformation(metadata: LayoutMetadata): SummaryInformationProperties;
+/** Whether a LayoutMetadata carries anything SummaryInformation can actually represent -- `creator`/`producer`/`language` alone should not force a stream carrying nothing but the CodePage property into existence, since a reader would see that back as `{}` regardless (see each caller's own write-side entry point). */
+declare function hasSummaryInformationFields(metadata: LayoutMetadata): boolean;
+//#endregion
+export { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata };

package/dist/oleps/layout-metadata.js

@@ -0,0 +1,27 @@
+//#region src/oleps/layout-metadata.ts
+function summaryInformationToLayoutMetadata(info) {
+	return {
+		title: info.title,
+		subject: info.subject,
+		author: info.author,
+		keywords: info.keywords === void 0 ? void 0 : [...info.keywords],
+		createdIso: info.createdIso,
+		modifiedIso: info.lastSavedIso
+	};
+}
+function layoutMetadataToSummaryInformation(metadata) {
+	return {
+		title: metadata.title,
+		subject: metadata.subject,
+		author: metadata.author,
+		keywords: metadata.keywords,
+		createdIso: metadata.createdIso,
+		lastSavedIso: metadata.modifiedIso
+	};
+}
+/** Whether a LayoutMetadata carries anything SummaryInformation can actually represent -- `creator`/`producer`/`language` alone should not force a stream carrying nothing but the CodePage property into existence, since a reader would see that back as `{}` regardless (see each caller's own write-side entry point). */
+function hasSummaryInformationFields(metadata) {
+	return metadata.title !== void 0 || metadata.subject !== void 0 || metadata.author !== void 0 || metadata.keywords !== void 0 && metadata.keywords.length > 0 || metadata.createdIso !== void 0 || metadata.modifiedIso !== void 0;
+}
+//#endregion
+export { hasSummaryInformationFields, layoutMetadataToSummaryInformation, summaryInformationToLayoutMetadata };

package/dist/oleps/read.cjs

@@ -0,0 +1,132 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_oleps_wire = require("./wire.cjs");
+//#region src/oleps/read.ts
+var PropertySetFormatError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PropertySetFormatError";
+	}
+};
+function requireBytes(byteLength, offset, length, what) {
+	if (offset < 0 || length < 0 || offset + length > byteLength) throw new PropertySetFormatError(`property set stream ends before ${what} (needs ${length} bytes at offset ${offset}, stream is ${byteLength} bytes)`);
+}
+const ANSI_DECODER = new TextDecoder("windows-1252");
+const UTF16_DECODER = new TextDecoder("utf-16le");
+function decodeAnsi(bytes, codepage) {
+	if (codepage !== 1252) return;
+	return ANSI_DECODER.decode(bytes);
+}
+function truncateAtNull(value) {
+	const index = value.indexOf("\0");
+	return index === -1 ? value : value.slice(0, index);
+}
+function readCodePageString(bytes, view, offset, codepage) {
+	requireBytes(bytes.length, offset, 4, "a CodePageString's Size field");
+	const size = view.getUint32(offset, true);
+	requireBytes(bytes.length, offset + 4, size, "a CodePageString's Characters field");
+	const raw = bytes.subarray(offset + 4, offset + 4 + size);
+	if (codepage === 1200) return truncateAtNull(UTF16_DECODER.decode(raw));
+	const decoded = decodeAnsi(raw, codepage);
+	return decoded === void 0 ? void 0 : truncateAtNull(decoded);
+}
+function readUnicodeString(bytes, view, offset) {
+	requireBytes(bytes.length, offset, 4, "a UnicodeString's Length field");
+	const byteLength = view.getUint32(offset, true) * 2;
+	requireBytes(bytes.length, offset + 4, byteLength, "a UnicodeString's Characters field");
+	const raw = bytes.subarray(offset + 4, offset + 4 + byteLength);
+	return truncateAtNull(UTF16_DECODER.decode(raw));
+}
+function readPropertySetStream(bytes) {
+	requireBytes(bytes.length, 0, 48, "the PropertySetStream header");
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const byteOrder = view.getUint16(0, true);
+	if (byteOrder !== 65534) throw new PropertySetFormatError(`property set stream's ByteOrder field is 0x${byteOrder.toString(16)}, not the mandated 0xFFFE`);
+	const numPropertySets = view.getUint32(24, true);
+	if (numPropertySets !== 1) throw new PropertySetFormatError(`property set stream declares ${numPropertySets} property sets; this reader only handles the single-property-set form every "\\x05SummaryInformation" stream uses (the two-property-set DocumentSummaryInformation/UserDefinedProperties spelling is out of scope, see the package README)`);
+	const formatId = require_oleps_wire.readGuid(view, 28);
+	const offset0 = view.getUint32(44, true);
+	requireBytes(bytes.length, offset0, 8, "the PropertySet packet header");
+	const size = view.getUint32(offset0, true);
+	requireBytes(bytes.length, offset0, size, "the PropertySet packet's own declared Size");
+	const numProperties = view.getUint32(offset0 + 4, true);
+	const tableStart = offset0 + 8;
+	requireBytes(bytes.length, tableStart, numProperties * 8, "the PropertyIdentifierAndOffset dictionary");
+	const entries = [];
+	for (let i = 0; i < numProperties; i++) {
+		const entryOffset = tableStart + i * 8;
+		const pid = view.getUint32(entryOffset, true);
+		if (pid === 0) throw new PropertySetFormatError("property set carries a Dictionary property (PID 0), which names string-keyed properties this reader does not support -- no \"\\x05SummaryInformation\" stream should carry one");
+		entries.push({
+			pid,
+			relativeOffset: view.getUint32(entryOffset + 4, true)
+		});
+	}
+	let codepage = require_oleps_wire.WINDOWS_1252_CODEPAGE;
+	for (const entry of entries) {
+		if (entry.pid !== 1) continue;
+		const abs = offset0 + entry.relativeOffset;
+		requireBytes(bytes.length, abs, 8, "the CodePage property's TypedPropertyValue");
+		const type = view.getUint16(abs, true);
+		if (type !== 2) throw new PropertySetFormatError(`CodePage property (PID 1) has type 0x${type.toString(16)}, not VT_I2 as [MS-OLEPS] requires`);
+		const raw = view.getInt16(abs + 4, true);
+		codepage = raw < 0 ? raw + 65536 : raw;
+	}
+	const properties = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const abs = offset0 + entry.relativeOffset;
+		requireBytes(bytes.length, abs, 4, "a property's TypedPropertyValue header");
+		const type = view.getUint16(abs, true);
+		const padding = view.getUint16(abs + 2, true);
+		if (padding !== 0) throw new PropertySetFormatError(`property ${entry.pid}'s TypedPropertyValue padding is 0x${padding.toString(16)}, not zero as [MS-OLEPS] requires`);
+		const valueOffset = abs + 4;
+		switch (type) {
+			case 2:
+				requireBytes(bytes.length, valueOffset, 4, `property ${entry.pid}'s VT_I2 value`);
+				properties.set(entry.pid, {
+					type: "VT_I2",
+					value: view.getInt16(valueOffset, true)
+				});
+				break;
+			case 3:
+				requireBytes(bytes.length, valueOffset, 4, `property ${entry.pid}'s VT_I4 value`);
+				properties.set(entry.pid, {
+					type: "VT_I4",
+					value: view.getInt32(valueOffset, true)
+				});
+				break;
+			case 30: {
+				const value = readCodePageString(bytes, view, valueOffset, codepage);
+				if (value !== void 0) properties.set(entry.pid, {
+					type: "VT_LPSTR",
+					value
+				});
+				break;
+			}
+			case 31: {
+				const value = readUnicodeString(bytes, view, valueOffset);
+				properties.set(entry.pid, {
+					type: "VT_LPWSTR",
+					value
+				});
+				break;
+			}
+			case 64: {
+				requireBytes(bytes.length, valueOffset, 8, `property ${entry.pid}'s VT_FILETIME value`);
+				const low = view.getUint32(valueOffset, true);
+				const high = view.getUint32(valueOffset + 4, true);
+				properties.set(entry.pid, {
+					type: "VT_FILETIME",
+					value: require_oleps_wire.filetimeToDate(low, high)
+				});
+				break;
+			}
+		}
+	}
+	return {
+		formatId,
+		properties
+	};
+}
+//#endregion
+exports.PropertySetFormatError = PropertySetFormatError;
+exports.readPropertySetStream = readPropertySetStream;

package/dist/oleps/read.d.cts

@@ -0,0 +1,8 @@
+import { PropertySet } from "./wire.cjs";
+//#region src/oleps/read.d.ts
+declare class PropertySetFormatError extends Error {
+  constructor(message: string);
+}
+declare function readPropertySetStream(bytes: Uint8Array<ArrayBuffer>): PropertySet;
+//#endregion
+export { PropertySetFormatError, readPropertySetStream };

package/dist/oleps/read.d.ts

@@ -0,0 +1,8 @@
+import { PropertySet } from "./wire.js";
+//#region src/oleps/read.d.ts
+declare class PropertySetFormatError extends Error {
+  constructor(message: string);
+}
+declare function readPropertySetStream(bytes: Uint8Array<ArrayBuffer>): PropertySet;
+//#endregion
+export { PropertySetFormatError, readPropertySetStream };