@stll/folio-core 0.6.0 → 0.7.0

package/dist/controller/layoutPipeline.js

@@ -1,6 +1,8 @@
 import "../layout-engine/types.js";
 import { renderPages } from "../layout-painter/renderPage.js";
 import { templatePreviewValuesKey } from "../prosemirror/plugins/templatePreviewValues.js";
+import { getMargins, getPageSize, twipsToPixels } from "../paged-layout/sectionGeometry.js";
+import { getColumns } from "../layout-bridge/sectionColumns.js";
 import { toFlowBlocks } from "../layout-bridge/convert/toFlowBlocks.js";
 import { recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart } from "../layout-engine/layoutInstrumentation.js";
 import { buildBookmarkPageMap } from "../fields/bookmarkPages.js";
@@ -15,9 +17,17 @@ import { layoutDocument } from "../layout-engine/index.js";
 import { measureBlocks, measureSingleBlockWithoutFloatingZones } from "../layout-engine/measure/measureBlocks.js";
 import { tryBuildIncrementalMeasures } from "../paged-layout/incrementalMeasure.js";
 import { computePerBlockMeasureInputs } from "../paged-layout/sectionBlockWidths.js";
-import { getMargins, getPageSize, twipsToPixels } from "../paged-layout/sectionGeometry.js";
 import { getDocumentWatermark } from "../watermark/index.js";
 //#region src/controller/layoutPipeline.ts
