archive-codec 1.1.0 → 1.1.2

package/dist/index.js

@@ -1,330 +1,7 @@
-import { unzipSync, zipSync } from "fflate";
-//#region src/magic.ts
-function startsWithMagic(bytes, magic) {
-	if (bytes.length < magic.length) return false;
-	for (let i = 0; i < magic.length; i++) if (bytes[i] !== magic[i]) return false;
-	return true;
-}
-//#endregion
-//#region src/cfb/detect.ts
-const COMPOUND_FILE_MAGIC = [
-	208,
-	207,
-	17,
-	224,
-	161,
-	177,
-	26,
-	225
-];
-function isCompoundFile(bytes) {
-	return startsWithMagic(bytes, COMPOUND_FILE_MAGIC);
-}
-//#endregion
-//#region src/cfb/ole-package.ts
-var OlePackageFormatError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "OlePackageFormatError";
-	}
-};
-const ANSI_DECODER = new TextDecoder("windows-1252");
-function readZeroTerminated(bytes, offset, fieldName) {
-	let end = offset;
-	while (end < bytes.length && bytes[end] !== 0) end++;
-	if (end >= bytes.length) throw new OlePackageFormatError(`Package stream ends inside its ${fieldName} string with no terminator`);
-	return {
-		value: ANSI_DECODER.decode(bytes.subarray(offset, end)),
-		next: end + 1
-	};
-}
-function readOlePackage(bytes) {
-	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	let offset = 2;
-	const label = readZeroTerminated(bytes, offset, "label");
-	offset = label.next;
-	const sourcePath = readZeroTerminated(bytes, offset, "source path");
-	offset = sourcePath.next;
-	offset += 8;
-	const tempPath = readZeroTerminated(bytes, offset, "temp path");
-	offset = tempPath.next;
-	if (offset + 4 > bytes.length) throw new OlePackageFormatError("Package stream ends before its packaged file size field");
-	const fileByteCount = view.getUint32(offset, true);
-	offset += 4;
-	if (offset + fileByteCount > bytes.length) throw new OlePackageFormatError(`Package stream declares ${fileByteCount} packaged-file bytes but holds only ${bytes.length - offset}`);
-	return {
-		label: label.value,
-		sourcePath: sourcePath.value,
-		tempPath: tempPath.value,
-		fileBytes: bytes.slice(offset, offset + fileByteCount)
-	};
-}
-//#endregion
-//#region src/cfb/read.ts
-const ENDOFCHAIN = 4294967294;
-const FREESECT = 4294967295;
-const FATSECT = 4294967293;
-const DIFSECT = 4294967292;
-const NOSTREAM = 4294967295;
-const HEADER_SIZE = 512;
-const HEADER_DIFAT_ENTRIES = 109;
-const OBJECT_TYPE_STORAGE = 1;
-const OBJECT_TYPE_STREAM = 2;
-const OBJECT_TYPE_ROOT = 5;
-const MAX_CFB_TOTAL_STREAM_BYTES = 536870912;
-var CompoundFileFormatError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "CompoundFileFormatError";
-	}
-};
-function u32(view, offset) {
-	return view.getUint32(offset, true);
-}
-function u16(view, offset) {
-	return view.getUint16(offset, true);
-}
-function readCompoundFile(bytes, options = {}) {
-	const maxTotalBytes = options.maxTotalBytes ?? 536870912;
-	if (!isCompoundFile(bytes)) throw new CompoundFileFormatError("readCompoundFile input does not carry the compound-file signature (leading magic bytes are not D0 CF 11 E0 A1 B1 1A E1)");
-	if (bytes.length < HEADER_SIZE) throw new CompoundFileFormatError(`compound file is ${bytes.length} bytes, shorter than the fixed ${HEADER_SIZE}-byte header`);
-	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	const majorVersion = u16(view, 26);
-	if (majorVersion !== 3 && majorVersion !== 4) throw new CompoundFileFormatError(`compound file major version ${majorVersion} is not 3 or 4`);
-	if (u16(view, 28) !== 65534) throw new CompoundFileFormatError("compound file byte order is not little-endian");
-	const sectorShift = u16(view, 30);
-	if (majorVersion === 3 && sectorShift !== 9 || majorVersion === 4 && sectorShift !== 12) throw new CompoundFileFormatError(`compound file sector shift 2^${sectorShift} does not match major version ${majorVersion} (version 3 requires 512-byte sectors, version 4 requires 4096-byte)`);
-	const miniSectorShift = u16(view, 32);
-	if (miniSectorShift !== 6) throw new CompoundFileFormatError(`compound file mini sector shift 2^${miniSectorShift} is not the mandated 64-byte mini sector`);
-	const sectorSize = 1 << sectorShift;
-	const miniSectorSize = 1 << miniSectorShift;
-	const miniStreamCutoff = u32(view, 56);
-	if (miniStreamCutoff < miniSectorSize) throw new CompoundFileFormatError(`compound file mini stream cutoff ${miniStreamCutoff} is smaller than the ${miniSectorSize}-byte mini sector itself`);
-	const firstDirectorySector = u32(view, 48);
-	const firstMiniFatSector = u32(view, 60);
-	const firstDifatSector = u32(view, 68);
-	const sectorCount = Math.floor(bytes.length / sectorSize) - 1;
-	if (sectorCount < 1) throw new CompoundFileFormatError(`compound file holds no complete ${sectorSize}-byte sector after its header`);
-	const sectorOffset = (sector) => (sector + 1) * sectorSize;
-	const sectorBytes = (sector) => bytes.subarray(sectorOffset(sector), sectorOffset(sector) + sectorSize);
-	const fatSectorIds = [];
-	const acceptFatSector = (sector, provenance) => {
-		if (sector === FREESECT) return;
-		if (sector >= sectorCount) throw new CompoundFileFormatError(`${provenance} names FAT sector ${sector}, which is outside the file's ${sectorCount} sectors`);
-		fatSectorIds.push(sector);
-	};
-	for (let i = 0; i < HEADER_DIFAT_ENTRIES; i++) acceptFatSector(u32(view, 76 + i * 4), "the header DIFAT array");
-	let difatSector = firstDifatSector;
-	let difatSectorsWalked = 0;
-	while (difatSector !== ENDOFCHAIN) {
-		if (difatSector >= sectorCount) throw new CompoundFileFormatError(`the DIFAT chain names sector ${difatSector}, which is outside the file's ${sectorCount} sectors`);
-		if (++difatSectorsWalked > sectorCount) throw new CompoundFileFormatError("the DIFAT chain visits more sectors than the file holds, so it must cycle");
-		const difatView = new DataView(bytes.buffer, bytes.byteOffset + sectorOffset(difatSector), sectorSize);
-		const entriesPerDifatSector = sectorSize / 4 - 1;
-		for (let i = 0; i < entriesPerDifatSector; i++) acceptFatSector(u32(difatView, i * 4), "a DIFAT sector");
-		difatSector = u32(difatView, entriesPerDifatSector * 4);
-	}
-	if (fatSectorIds.length === 0) throw new CompoundFileFormatError("compound file declares no FAT sectors, so no sector chain can be walked");
-	const fatBytes = new Uint8Array(fatSectorIds.length * sectorSize);
-	for (let i = 0; i < fatSectorIds.length; i++) fatBytes.set(sectorBytes(fatSectorIds[i] ?? 0), i * sectorSize);
-	const fat = new DataView(fatBytes.buffer);
-	const fatEntry = (sector) => {
-		const offset = sector * 4;
-		if (offset < 0 || offset + 4 > fatBytes.length) throw new CompoundFileFormatError(`FAT entry for sector ${sector} lies beyond the sectors the DIFAT named`);
-		return fat.getUint32(offset, true);
-	};
-	const chainSectorIds = (start) => {
-		const ids = [];
-		let current = start;
-		while (current !== ENDOFCHAIN) {
-			if (current >= sectorCount) throw new CompoundFileFormatError(`a FAT chain steps to sector ${current}, which is outside the file's ${sectorCount} sectors`);
-			if (ids.length >= sectorCount) throw new CompoundFileFormatError("a FAT chain visits more sectors than the file holds, so it must cycle");
-			ids.push(current);
-			const next = fatEntry(current);
-			if (next === FREESECT || next === FATSECT || next === DIFSECT) throw new CompoundFileFormatError(`a FAT chain steps to sector ${current}'s entry ${next}, which is a sector-role marker, not a chain continuation`);
-			current = next;
-		}
-		return ids;
-	};
-	const chainBytes = (start) => {
-		const ids = chainSectorIds(start);
-		const out = new Uint8Array(ids.length * sectorSize);
-		for (let i = 0; i < ids.length; i++) out.set(sectorBytes(ids[i] ?? 0), i * sectorSize);
-		return out;
-	};
-	const directoryBytes = chainBytes(firstDirectorySector);
-	if (directoryBytes.length === 0) throw new CompoundFileFormatError("compound file has an empty directory chain");
-	const directoryView = new DataView(directoryBytes.buffer);
-	const entryCount = directoryBytes.length / 128;
-	const nameDecoder = new TextDecoder("utf-16le");
-	const entries = [];
-	for (let id = 0; id < entryCount; id++) {
-		const base = id * 128;
-		const nameLength = u16(directoryView, base + 64);
-		entries.push({
-			name: nameDecoder.decode(directoryBytes.subarray(base, base + Math.max(0, nameLength - 2))),
-			nameLength,
-			objectType: directoryView.getUint8(base + 66),
-			leftSibling: u32(directoryView, base + 68),
-			rightSibling: u32(directoryView, base + 72),
-			child: u32(directoryView, base + 76),
-			startSector: u32(directoryView, base + 116),
-			size: u32(directoryView, base + 120) + u32(directoryView, base + 124) * 4294967296
-		});
-	}
-	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");
-	const miniStream = chainBytes(root.startSector).subarray(0, root.size);
-	const miniSectorCount = Math.floor(miniStream.length / miniSectorSize);
-	const miniFatBytes = chainBytes(firstMiniFatSector);
-	const miniFat = new DataView(miniFatBytes.buffer);
-	const miniChainSectorIds = (start) => {
-		const ids = [];
-		let current = start;
-		while (current !== ENDOFCHAIN) {
-			if (current >= miniSectorCount) throw new CompoundFileFormatError(`a mini-FAT chain steps to mini sector ${current}, which is outside the mini stream's ${miniSectorCount} mini sectors`);
-			if (ids.length >= miniSectorCount) throw new CompoundFileFormatError("a mini-FAT chain visits more mini sectors than the mini stream holds, so it must cycle");
-			ids.push(current);
-			const next = miniFat.getUint32(current * 4, true);
-			if (next === FREESECT || next === FATSECT || next === DIFSECT) throw new CompoundFileFormatError(`a mini-FAT chain steps to mini sector ${current}'s entry ${next}, which is a sector-role marker, not a chain continuation`);
-			current = next;
-		}
-		return ids;
-	};
-	let totalExtractedBytes = 0;
-	const extractStream = (entry) => {
-		if (entry.size === 0) return /* @__PURE__ */ new Uint8Array(0);
-		if (entry.size > Number.MAX_SAFE_INTEGER) throw new CompoundFileFormatError(`stream '${entry.name}' declares a size beyond the integer range this reader addresses`);
-		let out;
-		if (entry.size < miniStreamCutoff) {
-			const ids = miniChainSectorIds(entry.startSector);
-			const raw = new Uint8Array(ids.length * miniSectorSize);
-			for (let i = 0; i < ids.length; i++) {
-				const miniSector = ids[i] ?? 0;
-				raw.set(miniStream.subarray(miniSector * miniSectorSize, (miniSector + 1) * miniSectorSize), i * miniSectorSize);
-			}
-			out = raw;
-		} else out = chainBytes(entry.startSector);
-		if (out.length < entry.size) throw new CompoundFileFormatError(`stream '${entry.name}' declares ${entry.size} bytes but its chain holds only ${out.length}`);
-		totalExtractedBytes += entry.size;
-		if (totalExtractedBytes > maxTotalBytes) throw new CompoundFileFormatError(`cumulative extracted stream size exceeded the ${maxTotalBytes}-byte budget at '${entry.name}'`);
-		return out.slice(0, entry.size);
-	};
-	const streams = [];
-	const visited = /* @__PURE__ */ new Set();
-	const stack = [{
-		id: root.child,
-		prefix: "",
-		stage: "descend"
-	}];
-	for (let frame = stack.pop(); frame !== void 0; frame = stack.pop()) if (frame.stage === "descend") {
-		const { id, prefix } = frame;
-		if (id === NOSTREAM) continue;
-		const entry = entries[id];
-		if (id >= entryCount || entry === void 0) throw new CompoundFileFormatError(`the directory tree links to entry ${id}, which is outside the directory's ${entryCount} entries`);
-		if (visited.has(id)) throw new CompoundFileFormatError(`the directory tree reaches entry ${id} twice, so its sibling and child links cycle`);
-		visited.add(id);
-		if (entry.nameLength < 2 || entry.nameLength > 64 || entry.nameLength % 2 === 1) throw new CompoundFileFormatError(`directory entry ${id} declares name length ${entry.nameLength}, which is not an even byte count between 2 and 64`);
-		if (entry.objectType !== OBJECT_TYPE_STORAGE && entry.objectType !== OBJECT_TYPE_STREAM && entry.objectType !== OBJECT_TYPE_ROOT) throw new CompoundFileFormatError(`directory entry ${id} ('${entry.name}') carries object type ${entry.objectType}, which is not a storage (1), stream (2), or root (5) entry`);
-		stack.push({
-			entry,
-			prefix,
-			stage: "self"
-		});
-		stack.push({
-			id: entry.leftSibling,
-			prefix,
-			stage: "descend"
-		});
-	} else if (frame.entry.objectType === OBJECT_TYPE_STREAM) {
-		streams.push({
-			path: frame.prefix + frame.entry.name,
-			bytes: extractStream(frame.entry)
-		});
-		stack.push({
-			id: frame.entry.rightSibling,
-			prefix: frame.prefix,
-			stage: "descend"
-		});
-	} else if (frame.entry.objectType === OBJECT_TYPE_STORAGE) {
-		stack.push({
-			id: frame.entry.rightSibling,
-			prefix: frame.prefix,
-			stage: "descend"
-		});
-		stack.push({
-			id: frame.entry.child,
-			prefix: `${frame.prefix}${frame.entry.name}/`,
-			stage: "descend"
-		});
-	} else throw new CompoundFileFormatError(`the directory tree reaches entry ${frame.entry.name}, which is not a storage or stream entry`);
-	return streams;
-}
-//#endregion
-//#region src/zip/container.ts
-function unzipPackage(bytes) {
-	return unzipSync(bytes);
-}
-function zipPackage(entries) {
-	const data = {};
-	for (const [path, entry] of entries) if (entry.stored === true) data[path] = [entry.bytes, { level: 0 }];
-	else data[path] = entry.bytes;
-	return zipSync(data);
-}
-//#endregion
-//#region src/zip/detect.ts
-const ZIP_LOCAL_FILE_HEADER_MAGIC = [
-	80,
-	75,
-	3,
-	4
-];
-const ZIP_END_OF_CENTRAL_DIRECTORY_MAGIC = [
-	80,
-	75,
-	5,
-	6
-];
-function isZipArchive(bytes) {
-	return startsWithMagic(bytes, ZIP_LOCAL_FILE_HEADER_MAGIC) || startsWithMagic(bytes, ZIP_END_OF_CENTRAL_DIRECTORY_MAGIC);
-}
-function detectArchiveFormat(bytes) {
-	if (isZipArchive(bytes)) return "zip";
-	return isCompoundFile(bytes) ? "cfb" : "unknown";
-}
-//#endregion
-//#region src/zip/walk.ts
-const MAX_WALK_DEPTH = 8;
-const MAX_WALK_TOTAL_BYTES = 536870912;
-var ArchiveWalkLimitError = class extends Error {
-	limit;
-	constructor(limit, message) {
-		super(message);
-		this.name = "ArchiveWalkLimitError";
-		this.limit = limit;
-	}
-};
-function walkArchive(bytes, options = {}) {
-	const maxDepth = options.maxDepth ?? 8;
-	const maxTotalBytes = options.maxTotalBytes ?? 536870912;
-	if (!isZipArchive(bytes)) throw new Error("walkArchive input is not a ZIP archive (leading magic bytes are not PK\\x03\\x04 or PK\\x05\\x06)");
-	const entries = [];
-	let totalBytes = 0;
-	visit(bytes, []);
-	return entries;
-	function visit(archive, ancestors) {
-		if (ancestors.length + 1 > maxDepth) throw new ArchiveWalkLimitError("depth", `archive nesting exceeds the maximum walk depth of ${maxDepth} at ${ancestors.join(" > ")}`);
-		for (const [path, entryBytes] of Object.entries(unzipPackage(archive))) {
-			totalBytes += entryBytes.length;
-			if (totalBytes > maxTotalBytes) throw new ArchiveWalkLimitError("total-bytes", `cumulative decompressed size of the walk exceeded the ${maxTotalBytes}-byte budget at ${path}`);
-			entries.push({
-				path,
-				ancestors,
-				bytes: entryBytes
-			});
-			if (isZipArchive(entryBytes)) visit(entryBytes, [...ancestors, path]);
-		}
-	}
-}
-//#endregion
+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 { 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 };

