@stll/folio-core 0.54.0 → 0.54.2

package/dist/docx/ensureParaIds.d.ts

@@ -15,6 +15,11 @@ type EnsureParaIdsResult = {
   deduplicated: number;
   /** True when the input already had full, unique coverage. */
   alreadyComplete: boolean;
+  /**
+   * Every id this pass wrote (assigned or deduplicated), in scan order. An id
+   * absent from this list was already the package's own.
+   */
+  mintedParaIds: readonly string[];
 };
 /** Controls mutation of package metadata that has security implications. */
 type EnsureParaIdsOptions = {

package/dist/docx/ensureParaIds.js

@@ -233,6 +233,7 @@ const mintParaId = (context, partPath, ordinal) => {
 */
 const scanPart = (xml, partPath, spelling, context, seen) => {
 	const edits = [];
+	const minted = [];
 	const w14 = spelling.w14Prefix;
 	let assigned = 0;
 	let deduplicated = 0;
@@ -261,6 +262,7 @@ const scanPart = (xml, partPath, spelling, context, seen) => {
 				text: ` ${w14}:paraId="${id}" ${w14}:textId="${id}"`
 			});
 			assigned += 1;
+			minted.push(id);
 			seen.add(id);
 			continue;
 		}
@@ -287,10 +289,12 @@ const scanPart = (xml, partPath, spelling, context, seen) => {
 		});
 		if (unassigned) assigned += 1;
 		else deduplicated += 1;
+		minted.push(id);
 		seen.add(id);
 	}
 	return {
 		edits,
+		minted,
 		assigned,
 		deduplicated,
 		paragraphs: ordinal
@@ -404,6 +408,7 @@ const ensureParaIdsInternal = async (docx, options) => {
 		collectFallbackParaIds(xml, partPath, spelling, seen);
 	} else collectExistingParaIds(xml, seen);
 	const updates = /* @__PURE__ */ new Map();
+	const mintedParaIds = [];
 	let assigned = 0;
 	let deduplicated = 0;
 	for (const partPath of targetParts) {
@@ -414,13 +419,15 @@ const ensureParaIdsInternal = async (docx, options) => {
 		if (scan.edits.length === 0) continue;
 		assigned += scan.assigned;
 		deduplicated += scan.deduplicated;
+		for (const id of scan.minted) mintedParaIds.push(id);
 		updates.set(partPath, applySplices(xml, [...scan.edits, ...ensureRootNamespaces(xml, partPath, spelling)], partPath));
 	}
 	if (updates.size === 0) return {
 		docx: toUint8Array(docx),
 		assigned: 0,
 		deduplicated: 0,
-		alreadyComplete: true
+		alreadyComplete: true,
+		mintedParaIds: []
 	};
 	const zip = await JSZip.loadAsync(docx);
 	if (hasDigitalSignatureParts(zip) && options.allowSignedPackageMutation !== true) throw createEnsureParaIdsError("Refusing to normalize a digitally signed package because rewriting OOXML invalidates its signatures. Warn the user and pass allowSignedPackageMutation only if invalidation is acceptable.");
@@ -441,7 +448,8 @@ const ensureParaIdsInternal = async (docx, options) => {
 		}),
 		assigned,
 		deduplicated,
-		alreadyComplete: false
+		alreadyComplete: false,
+		mintedParaIds
 	};
 };
 /**

package/dist/docx/listNumberingInstances.js

@@ -1,3 +1,4 @@
+import { createNumberingIdAllocator, mintNumberingId } from "./numberingIds.js";
 import { NUMBER_FORMATS } from "@stll/docx-core/model";
 //#region src/docx/listNumberingInstances.ts
 /**
@@ -115,15 +116,16 @@ const EMPTY_DEFINITIONS = {
 	abstractNums: [],
 	nums: []
 };
-const nextId = (ids, floor) => {
-	let next = floor;
-	for (const id of ids) next = Math.max(next, id + 1);
-	return next;
-};
 /** A fresh `w:numId` for `definitions`; zero is reserved for "no numbering". */