+function bodyMarginsBelowHeader(authoredMargins, preparedHeader) {
+	if (!preparedHeader) return authoredMargins;
+	const headerBottom = (authoredMargins.header ?? 0) + (preparedHeader.marginPushBottom ?? preparedHeader.height);
+	if (headerBottom <= authoredMargins.top) return authoredMargins;
+	return {
+		...authoredMargins,
+		top: headerBottom
+	};
+}
 function runLayoutPipeline(deps, state, options = {}) {
 	const { contentWidth, columns, pageSize, margins, pageGap, syncCoordinator, headerContent, footerContent, firstPageHeaderContent, firstPageFooterContent, headerContentRId, footerContentRId, firstPageHeaderContentRId, firstPageFooterContentRId, sectionHeaderFooterRefs, theme: _theme, sectionProperties, document, defaultTabStop, mirrorMargins, styles, layout, hfPMs, painter, pagesContainer, session, renderHfFromContentOrPm, renderHeaderFooterContentByRId, documentFontsAreLoaded, buildFootnoteRenderItems, describeInvalidHighlightMarks, emptyTemplatePreviewEntries: EMPTY_TEMPLATE_PREVIEW_ENTRIES } = deps;
 	let outcome = {};
@@ -91,17 +101,29 @@ function runLayoutPipeline(deps, state, options = {}) {
 		let firstPageFooterForRender = hasTitlePg ? renderHfFromContentOrPm(firstPageFooterContent, firstPageFooterContentRId, hfPMs, contentWidth, hfMetricsFooter, hfOptions) : void 0;
 		let headerContentByRId = renderHeaderFooterContentByRId(document?.package.headers, hfPMs, contentWidth, hfMetricsHeader, hfOptions);
 		let footerContentByRId = renderHeaderFooterContentByRId(document?.package.footers, hfPMs, contentWidth, hfMetricsFooter, hfOptions);
+		const initialBodyMargins = bodyMarginsBelowHeader(margins, headerContentForRender);
 		recordPhaseDuration("header-footer", phaseStartedAt);
 		phaseStartedAt = performance.now();
 		const bodyLayoutConfig = {
 			pageSize,
-			margins
+			margins: initialBodyMargins
 		};
 		if (columns !== void 0) bodyLayoutConfig.columns = columns;
+		const finalSectionProperties = document?.package.document.sections?.at(-1)?.properties;
+		const finalHeaderRId = sectionHeaderFooterRefs?.at(-1)?.headerDefault;
+		let finalHeaderForLayout = headerContentForRender;
+		if (finalHeaderRId) finalHeaderForLayout = headerContentByRId?.get(finalHeaderRId);
+		else if (sectionHeaderFooterRefs !== void 0) finalHeaderForLayout = void 0;
+		const finalLayoutConfig = finalSectionProperties ? {
+			pageSize: getPageSize(finalSectionProperties),
+			margins: bodyMarginsBelowHeader(getMargins(finalSectionProperties), finalHeaderForLayout)
+		} : bodyLayoutConfig;
+		const finalColumns = getColumns(finalSectionProperties);
+		if (finalColumns !== void 0) finalLayoutConfig.columns = finalColumns;
 		const blockMeasureInputs = computePerBlockMeasureInputs({
 			blocks: newBlocks,
 			bodyConfig: bodyLayoutConfig,
-			finalConfig: bodyLayoutConfig
+			finalConfig: finalLayoutConfig
 		});
 		const blockWidths = blockMeasureInputs.widths;
 		const previousArtifacts = session.artifacts;
@@ -133,22 +155,19 @@ function runLayoutPipeline(deps, state, options = {}) {
 		const buildLayoutOpts = () => {
 			const nextLayoutOpts = {
 				pageSize,
-				margins,
+				margins: initialBodyMargins,
 				pageGap,
 				mirrorMargins
 			};
-			if (hasTitlePg && firstPageHeaderForRender) {
-				const headerBottom = (margins.header ?? 0) + (firstPageHeaderForRender.marginPushBottom ?? firstPageHeaderForRender.height);
-				if (headerBottom > margins.top) nextLayoutOpts.firstPageMargins = {
-					...margins,
-					top: headerBottom
+			if (hasTitlePg) nextLayoutOpts.firstPageMargins = bodyMarginsBelowHeader(margins, firstPageHeaderForRender);
+			if (finalSectionProperties) {
+				nextLayoutOpts.finalPageSize = finalLayoutConfig.pageSize;
+				nextLayoutOpts.finalMargins = finalLayoutConfig.margins;
+				nextLayoutOpts.finalColumns = finalLayoutConfig.columns ?? {
+					count: 1,
+					gap: 0
 				};
 			}
-			const finalSection = document?.package.document.sections?.at(-1);
-			if (finalSection) {
-				nextLayoutOpts.finalPageSize = getPageSize(finalSection.properties);
-				nextLayoutOpts.finalMargins = getMargins(finalSection.properties);
-			}
 			if (columns !== void 0) nextLayoutOpts.columns = columns;
 			if (bodyBreakType !== void 0) nextLayoutOpts.bodyBreakType = bodyBreakType;
 			if (sectionHeaderFooterRefs !== void 0) nextLayoutOpts.sectionHeaderFooterRefs = sectionHeaderFooterRefs;

package/dist/docx/blockContentParser.js

@@ -1,9 +1,9 @@
-import { elementToXml, findChild, findDeep, getChildElements, getLocalName, mergeXmlnsDeclarations } from "./xmlParser.js";
+import { elementToXml, findChild, getChildElements, getLocalName, mergeXmlnsDeclarations } from "./xmlParser.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
-import { getTextBoxContentElement, isTextBoxDrawing, parseTextBox, parseTextBoxContent } from "./textBoxParser.js";
 import { parseSdtProperties } from "./sdtProperties.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { appendBookmarkMarkerToLastParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInBlocks } from "./bookmarkPlacement.js";
+import { enrichParagraphTextBoxes } from "./paragraphTextBoxEnrichment.js";
 import { parseTable } from "./tableParser.js";
 import { padDecimal } from "./numberingParser.js";
 import { convertBulletToUnicode } from "./bulletMarkers.js";
@@ -100,104 +100,6 @@ const computeListMarker = (paragraph, numbering, listCounters, abstractCounters)
 	}
 	listRendering.marker = computedMarker;
 };
-const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering, rels, media) => {
-	const xmlChildren = getChildElements(paraXml);
-	let parsedIndex = 0;
-	let lastConsumedRun;
-	for (const xmlChild of xmlChildren) {
-		if (getLocalName(xmlChild.name ?? "") !== "r") {
-			if (parsedIndex < paragraph.content.length && paragraph.content[parsedIndex]?.type !== "run") parsedIndex += 1;
-			continue;
-		}
-		const { textBoxDrawings, hasNonTextBoxContent } = scanRunForTextBoxDrawings(xmlChild);
-		const parsedContent = paragraph.content[parsedIndex];
-		const parsedRun = parsedContent?.type === "run" ? parsedContent : void 0;
-		const targetRun = parsedRun ?? (hasNonTextBoxContent ? lastConsumedRun : void 0);
-		for (const runEl of textBoxDrawings) {
-			const textBox = parseTextBox(runEl);
-			if (!textBox) continue;
-			const wsp = findDeep(runEl, "wps", "wsp");
-			if (wsp) {
-				const txbxContentEl = getTextBoxContentElement(wsp);
-				if (txbxContentEl) textBox.content = parseTextBoxContent(txbxContentEl, parseParagraph, null, styles, theme, numbering, rels ?? void 0, media ?? void 0);
-			}
-			const shape = {
-				type: "shape",
-				shapeType: "textBox",
-				size: textBox.size,
-				...textBox.position !== void 0 ? { position: textBox.position } : {},
-				...textBox.wrap !== void 0 ? { wrap: textBox.wrap } : {},
-				...textBox.fill !== void 0 ? { fill: textBox.fill } : {},
-				...textBox.outline !== void 0 ? { outline: textBox.outline } : {},
-				textBody: {
-					content: textBox.content,
-					...textBox.margins !== void 0 ? { margins: textBox.margins } : {}
-				}
-			};
-			if (textBox.id) shape.id = textBox.id;
-			const shapeContent = {
-				type: "shape",
-				shape
-			};
-			if (targetRun && hasNonTextBoxContent) targetRun.content.push(shapeContent);
-			else {
-				const newRun = {
-					type: "run",
-					content: [shapeContent]
-				};
-				paragraph.content.splice(parsedIndex, 0, newRun);
-				lastConsumedRun = newRun;
-				parsedIndex += 1;
-			}
-		}
-		if (hasNonTextBoxContent && parsedRun) {
-			lastConsumedRun = parsedRun;
-			parsedIndex += 1;
-		}
-	}
-};
-const scanRunForTextBoxDrawings = (xmlRun) => {
-	const textBoxDrawings = [];
-	let hasNonTextBoxContent = false;
-	const visitDrawing = (drawingEl) => {
-		if (isTextBoxDrawing(drawingEl)) {
-			textBoxDrawings.push(drawingEl);
-			return;
-		}
-		hasNonTextBoxContent = true;
-	};
-	for (const el of getChildElements(xmlRun)) {
-		const name = getLocalName(el.name ?? "");
-		if (name === "rPr") continue;
-		if (name === "drawing") {
-			visitDrawing(el);
-			continue;
-		}
-		if (name === "AlternateContent") {
-			const branches = getChildElements(el);
-			const choice = branches.find((branch) => getLocalName(branch.name ?? "") === "Choice");
-			const fallback = branches.find((branch) => getLocalName(branch.name ?? "") === "Fallback");
-			const tryBranch = (branch) => {
-				if (!branch) return false;
-				let found = false;
-				for (const innerEl of getChildElements(branch)) if (getLocalName(innerEl.name ?? "") === "drawing") {
-					visitDrawing(innerEl);
-					found = true;
-				}
-				return found;
-			};
-			let foundInBranch = tryBranch(choice);
-			if (!foundInBranch) foundInBranch = tryBranch(fallback);
-			if (!foundInBranch) hasNonTextBoxContent = true;
-			continue;
-		}
-		hasNonTextBoxContent = true;
-	}
-	return {
-		textBoxDrawings,
-		hasNonTextBoxContent
-	};
-};
 const parseBlockContent = (parent, styles, theme, numbering, rels, media, options) => parseBlockContentWithState(parent, styles, theme, numbering, rels, media, {
 	listCounters: /* @__PURE__ */ new Map(),
 	abstractCounters: /* @__PURE__ */ new Map(),

package/dist/docx/groupDrawingParser.d.ts

@@ -3,6 +3,6 @@ import { XmlElement } from "./xmlParser.js";
 
 //#region src/docx/groupDrawingParser.d.ts
 /** Parse a WordprocessingGroup drawing into a safe SVG-backed image preview. */
-declare const parseGroupDrawing: (drawing: XmlElement) => document_d_exports.Image | null;
+declare const parseGroupDrawing: (drawing: XmlElement, rels?: document_d_exports.RelationshipMap, media?: Map<string, document_d_exports.MediaFile>) => document_d_exports.Image | null;
 //#endregion
 export { parseGroupDrawing };

package/dist/docx/groupDrawingParser.js

@@ -1,6 +1,6 @@
-import { findAllDeep, findChildByLocalName, findChildrenByLocalName, getAttribute, getLocalName, getTextContent, parseNumericAttribute } from "./xmlParser.js";
+import { findAllDeep, findChildByLocalName, findChildrenByLocalName, getAttribute, getChildElements, getLocalName, getTextContent, parseNumericAttribute } from "./xmlParser.js";
 import { emuToPixels } from "../utils/units.js";
-import { parseImage } from "./imageParser.js";
+import { parseImage, resolveImageData } from "./imageParser.js";
 //#region src/docx/groupDrawingParser.ts
 const HEX_COLOR = /^[0-9A-Fa-f]{6}$/u;
 const DEFAULT_TEXT_COLOR = "000000";
@@ -8,6 +8,7 @@ const DEFAULT_FONT_HALF_POINTS = 22;
 const DEFAULT_LINE_WIDTH_EMU = 9525;
 const HALF_POINT_TO_EMU = 6350;
 const MAX_GROUP_SHAPES = 256;
+const CROP_SCALE = 1e5;
 const MAX_PATH_COMMANDS = 1e4;
 const MAX_TEXT_CHARACTERS = 2e4;
 const MAX_SVG_CHARACTERS = 1e6;
@@ -110,18 +111,58 @@ const renderTextBox = (wsp) => {
 	const lineStep = lineHeight / fontSize * svgFontSize;
 	return `<text x="0" y="${svgFontSize}" transform="translate(${x} ${y}) scale(${scale})" font-family="Arial, sans-serif" font-size="${svgFontSize}" fill="#${color}">${lines.map((line, index) => `<tspan x="0" dy="${index === 0 ? 0 : lineStep}">${line}</tspan>`).join("")}</text>`;
 };
-const createSvg = (group, width, height) => {
-	const content = findChildrenByLocalName(group, "wsp").slice(0, MAX_GROUP_SHAPES).map((wsp) => findChildByLocalName(wsp, "txbx") ? renderTextBox(wsp) : renderGeometry(wsp)).join("");
-	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${emuToPixels(width)}" height="${emuToPixels(height)}">${content}</svg>`;
+const renderPicture = (picture, index, rels, media) => {
+	const { x, y, width, height } = childTransform(picture);
+	if (width <= 0 || height <= 0) return "";
+	const blipFill = findChildByLocalName(picture, "blipFill");
+	const blip = findChildByLocalName(blipFill, "blip");
+	const { src } = resolveImageData(getAttribute(blip, "r", "embed") ?? getAttribute(blip, "r", "link") ?? "", rels, media);
+	if (!src) return "";
+	const sourceRect = findChildByLocalName(blipFill, "srcRect");
+	const left = Math.max(0, numericAttr(sourceRect, "l")) / CROP_SCALE;
+	const top = Math.max(0, numericAttr(sourceRect, "t")) / CROP_SCALE;
+	const right = Math.max(0, numericAttr(sourceRect, "r")) / CROP_SCALE;
+	const bottom = Math.max(0, numericAttr(sourceRect, "b")) / CROP_SCALE;
+	const visibleWidth = 1 - left - right;
+	const visibleHeight = 1 - top - bottom;
+	if (visibleWidth <= 0 || visibleHeight <= 0) return "";
+	const image = `<image x="${x - width * left / visibleWidth}" y="${y - height * top / visibleHeight}" width="${width / visibleWidth}" height="${height / visibleHeight}" href="${escapeXml(src)}" preserveAspectRatio="none"/>`;
+	if (left === 0 && top === 0 && right === 0 && bottom === 0) return image;
+	const clipId = `group-picture-${index}`;
+	return `<defs><clipPath id="${clipId}"><rect x="${x}" y="${y}" width="${width}" height="${height}"/></clipPath></defs><g clip-path="url(#${clipId})">${image}</g>`;
+};
+const groupViewBox = (group, width, height) => {
+	const transform = findChildByLocalName(findChildByLocalName(group, "grpSpPr"), "xfrm");
+	const childOffset = findChildByLocalName(transform, "chOff");
+	const childExtent = findChildByLocalName(transform, "chExt");
+	const childWidth = numericAttr(childExtent, "cx");
+	const childHeight = numericAttr(childExtent, "cy");
+	return {
+		x: numericAttr(childOffset, "x"),
+		y: numericAttr(childOffset, "y"),
+		width: childWidth > 0 ? childWidth : width,
+		height: childHeight > 0 ? childHeight : height
+	};
+};
+const createSvg = (group, width, height, rels, media) => {
+	const content = getChildElements(group).slice(0, MAX_GROUP_SHAPES).map((child, index) => {
+		const localName = getLocalName(child.name ?? "");
+		if (localName === "pic") return renderPicture(child, index, rels, media);
+		if (localName !== "wsp") return "";
+		return findChildByLocalName(child, "txbx") ? renderTextBox(child) : renderGeometry(child);
+	}).join("");
+	if (!content) return null;
+	const viewBox = groupViewBox(group, width, height);
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}" width="${emuToPixels(width)}" height="${emuToPixels(height)}">${content}</svg>`;
 };
 /** Parse a WordprocessingGroup drawing into a safe SVG-backed image preview. */
-const parseGroupDrawing = (drawing) => {
+const parseGroupDrawing = (drawing, rels, media) => {
 	const group = findChildByLocalName(findAllDeep(drawing, "a", "graphicData").at(0) ?? null, "wgp");
 	if (!group) return null;
 	const image = parseImage(drawing, void 0, void 0);
 	if (!image || image.size.width <= 0 || image.size.height <= 0) return null;
-	const svg = createSvg(group, image.size.width, image.size.height);
-	if (svg.length > MAX_SVG_CHARACTERS) return null;
+	const svg = createSvg(group, image.size.width, image.size.height, rels, media);
+	if (!svg || svg.length > MAX_SVG_CHARACTERS) return null;
 	image.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
 	image.mimeType = "image/svg+xml";
 	image.filename = "wordprocessing-group.svg";

package/dist/docx/paragraphTextBoxEnrichment.d.ts

@@ -0,0 +1,9 @@
+import { document_d_exports } from "../types/document.js";
+import { NumberingMap } from "./numberingParser.js";
+import { StyleMap } from "./styleParser.js";
+import { XmlElement } from "./xmlParser.js";
+
+//#region src/docx/paragraphTextBoxEnrichment.d.ts
+declare const enrichParagraphTextBoxes: (paragraph: document_d_exports.Paragraph, paraXml: XmlElement, styles: StyleMap | null, theme: document_d_exports.Theme | null, numbering: NumberingMap | null, rels: document_d_exports.RelationshipMap | null, media: Map<string, document_d_exports.MediaFile> | null) => void;
+//#endregion
+export { enrichParagraphTextBoxes };

package/dist/docx/paragraphTextBoxEnrichment.js

@@ -0,0 +1,104 @@
+import { findDeep, getChildElements, getLocalName } from "./xmlParser.js";
+import { getTextBoxContentElement, isTextBoxDrawing, parseTextBox, parseTextBoxContent } from "./textBoxParser.js";
+import { parseParagraph } from "./paragraphParser.js";
+//#region src/docx/paragraphTextBoxEnrichment.ts
+const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering, rels, media) => {
+	const xmlChildren = getChildElements(paraXml);
+	let parsedIndex = 0;
+	let lastConsumedRun;
+	for (const xmlChild of xmlChildren) {
+		if (getLocalName(xmlChild.name ?? "") !== "r") {
+			if (parsedIndex < paragraph.content.length && paragraph.content[parsedIndex]?.type !== "run") parsedIndex += 1;
+			continue;
+		}
+		const { textBoxDrawings, hasNonTextBoxContent } = scanRunForTextBoxDrawings(xmlChild);
+		const parsedContent = paragraph.content[parsedIndex];
+		const parsedRun = parsedContent?.type === "run" ? parsedContent : void 0;
+		const targetRun = parsedRun ?? (hasNonTextBoxContent ? lastConsumedRun : void 0);
+		for (const runEl of textBoxDrawings) {
+			const textBox = parseTextBox(runEl);
+			if (!textBox) continue;
+			const wsp = findDeep(runEl, "wps", "wsp");
+			if (wsp) {
+				const txbxContentEl = getTextBoxContentElement(wsp);
+				if (txbxContentEl) textBox.content = parseTextBoxContent(txbxContentEl, parseParagraph, null, styles, theme, numbering, rels ?? void 0, media ?? void 0);
+			}
+			const shape = {
+				type: "shape",
+				shapeType: "textBox",
+				size: textBox.size,
+				...textBox.position !== void 0 ? { position: textBox.position } : {},
+				...textBox.wrap !== void 0 ? { wrap: textBox.wrap } : {},
+				...textBox.fill !== void 0 ? { fill: textBox.fill } : {},
+				...textBox.outline !== void 0 ? { outline: textBox.outline } : {},
+				textBody: {
+					content: textBox.content,
+					...textBox.margins !== void 0 ? { margins: textBox.margins } : {}
+				}
+			};
+			if (textBox.id) shape.id = textBox.id;
+			const shapeContent = {
+				type: "shape",
+				shape
+			};
+			if (targetRun && hasNonTextBoxContent) targetRun.content.push(shapeContent);
+			else {
+				const newRun = {
+					type: "run",
+					content: [shapeContent]
+				};
+				paragraph.content.splice(parsedIndex, 0, newRun);
+				lastConsumedRun = newRun;
+				parsedIndex += 1;
+			}
+		}
+		if (hasNonTextBoxContent && parsedRun) {
+			lastConsumedRun = parsedRun;
+			parsedIndex += 1;
+		}
+	}
+};
+const scanRunForTextBoxDrawings = (xmlRun) => {
+	const textBoxDrawings = [];
+	let hasNonTextBoxContent = false;
+	const visitDrawing = (drawingEl) => {
+		if (isTextBoxDrawing(drawingEl)) {
+			textBoxDrawings.push(drawingEl);
+			return;
+		}
+		hasNonTextBoxContent = true;
+	};
+	for (const el of getChildElements(xmlRun)) {
+		const name = getLocalName(el.name ?? "");
+		if (name === "rPr") continue;
+		if (name === "drawing") {
+			visitDrawing(el);
+			continue;
+		}
+		if (name === "AlternateContent") {
+			const branches = getChildElements(el);
+			const choice = branches.find((branch) => getLocalName(branch.name ?? "") === "Choice");
+			const fallback = branches.find((branch) => getLocalName(branch.name ?? "") === "Fallback");
+			const tryBranch = (branch) => {
+				if (!branch) return false;
+				let found = false;
+				for (const innerEl of getChildElements(branch)) if (getLocalName(innerEl.name ?? "") === "drawing") {
+					visitDrawing(innerEl);
+					found = true;
+				}
+				return found;
+			};
+			let foundInBranch = tryBranch(choice);
+			if (!foundInBranch) foundInBranch = tryBranch(fallback);
+			if (!foundInBranch) hasNonTextBoxContent = true;
+			continue;
+		}
+		hasNonTextBoxContent = true;
+	}
+	return {
+		textBoxDrawings,
+		hasNonTextBoxContent
+	};
+};
+//#endregion
+export { enrichParagraphTextBoxes };

package/dist/docx/runParser.js

@@ -1,4 +1,4 @@
-import { cloneWithXmlnsDeclarations, elementToXml, findChild, findChildren, getAttribute, getChildElements, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
+import { cloneWithXmlnsDeclarations, elementToXml, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
 import { EmphasisMarkSchema, FontThemeSchema, HighlightColorSchema, ShadingPatternSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
 import { parseImage } from "./imageParser.js";
 import { parseGroupDrawing } from "./groupDrawingParser.js";
@@ -443,7 +443,7 @@ function parseInstrText(element) {
 *   `shapeParser.parseShapeFromDrawing` into a `ShapeContent`.
 */
 function parseDrawingContent(element, rels, media) {
-	const groupImage = parseGroupDrawing(element);
+	const groupImage = parseGroupDrawing(element, rels ?? void 0, media ?? void 0);
 	if (groupImage) return {
 		type: "drawing",
 		image: groupImage,
@@ -544,6 +544,15 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 			const alternateChildren = getChildElements(child);
 			const choiceEl = alternateChildren.find((el) => getLocalName(el.name) === "Choice");
 			const fallbackEl = alternateChildren.find((el) => getLocalName(el.name) === "Fallback");
+			const groupedChoiceDrawing = choiceEl ? getChildElements(choiceEl).find((element) => getLocalName(element.name) === "drawing" && findAllDeep(element, "wpg", "wgp").length > 0) : void 0;
+			if (groupedChoiceDrawing) {
+				const groupedDrawing = parseDrawingContent(groupedChoiceDrawing, rels, media);
+				if (groupedDrawing?.type === "drawing" && groupedDrawing.image.src) {
+					groupedDrawing.rawXml = elementToXml(child);
+					contents.push(groupedDrawing);
+					break;
+				}
+			}
 			const fallbackPict = fallbackEl ? getChildElements(fallbackEl).find((el) => getLocalName(el.name) === "pict") : void 0;
 			const fallbackVml = fallbackPict ? parseVmlImageContent(fallbackPict, rels, media, rootXmlns) : null;
 			if (fallbackVml?.image.src) {

package/dist/docx/server/boundedArchive.d.ts

@@ -0,0 +1,24 @@
+//#region src/docx/server/boundedArchive.d.ts
+declare const DOCX_MAX_ENTRY_BYTES: number;
+declare const DOCX_MAX_TOTAL_BYTES: number;
+declare const DOCX_MAX_ENTRIES = 4096;
+declare const DocxArchiveError_base: import("better-result").TaggedErrorClass<"DocxArchiveError", {
+  message: string;
+  reason: "load-failed" | "too-many-entries" | "entry-too-large" | "total-too-large";
+  cause?: unknown;
+}>;
+/** Error raised when a DOCX archive cannot be loaded within configured limits. */
+declare class DocxArchiveError extends DocxArchiveError_base {}
+type DocxArchiveOptions = {
+  maxEntryBytes?: number;
+  maxTotalBytes?: number;
+  maxEntries?: number;
+};
+type DocxArchive = {
+  entries: readonly string[];
+  readEntryString: (path: string) => Promise<string | null>;
+  readEntryUint8: (path: string) => Promise<Uint8Array | null>;
+};
+declare const loadDocxArchive: (bytes: ArrayBuffer | Uint8Array, options?: DocxArchiveOptions) => Promise<DocxArchive>;
+//#endregion
+export { DOCX_MAX_ENTRIES, DOCX_MAX_ENTRY_BYTES, DOCX_MAX_TOTAL_BYTES, DocxArchive, DocxArchiveError, DocxArchiveOptions, loadDocxArchive };

package/dist/docx/server/boundedArchive.js

@@ -0,0 +1,106 @@
+import { TaggedError } from "better-result";
+import JSZip from "jszip";
+//#region src/docx/server/boundedArchive.ts
+const DOCX_MAX_ENTRY_BYTES = 128 * 1024 * 1024;
+const DOCX_MAX_TOTAL_BYTES = 256 * 1024 * 1024;
+const DOCX_MAX_ENTRIES = 4096;
+/** Error raised when a DOCX archive cannot be loaded within configured limits. */
+var DocxArchiveError = class extends TaggedError("DocxArchiveError")() {};
+const collectStream = async ({ stream, maxEntryBytes, remainingBytes, maxTotalBytes, path }) => await new Promise((resolve, reject) => {
+	const chunks = [];
+	let entryBytes = 0;
+	const fail = (reason, message) => {
+		const destroy = Reflect.get(stream, "destroy");
+		if (typeof destroy === "function") Reflect.apply(destroy, stream, []);
+		reject(new DocxArchiveError({
+			message,
+			reason
+		}));
+	};
+	stream.on("data", (chunk) => {
+		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		entryBytes += bytes.length;
+		if (entryBytes > maxEntryBytes) {
+			fail("entry-too-large", `DOCX entry "${path}" exceeded the ${maxEntryBytes}-byte limit`);
+			return;
+		}
+		if (entryBytes > remainingBytes) {
+			fail("total-too-large", `DOCX archive exceeded the ${maxTotalBytes}-byte cumulative limit while reading "${path}"`);
+			return;
+		}
+		chunks.push(bytes);
+	});
+	stream.on("end", () => resolve(Buffer.concat(chunks)));
+	stream.on("error", reject);
+});
+const loadDocxArchive = async (bytes, options = {}) => {
+	const maxEntryBytes = options.maxEntryBytes ?? 134217728;
+	const maxTotalBytes = options.maxTotalBytes ?? 268435456;
+	const maxEntries = options.maxEntries ?? 4096;
+	let zip;
+	try {
+		zip = await JSZip.loadAsync(bytes);
+	} catch (cause) {
+		throw new DocxArchiveError({
+			message: "Failed to parse DOCX archive",
+			reason: "load-failed",
+			cause
+		});
+	}
+	const archiveEntries = Object.values(zip.files);
+	if (archiveEntries.length > maxEntries) throw new DocxArchiveError({
+		message: `DOCX archive declares ${archiveEntries.length} entries (max ${maxEntries})`,
+		reason: "too-many-entries"
+	});
+	let declaredTotalBytes = 0;
+	for (const entry of archiveEntries) {
+		const data = "_data" in entry ? entry._data : void 0;
+		const declaredBytes = typeof data === "object" && data !== null && "uncompressedSize" in data ? data.uncompressedSize : void 0;
+		if (typeof declaredBytes !== "number" || !Number.isFinite(declaredBytes)) {
+			declaredTotalBytes = NaN;
+			break;
+		}
+		if (declaredBytes > maxEntryBytes) throw new DocxArchiveError({
+			message: `DOCX entry "${entry.name}" declares ${declaredBytes} bytes (max ${maxEntryBytes})`,
+			reason: "entry-too-large"
+		});
+		declaredTotalBytes += declaredBytes;
+	}
+	if (Number.isFinite(declaredTotalBytes) && declaredTotalBytes > maxTotalBytes) throw new DocxArchiveError({
+		message: `DOCX archive declares ${declaredTotalBytes} cumulative bytes (max ${maxTotalBytes})`,
+		reason: "total-too-large"
+	});
+	let totalBytesRead = 0;
+	let readChain = Promise.resolve();
+	const readEntry = async (path) => {
+		const work = async () => {
+			const entry = zip.file(path);
+			if (!entry) return null;
+			const buffer = await collectStream({
+				stream: entry.nodeStream("nodebuffer"),
+				maxEntryBytes,
+				remainingBytes: maxTotalBytes - totalBytesRead,
+				maxTotalBytes,
+				path
+			});
+			totalBytesRead += buffer.length;
+			return buffer;
+		};
+		const next = readChain.then(work, work);
+		readChain = next.then(() => void 0, () => void 0);
+		return await next;
+	};
+	return {
+		entries: Object.freeze(archiveEntries.map(({ name }) => name)),
+		async readEntryString(path) {
+			const buffer = await readEntry(path);
+			return buffer === null ? null : buffer.toString("utf-8");
+		},
+		async readEntryUint8(path) {
+			const buffer = await readEntry(path);
+			return buffer === null ? null : new Uint8Array(buffer);
+		}
+	};
+};
+//#endregion
+export { DOCX_MAX_ENTRIES, DOCX_MAX_ENTRY_BYTES, DOCX_MAX_TOTAL_BYTES, DocxArchiveError, loadDocxArchive };

package/dist/docx/server/extractDocxText.d.ts

@@ -0,0 +1,23 @@
+//#region src/docx/server/extractDocxText.d.ts
+/** Document part containing an extracted paragraph. */
+type DocxParagraphSource = "header" | "body" | "footer";
+/** Paragraph text and lightweight formatting metadata from a DOCX archive. */
+type ExtractedDocxParagraph = {
+  index: number;
+  text: string;
+  source: DocxParagraphSource;
+  style?: string;
+  bold?: boolean;
+  fontSize?: number;
+  alignment?: "left" | "center" | "right" | "both";
+};
+/** Accepted-revision paragraph text extracted in deterministic part order. */
+type ExtractedDocxText = {
+  paragraphs: ExtractedDocxParagraph[];
+  charCount: number;
+  view: "accepted";
+};
+/** Extract paragraph text and formatting metadata from a DOCX archive. */
+declare const extractDocxText: (bytes: ArrayBuffer | Uint8Array) => Promise<ExtractedDocxText>;
+//#endregion
+export { DocxParagraphSource, ExtractedDocxParagraph, ExtractedDocxText, extractDocxText };