package/dist/magic.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/magic.ts
+function startsWithMagic(bytes, magic) {
+	if (bytes.length < magic.length) return false;
+	for (let i = 0; i < magic.length; i++) if (bytes[i] !== magic[i]) return false;
+	return true;
+}
+//#endregion
+exports.startsWithMagic = startsWithMagic;

package/dist/magic.d.cts

@@ -0,0 +1,4 @@
+//#region src/magic.d.ts
+declare function startsWithMagic(bytes: Uint8Array, magic: readonly number[]): boolean;
+//#endregion
+export { startsWithMagic };

package/dist/magic.d.ts

@@ -0,0 +1,4 @@
+//#region src/magic.d.ts
+declare function startsWithMagic(bytes: Uint8Array, magic: readonly number[]): boolean;
+//#endregion
+export { startsWithMagic };

package/dist/magic.js

@@ -0,0 +1,8 @@
+//#region src/magic.ts
+function startsWithMagic(bytes, magic) {
+	if (bytes.length < magic.length) return false;
+	for (let i = 0; i < magic.length; i++) if (bytes[i] !== magic[i]) return false;
+	return true;
+}
+//#endregion
+export { startsWithMagic };

package/dist/zip/container.cjs

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let fflate = require("fflate");
+//#region src/zip/container.ts
+function unzipPackage(bytes) {
+	return (0, fflate.unzipSync)(bytes);
+}
+function zipPackage(entries) {
+	const data = {};
+	for (const [path, entry] of entries) if (entry.stored === true) data[path] = [entry.bytes, { level: 0 }];
+	else data[path] = entry.bytes;
+	return (0, fflate.zipSync)(data);
+}
+//#endregion
+exports.unzipPackage = unzipPackage;
+exports.zipPackage = zipPackage;