-const nextNumId = (definitions) => nextId((definitions?.nums ?? []).map(({ numId }) => numId), 1);
+const nextNumId = (definitions) => mintNumberingId({
+	kind: "num",
+	existingIds: (definitions?.nums ?? []).map(({ numId }) => numId)
+});
 /** A fresh `w:abstractNumId` for `definitions`. */
-const nextAbstractNumId = (definitions) => nextId((definitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), 0);
+const nextAbstractNumId = (definitions) => mintNumberingId({
+	kind: "abstract",
+	existingIds: (definitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId)
+});
 /**
 * Define a new list: a new `w:abstractNum` of the requested kind and the
 * `w:num` naming it. `definitions` must already hold every instance the
@@ -218,11 +220,11 @@ const completeListNumbering = (definitions, references) => {
 	const current = definitions ?? EMPTY_DEFINITIONS;
 	const abstractIds = new Set(current.abstractNums.map(({ abstractNumId }) => abstractNumId));
 	const statedAbstractIds = [...missing.values()].flatMap((group) => group.flatMap(({ rendering }) => rendering.abstractNumId === void 0 ? [] : [rendering.abstractNumId]));
-	let freeAbstractId = nextId([...abstractIds, ...statedAbstractIds], 0);
+	const missingAbstractIds = createNumberingIdAllocator("abstract", [...abstractIds, ...statedAbstractIds]);
 	const abstractNums = [];
 	const nums = [];
 	for (const [numId, group] of missing) {
-		const abstractNumId = group.find(({ rendering }) => rendering.abstractNumId !== void 0)?.rendering.abstractNumId ?? freeAbstractId++;
+		const abstractNumId = group.find(({ rendering }) => rendering.abstractNumId !== void 0)?.rendering.abstractNumId ?? missingAbstractIds.next();
 		if (!abstractIds.has(abstractNumId)) {
 			abstractIds.add(abstractNumId);
 			const kind = group.some(({ rendering }) => rendering.isBullet) ? "bullet" : "numbered";

package/dist/docx/noteIds.d.ts

@@ -0,0 +1,4 @@
+//#region src/docx/noteIds.d.ts
+declare const mintEndnoteId: (existingIds: Iterable<number>) => number;
+//#endregion
+export { mintEndnoteId };

package/dist/docx/noteIds.js

@@ -0,0 +1,13 @@
+import { createNumericIdAllocator } from "./numericIdAllocator.js";
+//#region src/docx/noteIds.ts
+let endnoteIds;
+const mintEndnoteId = (existingIds) => {
+	const allocator = endnoteIds ??= createNumericIdAllocator({
+		space: "endnote",
+		firstId: 1
+	});
+	allocator.reserve(existingIds);
+	return allocator.next();
+};
+//#endregion
+export { mintEndnoteId };

package/dist/docx/numberingIds.d.ts

@@ -0,0 +1,14 @@
+//#region src/docx/numberingIds.d.ts
+type NumberingKind = "num" | "abstract";
+type MintNumberingIdOptions = {
+  kind: NumberingKind;
+  existingIds: Iterable<number>;
+};
+/** Independent offline packages can allocate deterministically without retaining realm state. */
+declare const createNumberingIdAllocator: (kind: NumberingKind, existingIds: Iterable<number>) => {
+  reserve: (ids: Iterable<number>) => void;
+  next: () => number;
+};
+declare const mintNumberingId: ({ kind, existingIds }: MintNumberingIdOptions) => number;
+//#endregion
+export { createNumberingIdAllocator, mintNumberingId };

package/dist/docx/numberingIds.js

