@stll/folio-core 0.64.1 → 0.65.0

package/dist/docx/rezip.js

@@ -45,8 +45,7 @@ import { OFFICE_RELATIONSHIP_NAMESPACE_URIS, OOXML_NAMESPACE_SCOPE, WORDPROCESSI
 import { Result, TaggedError, panic } from "better-result";
 import { assertValidOoxmlNumericIds, escapeXmlAttribute, escapeXmlText, validateDocxPackage } from "@stll/docx-core";
 import { mintRelationshipId, numberingInstanceResolves } from "@stll/docx-core/model";
-import JSZip from "jszip";
-import { writeZipPart } from "@stll/docx-core/zip";
+import { ZipArchive } from "@stll/docx-core/zip";
 // src/docx/rezip.ts
 const DocxPackageFidelityErrorBase = TaggedError("DocxPackageFidelityError");
 var DocxPackageFidelityError = class extends DocxPackageFidelityErrorBase {
@@ -172,7 +171,7 @@ function assertDocumentPackageFidelity({ originalDocumentFacts, serializedDocume
 async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	const comments = doc.package.document.comments ?? [];
 	const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
-	const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })) : void 0;
+	const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })) : void 0;
 	if (sourceCommentsXml !== void 0 && canReplayCommentsPart(doc, sourceCommentsXml)) return;
 	if (comments.length === 0) {
 		const ownsCommentsPart = hasOwnedCommentsPart(doc);
@@ -180,15 +179,7 @@ async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	}
 	const plan = planCommentParts(comments);
 	const commentsXml = serializeComments(plan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
-	writeZipPart({
-		zip,
-		path: sourceCommentsFile?.name ?? "word/comments.xml",
-		data: encodeUtf8(commentsXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	zip.set(sourceCommentsFile?.path ?? "word/comments.xml", commentsXml, { level: compressionLevel });
 	await ensureCommentsContentType(zip, compressionLevel);
 	await ensureCommentsRelationship(zip, compressionLevel);
 	await syncCommentsExtendedPart(plan, zip, compressionLevel);
@@ -212,43 +203,30 @@ async function syncCommentsExtendedPart(plan, zip, compressionLevel) {
 	const existing = findZipEntryCaseInsensitive(zip, COMMENTS_EXTENDED_PART_LOWER);
 	if (!xml) {
 		if (!existing) return;
-		zip.remove(existing.name);
+		zip.delete(existing.path);
 		await transformPackagingFile(zip, "[Content_Types].xml", removeCommentsExtendedOverride, compressionLevel);
 		await transformPackagingFile(zip, "word/_rels/document.xml.rels", removeCommentsExtendedRelationship, compressionLevel);
 		return;
 	}
-	writeZipPart({
-		zip,
-		path: existing?.name ?? "word/commentsExtended.xml",
-		data: encodeUtf8(xml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	zip.set(existing?.path ?? "word/commentsExtended.xml", xml, { level: compressionLevel });
 	await transformPackagingFile(zip, "[Content_Types].xml", addCommentsExtendedOverride, compressionLevel);
 	await transformPackagingFile(zip, "word/_rels/document.xml.rels", addCommentsExtendedRelationship, compressionLevel);
 }
 /** Read a packaging file, apply a pure transform, and write it back if it changed. */
 async function transformPackagingFile(zip, path, transform, compressionLevel) {
-	const file = zip.file(path);
+	const file = zip.entry(path);
 	if (!file) return;
-	const xml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const xml = await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	const next = transform(xml);
-	if (next !== xml) writeZipPart({
-		zip,
-		path,
-		data: encodeUtf8(next),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	if (next !== xml) zip.set(path, next, { level: compressionLevel });
 }
 function findZipEntryCaseInsensitive(zip, lowerPath) {
-	const direct = zip.file(lowerPath);
+	const direct = zip.entry(lowerPath);
 	if (direct) return direct;
-	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.toLowerCase() === lowerPath) return file;
+	for (const file of zip.entries()) {
+		const { path } = file;
+		if (path.toLowerCase() === lowerPath) return file;
+	}
 	return null;
 }
 const PACKAGE_RELATIONSHIPS_NAMESPACE_URI = "http://schemas.openxmlformats.org/package/2006/relationships";
@@ -312,7 +290,7 @@ function collectDocxParts(doc, zip) {
 	addHeaderFooterParts(doc.package.footers, RELATIONSHIP_TYPES.footer);
 	const addNoteParts = (notes, conventionalLowerPath) => {
 		if (!notes || notes.length === 0) return;
-		const partPath = findNotePartEntry(zip, conventionalLowerPath)?.name ?? conventionalLowerPath;
+		const partPath = findNotePartEntry(zip, conventionalLowerPath)?.path ?? conventionalLowerPath;
 		parts.push({
 			relsPath: notePartRelsPath(partPath),
 			blocks: notes.flatMap((note) => note.content)
@@ -323,25 +301,25 @@ function collectDocxParts(doc, zip) {
 	return parts;
 }
 async function readRelsOrStub(zip, relsPath) {
-	const file = zip.file(relsPath);
-	return (file ? await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })) : EMPTY_RELS_XML).replace(/<Relationships(?<attrs>[^>]*)\/>/u, "<Relationships$<attrs>></Relationships>");
+	const file = zip.entry(relsPath);
+	return (file ? await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })) : EMPTY_RELS_XML).replace(/<Relationships(?<attrs>[^>]*)\/>/u, "<Relationships$<attrs>></Relationships>");
 }
 function findMaxImageNum(zip) {
 	let maxImageNum = 0;
-	zip.forEach((relativePath) => {
+	for (const relativePath of zip.paths()) {
 		const m = /^word\/media\/image(?<num>\d+)\./u.exec(relativePath);
 		if (m) {
 			const num = Number.parseInt(m.groups["num"], 10);
 			if (num > maxImageNum) maxImageNum = num;
 		}
-	});
+	}
 	return maxImageNum;
 }
 async function registerImageExtensions(zip, extensions, compressionLevel) {
 	if (extensions.size === 0) return;
-	const ctFile = zip.file("[Content_Types].xml");
+	const ctFile = zip.entry("[Content_Types].xml");
 	if (!ctFile) return;
-	let ctXml = await ctFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	let ctXml = await ctFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	let changed = false;
 	for (const ext of extensions) {
 		if (ctXml.includes(`Extension="${ext}"`)) continue;
@@ -350,15 +328,7 @@ async function registerImageExtensions(zip, extensions, compressionLevel) {
 		changed = true;
 	}
 	if (!changed) return;
-	writeZipPart({
-		zip,
-		path: "[Content_Types].xml",
-		data: encodeUtf8(ctXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	zip.set("[Content_Types].xml", ctXml, { level: compressionLevel });
 }
 function collectNewImages(blocks) {
 	const images = [];
@@ -425,15 +395,7 @@ async function processNewImages(parts, zip, compressionLevel) {
 			maxId++;
 			const mediaPath = `word/media/${`image${maxImageNum}.${extension}`}`;
 			const newRId = mintRelationshipId(maxId);
-			writeZipPart({
-				zip,
-				path: mediaPath,
-				data: new Uint8Array(data),
-				options: {
-					compression: "DEFLATE",
-					compressionOptions: { level: compressionLevel }
-				}
-			});
+			zip.set(mediaPath, new Uint8Array(data), { level: compressionLevel });
 			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXmlAttribute(relativeTargetForPart(partPath, mediaPath))}"/>`);
 			extensionsAdded.add(extension);
 			if (drawing.rawXml) drawing.rawXml = rebindDrawingImageRelationship({
@@ -445,15 +407,7 @@ async function processNewImages(parts, zip, compressionLevel) {
 		}
 		if (relEntries.length > 0) {
 			const updatedRelsXml = relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`);
-			writeZipPart({
-				zip,
-				path: relsPath,
-				data: encodeUtf8(updatedRelsXml),
-				options: {
-					compression: "DEFLATE",
-					compressionOptions: { level: compressionLevel }
-				}
-			});
+			zip.set(relsPath, updatedRelsXml, { level: compressionLevel });
 		}
 	}
 	await registerImageExtensions(zip, extensionsAdded, compressionLevel);
@@ -466,15 +420,7 @@ const materializeEmbeddedMedia = async ({ document, zip, compressionLevel }) =>
 		if (isUnsafePackagePath(media.path) || !media.path.startsWith("word/media/")) panic("Detached media has an invalid package path");
 		const extension = media.path.split(".").at(-1)?.toLowerCase();
 		if (!extension || !/^[a-z0-9]+$/u.test(extension)) panic("Embedded media has an invalid extension");
-		writeZipPart({
-			zip,
-			path: media.path,
-			data: new Uint8Array(media.data),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			}
-		});
+		zip.set(media.path, new Uint8Array(media.data), { level: compressionLevel });
 		extensions.add(extension);
 	}
 	await registerImageExtensions(zip, extensions, compressionLevel);
@@ -529,15 +475,7 @@ const publishCanonicalImageResources = async ({ document, zip, compressionLevel
 				const media = document.package.media?.get(absolute);
 				if (!media) return refuse("missingMedia", "A canonical inline picture is missing its media bytes.");
 				if (isUnsafePackagePath(media.path) || media.path !== absolute) return refuse("unsafeTarget", "A canonical inline picture media path does not match its relationship.");
-				writeZipPart({
-					zip,
-					path: absolute,
-					data: new Uint8Array(media.data),
-					options: {
-						compression: "DEFLATE",
-						compressionOptions: { level: compressionLevel }
-					}
-				});
+				zip.set(absolute, new Uint8Array(media.data), { level: compressionLevel });
 				const extension = absolute.split(".").at(-1)?.toLowerCase();
 				if (!extension || !/^[a-z0-9]+$/u.test(extension)) return refuse("unsafeTarget", "A canonical inline picture media extension is invalid.");
 				await registerImageExtensions(zip, /* @__PURE__ */ new Set([extension]), compressionLevel);
@@ -559,15 +497,7 @@ const publishCanonicalImageResources = async ({ document, zip, compressionLevel
 			});
 			changed = true;
 		}
-		if (changed) writeZipPart({
-			zip,
-			path: relsPath,
-			data: encodeUtf8(xml),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			}
-		});
+		if (changed) zip.set(relsPath, xml, { level: compressionLevel });
 	}
 };
 const collectExternalHyperlinkResources = (blocks) => {
@@ -710,15 +640,7 @@ async function processNewHyperlinks(parts, zip, compressionLevel) {
 		}
 		if (relEntries.length > 0) {
 			(root.elements ??= []).push(...relEntries);
-			writeZipPart({
-				zip,
-				path: relsPath,
-				data: encodeUtf8(captureVerbatimXml(root)),
-				options: {
-					compression: "DEFLATE",
-					compressionOptions: { level: compressionLevel }
-				}
-			});
+			zip.set(relsPath, captureVerbatimXml(root), { level: compressionLevel });
 		}
 	}
 }
@@ -736,23 +658,18 @@ async function processNewHyperlinks(parts, zip, compressionLevel) {
 */
 const normalizePackageIdsInZip = async (zip, compressionLevel) => {
 	const xmlParts = /* @__PURE__ */ new Map();
-	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.startsWith("word/") && path.endsWith(".xml")) {
-		const xml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
-		assertValidOoxmlNumericIds(xml, path);
-		xmlParts.set(path, xml);
+	for (const file of zip.entries()) {
+		const { path } = file;
+		if (path.startsWith("word/") && path.endsWith(".xml")) {
+			const xml = await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+			assertValidOoxmlNumericIds(xml, path);
+			xmlParts.set(path, xml);
+		}
 	}
 	const normalizedParts = normalizeParaIdRangeInXmlParts(normalizeRevisionIdsInXmlParts(xmlParts));
 	for (const [path, xml] of normalizedParts) if (xml !== xmlParts.get(path)) {
 		assertValidOoxmlNumericIds(xml, path);
-		writeZipPart({
-			zip,
-			path,
-			data: encodeUtf8(xml),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			}
-		});
+		zip.set(path, xml, { level: compressionLevel });
 	}
 };
 const EXTENDED_PROPERTIES_PATH = "docProps/app.xml";
@@ -762,19 +679,11 @@ const EXTENDED_PROPERTIES_PATH = "docProps/app.xml";
 * holding none.
 */
 const normalizeAppVersionInZip = async (zip, compressionLevel) => {
-	const extendedProperties = zip.file(EXTENDED_PROPERTIES_PATH);
+	const extendedProperties = zip.entry(EXTENDED_PROPERTIES_PATH);
 	if (!extendedProperties) return;
-	const xml = await extendedProperties.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const xml = await extendedProperties.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	const normalized = normalizeAppVersionInExtendedProperties(xml);
-	if (normalized !== xml) writeZipPart({
-		zip,
-		path: EXTENDED_PROPERTIES_PATH,
-		data: encodeUtf8(normalized),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	if (normalized !== xml) zip.set(EXTENDED_PROPERTIES_PATH, normalized, { level: compressionLevel });
 };
 /**
 * Every pass a save owes the package as a whole, in one function so that the
@@ -792,11 +701,7 @@ const normalizePackageOnSave = async (zip, compressionLevel) => {
 const generateDocxZip = async (zip, compressionLevel) => {
 	await reconcilePackageReferences(zip, compressionLevel);
 	await normalizePackageOnSave(zip, compressionLevel);
-	return zip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
-	});
+	return zip.generate({ level: compressionLevel }).then((bytes) => bytes.buffer);
 };
 /**
 * Section facts of each source package's `word/document.xml`, keyed by the
@@ -826,9 +731,9 @@ const parsedZipSources = /* @__PURE__ */ new WeakMap();
 const loadParsedZipSource = async (document, buffer) => {
 	const cached = parsedZipSources.get(document);
 	if (cached?.buffer === buffer) return cached;
-	const zip = await JSZip.loadAsync(buffer);
+	const zip = await ZipArchive.read(buffer);
 	removeUnsafeEntries(zip);
-	const [documentXml, corePropertiesXml] = await Promise.all([zip.file("word/document.xml")?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })), zip.file("docProps/core.xml")?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))]);
+	const [documentXml, corePropertiesXml] = await Promise.all([zip.entry("word/document.xml")?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })), zip.entry("docProps/core.xml")?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }))]);
 	const source = {
 		buffer,
 		zip,
@@ -838,11 +743,7 @@ const loadParsedZipSource = async (document, buffer) => {
 	parsedZipSources.set(document, source);
 	return source;
 };
-const cloneDocxZip = (source) => {
-	const clone = new JSZip();
-	clone.files = { ...source.files };
-	return clone;
-};
+const cloneDocxZip = (source) => source.clone();
 const normalizeExportDrawingIds = ({ package: docxPackage }) => {
 	normalizeDrawingIds({
 		documentBody: docxPackage.document,
@@ -896,15 +797,7 @@ const finishRepack = async ({ document: sourceDocument, originalZip, outputZip,
 		removedReferences: [...sectionReferenceRemovals ?? [], ...sectionEndpointRemoval?.removedReferences ?? []],
 		compressionLevel
 	});
-	writeZipPart({
-		zip: outputZip,
-		path: "word/document.xml",
-		data: encodeUtf8(documentXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	outputZip.set("word/document.xml", documentXml, { level: compressionLevel });
 	await rebindWatermarkRelIds({
 		document,
 		zip: outputZip,
@@ -934,15 +827,7 @@ const finishRepack = async ({ document: sourceDocument, originalZip, outputZip,
 			updateModifiedDate,
 			...modifiedBy !== void 0 ? { modifiedBy } : {}
 		});
-		writeZipPart({
-			zip: outputZip,
-			path: "docProps/core.xml",
-			data: encodeUtf8(updatedCoreProperties),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			}
-		});
+		outputZip.set("docProps/core.xml", updatedCoreProperties, { level: compressionLevel });
 	}
 	return generateDocxZip(outputZip, compressionLevel);
 };
@@ -950,8 +835,8 @@ async function repackDocxWithSectionEndpointRemoval({ document: doc, options, se
 	if (!doc.originalBuffer) panic("Cannot repack document: no original buffer for round-trip. Use createDocx() for new documents.");
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
 	const exportDocument = withoutExhaustedComments(withoutOrphanCommentRanges(doc));
-	const originalZip = await JSZip.loadAsync(doc.originalBuffer);
-	const [originalDocumentXml, originalCorePropertiesXml] = await Promise.all([originalZip.file("word/document.xml")?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })), originalZip.file("docProps/core.xml")?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))]);
+	const originalZip = await ZipArchive.read(doc.originalBuffer);
+	const [originalDocumentXml, originalCorePropertiesXml] = await Promise.all([originalZip.entry("word/document.xml")?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })), originalZip.entry("docProps/core.xml")?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }))]);
 	removeUnsafeEntries(originalZip);
 	const newZip = cloneDocxZip(originalZip);
 	return finishRepack({
@@ -991,32 +876,8 @@ function repackDocx(doc, options = {}) {
 async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
 	let exportDocument = withoutExhaustedComments(withoutOrphanCommentRanges(cloneExportDocument(doc)));
-	const newZip = new JSZip();
-	for (const [path, file] of Object.entries(rawContent.originalZip.files)) {
-		if (file.dir) {
-			writeZipPart({
-				zip: newZip,
-				path,
-				data: /* @__PURE__ */ new Uint8Array(),
-				options: {
-					dir: true,
-					date: file.date
-				}
-			});
-			continue;
-		}
-		if (isUnsafePackagePath(path)) continue;
-		const content = await file.async("arraybuffer");
-		writeZipPart({
-			zip: newZip,
-			path,
-			data: new Uint8Array(content),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			}
-		});
-	}
+	const newZip = rawContent.originalZip.clone();
+	for (const path of newZip.paths()) if (isUnsafePackagePath(path)) newZip.delete(path);
 	exportDocument = await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
 	await materializeEmbeddedMedia({
 		document: exportDocument,
@@ -1044,15 +905,7 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 		serializedDocumentXml: documentXml,
 		doc: exportDocument
 	});
-	writeZipPart({
-		zip: newZip,
-		path: "word/document.xml",
-		data: encodeUtf8(documentXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	newZip.set("word/document.xml", documentXml, { level: compressionLevel });
 	await rebindWatermarkRelIds({
 		document: exportDocument,
 		zip: newZip,
@@ -1082,15 +935,7 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 			updateModifiedDate,
 			...modifiedBy !== void 0 ? { modifiedBy } : {}
 		});
-		writeZipPart({
-			zip: newZip,
-			path: "docProps/core.xml",
-			data: encodeUtf8(updatedCoreProps),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			}
-		});
+		newZip.set("docProps/core.xml", updatedCoreProps, { level: compressionLevel });
 	}
 	return generateDocxZip(newZip, compressionLevel);
 }
@@ -1176,49 +1021,25 @@ function withoutRelationships(relsXml, ids) {
 * can neither read nor rewrite. Both sides are filtered on save.
 */
 async function dropAttachedTemplateReference(zip, compressionLevel) {
-	const settingsFile = zip.file(SETTINGS_PART);
+	const settingsFile = zip.entry(SETTINGS_PART);
 	if (!settingsFile) return;
-	const relsFile = zip.file(SETTINGS_RELS_PART);
-	const filtered = withoutAttachedTemplate(await settingsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })), await relsFile?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })));
-	if (filtered.settingsXml !== void 0) writeZipPart({
-		zip,
-		path: SETTINGS_PART,
-		data: encodeUtf8(filtered.settingsXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
-	if (filtered.relsXml !== void 0) writeZipPart({
-		zip,
-		path: SETTINGS_RELS_PART,
-		data: encodeUtf8(filtered.relsXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	const relsFile = zip.entry(SETTINGS_RELS_PART);
+	const filtered = withoutAttachedTemplate(await settingsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })), await relsFile?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })));
+	if (filtered.settingsXml !== void 0) zip.set(SETTINGS_PART, filtered.settingsXml, { level: compressionLevel });
+	if (filtered.relsXml !== void 0) zip.set(SETTINGS_RELS_PART, filtered.relsXml, { level: compressionLevel });
 }
 /**
 * Ensure [Content_Types].xml contains an Override for word/comments.xml.
 * If the document already had comments, this is a no-op.
 */
 async function ensureCommentsContentType(zip, compressionLevel) {
-	const ctFile = zip.file("[Content_Types].xml");
+	const ctFile = zip.entry("[Content_Types].xml");
 	if (!ctFile) return;
-	let ctXml = await ctFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	let ctXml = await ctFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (ctXml.toLowerCase().includes("/word/comments.xml")) return;
-	const commentsPartPath = findZipEntryCaseInsensitive(zip, "word/comments.xml")?.name ?? "word/comments.xml";
+	const commentsPartPath = findZipEntryCaseInsensitive(zip, "word/comments.xml")?.path ?? "word/comments.xml";
 	ctXml = ctXml.replace("</Types>", `<Override PartName="/${commentsPartPath}" ContentType="${COMMENTS_CONTENT_TYPE}"/></Types>`);
-	writeZipPart({
-		zip,
-		path: "[Content_Types].xml",
-		data: encodeUtf8(ctXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	zip.set("[Content_Types].xml", ctXml, { level: compressionLevel });
 }
 /**
 * Ensure word/_rels/document.xml.rels contains a Relationship for comments.xml.
@@ -1226,22 +1047,14 @@ async function ensureCommentsContentType(zip, compressionLevel) {
 */
 async function ensureCommentsRelationship(zip, compressionLevel) {
 	const relsPath = "word/_rels/document.xml.rels";
-	const relsFile = zip.file(relsPath);
+	const relsFile = zip.entry(relsPath);
 	if (!relsFile) return;
-	let relsXml = await relsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	let relsXml = await relsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (relsXml.toLowerCase().includes("comments.xml")) return;
-	const commentsPartPath = findZipEntryCaseInsensitive(zip, "word/comments.xml")?.name ?? "word/comments.xml";
+	const commentsPartPath = findZipEntryCaseInsensitive(zip, "word/comments.xml")?.path ?? "word/comments.xml";
 	const newRId = `rId${findMaxRId(relsXml) + 1}`;
 	relsXml = relsXml.replace("</Relationships>", `<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.comments}" Target="${commentsPartPath.slice(5)}"/></Relationships>`);
-	writeZipPart({
-		zip,
-		path: relsPath,
-		data: encodeUtf8(relsXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	zip.set(relsPath, relsXml, { level: compressionLevel });
 }
 /**
 * Update only document.xml in a DOCX buffer (minimal changes)
@@ -1253,21 +1066,9 @@ async function ensureCommentsRelationship(zip, compressionLevel) {
 */
 async function updateDocumentXml(originalBuffer, newDocumentXml, options = {}) {
 	const { compressionLevel = 6 } = options;
-	const zip = await JSZip.loadAsync(originalBuffer);
-	writeZipPart({
-		zip,
-		path: "word/document.xml",
-		data: encodeUtf8(newDocumentXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
-	return zip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
-	});
+	const zip = await ZipArchive.read(originalBuffer);
+	zip.set("word/document.xml", newDocumentXml, { level: compressionLevel });
+	return zip.generate({ level: compressionLevel }).then((bytes) => bytes.buffer);
 }
 /**
 * Update a specific XML file in a DOCX buffer
@@ -1280,21 +1081,9 @@ async function updateDocumentXml(originalBuffer, newDocumentXml, options = {}) {
 */
 async function updateXmlFile(originalBuffer, path, content, options = {}) {
 	const { compressionLevel = 6 } = options;
-	const zip = await JSZip.loadAsync(originalBuffer);
-	writeZipPart({
-		zip,
-		path,
-		data: encodeUtf8(content),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
-	return zip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
-	});
+	const zip = await ZipArchive.read(originalBuffer);
+	zip.set(path, content, { level: compressionLevel });
+	return zip.generate({ level: compressionLevel }).then((bytes) => bytes.buffer);
 }
 /**
 * Update multiple files in a DOCX buffer
@@ -1305,10 +1094,10 @@ async function updateXmlFile(originalBuffer, path, content, options = {}) {
 * @returns Promise resolving to DOCX as ArrayBuffer
 */
 async function updateMultipleFiles(originalBuffer, updates, options = {}) {
-	return applyUpdatesToZip(await JSZip.loadAsync(originalBuffer), updates, options);
+	return applyUpdatesToZip(await ZipArchive.read(originalBuffer), updates, options);
 }
 /**
-* Apply file updates to an already-loaded JSZip instance and generate the output.
+* Apply file updates to an already-loaded ZipArchive instance and generate the output.
 * Use this when the zip is already loaded to avoid a redundant decompression pass.
 *
 * This is the selective save's exit, so it owes the package the same passes
@@ -1319,21 +1108,9 @@ async function updateMultipleFiles(originalBuffer, updates, options = {}) {
 */
 async function applyUpdatesToZip(zip, updates, options = {}) {
 	const { compressionLevel = 6 } = options;
-	for (const [path, content] of updates) writeZipPart({
-		zip,
-		path,
-		data: typeof content === "string" ? encodeUtf8(content) : new Uint8Array(content),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	for (const [path, content] of updates) zip.set(path, typeof content === "string" ? encodeUtf8(content) : new Uint8Array(content), { level: compressionLevel });
 	await normalizePackageOnSave(zip, compressionLevel);
-	return await zip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
-	});
+	return (await zip.generate({ level: compressionLevel })).buffer;
 }
 /**
 * Add a new relationship to document.xml.rels
@@ -1343,26 +1120,18 @@ async function applyUpdatesToZip(zip, updates, options = {}) {
 * @returns Promise resolving to { buffer: ArrayBuffer, rId: string }
 */
 async function addRelationship(originalBuffer, relationship) {
-	const zip = await JSZip.loadAsync(originalBuffer);
+	const zip = await ZipArchive.read(originalBuffer);
 	const relsPath = "word/_rels/document.xml.rels";
-	const relsFile = zip.file(relsPath);
+	const relsFile = zip.entry(relsPath);
 	if (!relsFile) panic("document.xml.rels not found in DOCX");
-	const relsXml = await relsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const relsXml = await relsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	const newRId = `rId${findMaxRId(relsXml) + 1}`;
 	const targetModeAttr = relationship.targetMode === "External" ? " TargetMode=\"External\"" : "";
 	const newRelElement = `<Relationship Id="${newRId}" Type="${relationship.type}" Target="${escapeXmlAttribute(relationship.target)}"${targetModeAttr}/>`;
 	const updatedRelsXml = relsXml.replace("</Relationships>", `${newRelElement}</Relationships>`);
-	writeZipPart({
-		zip,
-		path: relsPath,
-		data: encodeUtf8(updatedRelsXml)
-	});
+	zip.set(relsPath, updatedRelsXml);
 	return {
-		buffer: await zip.generateAsync({
-			type: "arraybuffer",
-			compression: "DEFLATE",
-			compressionOptions: { level: 6 }
-		}),
+		buffer: (await zip.generate({ level: 6 })).buffer,
 		rId: newRId
 	};
 }
@@ -1376,36 +1145,24 @@ async function addRelationship(originalBuffer, relationship) {
 * @returns Promise resolving to { buffer: ArrayBuffer, rId: string, path: string }
 */
 async function addMedia(originalBuffer, filename, data, mimeType) {
-	const zip = await JSZip.loadAsync(originalBuffer);
+	const zip = await ZipArchive.read(originalBuffer);
 	const mediaPath = `word/media/${filename}`;
-	writeZipPart({
-		zip,
-		path: mediaPath,
-		data: new Uint8Array(data)
-	});
-	const relResult = await addRelationship(await zip.generateAsync({ type: "arraybuffer" }), {
+	zip.set(mediaPath, new Uint8Array(data));
+	const relResult = await addRelationship((await zip.generate({ compression: "store" })).buffer, {
 		type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
 		target: `media/${filename}`
 	});
-	const contentTypesFile = zip.file("[Content_Types].xml");
+	const contentTypesFile = zip.entry("[Content_Types].xml");
 	if (contentTypesFile) {
-		const contentTypesXml = await contentTypesFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+		const contentTypesXml = await contentTypesFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		const extension = filename.split(".").pop()?.toLowerCase() || "";
 		if (!contentTypesXml.includes(`Extension="${extension}"`) && extension) {
 			const extensionElement = `<Default Extension="${extension}" ContentType="${getContentTypeForExtension(extension, mimeType)}"/>`;
 			const updatedContentTypes = contentTypesXml.replace("</Types>", `${extensionElement}</Types>`);
-			const finalZip = await JSZip.loadAsync(relResult.buffer);
-			writeZipPart({
-				zip: finalZip,
-				path: "[Content_Types].xml",
-				data: encodeUtf8(updatedContentTypes)
-			});
+			const finalZip = await ZipArchive.read(relResult.buffer);
+			finalZip.set("[Content_Types].xml", updatedContentTypes);
 			return {
-				buffer: await finalZip.generateAsync({
-					type: "arraybuffer",
-					compression: "DEFLATE",
-					compressionOptions: { level: 6 }
-				}),
+				buffer: (await finalZip.generate({ level: 6 })).buffer,
 				rId: relResult.rId,
 				path: mediaPath
 			};
@@ -1445,13 +1202,13 @@ function hasUnmaterializedHeaderFooter(doc) {
 function findMaxHeaderFooterNum(zip, prefix) {
 	let max = 0;
 	const pattern = new RegExp(`^word/${prefix}(\\d+)\\.xml$`, "u");
-	zip.forEach((relativePath) => {
+	for (const relativePath of zip.paths()) {
 		const m = pattern.exec(relativePath);
 		if (m) {
 			const num = Number.parseInt(m[1], 10);
 			if (num > max) max = num;
 		}
-	});
+	}
 	return max;
 }
 /**
@@ -1545,28 +1302,12 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 	materialize(doc.package.headers, RELATIONSHIP_TYPES.header, "header", HEADER_CONTENT_TYPE, true);
 	materialize(doc.package.footers, RELATIONSHIP_TYPES.footer, "footer", FOOTER_CONTENT_TYPE, false);
 	const compressionOptions = { level: compressionLevel };
-	if (relEntries.length > 0) writeZipPart({
-		zip,
-		path: relsPath,
-		data: encodeUtf8(relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`)),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions
-		}
-	});
-	const ctFile = zip.file("[Content_Types].xml");
+	if (relEntries.length > 0) zip.set(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), compressionOptions);
+	const ctFile = zip.entry("[Content_Types].xml");
 	if (ctFile) {
-		const original = await ctFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+		const original = await ctFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		const updated = registerContentTypeParts(original, contentTypeParts);
-		if (updated !== original) writeZipPart({
-			zip,
-			path: "[Content_Types].xml",
-			data: encodeUtf8(updated),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions
-			}
-		});
+		if (updated !== original) zip.set("[Content_Types].xml", updated, compressionOptions);
 	}
 	return doc;
 }
@@ -1672,7 +1413,7 @@ async function rebindWatermarkRelIds({ document: doc, zip, compressionLevel, bod
 			if (bodyAuthority === "canonical") throw new DocxPackageFidelityError("A canonical picture watermark image cannot be resolved");
 			continue;
 		}
-		if (bodyAuthority === "canonical" && canonical.mode === "internal" && !zip.file(canonical.absolute)) throw new DocxPackageFidelityError("A canonical picture watermark image part is missing");
+		if (bodyAuthority === "canonical" && canonical.mode === "internal" && !zip.entry(canonical.absolute)) throw new DocxPackageFidelityError("A canonical picture watermark image part is missing");
 		const relsXml = relsXmlByPath.get(relsPath) ?? EMPTY_RELS_XML;
 		const localRels = parseRelationships(relsXml);
 		const local = relImage(localRels.get(watermark.imageRId), relsPath);
@@ -1712,15 +1453,7 @@ async function rebindWatermarkRelIds({ document: doc, zip, compressionLevel, bod
 	const compressionOptions = { level: compressionLevel };
 	for (const path of changedPaths) {
 		const xml = relsXmlByPath.get(path);
-		if (xml) writeZipPart({
-			zip,
-			path,
-			data: encodeUtf8(xml),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions
-			}
-		});
+		if (xml) zip.set(path, xml, compressionOptions);
 	}
 }
 async function collectHeaderFooterUpdates(doc, { sourceZip, onDiagnostic }) {
@@ -1742,7 +1475,7 @@ async function collectHeaderFooterUpdates(doc, { sourceZip, onDiagnostic }) {
 			if (rel && rel.type === type && rel.target) {
 				const path = resolveRelativePath(documentRelsPath, rel.target);
 				const sourceFile = findZipEntryCaseInsensitive(sourceZip, path.toLowerCase());
-				const bindings = sourceFile ? readRootNamespaceBindings(await sourceFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))) : /* @__PURE__ */ new Map();
+				const bindings = sourceFile ? readRootNamespaceBindings(await sourceFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }))) : /* @__PURE__ */ new Map();
 				updates.set(path, serializeHeaderFooter(headerFooter, {
 					path,
 					bindings,
@@ -1759,15 +1492,7 @@ async function serializeHeadersFootersToZip({ doc, zip, compressionLevel, onDiag
 	for (const [filename, xml] of await collectHeaderFooterUpdates(doc, {
 		sourceZip: zip,
 		onDiagnostic
-	})) writeZipPart({
-		zip,
-		path: filename,
-		data: encodeUtf8(xml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions
-		}
-	});
+	})) zip.set(filename, xml, compressionOptions);
 }
 async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel, changedNoteParaIds }) {
 	const footnotes = doc.package.footnotes ?? [];
@@ -1822,46 +1547,22 @@ async function materializeNewNotePart({ contentType, newZip, partPath, relations
 	const relationshipsFile = findNotePartEntry(newZip, "word/_rels/document.xml.rels");
 	if (!contentTypesFile || !relationshipsFile) throw new DocxPackageFidelityError(`Cannot create ${partPath}: the DOCX package is missing content types or document relationships`);
 	const compressionOptions = { level: compressionLevel };
-	const contentTypesXml = await contentTypesFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const contentTypesXml = await contentTypesFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	const partName = `/${partPath}`;
-	if (!contentTypesXml.toLowerCase().includes(partName.toLowerCase())) writeZipPart({
-		zip: newZip,
-		path: contentTypesFile.name,
-		data: encodeUtf8(contentTypesXml.replace("</Types>", () => `<Override PartName="${partName}" ContentType="${contentType}"/></Types>`)),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions
-		}
-	});
-	const relationshipsXml = await relationshipsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	if (!contentTypesXml.toLowerCase().includes(partName.toLowerCase())) newZip.set(contentTypesFile.path, contentTypesXml.replace("</Types>", () => `<Override PartName="${partName}" ContentType="${contentType}"/></Types>`), compressionOptions);
+	const relationshipsXml = await relationshipsFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (!relationshipsXml.includes(relationshipType)) {
 		const relationshipId = `rId${findMaxRId(relationshipsXml) + 1}`;
 		const target = partPath.slice(5);
-		writeZipPart({
-			zip: newZip,
-			path: relationshipsFile.name,
-			data: encodeUtf8(relationshipsXml.replace("</Relationships>", () => `<Relationship Id="${relationshipId}" Type="${relationshipType}" Target="${target}"/></Relationships>`)),
-			options: {
-				compression: "DEFLATE",
-				compressionOptions
-			}
-		});
+		newZip.set(relationshipsFile.path, relationshipsXml.replace("</Relationships>", () => `<Relationship Id="${relationshipId}" Type="${relationshipType}" Target="${target}"/></Relationships>`), compressionOptions);
 	}
-	writeZipPart({
-		zip: newZip,
-		path: partPath,
-		data: encodeUtf8(serializedPart),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions
-		}
-	});
+	newZip.set(partPath, serializedPart, compressionOptions);
 }
 /** Only this modeled switch changes on story lifecycle edits; preserve all other settings. */
 async function serializeHeaderFooterSettingsIntoZip(doc, zip, compressionLevel) {
 	if (!doc.package.settings) return;
 	const enabled = doc.package.settings.evenAndOddHeaders;
-	const file = zip.file(SETTINGS_PART);
+	const file = zip.entry(SETTINGS_PART);
 	if (!file) {
 		if (enabled === void 0) return;
 		await materializeNewNotePart({
@@ -1874,19 +1575,11 @@ async function serializeHeaderFooterSettingsIntoZip(doc, zip, compressionLevel)
 		});
 		return;
 	}
-	const xml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const xml = await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (parseSettings(xml).evenAndOddHeaders === enabled) return;
 	const patched = updateEvenAndOddHeaders(xml, enabled);
 	if (patched === null) throw new DocxPackageFidelityError("Cannot update malformed header/footer settings");
-	writeZipPart({
-		zip,
-		path: file.name,
-		data: encodeUtf8(patched),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	zip.set(file.path, patched, { level: compressionLevel });
 }
 const numberingBaselines = /* @__PURE__ */ new WeakMap();
 async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLevel) {
@@ -1906,7 +1599,7 @@ async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLe
 	}
 	let baseline = doc.originalBuffer ? numberingBaselines.get(doc) : void 0;
 	if (!baseline || baseline.originalBuffer !== doc.originalBuffer) {
-		const originalXml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+		const originalXml = await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		baseline = {
 			originalBuffer: doc.originalBuffer,
 			originalXml,
@@ -1921,15 +1614,7 @@ async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLe
 		currentXml
 	});
 	if (patched === null || patched === baseline.originalXml) return;
-	writeZipPart({
-		zip: newZip,
-		path: file.name,
-		data: encodeUtf8(patched),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	newZip.set(file.path, patched, { level: compressionLevel });
 }
 const STYLES_PART_PATH = "word/styles.xml";
 const STYLES_CLOSE_ROOT = "</w:styles>";
@@ -2041,7 +1726,7 @@ async function planAddedStyles(doc, originalZip) {
 	const styles = doc.package.styles;
 	if (!styles || styles.styles.length === 0) return { type: "unchanged" };
 	const file = findNotePartEntry(originalZip, STYLES_PART_PATH);
-	const originalXml = file ? await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })) : null;
+	const originalXml = file ? await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })) : null;
 	const rootName = originalXml === null ? void 0 : /<(?![?!])(?<name>[^\s/>]+)/u.exec(originalXml)?.groups?.["name"];
 	const rootClose = originalXml !== null && rootName !== void 0 && getLocalName(rootName) === "styles" ? originalXml.lastIndexOf(`</${rootName}>`) : -1;
 	if (file === null || originalXml === null || rootClose < 0) return {
@@ -2057,10 +1742,10 @@ async function planAddedStyles(doc, originalZip) {
 	}
 	if (added.length === 0) return { type: "unchanged" };
 	const canonical = hasCanonicalWordprocessingPrefixes(originalXml);
-	const patched = originalXml.slice(0, rootClose) + added.map((style) => canonical ? serializeStyle(style) : selfBoundFragment(serializeStyle(style), file.name)).join("") + originalXml.slice(rootClose);
+	const patched = originalXml.slice(0, rootClose) + added.map((style) => canonical ? serializeStyle(style) : selfBoundFragment(serializeStyle(style), file.path)).join("") + originalXml.slice(rootClose);
 	return {
 		type: "patch",
-		path: file.name,
+		path: file.path,
 		xml: patched
 	};
 }
@@ -2079,15 +1764,7 @@ async function serializeAddedStylesIntoZip(doc, originalZip, newZip, compression
 			});
 			return;
 		case "patch":
-			writeZipPart({
-				zip: newZip,
-				path: plan.path,
-				data: encodeUtf8(plan.xml),
-				options: {
-					compression: "DEFLATE",
-					compressionOptions: { level: compressionLevel }
-				}
-			});
+			newZip.set(plan.path, plan.xml, { level: compressionLevel });
 			return;
 		default: return plan;
 	}
@@ -2125,7 +1802,7 @@ const notePartXmlFor = ({ patch, originalXml, replacementXml, hasDirtyParagraph,
 async function patchNotePartIntoZip({ conventionalLowerPath, currentXml, replacementXml, baselineFrom, elementName, changedNoteParaIds, originalZip, newZip, compressionLevel }) {
 	const file = findNotePartEntry(originalZip, conventionalLowerPath);
 	if (!file) return;
-	const originalXml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+	const originalXml = await file.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	const baselineXml = baselineFrom(originalXml);
 	const effectiveChangedNoteParaIds = changedNoteParaIds ?? collectChangedNoteParaIds(baselineXml, currentXml);
 	const currentParaIds = collectParaIds(currentXml);
@@ -2142,18 +1819,10 @@ async function patchNotePartIntoZip({ conventionalLowerPath, currentXml, replace
 		replacementXml,
 		hasDirtyParagraph: [...effectiveChangedNoteParaIds].some((paraId) => currentParaIds.has(paraId)),
 		elementName,
-		partName: file.name
+		partName: file.path
 	});
 	if (patchedXml === null || patchedXml === originalXml) return;
-	writeZipPart({
-		zip: newZip,
-		path: file.name,
-		data: encodeUtf8(patchedXml),
-		options: {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		}
-	});
+	newZip.set(file.path, patchedXml, { level: compressionLevel });
 }
 /** `word/Footnotes.xml` -> `word/_rels/Footnotes.xml.rels` (casing preserved). */
 function notePartRelsPath(partPath) {
@@ -2165,9 +1834,12 @@ function notePartRelsPath(partPath) {
 * cased the entry differently still resolves to the existing part.
 */
 function findNotePartEntry(zip, conventionalLowerPath) {
-	const direct = zip.file(conventionalLowerPath);
+	const direct = zip.entry(conventionalLowerPath);
 	if (direct) return direct;
-	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.toLowerCase() === conventionalLowerPath) return file;
+	for (const file of zip.entries()) {
+		const { path } = file;
+		if (path.toLowerCase() === conventionalLowerPath) return file;
+	}
 	return null;
 }
 /** Update existing core-property values without synthesizing absent metadata. */
@@ -2249,11 +1921,8 @@ function createEmptyDocx(properties = {}) {
 	return generateDocxZip(createEmptyDocxZip(properties), 6);
 }
 const createEmptyDocxZip = ({ creator, application }) => {
-	const zip = new JSZip();
-	writeZipPart({
-		zip,
-		path: "[Content_Types].xml",
-		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	const zip = new ZipArchive();
+	zip.set("[Content_Types].xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
   <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
   <Default Extension="xml" ContentType="application/xml"/>
@@ -2261,30 +1930,18 @@ const createEmptyDocxZip = ({ creator, application }) => {
   <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
   <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
   <Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
-</Types>`)
-	});
-	writeZipPart({
-		zip,
-		path: "_rels/.rels",
-		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+</Types>`);
+	zip.set("_rels/.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
   <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
   <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
   <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
-</Relationships>`)
-	});
-	writeZipPart({
-		zip,
-		path: "word/_rels/document.xml.rels",
-		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+</Relationships>`);
+	zip.set("word/_rels/document.xml.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
   <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
-</Relationships>`)
-	});
-	writeZipPart({
-		zip,
-		path: "word/document.xml",
-		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+</Relationships>`);
+	zip.set("word/document.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
   <w:body>
     <w:p>
@@ -2297,32 +1954,19 @@ const createEmptyDocxZip = ({ creator, application }) => {
       <w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="720" w:footer="720" w:gutter="0"/>
     </w:sectPr>
   </w:body>
-</w:document>`)
-	});
-	writeZipPart({
-		zip,
-		path: STYLES_PART_PATH,
-		data: encodeUtf8(SEED_STYLES_XML)
-	});
+</w:document>`);
+	zip.set(STYLES_PART_PATH, SEED_STYLES_XML);
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const creatorElement = creator === void 0 ? "" : `\n  <dc:creator>${escapeXmlText(creator)}</dc:creator>`;
-	writeZipPart({
-		zip,
-		path: "docProps/core.xml",
-		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	zip.set("docProps/core.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${creatorElement}
   <dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>
   <dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
-</cp:coreProperties>`)
-	});
+</cp:coreProperties>`);
 	const applicationElements = application === void 0 ? "" : `\n  <Application>${escapeXmlText(application)}</Application>\n  <AppVersion>${CREATED_APP_VERSION}</AppVersion>`;
-	writeZipPart({
-		zip,
-		path: "docProps/app.xml",
-		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	zip.set("docProps/app.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">${applicationElements}
-</Properties>`)
-	});
+</Properties>`);
 	return zip;
 };
 /**
@@ -2354,7 +1998,7 @@ async function createDocx(doc, properties = {}) {
 		originalZip: zip,
 		outputZip: zip,
 		originalDocument: void 0,
-		originalCorePropertiesXml: await zip.file("docProps/core.xml")?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })),
+		originalCorePropertiesXml: await zip.entry("docProps/core.xml")?.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true })),
 		compressionLevel: 6,
 		updateModifiedDate: true,
 		onDiagnostic: properties.onDiagnostic,
@@ -2369,70 +2013,38 @@ const createDocumentSeedZip = async (doc, properties) => {
 	const styleDefinitions = styleDefinitionsToSerialize(doc);
 	if (styleDefinitions) {
 		assertStyleNumberingReferences(doc);
-		writeZipPart({
-			zip,
-			path: STYLES_PART_PATH,
-			data: encodeUtf8(serializeStylesXml(styleDefinitions))
-		});
-	} else writeZipPart({
-		zip,
-		path: STYLES_PART_PATH,
-		data: encodeUtf8(seedStylesXmlWith(missingNoteReferenceStyles(void 0, noteReferenceNeeds(doc.package))))
-	});
+		zip.set(STYLES_PART_PATH, serializeStylesXml(styleDefinitions));
+	} else zip.set(STYLES_PART_PATH, seedStylesXmlWith(missingNoteReferenceStyles(void 0, noteReferenceNeeds(doc.package))));
 	const numbering = doc.package.numbering;
 	if (numbering && (numbering.abstractNums.length > 0 || numbering.nums.length > 0)) {
-		writeZipPart({
-			zip,
-			path: "word/numbering.xml",
-			data: encodeUtf8(serializeNumberingXml(numbering))
-		});
+		zip.set("word/numbering.xml", serializeNumberingXml(numbering));
 		relationships.push(relationshipXml(nextRelationshipId, "numbering", "numbering.xml"));
 		overrides.push(overrideXml("/word/numbering.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"));
 		nextRelationshipId += 1;
 	}
 	if (doc.package.theme) {
-		writeZipPart({
-			zip,
-			path: "word/theme/theme1.xml",
-			data: encodeUtf8(serializeThemeXml(doc.package.theme))
-		});
+		zip.set("word/theme/theme1.xml", serializeThemeXml(doc.package.theme));
 		relationships.push(relationshipXml(nextRelationshipId, "theme", "theme/theme1.xml"));
 		overrides.push(overrideXml("/word/theme/theme1.xml", "application/vnd.openxmlformats-officedocument.theme+xml"));
 		nextRelationshipId += 1;
 	}
 	if (doc.package.fontTable && doc.package.fontTable.fonts.length > 0) {
-		writeZipPart({
-			zip,
-			path: "word/fontTable.xml",
-			data: encodeUtf8(serializeFontTableXml(doc.package.fontTable))
-		});
+		zip.set("word/fontTable.xml", serializeFontTableXml(doc.package.fontTable));
 		relationships.push(relationshipXml(nextRelationshipId, "fontTable", "fontTable.xml"));
 		overrides.push(overrideXml("/word/fontTable.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"));
 		nextRelationshipId += 1;
 	}
 	if (doc.package.settings) {
-		writeZipPart({
-			zip,
-			path: "word/settings.xml",
-			data: encodeUtf8(serializeSettingsXml(doc.package.settings))
-		});
+		zip.set("word/settings.xml", serializeSettingsXml(doc.package.settings));
 		relationships.push(relationshipXml(nextRelationshipId, "settings", "settings.xml"));
 		overrides.push(overrideXml("/word/settings.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"));
 	}
-	writeZipPart({
-		zip,
-		path: "word/_rels/document.xml.rels",
-		data: encodeUtf8(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${relationships.join("")}</Relationships>`)
-	});
+	zip.set("word/_rels/document.xml.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${relationships.join("")}</Relationships>`);
 	if (overrides.length > 0) {
-		const contentTypesFile = zip.file("[Content_Types].xml");
+		const contentTypesFile = zip.entry("[Content_Types].xml");
 		if (!contentTypesFile) panic("Fresh DOCX seed is missing [Content_Types].xml");
-		const contentTypes = await contentTypesFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
-		writeZipPart({
-			zip,
-			path: "[Content_Types].xml",
-			data: encodeUtf8(contentTypes.replace("</Types>", `${overrides.join("")}\n</Types>`))
-		});
+		const contentTypes = await contentTypesFile.bytes().then((bytes) => decodeText(bytes, { ignoreBOM: true }));
+		zip.set("[Content_Types].xml", contentTypes.replace("</Types>", `${overrides.join("")}\n</Types>`));
 	}
 	return zip;
 };