package/dist/zip/container.d.cts

@@ -0,0 +1,9 @@
+//#region src/zip/container.d.ts
+interface ZipEntry {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly stored?: boolean;
+}
+declare function unzipPackage(bytes: Uint8Array<ArrayBuffer>): Record<string, Uint8Array<ArrayBuffer>>;
+declare function zipPackage(entries: readonly (readonly [string, ZipEntry])[]): Uint8Array<ArrayBuffer>;
+//#endregion
+export { ZipEntry, unzipPackage, zipPackage };

package/dist/zip/container.d.ts

@@ -0,0 +1,9 @@
+//#region src/zip/container.d.ts
+interface ZipEntry {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly stored?: boolean;
+}
+declare function unzipPackage(bytes: Uint8Array<ArrayBuffer>): Record<string, Uint8Array<ArrayBuffer>>;
+declare function zipPackage(entries: readonly (readonly [string, ZipEntry])[]): Uint8Array<ArrayBuffer>;
+//#endregion
+export { ZipEntry, unzipPackage, zipPackage };

package/dist/zip/container.js

@@ -0,0 +1,13 @@
+import { unzipSync, zipSync } from "fflate";
+//#region src/zip/container.ts
+function unzipPackage(bytes) {
+	return unzipSync(bytes);
+}
+function zipPackage(entries) {
+	const data = {};
+	for (const [path, entry] of entries) if (entry.stored === true) data[path] = [entry.bytes, { level: 0 }];
+	else data[path] = entry.bytes;
+	return zipSync(data);
+}
+//#endregion
+export { unzipPackage, zipPackage };