@@ -0,0 +1,16 @@
+import { createNumericIdAllocator } from "./numericIdAllocator.js";
+//#region src/docx/numberingIds.ts
+/** Independent offline packages can allocate deterministically without retaining realm state. */
+const createNumberingIdAllocator = (kind, existingIds) => {
+	const allocator = createNumericIdAllocator({
+		space: kind === "num" ? "numbering instance" : "abstract numbering",
+		firstId: kind === "num" ? 1 : 0
+	});
+	allocator.reserve(existingIds);
+	return allocator;
+};
+const mintNumberingId = ({ kind, existingIds }) => {
+	return createNumberingIdAllocator(kind, existingIds).next();
+};
+//#endregion
+export { createNumberingIdAllocator, mintNumberingId };

package/dist/docx/numericIdAllocator.d.ts

@@ -0,0 +1,12 @@
+//#region src/docx/numericIdAllocator.d.ts
+type NumericIdAllocatorOptions = {
+  space: string;
+  firstId: 0 | 1;
+};
+/** Each OOXML id space owns one instance, retaining loaded and minted ids through rollover. */
+declare const createNumericIdAllocator: ({ space, firstId }: NumericIdAllocatorOptions) => {
+  reserve: (ids: Iterable<number>) => void;
+  next: () => number;
+};
+//#endregion
+export { createNumericIdAllocator };

package/dist/docx/numericIdAllocator.js

@@ -0,0 +1,33 @@
+import { TaggedError } from "better-result";
+import { MAX_REVISION_ID } from "@stll/docx-core/model";
+//#region src/docx/numericIdAllocator.ts
+var OoxmlIdSpaceExhaustedError = class extends TaggedError("OoxmlIdSpaceExhaustedError") {};
+/** Each OOXML id space owns one instance, retaining loaded and minted ids through rollover. */
+const createNumericIdAllocator = ({ space, firstId }) => {
+	const reserved = /* @__PURE__ */ new Set();
+	let nextId = firstId;
+	return {
+		reserve: (ids) => {
+			let max = -1;
+			for (const id of ids) {
+				if (!Number.isInteger(id) || id < firstId || id > MAX_REVISION_ID) continue;
+				reserved.add(id);
+				max = Math.max(max, id);
+			}
+			if (max >= nextId) nextId = max === MAX_REVISION_ID ? firstId : max + 1;
+		},
+		next: () => {
+			if (reserved.size >= MAX_REVISION_ID - firstId + 1) throw new OoxmlIdSpaceExhaustedError({
+				message: `OOXML ${space} id space is exhausted`,
+				space
+			});
+			while (reserved.has(nextId)) nextId = nextId === MAX_REVISION_ID ? firstId : nextId + 1;
+			const id = nextId;
+			reserved.add(id);
+			nextId = id === MAX_REVISION_ID ? firstId : id + 1;
+			return id;
+		}
+	};
+};
+//#endregion
+export { createNumericIdAllocator };

package/dist/docx/numericIdNormalization.d.ts

@@ -0,0 +1,16 @@
+import { RawDocxContent } from "./unzip.js";
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/numericIdNormalization.d.ts
+type NumericIdNormalizationOptions = {
+  onParsedDocument?: (document: XmlElement) => void;
+};
+/**
+ * Repair out-of-range imported integers before any model or opaque XML is captured.
+ * Reserve the complete package first, then remap each old value once per space.
+ * Source splices preserve unrelated XML bytes; a valid package takes the fast path.
+ */
+declare const normalizeImportedNumericIds: (parts: ReadonlyMap<string, string>, options?: NumericIdNormalizationOptions) => ReadonlyMap<string, string>;
+/** Parser boundary: all captures and selective-save bytes see the same identities. */
+declare const normalizeRawDocxNumericIds: (raw: RawDocxContent) => Promise<XmlElement | undefined>;
+//#endregion
+export { normalizeImportedNumericIds, normalizeRawDocxNumericIds };

package/dist/docx/numericIdNormalization.js

