@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/{markit-Dvp2JPdT.mjs → markit-CCcyeAds.mjs}

@@ -1,14 +1,15 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { n as fs_promises_shim_exports } from "./fs-promises-shim-B2YFWkcd.mjs";
-import { k as formatBytes } from "./src-AELUUb5U.mjs";
-import { l as unzip, u as unzipText } from "./zip-DRrycScC.mjs";
-import { n as normalizeTablesHtml, t as createTurndown } from "./turndown-D6fof1OX.mjs";
+import { n as fs_promises_shim_exports } from "./fs-promises-shim-CANAxFWh.mjs";
+import { R as formatBytes } from "./src-BhinCSpi.mjs";
+import { l as unzip, u as unzipText } from "./zip-DG1mUV6X.mjs";
+import { n as normalizeTablesHtml, t as createTurndown } from "./turndown-Vya8SavL.mjs";
 import { pdfToMarkdown } from "@oh-my-pi/pi-natives";
 import * as path$1 from "node:path";
-import * as zlib from "node:zlib";
 import { promisify } from "node:util";
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/error.ts
+import * as zlib from "node:zlib";
+import { Readable } from "node:stream";
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/error.ts
 /**
 * Error raised for invalid, unsupported, or unsafe archive input. The message
 * is safe to surface directly to users/models; callers that need a different
@@ -21,7 +22,7 @@ var ArchiveError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/bytes.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/bytes.ts
 /** Shared UTF-8 decoder for archive member names and text payloads. */
 const UTF8_DECODER$2 = new TextDecoder();
 function readUInt16LE(bytes, offset) {
@@ -49,7 +50,7 @@ function bytesMatchAscii(bytes, offset, value) {
 	return true;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/paths.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/paths.ts
 const PATH_ERROR_PREVIEW_BYTES = 256;
 /**
 * Normalize a user-supplied lookup path inside an archive. Returns `""` for
@@ -107,10 +108,11 @@ function assertArchivePathString(value, field, maxPathBytes) {
 	assertArchivePathBytes(Buffer.byteLength(value, "utf-8"), field, maxPathBytes);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/limits.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/limits.ts
 const DEFAULT_ARCHIVE_LIMITS = {
 	maxEntries: 1e6,
 	maxInMemorySize: 268435456,
+	maxStreamSize: 4294967296,
 	maxIndexSize: 67108864,
 	maxMemberSize: 67108864,
 	maxPathBytes: 4096,
@@ -140,7 +142,7 @@ function assertEntryCount(count, limits) {
 	if (count > limits.maxEntries) throw new ArchiveError(`Archive has too many entries (> ${limits.maxEntries} limit)`);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/entries.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/entries.ts
 /**
 * Insert `entry` into the index map with archive append/update semantics:
 * files replace directories of the same path, directories never shadow files,
@@ -215,7 +217,7 @@ function resolveArchiveLinkPath(entries, archivePath, maxLinkDepth) {
 	throw new ArchiveError(`Archive path '${archivePath}' crosses a cyclic symlink`);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/reader.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/reader.ts
 /** Raise the canonical error for a symlink whose target cannot be materialized. */
 function throwUnreadableArchiveLink(targetPath, memberPath) {
 	throw new ArchiveError(`Archive symlink '${formatArchivePathForError(memberPath)}' cannot be materialized from target '${formatArchivePathForError(targetPath)}'`);
@@ -329,7 +331,7 @@ var ArchiveReader = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/checksums.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/checksums.ts
 /** CRC-32 (IEEE 802.3, reflected). Chainable: pass the previous value as `seed`. */
 function crc32(bytes, seed = 0) {
 	return Bun.hash.crc32(bytes, seed) >>> 0;
@@ -380,7 +382,7 @@ function crc16Arc(bytes, seed = 0) {
 	return value;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/source.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/source.ts
 /** Reject a nonsensical `[start, end)` range before any read. */
 function assertValidRange(start, end) {
 	if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start) throw new ArchiveError("Invalid archive range");
@@ -419,8 +421,35 @@ function fileByteSource(filePath) {
 async function readAllBytes(source) {
 	return source.read(0, source.size);
 }
+/** Chunk size for streamed decompression, on both the compressed and the decompressed side. */
+const STREAM_CHUNK_SIZE = 1048576;
+async function* readChunks(source) {
+	for (let start = 0; start < source.size; start += STREAM_CHUNK_SIZE) yield await source.read(start, Math.min(source.size, start + STREAM_CHUNK_SIZE));
+}
+/**
+* Decompress a {@link ByteSource} through `decoder` chunk by chunk, so neither
+* the compressed nor the decompressed stream is ever held whole. Output past
+* `maxOutput` bytes fails, so a decompression bomb cannot run without bound.
+*/
+async function* decodeByteSource(source, decoder, maxOutput) {
+	const input = Readable.from(readChunks(source));
+	input.once("error", (error) => decoder.destroy(error));
+	let output = 0;
+	try {
+		for await (const chunk of input.pipe(decoder)) {
+			output += chunk.byteLength;
+			if (output > maxOutput) throw new ArchiveError(`Archive decompresses past the ${formatBytes(maxOutput)} stream limit`);
+			yield chunk;
+		}
+	} catch (error) {
+		if (error instanceof ArchiveError) throw error;
+		throw new ArchiveError(error instanceof Error ? error.message : String(error));
+	} finally {
+		input.destroy();
+	}
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/lzh.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/lzh.ts
 const LEGACY_DECODER$1 = new TextDecoder("windows-1252");
 const UTF16LE_DECODER = new TextDecoder("utf-16");
 const LHA_METHOD_PATTERN = /^-(?:lh[0-7d]|lz[45s])-$/;
@@ -939,7 +968,7 @@ const readLzh = async (source, options) => {
 	return entries;
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/arj.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/arj.ts
 const ARJ_SIGNATURE_0 = 96;
 const ARJ_SIGNATURE_1 = 234;
 const ARJ_MAX_BASIC_HEADER = 2600;
@@ -1189,7 +1218,7 @@ const readArj = async (source, options) => {
 	return entries;
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/asar.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/asar.ts
 const ASAR_HEADER_DECODER = new TextDecoder("utf-8", { fatal: true });
 new TextEncoder();
 const ASAR_PICKLE_PREFIX_SIZE = 8;
@@ -1417,7 +1446,7 @@ const readAsar = async (source, options) => {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/lzx.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/lzx.ts
 const FRAME_SIZE = 32768;
 const MIN_MATCH = 2;
 const NUM_PRIMARY_LENGTHS = 7;
@@ -1731,7 +1760,7 @@ var LzxDecoder = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/cab.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/cab.ts
 const CAB_SIGNATURE = "MSCF";
 const FIXED_HEADER_SIZE = 36;
 const DATA_BLOCK_SIZE = 8;
@@ -1997,7 +2026,7 @@ const readCab = async (source, options) => {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/bzip2.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/bzip2.ts
 const BLOCK_MAGIC = [
 	49,
 	65,
@@ -2863,8 +2892,12 @@ async function gzipDecompress(bytes, maxOutput) {
 		throw new ArchiveError(error instanceof Error ? error.message : String(error));
 	}
 }
+/** Decompress a gzip source as a stream of chunks, bounded to `maxOutput` bytes, for output too large to hold at once. */
+function gzipDecompressStream(source, maxOutput) {
+	return decodeByteSource(source, zlib.createGunzip({ chunkSize: STREAM_CHUNK_SIZE }), maxOutput);
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/lzma.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/lzma.ts
 const TOP_VALUE = 1 << 24;
 const BIT_MODEL_TOTAL = 2048;
 const MOVE_BITS = 5;
@@ -3247,7 +3280,7 @@ async function lzma2Decompress(dictSizeProp, bytes, maxOutput) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/lzw.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/lzw.ts
 const CLEAR_CODE = 256;
 const FIRST_BLOCK_CODE = 257;
 const MIN_BITS = 9;
@@ -3377,7 +3410,7 @@ async function lzwDecompress(bytes, maxOutput) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/xz.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/codecs/xz.ts
 const XZ_MAGIC = Uint8Array.of(253, 55, 122, 88, 90, 0);
 function read32LE$1(bytes, offset) {
 	if (offset < 0 || offset + 4 > bytes.byteLength) throw new ArchiveError("Invalid XZ stream: truncated integer");
@@ -3855,8 +3888,12 @@ async function zstdDecompress(bytes, maxOutput) {
 		throw new ArchiveError(error instanceof Error ? error.message : String(error));
 	}
 }
+/** Decompress a zstd source as a stream of chunks, bounded to `maxOutput` bytes, for output too large to hold at once. */
+function zstdDecompressStream(source, maxOutput) {
+	return decodeByteSource(source, zlib.createZstdDecompress({ chunkSize: STREAM_CHUNK_SIZE }), maxOutput);
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/cpio.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/cpio.ts
 const NEWC_HEADER_SIZE = 110;
 const ODC_HEADER_SIZE = 76;
 const BINARY_HEADER_SIZE = 26;
@@ -4158,7 +4195,7 @@ function sniffCpio(bytes) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/tar.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/tar.ts
 const BLOCK_SIZE = 512;
 const NAME_OFFSET = 0;
 const NAME_LENGTH = 100;
@@ -4185,21 +4222,120 @@ const MAX_PAX_NUMERIC_BYTES = 32;
 const PAX_SPARSE_MARKER = "GNU.sparse.";
 const TEXT_DECODER = new TextDecoder();
 new TextEncoder();
-var TarMemberSource = class {
+/** Forward-only reader over tar bytes that arrive in chunks: one buffer, or a decompressing stream. */
+var TarByteStream = class {
+	#chunks;
+	#chunk = /* @__PURE__ */ new Uint8Array(0);
+	#position = 0;
+	constructor(chunks) {
+		this.#chunks = Symbol.asyncIterator in chunks ? chunks[Symbol.asyncIterator]() : chunks[Symbol.iterator]();
+	}
+	/** Bytes consumed so far. */
+	get position() {
+		return this.#position;
+	}
+	/** The next `length` bytes; shorter only when the stream ends first. */
+	async read(length) {
+		if (this.#chunk.byteLength >= length) {
+			const bytes = this.#chunk.subarray(0, length);
+			this.#chunk = this.#chunk.subarray(length);
+			this.#position += length;
+			return bytes;
+		}
+		const bytes = new Uint8Array(length);
+		let filled = 0;
+		while (filled < length && (this.#chunk.byteLength > 0 || await this.#next())) {
+			const take = Math.min(length - filled, this.#chunk.byteLength);
+			bytes.set(this.#chunk.subarray(0, take), filled);
+			this.#chunk = this.#chunk.subarray(take);
+			filled += take;
+		}
+		this.#position += filled;
+		return filled === length ? bytes : bytes.subarray(0, filled);
+	}
+	/** Step over `length` bytes; false when the stream ends first. */
+	async skip(length) {
+		let remaining = length;
+		while (remaining > 0) {
+			if (this.#chunk.byteLength === 0 && !await this.#next()) return false;
+			const take = Math.min(remaining, this.#chunk.byteLength);
+			this.#chunk = this.#chunk.subarray(take);
+			this.#position += take;
+			remaining -= take;
+		}
+		return true;
+	}
+	/** Stop the underlying stream without draining it. */
+	async close() {
+		await this.#chunks.return?.();
+	}
+	async #next() {
+		const result = await this.#chunks.next();
+		if (result.done) return false;
+		this.#chunk = result.value;
+		return true;
+	}
+};
+var TarBufferPayload = class {
 	#buffer;
+	constructor(buffer) {
+		this.#buffer = buffer;
+	}
+	async read(offset, size, memberPath) {
+		if (size > this.#buffer.byteLength - offset) throw new ArchiveError(`Archive member '${formatArchivePathForError(memberPath)}' is truncated`);
+		const bytes = this.#buffer.subarray(offset, offset + size);
+		if (bytes.byteLength !== size) throw new ArchiveError(`Archive member '${formatArchivePathForError(memberPath)}' has an invalid size`);
+		return bytes;
+	}
+};
+/**
+* Member bytes of a tar too large to hold decompressed: each read decompresses
+* the stream again up to the member. Reads are serialized, and a read ahead of
+* the previous one continues that pass, so reading every member in archive
+* order decompresses the stream once.
+*/
+var TarStreamPayload = class {
+	#open;
+	#stream;
+	#pending = Promise.resolve();
+	constructor(open) {
+		this.#open = open;
+	}
+	read(offset, size, memberPath) {
+		const bytes = this.#pending.then(() => this.#readAt(offset, size, memberPath));
+		this.#pending = bytes.catch(() => void 0);
+		return bytes;
+	}
+	async #readAt(offset, size, memberPath) {
+		let stream = this.#stream;
+		this.#stream = void 0;
+		if (!stream || stream.position > offset) {
+			await stream?.close();
+			stream = new TarByteStream(this.#open());
+		}
+		try {
+			const bytes = await stream.skip(offset - stream.position) ? await stream.read(size) : void 0;
+			if (bytes?.byteLength !== size) throw new ArchiveError(`Archive member '${formatArchivePathForError(memberPath)}' is truncated`);
+			this.#stream = stream;
+			return bytes.byteLength === bytes.buffer.byteLength ? bytes : new Uint8Array(bytes);
+		} catch (error) {
+			await stream.close();
+			throw error;
+		}
+	}
+};
+var TarMemberSource = class {
+	#payload;
 	#dataOffset;
 	#sparse;
-	constructor(buffer, dataOffset, sparse) {
-		this.#buffer = buffer;
+	constructor(payload, dataOffset, sparse) {
+		this.#payload = payload;
 		this.#dataOffset = dataOffset;
 		this.#sparse = sparse;
 	}
 	async read(size, memberPath) {
 		if (this.#sparse) throw new ArchiveError(`Archive member '${formatArchivePathForError(memberPath)}' is a sparse file and cannot be read`);
-		if (size > this.#buffer.byteLength - this.#dataOffset) throw new ArchiveError(`Archive member '${formatArchivePathForError(memberPath)}' is truncated`);
-		const bytes = this.#buffer.subarray(this.#dataOffset, this.#dataOffset + size);
-		if (bytes.byteLength !== size) throw new ArchiveError(`Archive member '${formatArchivePathForError(memberPath)}' has an invalid size`);
-		return bytes;
+		return this.#payload.read(this.#dataOffset, size, memberPath);
 	}
 };
 function readTarString(buffer, offset, length) {
@@ -4271,7 +4407,6 @@ function checksumMatches(buffer, offset) {
 	return stored === unsigned || stored === signed;
 }
 function parsePaxRecords(data, limits) {
-	assertIndexSize(data.byteLength, limits, "tar PAX metadata");
 	const attrs = /* @__PURE__ */ new Map();
 	let pos = 0;
 	while (pos < data.byteLength) {
@@ -4348,7 +4483,6 @@ function renameOldGnuEntries(entries, pendingLinks, fromPath, toPath, limits) {
 	for (const pending of pendingLinks.values()) if (pending.kind === "hard link" && (pending.targetPath === fromPath || pending.targetPath.startsWith(`${fromPath}/`))) pending.targetPath = `${toPath}${pending.targetPath.slice(fromPath.length)}`;
 }
 function applyOldGnuNameRecords(data, entries, pendingLinks, limits) {
-	assertIndexSize(data.byteLength, limits, "old-GNU name metadata");
 	const terminator = data.indexOf(0);
 	const end = terminator === -1 ? data.byteLength : terminator;
 	let start = 0;
@@ -4448,10 +4582,19 @@ function resolvePendingLinks(entries, pendingLinks, limits) {
 	}
 	if (unresolved.size > 0) throw new ArchiveError("Archive contains cyclic or unsupported links");
 }
-/** Index an already-decompressed tar buffer with bounded GNU, ustar, and PAX handling. */
-function readTarEntriesFromBuffer(buffer, options) {
+/** Read one metadata record's payload, bounded by `maxIndexSize`, and step over its padding. */
+async function readTarMetadata(stream, size, limits, what) {
+	assertIndexSize(size, limits, what);
+	const data = await stream.read(size);
+	if (data.byteLength !== size || !await stream.skip(paddedSize(size) - size)) throw new ArchiveError("Archive member data is truncated");
+	return data;
+}
+/**
+* Walk tar headers with bounded GNU, ustar, and PAX handling. Member data is
+* stepped over, never held: entries point into `payload` by stream offset.
+*/
+async function readTarEntries(stream, payload, options) {
 	const { limits } = options;
-	assertInMemorySize(buffer.byteLength, limits);
 	const entries = /* @__PURE__ */ new Map();
 	const pendingLinks = /* @__PURE__ */ new Map();
 	const addEntry = (entry, pendingLink) => {
@@ -4462,59 +4605,46 @@ function readTarEntriesFromBuffer(buffer, options) {
 		if (pendingLink) pendingLinks.set(indexed, pendingLink);
 		assertEntryCount(entries.size, limits);
 	};
-	let offset = 0;
 	let longName;
 	let longLink;
 	let localPax;
 	const globalPax = /* @__PURE__ */ new Map();
 	let sawTerminator = false;
-	while (offset + BLOCK_SIZE <= buffer.byteLength) {
-		if (isZeroBlock(buffer, offset)) {
+	for (let header = await stream.read(BLOCK_SIZE); header.byteLength === BLOCK_SIZE; header = await stream.read(BLOCK_SIZE)) {
+		if (isZeroBlock(header, 0)) {
 			sawTerminator = true;
 			break;
 		}
-		if (!checksumMatches(buffer, offset)) throw new ArchiveError("Invalid or corrupt tar archive header");
-		const headerOffset = offset;
-		const typeFlag = String.fromCharCode(buffer[headerOffset + TYPEFLAG_OFFSET] || 48);
-		let size = readTarSize(buffer, headerOffset + SIZE_OFFSET);
-		let name = readTarString(buffer, headerOffset + NAME_OFFSET, NAME_LENGTH);
-		if (isUstarHeader(buffer, headerOffset)) {
-			const prefix = readTarString(buffer, headerOffset + PREFIX_OFFSET, PREFIX_LENGTH);
+		if (!checksumMatches(header, 0)) throw new ArchiveError("Invalid or corrupt tar archive header");
+		const typeFlag = String.fromCharCode(header[TYPEFLAG_OFFSET] || 48);
+		let size = readTarSize(header, SIZE_OFFSET);
+		let name = readTarString(header, NAME_OFFSET, NAME_LENGTH);
+		if (isUstarHeader(header, 0)) {
+			const prefix = readTarString(header, PREFIX_OFFSET, PREFIX_LENGTH);
 			if (prefix) name = `${prefix}/${name}`;
 		}
-		let linkName = readTarString(buffer, headerOffset + LINKNAME_OFFSET, LINKNAME_LENGTH);
-		const mtime = readTarNumeric(buffer, headerOffset + MTIME_OFFSET, MTIME_LENGTH);
-		const rawMode = readTarNumeric(buffer, headerOffset + MODE_OFFSET, MODE_LENGTH);
+		let linkName = readTarString(header, LINKNAME_OFFSET, LINKNAME_LENGTH);
+		const mtime = readTarNumeric(header, MTIME_OFFSET, MTIME_LENGTH);
+		const rawMode = readTarNumeric(header, MODE_OFFSET, MODE_LENGTH);
 		const mode = Number.isSafeInteger(rawMode) && rawMode >= 0 ? rawMode : void 0;
-		offset += BLOCK_SIZE;
-		const dataBlocks = paddedSize(size);
-		if (dataBlocks > buffer.byteLength - offset) throw new ArchiveError("Archive member data is truncated");
-		const data = buffer.subarray(offset, offset + size);
 		if (typeFlag === "L") {
-			assertIndexSize(data.byteLength, limits, "GNU long-name metadata");
-			longName = readMetadataPath(data, "GNU long path", limits);
-			offset += dataBlocks;
+			longName = readMetadataPath(await readTarMetadata(stream, size, limits, "GNU long-name metadata"), "GNU long path", limits);
 			continue;
 		}
 		if (typeFlag === "K") {
-			assertIndexSize(data.byteLength, limits, "GNU long-link metadata");
-			longLink = readMetadataPath(data, "GNU long link target", limits);
-			offset += dataBlocks;
+			longLink = readMetadataPath(await readTarMetadata(stream, size, limits, "GNU long-link metadata"), "GNU long link target", limits);
 			continue;
 		}
 		if (typeFlag === "N") {
-			applyOldGnuNameRecords(data, entries, pendingLinks, limits);
-			offset += dataBlocks;
+			applyOldGnuNameRecords(await readTarMetadata(stream, size, limits, "old-GNU name metadata"), entries, pendingLinks, limits);
 			continue;
 		}
 		if (typeFlag === "x" || typeFlag === "X") {
-			localPax = parsePaxRecords(data, limits);
-			offset += dataBlocks;
+			localPax = parsePaxRecords(await readTarMetadata(stream, size, limits, "tar PAX metadata"), limits);
 			continue;
 		}
 		if (typeFlag === "g") {
-			applyGlobalPax(globalPax, parsePaxRecords(data, limits));
-			offset += dataBlocks;
+			applyGlobalPax(globalPax, parsePaxRecords(await readTarMetadata(stream, size, limits, "tar PAX metadata"), limits));
 			continue;
 		}
 		if (typeFlag === "M") throw new ArchiveError("GNU multi-volume tar members are not supported");
@@ -4532,18 +4662,16 @@ function readTarEntriesFromBuffer(buffer, options) {
 		const paxSparseRealSize = paxAttribute(globalPax, localPax, "GNU.sparse.realsize");
 		if (paxSparseRealSize !== void 0) displaySize = parsePaxSize(paxSparseRealSize, "sparse real size");
 		const sparse = typeFlag === "S" || paxDeclaresSparse(globalPax, localPax);
-		if (typeFlag === "S" && buffer[headerOffset + GNU_SPARSE_ISEXTENDED_OFFSET] === 1) {
+		if (typeFlag === "S" && header[GNU_SPARSE_ISEXTENDED_OFFSET] === 1) {
 			let extended = true;
 			while (extended) {
-				if (offset + BLOCK_SIZE > buffer.byteLength) throw new ArchiveError("Archive sparse metadata is truncated");
-				extended = buffer[offset + GNU_SPARSE_CONT_ISEXTENDED_OFFSET] === 1;
-				offset += BLOCK_SIZE;
+				const block = await stream.read(BLOCK_SIZE);
+				if (block.byteLength < BLOCK_SIZE) throw new ArchiveError("Archive sparse metadata is truncated");
+				extended = block[GNU_SPARSE_CONT_ISEXTENDED_OFFSET] === 1;
 			}
 		}
-		const dataOffset = offset;
-		const memberDataBlocks = paddedSize(size);
-		if (memberDataBlocks > buffer.byteLength - dataOffset) throw new ArchiveError(`Archive member '${formatArchivePathForError(name)}' is truncated`);
-		offset += memberDataBlocks;
+		const dataOffset = stream.position;
+		if (!await stream.skip(paddedSize(size))) throw new ArchiveError(`Archive member '${formatArchivePathForError(name)}' is truncated`);
 		longName = void 0;
 		longLink = void 0;
 		localPax = void 0;
@@ -4601,7 +4729,7 @@ function readTarEntriesFromBuffer(buffer, options) {
 			mode,
 			storage: {
 				type: "member",
-				source: new TarMemberSource(buffer, dataOffset, sparse)
+				source: new TarMemberSource(payload, dataOffset, sparse)
 			}
 		});
 	}
@@ -4609,6 +4737,25 @@ function readTarEntriesFromBuffer(buffer, options) {
 	resolvePendingLinks(entries, pendingLinks, limits);
 	return [...entries.values()];
 }
+/** Index an already-decompressed tar buffer; members are views into it. */
+async function readTarEntriesFromBuffer(buffer, options) {
+	assertInMemorySize(buffer.byteLength, options.limits);
+	return readTarEntries(new TarByteStream([buffer]), new TarBufferPayload(buffer), options);
+}
+/**
+* Index a decompressed tar stream that is too large to hold in memory: one
+* pass over `open()` walks the headers, and member reads open it again.
+*/
+async function readTarEntriesFromStream(open, options) {
+	const stream = new TarByteStream(open());
+	try {
+		const entries = await readTarEntries(stream, new TarStreamPayload(open), options);
+		await stream.skip(Number.POSITIVE_INFINITY);
+		return entries;
+	} finally {
+		await stream.close();
+	}
+}
 /** Read and index a tar source after one bounded whole-stream read. */
 const readTar = async (source, options) => {
 	assertInMemorySize(source.size, options.limits);
@@ -4635,7 +4782,7 @@ function sniffTar(bytes) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/unix-ar.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/unix-ar.ts
 const SIGNATURE$1 = "!<arch>\n";
 const HEADER_SIZE = 60;
 const NAME_SIZE = 16;
@@ -4848,7 +4995,7 @@ function sniffUnixAr(bytes) {
 	return bytesMatchAscii(bytes, 0, SIGNATURE$1);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/deb.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/deb.ts
 const AR_SIGNATURE = "!<arch>\n";
 const DEBIAN_BINARY = "debian-binary";
 function firstArMemberName(bytes) {
@@ -4950,7 +5097,7 @@ async function readDebImpl(source, options) {
 			upsertArchiveEntry(result, outerEntry);
 			continue;
 		}
-		const innerEntries = readTarEntriesFromBuffer(await decompressDebTar(await readOuterMember(outerEntry), tar.compression, options), options);
+		const innerEntries = await readTarEntriesFromBuffer(await decompressDebTar(await readOuterMember(outerEntry), tar.compression, options), options);
 		for (const innerEntry of innerEntries) upsertArchiveEntry(result, tar.kind === "control" ? prefixControlEntry(innerEntry) : innerEntry);
 	}
 	ensureParentDirectories(result, options.limits);
@@ -4970,7 +5117,7 @@ function sniffDeb(bytes) {
 	return firstArMemberName(bytes) === DEBIAN_BINARY;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/iso.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/iso.ts
 const ISO_SECTOR_SIZE = 2048;
 const VOLUME_DESCRIPTOR_START = 16 * ISO_SECTOR_SIZE;
 const MAX_DIRECTORY_DEPTH = 256;
@@ -5479,7 +5626,7 @@ const readIso = async (source, options) => {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/rar/rar4-decoder.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/rar/rar4-decoder.ts
 const MAIN_SIZE$1 = 299;
 const DIST_SIZE$1 = 60;
 const LOW_DIST_SIZE = 17;
@@ -5987,7 +6134,7 @@ function corrupt$1(reason) {
 	throw new ArchiveError(`Invalid RAR4 archive: ${reason}`);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/rar/rar5-decoder.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/rar/rar5-decoder.ts
 const MAIN_SIZE = 306;
 const DIST_SIZE = 80;
 const ALIGN_SIZE = 16;
@@ -6387,7 +6534,7 @@ function fail(reason) {
 	throw new ArchiveError(`Invalid RAR5 archive: ${reason}`);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/rar.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/rar.ts
 const RAR4_MARKER = Uint8Array.of(82, 97, 114, 33, 26, 7, 0);
 const RAR5_MARKER = Uint8Array.of(82, 97, 114, 33, 26, 7, 1, 0);
 const UTF8$1 = new TextDecoder("utf-8", { fatal: true });
@@ -7019,7 +7166,7 @@ function corrupt(reason) {
 	throw new ArchiveError(`Invalid RAR archive: ${reason}`);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/rpm.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/rpm.ts
 const RPM_LEAD_SIZE = 96;
 const RPM_HEADER_INTRO_SIZE = 16;
 const RPM_INDEX_ENTRY_SIZE = 16;
@@ -7236,7 +7383,7 @@ function sniffRpm(bytes) {
 	return bytes.byteLength >= 4 && bytes[0] === 237 && bytes[1] === 171 && bytes[2] === 238 && bytes[3] === 219;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/sevenzip/decode.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/sevenzip/decode.ts
 function methodName(id) {
 	switch (id) {
 		case 0n: return "Copy";
@@ -7400,7 +7547,7 @@ var SevenZipFolderSource = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/sevenzip.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/sevenzip.ts
 const SIGNATURE = Uint8Array.of(55, 122, 188, 175, 39, 28);
 const UTF16_LE = new TextDecoder("utf-16", { fatal: true });
 const UTF8 = new TextDecoder("utf-8", { fatal: true });
@@ -7962,7 +8109,7 @@ const readSevenZip = async (source, options) => {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/zip.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/zip.ts
 const LOCAL_HEADER_SIGNATURE = 67324752;
 const CENTRAL_HEADER_SIGNATURE = 33639248;
 const ZIP64_EOCD_SIGNATURE = 101075792;
@@ -8340,7 +8487,7 @@ const readZip = async (source, options) => {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/ar/registry.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/registry.ts
 /** Every recognized extension paired with its format, longest first. */
 const EXTENSION_TABLE = Object.entries({
 	zip: [
@@ -8412,6 +8559,20 @@ var BufferMember = class {
 		return this.#bytes;
 	}
 };
+/** Index decompressed bytes as tar when they are one, else as a single stem-named member. */
+async function readDecompressed(inner, options) {
+	assertInMemorySize(inner.byteLength, options.limits);
+	if (sniffTar(inner)) return readTarEntriesFromBuffer(inner, options);
+	return [{
+		path: stemMemberName(options.archivePath),
+		isDirectory: false,
+		size: inner.byteLength,
+		storage: {
+			type: "member",
+			source: new BufferMember(inner)
+		}
+	}];
+}
 /**
 * Reader for one compressed stream: decompress bounded, then index the inner
 * bytes as tar when they are one, else surface a single stem-named member.
@@ -8421,27 +8582,40 @@ var BufferMember = class {
 function compressedReader(decompress) {
 	return async (source, options) => {
 		assertInMemorySize(source.size, options.limits);
-		const inner = await decompress(await readAllBytes(source), options.limits.maxInMemorySize);
-		assertInMemorySize(inner.byteLength, options.limits);
-		if (sniffTar(inner)) return readTarEntriesFromBuffer(inner, options);
-		return [{
-			path: stemMemberName(options.archivePath),
-			isDirectory: false,
-			size: inner.byteLength,
-			storage: {
-				type: "member",
-				source: new BufferMember(inner)
-			}
-		}];
+		return readDecompressed(await decompress(await readAllBytes(source), options.limits.maxInMemorySize), options);
+	};
+}
+/**
+* {@link compressedReader} for codecs that decompress as a stream. Output that
+* fits `maxInMemorySize` is indexed the same way; a tar that inflates past it
+* is indexed by a streaming header walk instead, its members decompressed
+* again when read, so memory stays bounded by the limits either way. Each pass
+* stops at `maxStreamSize`.
+*/
+function streamedReader(decompress) {
+	return async (source, options) => {
+		const { maxInMemorySize, maxStreamSize } = options.limits;
+		const chunks = [];
+		let size = 0;
+		for await (const chunk of decompress(source, maxStreamSize)) {
+			chunks.push(chunk);
+			size += chunk.byteLength;
+			if (size > maxInMemorySize) break;
+		}
+		const kept = Buffer.concat(chunks, size <= maxInMemorySize ? size : Math.min(size, 512));
+		chunks.length = 0;
+		if (size <= maxInMemorySize) return readDecompressed(kept, options);
+		if (!sniffTar(kept)) throw new ArchiveError(`Archive is too large to read in memory (decompressed > ${formatBytes(maxInMemorySize)} limit)`);
+		return readTarEntriesFromStream(() => decompress(source, maxStreamSize), options);
 	};
 }
 const READERS = {
 	zip: readZip,
 	tar: readTar,
-	"tar.gz": compressedReader(gzipDecompress),
+	"tar.gz": streamedReader(gzipDecompressStream),
 	"tar.bz2": compressedReader(bzip2Decompress),
 	"tar.xz": compressedReader(xzDecompress),
-	"tar.zst": compressedReader(zstdDecompress),
+	"tar.zst": streamedReader(zstdDecompressStream),
 	"tar.Z": compressedReader(lzwDecompress),
 	asar: readAsar,
 	rar: readRar,
@@ -8454,10 +8628,10 @@ const READERS = {
 	deb: readDeb,
 	lzh: readLzh,
 	arj: readArj,
-	gz: compressedReader(gzipDecompress),
+	gz: streamedReader(gzipDecompressStream),
 	bz2: compressedReader(bzip2Decompress),
 	xz: compressedReader(xzDecompress),
-	zst: compressedReader(zstdDecompress),
+	zst: streamedReader(zstdDecompressStream),
 	Z: compressedReader(lzwDecompress),
 	lzma: compressedReader(lzmaAloneDecompress)
 };
@@ -8509,32 +8683,61 @@ async function openArchive(input, options = {}) {
 	};
 	return new ArchiveReader(format, await formatReaderFor(format)(source, readOptions), limits);
 }
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/ar/zip-package.ts
 /**
-* Fully materialize every file member into a `path → bytes` map. Use this
-* for whole-archive rewrite; browsing and single-member reads should use
-* {@link openArchive} so payloads remain lazy. Total extracted bytes are
-* bounded by `limits.maxInMemorySize`.
+* A ZIP-based document package (OOXML, EPUB) whose members are inflated only
+* when read. Lookups use exact member paths, so a converter sees the same
+* members a fully materialized `path → bytes` map would expose. Each member's
+* size counts once toward a cap on total inflated bytes, like a fully
+* materialized archive, so a crafted package cannot amplify past the in-memory
+* limit one member at a time.
 */
-async function readArchiveEntries(input, options = {}) {
-	const archive = await openArchive(input, options);
-	const entries = /* @__PURE__ */ new Map();
-	let total = 0;
-	for (const entry of archive.indexEntries()) {
-		if (entry.isDirectory) continue;
-		const file = await archive.readFile(entry.path);
-		entries.set(entry.path, file.bytes);
-		total += file.bytes.byteLength;
-		assertInMemorySize(total, archive.limits);
+var ZipPackage = class ZipPackage {
+	#archive;
+	#members = /* @__PURE__ */ new Set();
+	#limits;
+	/** Members already counted toward {@link #inflated}; re-reading one is free against the cap. */
+	#counted = /* @__PURE__ */ new Set();
+	#inflated = 0;
+	constructor(archive, maxTotalBytes = DEFAULT_ARCHIVE_LIMITS.maxInMemorySize) {
+		this.#archive = archive;
+		this.#limits = {
+			...DEFAULT_ARCHIVE_LIMITS,
+			maxInMemorySize: maxTotalBytes
+		};
+		for (const entry of archive.indexEntries()) if (!entry.isDirectory) this.#members.add(entry.path);
+	}
+	/** Index a ZIP buffer without inflating any member. */
+	static async open(bytes, maxTotalBytes) {
+		return new ZipPackage(await openArchive({
+			bytes,
+			format: "zip"
+		}), maxTotalBytes);
+	}
+	/** Exact paths of every file member. */
+	get members() {
+		return this.#members;
+	}
+	/** Inflate one member, or `undefined` when absent. Throws once distinct inflated bytes exceed the cap. */
+	async readBytes(memberPath) {
+		if (!this.#members.has(memberPath)) return void 0;
+		const { bytes } = await this.#archive.readFile(memberPath);
+		if (!this.#counted.has(memberPath)) {
+			this.#counted.add(memberPath);
+			this.#inflated += bytes.length;
+			assertInMemorySize(this.#inflated, this.#limits);
+		}
+		return bytes;
 	}
-	return entries;
-}
-/** Read one materialized member as UTF-8 text, or `undefined` when absent. */
-function archiveEntryText(entries, entryPath) {
-	const bytes = entries.get(entryPath);
-	return bytes ? UTF8_DECODER$2.decode(bytes) : void 0;
-}
+	/** Inflate one member as UTF-8 text, or `undefined` when absent. */
+	async readText(memberPath) {
+		const bytes = await this.readBytes(memberPath);
+		return bytes ? UTF8_DECODER$2.decode(bytes) : void 0;
+	}
+};
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/docx/xml.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/docx/xml.ts
 const ENTITY_PATTERN = /&(?:#x[\da-fA-F]+|#\d+|amp|apos|gt|lt|quot);/g;
 const ATTRIBUTE_PATTERN = /([^\s=]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
 function decodeEntities(value) {
@@ -8679,7 +8882,7 @@ function descendants(element, name) {
 	return matches;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/docx/converter.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/docx/converter.ts
 /** Mammoth-shaped helpers for configuring embedded image conversion. */
 const images = { 
 /** Wrap an image-to-attributes callback for `convertToHtml`. */
@@ -8885,8 +9088,8 @@ async function renderImage(element, context) {
 	const relationship = relationshipId ? context.relationships.get(relationshipId) : void 0;
 	if (!relationship || relationship.external) return "";
 	const memberPath = relationshipPath(relationship.target);
-	const bytes = context.entries.get(memberPath);
-	if (!bytes) {
+	const docx = context.package;
+	if (!docx.members.has(memberPath)) {
 		context.messages.push({
 			type: "warning",
 			message: `Could not find image ${memberPath}`
@@ -8901,13 +9104,23 @@ async function renderImage(element, context) {
 		altText,
 		async read(encoding) {
 			if (encoding !== "base64") throw new Error(`Unsupported image encoding: ${encoding}`);
+			const bytes = await readImageMember(docx, memberPath);
 			return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+		},
+		readBytes() {
+			return readImageMember(docx, memberPath);
 		}
 	};
 	const converted = await context.convertImage.convert(image);
 	const attributes = Object.entries(converted).filter((entry) => typeof entry[1] === "string").sort(([left], [right]) => left.localeCompare(right)).map(([name, value]) => `${name}="${escapeAttribute(value)}"`).join(" ");
 	return attributes ? `<img ${attributes} />` : "<img />";
 }
+/** Bytes of an image member already known to exist. */
+async function readImageMember(docx, memberPath) {
+	const bytes = await docx.readBytes(memberPath);
+	if (!bytes) throw new Error(`Could not find image ${memberPath}`);
+	return bytes;
+}
 function renderFootnoteReference(element, context) {
 	const id = attribute(element, "w:id");
 	if (!id || !context.footnotes.has(id)) return "";
@@ -9137,24 +9350,22 @@ function defaultImageConverter() {
 }
 /** Convert a DOCX buffer or path to mammoth-compatible HTML. */
 async function convertToHtml(input, options = {}) {
-	const entries = await readArchiveEntries({
-		bytes: "buffer" in input && input.buffer ? input.buffer : await fs_promises_shim_exports.readFile(input.path),
-		format: "zip"
-	});
-	const documentXml = archiveEntryText(entries, "word/document.xml");
+	const bytes = "buffer" in input && input.buffer ? input.buffer : await fs_promises_shim_exports.readFile(input.path);
+	const docx = await ZipPackage.open(bytes);
+	const documentXml = await docx.readText("word/document.xml");
 	if (!documentXml) throw new Error("Invalid DOCX: missing word/document.xml");
 	const context = {
-		entries,
-		relationships: parseRelationships(archiveEntryText(entries, "word/_rels/document.xml.rels")),
-		contentTypes: parseContentTypes(archiveEntryText(entries, "[Content_Types].xml")),
-		styles: parseStyles(archiveEntryText(entries, "word/styles.xml")),
-		numbering: parseNumbering(archiveEntryText(entries, "word/numbering.xml")),
+		package: docx,
+		relationships: parseRelationships(await docx.readText("word/_rels/document.xml.rels")),
+		contentTypes: parseContentTypes(await docx.readText("[Content_Types].xml")),
+		styles: parseStyles(await docx.readText("word/styles.xml")),
+		numbering: parseNumbering(await docx.readText("word/numbering.xml")),
 		messages: [],
 		warnedStyles: /* @__PURE__ */ new Set(),
 		customStyles: parseCustomStyles(options.styleMap),
 		includeDefaultStyleMap: options.includeDefaultStyleMap !== false,
 		convertImage: options.convertImage ?? defaultImageConverter(),
-		footnotes: parseFootnotes(archiveEntryText(entries, "word/footnotes.xml")),
+		footnotes: parseFootnotes(await docx.readText("word/footnotes.xml")),
 		usedFootnotes: [],
 		footnoteOrdinals: /* @__PURE__ */ new Map()
 	};
@@ -9166,7 +9377,7 @@ async function convertToHtml(input, options = {}) {
 	};
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/docx.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/docx.ts
 /** Mammoth-shaped default export for drop-in consumer imports. */
 const docx = {
 	convertToHtml,
@@ -9215,7 +9426,7 @@ var DocxConverter = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/xml.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/xml.ts
 const STANDARD_ENTITIES = {
 	amp: "&",
 	apos: "'",
@@ -9269,6 +9480,10 @@ var XmlReader = class {
 				this.#readProcessingInstruction(document);
 				continue;
 			}
+			if (this.#xml.startsWith("</", this.#position)) {
+				this.#skipThrough(">");
+				continue;
+			}
 			if (this.#xml[this.#position] === "<") {
 				const element = this.#readElement("");
 				this.#addValue(document, element.name, element.name, element.value, element.leaf, null);
@@ -9302,6 +9517,9 @@ var XmlReader = class {
 				this.#position++;
 				this.#skipWhitespace();
 				value = this.#readAttributeValue();
+			} else if (attributeName === "") {
+				this.#position++;
+				continue;
 			}
 			attributes.push([attributeName, value]);
 		}
@@ -9315,6 +9533,7 @@ var XmlReader = class {
 				this.#position = close < 0 ? this.#xml.length : close + 1;
 				break;
 			}
+			if (this.#xml.startsWith("</", this.#position)) break;
 			if (this.#xml.startsWith("<![CDATA[", this.#position)) {
 				const end = this.#xml.indexOf("]]>", this.#position + 9);
 				const normalized = this.#xml.slice(this.#position + 9, end < 0 ? this.#xml.length : end);