package/dist/zip/detect.cjs

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_magic = require("../magic.cjs");
+const require_cfb_detect = require("../cfb/detect.cjs");
+//#region src/zip/detect.ts
+const ZIP_LOCAL_FILE_HEADER_MAGIC = [
+	80,
+	75,
+	3,
+	4
+];
+const ZIP_END_OF_CENTRAL_DIRECTORY_MAGIC = [
+	80,
+	75,
+	5,
+	6
+];
+function isZipArchive(bytes) {
+	return require_magic.startsWithMagic(bytes, ZIP_LOCAL_FILE_HEADER_MAGIC) || require_magic.startsWithMagic(bytes, ZIP_END_OF_CENTRAL_DIRECTORY_MAGIC);
+}
+function detectArchiveFormat(bytes) {
+	if (isZipArchive(bytes)) return "zip";
+	return require_cfb_detect.isCompoundFile(bytes) ? "cfb" : "unknown";
+}
+//#endregion
+exports.detectArchiveFormat = detectArchiveFormat;
+exports.isZipArchive = isZipArchive;

package/dist/zip/detect.d.cts

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

package/dist/zip/detect.d.ts

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

package/dist/zip/detect.js

@@ -0,0 +1,24 @@
+import { startsWithMagic } from "../magic.js";
+import { isCompoundFile } from "../cfb/detect.js";
+//#region src/zip/detect.ts
+const ZIP_LOCAL_FILE_HEADER_MAGIC = [
+	80,
+	75,
+	3,
+	4
+];
+const ZIP_END_OF_CENTRAL_DIRECTORY_MAGIC = [
+	80,
+	75,
+	5,
+	6
+];
+function isZipArchive(bytes) {
+	return startsWithMagic(bytes, ZIP_LOCAL_FILE_HEADER_MAGIC) || startsWithMagic(bytes, ZIP_END_OF_CENTRAL_DIRECTORY_MAGIC);
+}
+function detectArchiveFormat(bytes) {
+	if (isZipArchive(bytes)) return "zip";
+	return isCompoundFile(bytes) ? "cfb" : "unknown";
+}
+//#endregion
+export { detectArchiveFormat, isZipArchive };