@@ -0,0 +1,174 @@
+import { REVISION_ELEMENT_NAMES } from "./revisionIdNormalization.js";
+import { parseStreamingXmlWithIdentityVisitor, scanStreamingXmlNumericIdAttributes } from "./streamingXmlParser.js";
+import { replaceRawDocxXmlParts } from "./unzip.js";
+import { getLocalName, getNamespaceUri, resolveAttributeNamespaceUri } from "./xmlParser.js";
+import { XmlResourceLimitError } from "./xmlResourceLimits.js";
+import { panic } from "better-result";
+import { assertValidOoxmlNumericId, isOoxmlNumericIdAttributeName, isValidOoxmlNumericId, mayContainInvalidOoxmlNumericIds, mayContainOoxmlNumericIds, ooxmlNumericIdDomain } from "@stll/docx-core";
+//#region src/docx/numericIdNormalization.ts
+const identityKey = (value) => {
+	const spelling = String(value).trim();
+	if (!/^[+-]?\d+$/u.test(spelling)) return spelling;
+	const digits = spelling.replace(/^[+-]?0*/u, "");
+	return digits === "" ? "0" : `${spelling.startsWith("-") ? "-" : ""}${digits}`;
+};
+const identitySpace = ({ elementName, attributeName, domain }) => {
+	if (domain === "unsigned32") return "drawing";
+	const element = getLocalName(elementName);
+	const attribute = getLocalName(attributeName);
+	switch (attribute === "val" ? element : attribute) {
+		case "numId": return "numbering-instance";
+		case "abstractNumId": return "numbering-abstract";
+		case "numPicBulletId":
+		case "lvlPicBulletId": return "numbering-picture";
+		default: break;
+	}
+	switch (element) {
+		case "footnote":
+		case "footnoteReference": return "footnote";
+		case "endnote":
+		case "endnoteReference": return "endnote";
+		case "id": return "content-control";
+		default: return `annotation:${REVISION_ELEMENT_NAMES.has(element) ? "revision" : element.replace(/(?:Range)?(?:Start|End)$/u, "").replace(/^comment.*$/u, "comment")}`;
+	}
+};
+const identifiedAttributes = (element) => {
+	const attributes = [];
+	for (const [name, value] of Object.entries(element.attributes ?? {})) {
+		if (!isOoxmlNumericIdAttributeName({
+			elementName: element.name ?? "",
+			attributeName: name
+		})) continue;
+		if (value === void 0 || !/^[+-]?\d+$/u.test(String(value).trim())) continue;
+		const domain = ooxmlNumericIdDomain({
+			elementName: element.name ?? "",
+			elementNamespace: getNamespaceUri(element),
+			attributeName: name,
+			attributeNamespace: resolveAttributeNamespaceUri(element, name)
+		});
+		if (domain === void 0) continue;
+		attributes.push({
+			name,
+			value,
+			domain,
+			space: identitySpace({
+				elementName: element.name ?? "",
+				attributeName: name,
+				domain
+			})
+		});
+	}
+	return attributes;
+};
+/**
+* Repair out-of-range imported integers before any model or opaque XML is captured.
+* Reserve the complete package first, then remap each old value once per space.
+* Source splices preserve unrelated XML bytes; a valid package takes the fast path.
+*/
+const normalizeImportedNumericIds = (parts, options = {}) => {
+	if (![...parts.values()].some((xml) => mayContainInvalidOoxmlNumericIds(xml, "range"))) return parts;
+	const normalized = new Map(parts);
+	const candidates = [...parts].filter(([, xml]) => mayContainOoxmlNumericIds(xml)).toSorted(([left], [right]) => left.localeCompare(right));
+	const spaces = /* @__PURE__ */ new Map();
+	const reservedPools = /* @__PURE__ */ new Map();
+	const changedSpans = /* @__PURE__ */ new Map();
+	let parsedDocument;
+	const scan = ({ path, xml, visitor }) => {
+		const scanned = path.toLowerCase() === "word/document.xml" && options.onParsedDocument !== void 0 ? parseStreamingXmlWithIdentityVisitor(xml, visitor) : scanStreamingXmlNumericIdAttributes(xml, visitor);
+		if (scanned.status === "unsupported") throw new XmlResourceLimitError({
+			message: `Numeric-id normalization could not safely scan ${path}`,
+			limit: "syntax",
+			observed: 0,
+			allowed: 0
+		});
+		if (scanned.status === "parsed") parsedDocument = scanned.value;
+	};
+	for (const [path, xml] of candidates) scan({
+		path,
+		xml,
+		visitor: (element, attributeValueSpans) => {
+			for (const attribute of identifiedAttributes(element)) {
+				let space = spaces.get(attribute.space);
+				if (space === void 0) {
+					const poolName = attribute.space.startsWith("annotation:") ? "annotation" : attribute.space;
+					let reserved = reservedPools.get(poolName);
+					if (reserved === void 0) {
+						reserved = /* @__PURE__ */ new Set();
+						reservedPools.set(poolName, reserved);
+					}
+					space = {
+						reserved,
+						replacements: /* @__PURE__ */ new Map(),
+						next: 1
+					};
+					spaces.set(attribute.space, space);
+				}
+				if (isValidOoxmlNumericId(attribute.value, attribute.domain)) {
+					space.reserved.add(Number(attribute.value));
+					continue;
+				}
+				const key = identityKey(attribute.value);
+				space.replacements.set(key, "");
+				const span = attributeValueSpans.get(attribute.name);
+				if (span === void 0) panic("Missing imported numeric identity source span");
+				let spans = changedSpans.get(path);
+				if (spans === void 0) {
+					spans = [];
+					changedSpans.set(path, spans);
+				}
+				spans.push({
+					start: span.start,
+					end: span.end,
+					space: attribute.space,
+					key,
+					element,
+					attributeName: attribute.name
+				});
+			}
+			return null;
+		}
+	});
+	for (const space of spaces.values()) for (const key of space.replacements.keys()) {
+		while (space.reserved.has(space.next)) space.next += 1;
+		assertValidOoxmlNumericId({
+			value: space.next,
+			partPath: "import",
+			elementName: "allocated identity",
+			attributeName: "id"
+		});
+		const replacement = String(space.next);
+		space.replacements.set(key, replacement);
+		space.reserved.add(space.next);
+		space.next += 1;
+	}
+	for (const [path, spans] of changedSpans) {
+		const xml = parts.get(path);
+		if (xml === void 0) panic(`Missing imported numeric identity part: ${path}`);
+		const chunks = [];
+		let cursor = 0;
+		for (const span of spans.toSorted((left, right) => left.start - right.start)) {
+			const replacement = spaces.get(span.space)?.replacements.get(span.key);
+			if (replacement === void 0 || replacement === "") panic("Missing imported numeric identity replacement");
+			if (span.element.attributes === void 0) panic("Missing imported numeric identity attributes");
+			span.element.attributes[span.attributeName] = replacement;
+			chunks.push(xml.slice(cursor, span.start), replacement);
+			cursor = span.end;
+		}
+		chunks.push(xml.slice(cursor));
+		normalized.set(path, chunks.join(""));
+	}
+	if (parsedDocument !== void 0) options.onParsedDocument?.(parsedDocument);
+	return normalized;
+};
+/** Parser boundary: all captures and selective-save bytes see the same identities. */
+const normalizeRawDocxNumericIds = async (raw) => {
+	let documentTree;
+	const normalized = normalizeImportedNumericIds(raw.allXml, { onParsedDocument: (tree) => {
+		documentTree = tree;
+	} });
+	if (normalized === raw.allXml) return documentTree;
+	await replaceRawDocxXmlParts(raw, normalized);
+	return documentTree;
+};
+//#endregion
+export { normalizeImportedNumericIds, normalizeRawDocxNumericIds };

package/dist/docx/paragraphPropertySource.js

@@ -542,7 +542,7 @@ const tableCellParagraphPropertySourceBindingForTransport = (paragraph, inspecti
 };
 /** Prepare opaque continuation cells for ProseMirror and Yjs transport. */
 const transportTableCellsWithParagraphPropertySources = (cells) => {
-	const cloned = structuredClone(cells);
+	const cloned = cells.map((cell) => structuredClone(cell));
 	const sources = paragraphsInTableCells(cells);
 	const targets = paragraphsInTableCells(cloned);
 	if (sources.length !== targets.length) panic("The cloned table cells changed paragraph graph ownership.");

package/dist/docx/paragraphTextBoxEnrichment.js

@@ -6,7 +6,7 @@ import { consolidateParagraphContent } from "./runConsolidator.js";
 import { captureShapeAlternateContent } from "./shapeAlternateContent.js";
 import { getTextBoxContentElement, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, scanRunForTextBoxDrawings } from "./textBoxParser.js";
 import { isVmlPictParsedByRunParser } from "./vmlImageParser.js";
-import { findChildByLocalName, findDeep, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
+import { findChildByLocalName, findDeep, findWordprocessingChild, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
 //#region src/docx/paragraphTextBoxEnrichment.ts
 const VML_HORIZONTAL_RELATIVES = /* @__PURE__ */ new Set([
 	"character",
@@ -396,6 +396,7 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 			lastConsumedRun = parsedRun;
 			parsedIndex += 1;
 		}
+		if (findWordprocessingChild(xmlChild, "commentReference") && content[parsedIndex]?.type === "commentReference") parsedIndex += 1;
 	}
 };
 const parseVmlTextBoxShape = (pictEl, { styles, theme, numbering, rels, media, parseTable, previews }) => {

package/dist/docx/parser.js

@@ -8,7 +8,7 @@ import { DANGLING_COMMENT_REFERENCE_WARNING, UNBALANCED_COMMENT_RANGE_WARNING, n
 import { detectDocxConformanceClass } from "./conformance.js";
 import { parseCoreProperties } from "./corePropertiesParser.js";
 import { countDanglingRelationshipReferences } from "./danglingRelationshipReferences.js";
-import { extractAllTemplateVariables, parseDocumentBody } from "./documentParser.js";
+import { extractAllTemplateVariables, parseDocumentBody, parseDocumentBodyTree } from "./documentParser.js";
 import { normalizeDrawingIds } from "./drawingIdNormalization.js";
 import { DocxEncryptionError } from "./encryption/errors.js";
 import { parseFontTable } from "./fontTableParser.js";
@@ -21,11 +21,13 @@ import { renderEmfSvg } from "./metafileSvg.js";
 import { DocxModelValidationError, formatDocumentModelIssues, validateFolioDocumentModel } from "./modelValidation.js";
 import { parseNumbering } from "./numberingParser.js";
 import { UNNUMBERED_PARAGRAPH_WARNING, UNNUMBERED_STYLE_WARNING, normalizeNumberingReferences, normalizeStyleNumberingReferences } from "./numberingReferenceNormalization.js";
+import { normalizeRawDocxNumericIds } from "./numericIdNormalization.js";
 import { countOpaqueRevisionWrappers } from "./opaqueCarrier.js";
 import { assignDocumentParagraphPropertySourceContract } from "./paragraphPropertySource.js";
 import { createParseWarningCollector } from "./parseContext.js";
 import { formatParseWarnings } from "./parseWarningMessage.js";
 import { createPackagePreviewBudget } from "./previewBudget.js";
+import { detectRasterMimeType } from "./rasterMime.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
 import { normalizeRenderedPageBreakHints } from "./renderedPageBreakNormalization.js";
 import { parseSettings } from "./settingsParser.js";
@@ -33,7 +35,7 @@ import { parseStylesPackage } from "./styleParser.js";
 import { applyThemeFontLang, parseTheme } from "./themeParser.js";
 import { UNBALANCED_MOVE_RANGE_WARNING, normalizeTrackedMoveRanges } from "./trackedMoveRangeNormalization.js";
 import { getEntryUncompressedSize, getMediaMimeType, mediaToDataUrl, unzipDocx } from "./unzip.js";
-import { getAttribute, getChildElements, getLocalName, parseXmlDocument } from "./xmlParser.js";
+import { getAttribute, getChildElements, getLocalName, parseXml, parseXmlDocument } from "./xmlParser.js";
 import { FOLIO_XML_RESOURCE_LIMITS } from "./xmlResourceLimits.js";
 import { TaggedError, panic } from "better-result";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
@@ -184,13 +186,14 @@ async function parseDocxWithPreviewBudget(input, options, previewBudget) {
 	try {
 		const timeStage = (_name, fn) => fn();
 		const timeStageAsync = async (_name, fn) => await fn();
-		const paragraphPropertySourceDigest = sha256Hex(buffer);
 		onProgress("Extracting DOCX...", 0);
 		const raw = await timeStageAsync("unzip", () => unzipDocx(buffer, {
 			...unzipLimits,
 			password,
 			extractAllXml: false
 		}));
+		const repairedDocumentTree = await normalizeRawDocxNumericIds(raw);
+		const paragraphPropertySourceDigest = sha256Hex(raw.originalBuffer);
 		if (raw.wasEncrypted) parseContext.warn({ code: PARSE_WARNING_CODES.packageDecrypted });
 		for (const message of raw.warnings) parseContext.warn({
 			code: PARSE_WARNING_CODES.packageArchive,
@@ -227,7 +230,16 @@ async function parseDocxWithPreviewBudget(input, options, previewBudget) {
 		onProgress("Parsing document body...", 40);
 		let documentBody = { content: [] };
 		timeStage("documentBody", () => {
-			if (raw.documentXml) documentBody = parseDocumentBody(raw.documentXml, styles, theme, numbering, rels, media, parseContext.scoped({ part: "word/document.xml" }), previews.ledger);
+			if (raw.documentXml) documentBody = parseDocumentBodyTree({
+				doc: repairedDocumentTree ?? parseXml(raw.documentXml),
+				styles,
+				theme,
+				numbering,
+				rels,
+				media,
+				context: parseContext.scoped({ part: "word/document.xml" }),
+				previews: previews.ledger
+			});
 			else parseContext.warn({ code: PARSE_WARNING_CODES.documentPartMissing });
 		});
 		onProgress("Parsed document body", 55);
@@ -507,7 +519,7 @@ async function buildMediaMap(raw, rels) {
 	let remainingEmfPreviewBytes = MAX_PACKAGE_EMF_PREVIEW_BYTES;
 	for (const [path, data] of raw.media.entries()) {
 		const filename = path.split("/").pop() || path;
-		const mimeType = getMediaMimeType(path);
+		const mimeType = detectRasterMimeType(data) ?? getMediaMimeType(path);
 		const isReferenced = referenced.has(path.toLowerCase());
 		if (isReferenced && isTiffMimeType(mimeType) && remainingTiffPixels > 0) {
 			const converted = await convertTiffToPngDataUrl(data, remainingTiffPixels);

package/dist/docx/rasterMime.d.ts

@@ -0,0 +1,64 @@
+//#region src/docx/rasterMime.d.ts
+declare const RASTER_SIGNATURES: readonly [{
+  readonly mimeType: "image/png";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [137, 80, 78, 71];
+  }];
+}, {
+  readonly mimeType: "image/jpeg";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [255, 216];
+  }];
+}, {
+  readonly mimeType: "image/gif";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [71, 73, 70, 56];
+  }];
+}, {
+  readonly mimeType: "image/bmp";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [66, 77];
+  }];
+}, {
+  readonly mimeType: "image/webp";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [82, 73, 70, 70];
+  }, {
+    readonly offset: 8;
+    readonly bytes: readonly [87, 69, 66, 80];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [73, 73, 42, 0];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [77, 77, 0, 42];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [73, 73, 43, 0];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [77, 77, 0, 43];
+  }];
+}];
+type RasterMimeType = (typeof RASTER_SIGNATURES)[number]["mimeType"];
+declare const RASTER_MIME_TYPES: ReadonlySet<string>;
+declare const detectRasterMimeType: (data: ArrayBuffer) => RasterMimeType | undefined;
+//#endregion
+export { RASTER_MIME_TYPES, RasterMimeType, detectRasterMimeType };