package/dist/zip/walk.cjs

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_zip_container = require("./container.cjs");
+const require_zip_detect = require("./detect.cjs");
+//#region src/zip/walk.ts
+const MAX_WALK_DEPTH = 8;
+const MAX_WALK_TOTAL_BYTES = 536870912;
+var ArchiveWalkLimitError = class extends Error {
+	limit;
+	constructor(limit, message) {
+		super(message);
+		this.name = "ArchiveWalkLimitError";
+		this.limit = limit;
+	}
+};
+function walkArchive(bytes, options = {}) {
+	const maxDepth = options.maxDepth ?? 8;
+	const maxTotalBytes = options.maxTotalBytes ?? 536870912;
+	if (!require_zip_detect.isZipArchive(bytes)) throw new Error("walkArchive input is not a ZIP archive (leading magic bytes are not PK\\x03\\x04 or PK\\x05\\x06)");
+	const entries = [];
+	let totalBytes = 0;
+	visit(bytes, []);
+	return entries;
+	function visit(archive, ancestors) {
+		if (ancestors.length + 1 > maxDepth) throw new ArchiveWalkLimitError("depth", `archive nesting exceeds the maximum walk depth of ${maxDepth} at ${ancestors.join(" > ")}`);
+		for (const [path, entryBytes] of Object.entries(require_zip_container.unzipPackage(archive))) {
+			totalBytes += entryBytes.length;
+			if (totalBytes > maxTotalBytes) throw new ArchiveWalkLimitError("total-bytes", `cumulative decompressed size of the walk exceeded the ${maxTotalBytes}-byte budget at ${path}`);
+			entries.push({
+				path,
+				ancestors,
+				bytes: entryBytes
+			});
+			if (require_zip_detect.isZipArchive(entryBytes)) visit(entryBytes, [...ancestors, path]);
+		}
+	}
+}
+//#endregion
+exports.ArchiveWalkLimitError = ArchiveWalkLimitError;
+exports.MAX_WALK_DEPTH = MAX_WALK_DEPTH;
+exports.MAX_WALK_TOTAL_BYTES = MAX_WALK_TOTAL_BYTES;
+exports.walkArchive = walkArchive;

package/dist/zip/walk.d.cts

@@ -0,0 +1,20 @@
+//#region src/zip/walk.d.ts
+declare const MAX_WALK_DEPTH = 8;
+declare const MAX_WALK_TOTAL_BYTES: number;
+interface ArchiveWalkEntry {
+  readonly path: string;
+  readonly ancestors: readonly string[];
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+type ArchiveWalkLimit = 'depth' | 'total-bytes';
+declare class ArchiveWalkLimitError extends Error {
+  readonly limit: ArchiveWalkLimit;
+  constructor(limit: ArchiveWalkLimit, message: string);
+}
+interface WalkArchiveOptions {
+  readonly maxDepth?: number;
+  readonly maxTotalBytes?: number;
+}
+declare function walkArchive(bytes: Uint8Array<ArrayBuffer>, options?: WalkArchiveOptions): ArchiveWalkEntry[];
+//#endregion
+export { ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, WalkArchiveOptions, walkArchive };

package/dist/zip/walk.d.ts

@@ -0,0 +1,20 @@
+//#region src/zip/walk.d.ts
+declare const MAX_WALK_DEPTH = 8;
+declare const MAX_WALK_TOTAL_BYTES: number;
+interface ArchiveWalkEntry {
+  readonly path: string;
+  readonly ancestors: readonly string[];
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+type ArchiveWalkLimit = 'depth' | 'total-bytes';
+declare class ArchiveWalkLimitError extends Error {
+  readonly limit: ArchiveWalkLimit;
+  constructor(limit: ArchiveWalkLimit, message: string);
+}
+interface WalkArchiveOptions {
+  readonly maxDepth?: number;
+  readonly maxTotalBytes?: number;
+}
+declare function walkArchive(bytes: Uint8Array<ArrayBuffer>, options?: WalkArchiveOptions): ArchiveWalkEntry[];
+//#endregion
+export { ArchiveWalkEntry, ArchiveWalkLimit, ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, WalkArchiveOptions, walkArchive };

package/dist/zip/walk.js

@@ -0,0 +1,37 @@
+import { unzipPackage } from "./container.js";
+import { isZipArchive } from "./detect.js";
+//#region src/zip/walk.ts
+const MAX_WALK_DEPTH = 8;
+const MAX_WALK_TOTAL_BYTES = 536870912;
+var ArchiveWalkLimitError = class extends Error {
+	limit;
+	constructor(limit, message) {
+		super(message);
+		this.name = "ArchiveWalkLimitError";
+		this.limit = limit;
+	}
+};
+function walkArchive(bytes, options = {}) {
+	const maxDepth = options.maxDepth ?? 8;
+	const maxTotalBytes = options.maxTotalBytes ?? 536870912;
+	if (!isZipArchive(bytes)) throw new Error("walkArchive input is not a ZIP archive (leading magic bytes are not PK\\x03\\x04 or PK\\x05\\x06)");
+	const entries = [];
+	let totalBytes = 0;
+	visit(bytes, []);
+	return entries;
+	function visit(archive, ancestors) {
+		if (ancestors.length + 1 > maxDepth) throw new ArchiveWalkLimitError("depth", `archive nesting exceeds the maximum walk depth of ${maxDepth} at ${ancestors.join(" > ")}`);
+		for (const [path, entryBytes] of Object.entries(unzipPackage(archive))) {
+			totalBytes += entryBytes.length;
+			if (totalBytes > maxTotalBytes) throw new ArchiveWalkLimitError("total-bytes", `cumulative decompressed size of the walk exceeded the ${maxTotalBytes}-byte budget at ${path}`);
+			entries.push({
+				path,
+				ancestors,
+				bytes: entryBytes
+			});
+			if (isZipArchive(entryBytes)) visit(entryBytes, [...ancestors, path]);
+		}
+	}
+}
+//#endregion
+export { ArchiveWalkLimitError, MAX_WALK_DEPTH, MAX_WALK_TOTAL_BYTES, walkArchive };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archive-codec",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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": {
@@ -57,10 +57,12 @@
     "_typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.node.json",
     "_typecheck:attw": "attw --pack",
     "test": "turbo run _test",
-    "_test": "vitest run",
-    "test:watch": "vitest",
+    "_test": "vitest run --project unit",
+    "test:watch": "vitest --project unit",
     "test:workers": "turbo run _test:workers",
     "_test:workers": "vitest run --config vitest.workers.config.ts",
+    "test:smoke": "turbo run _test:smoke",
+    "_test:smoke": "vitest run --project smoke",
     "prepare": "husky"
   },
   "packageManager": "pnpm@11.6.0",