@stll/folio-core 0.6.1 → 0.7.0

package/dist/controller/layoutPipeline.js

@@ -19,6 +19,15 @@ import { tryBuildIncrementalMeasures } from "../paged-layout/incrementalMeasure.
 import { computePerBlockMeasureInputs } from "../paged-layout/sectionBlockWidths.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 = {};
@@ -92,17 +101,22 @@ 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: getMargins(finalSectionProperties)
+			margins: bodyMarginsBelowHeader(getMargins(finalSectionProperties), finalHeaderForLayout)
 		} : bodyLayoutConfig;
 		const finalColumns = getColumns(finalSectionProperties);
 		if (finalColumns !== void 0) finalLayoutConfig.columns = finalColumns;
@@ -141,17 +155,11 @@ 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;

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/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 };

package/dist/docx/server/extractDocxText.js

@@ -0,0 +1,154 @@
+import { findAllDeep, findChild, findDeep, getAttributeAnyPrefix, getLocalName, getTextContent, parseXml } from "../xmlParser.js";
+import { loadDocxArchive } from "./boundedArchive.js";
+//#region src/docx/server/extractDocxText.ts
+const HEADER_FOOTER_PATH = /^word\/(?:header|footer)\d+\.xml$/u;
+const childElements = (element) => element.elements?.filter((child) => child.type === "element") ?? [];
+const collectText = (element) => {
+	let text = "";
+	const walk = (node) => {
+		const localName = getLocalName(node.name ?? "");
+		if (localName === "t") {
+			text += getTextContent(node);
+			return;
+		}
+		if (localName === "br") {
+			text += "\n";
+			return;
+		}
+		if (localName === "tab") {
+			text += "	";
+			return;
+		}
+		if (localName === "del" || localName === "delText" || localName === "moveFrom") return;
+		for (const child of childElements(node)) walk(child);
+	};
+	walk(element);
+	return text;
+};
+const readParagraphProperties = (paragraph) => {
+	const properties = findChild(paragraph, "w", "pPr");
+	if (!properties) return {};
+	const result = {};
+	const styleValue = getAttributeAnyPrefix(findChild(properties, "w", "pStyle"), "val");
+	if (styleValue !== null) result.style = styleValue;
+	const alignment = getAttributeAnyPrefix(findChild(properties, "w", "jc"), "val");
+	if (alignment === "left" || alignment === "center" || alignment === "right" || alignment === "both") result.alignment = alignment;
+	return result;
+};
+const readRunMetrics = (paragraph) => {
+	const metrics = [];
+	for (const run of childElements(paragraph)) {
+		if (getLocalName(run.name ?? "") !== "r") continue;
+		const properties = findChild(run, "w", "rPr");
+		const boldProperty = findChild(properties, "w", "b");
+		const boldValue = getAttributeAnyPrefix(boldProperty, "val");
+		const bold = boldProperty !== null && boldValue !== "0" && boldValue !== "false";
+		const sizeValue = getAttributeAnyPrefix(findChild(properties, "w", "sz"), "val");
+		const parsedSize = sizeValue === null ? NaN : Number.parseInt(sizeValue, 10);
+		const fontSize = Number.isFinite(parsedSize) && parsedSize > 0 ? parsedSize : void 0;
+		let chars = 0;
+		for (const textNode of findAllDeep(run, "w", "t")) chars += getTextContent(textNode).length;
+		if (chars === 0) continue;
+		const entry = {
+			bold,
+			chars
+		};
+		if (fontSize !== void 0) entry.fontSize = fontSize;
+		metrics.push(entry);
+	}
+	return metrics;
+};
+const extractContainer = ({ container, source, startIndex }) => {
+	const paragraphs = [];
+	let charCount = 0;
+	for (const [offset, paragraph] of findAllDeep(container, "w", "p").entries()) {
+		const text = collectText(paragraph);
+		const entry = {
+			index: startIndex + offset,
+			text,
+			source
+		};
+		const { style, alignment } = readParagraphProperties(paragraph);
+		if (style !== void 0) entry.style = style;
+		if (alignment !== void 0) entry.alignment = alignment;
+		const runs = readRunMetrics(paragraph);
+		if (runs.length > 0) {
+			const totalChars = runs.reduce((sum, run) => sum + run.chars, 0);
+			if (runs.reduce((sum, run) => sum + (run.bold ? run.chars : 0), 0) > totalChars / 2) entry.bold = true;
+			const firstFontSize = runs.find((run) => run.fontSize !== void 0)?.fontSize;
+			if (firstFontSize !== void 0) entry.fontSize = firstFontSize;
+		}
+		paragraphs.push(entry);
+		charCount += text.length;
+	}
+	return {
+		paragraphs,
+		charCount
+	};
+};
+const extractParts = async ({ archive, source, rootName, startIndex }) => {
+	const paragraphs = [];
+	let charCount = 0;
+	let nextIndex = startIndex;
+	const prefix = `word/${source}`;
+	const paths = archive.entries.filter((path) => HEADER_FOOTER_PATH.test(path) && path.startsWith(prefix)).toSorted();
+	for (const path of paths) {
+		const xml = await archive.readEntryString(path);
+		if (xml === null) continue;
+		const container = findDeep(parseXml(xml), "w", rootName);
+		if (!container) continue;
+		const result = extractContainer({
+			container,
+			source,
+			startIndex: nextIndex
+		});
+		paragraphs.push(...result.paragraphs);
+		charCount += result.charCount;
+		nextIndex += result.paragraphs.length;
+	}
+	return {
+		paragraphs,
+		charCount
+	};
+};
+const createEmptyResult = () => ({
+	paragraphs: [],
+	charCount: 0,
+	view: "accepted"
+});
+/** Extract paragraph text and formatting metadata from a DOCX archive. */
+const extractDocxText = async (bytes) => {
+	const archive = await loadDocxArchive(bytes);
+	const documentXml = await archive.readEntryString("word/document.xml");
+	if (documentXml === null) return createEmptyResult();
+	const body = findDeep(parseXml(documentXml), "w", "body");
+	if (!body) return createEmptyResult();
+	const headers = await extractParts({
+		archive,
+		source: "header",
+		rootName: "hdr",
+		startIndex: 0
+	});
+	const bodyResult = extractContainer({
+		container: body,
+		source: "body",
+		startIndex: headers.paragraphs.length
+	});
+	const footers = await extractParts({
+		archive,
+		source: "footer",
+		rootName: "ftr",
+		startIndex: headers.paragraphs.length + bodyResult.paragraphs.length
+	});
+	return {
+		paragraphs: [
+			...headers.paragraphs,
+			...bodyResult.paragraphs,
+			...footers.paragraphs
+		],
+		charCount: headers.charCount + bodyResult.charCount + footers.charCount,
+		view: "accepted"
+	};
+};
+//#endregion
+export { extractDocxText };

package/dist/layout-bridge/convert/toFlowBlocks.js

@@ -1,5 +1,5 @@
 import { NUMBER_FORMAT_VALUES } from "../../types/documentEnumValues.js";
-import { halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
+import { AUTO_PARAGRAPH_SPACING_PX, halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
 import { padDecimal } from "../../docx/numberingParser.js";
 import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
 import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
@@ -673,6 +673,7 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 		else if (align === "center") attrs.alignment = "center";
 		else if (align === "right") attrs.alignment = "right";
 	}
+	if (typeof pmAttrs.outlineLevel === "number") attrs.outlineLevel = pmAttrs.outlineLevel;
 	const spaceBefore = pmAttrs.spaceBefore;
 	const spaceAfter = pmAttrs.spaceAfter;
 	const lineSpacing = pmAttrs.lineSpacing;
@@ -680,10 +681,14 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 	const autoAfter = autospacingMatchesBase(pmAttrs._autospacingBase, "after", spaceAfter);
 	if (autoBefore || autoAfter || typeof spaceBefore === "number" || typeof spaceAfter === "number" || typeof lineSpacing === "number") {
 		attrs.spacing = {};
-		if (autoBefore) attrs.spacing.before = 14;
+		if (autoBefore) attrs.spacing.before = AUTO_PARAGRAPH_SPACING_PX;
 		else if (typeof spaceBefore === "number") attrs.spacing.before = twipsToPixels(spaceBefore);
-		if (autoAfter) attrs.spacing.after = 14;
+		if (autoAfter) attrs.spacing.after = AUTO_PARAGRAPH_SPACING_PX;
 		else if (typeof spaceAfter === "number") attrs.spacing.after = twipsToPixels(spaceAfter);
+		if (autoBefore || autoAfter) attrs.automaticSpacing = {
+			...autoBefore ? { before: true } : {},
+			...autoAfter ? { after: true } : {}
+		};
 		const pmSpacingExplicit = pmAttrs.spacingExplicit;
 		const spacingFromDocDefaults = pmAttrs.spacingFromDocDefaults;
 		const explicit = {};
@@ -703,7 +708,7 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 	let indentLeft = typeof pmAttrs.indentLeft === "number" ? pmAttrs.indentLeft : void 0;
 	let indentFirstLine = typeof pmAttrs.indentFirstLine === "number" ? pmAttrs.indentFirstLine : void 0;
 	let hangingIndent = pmAttrs.hangingIndent;
-	if (pmAttrs.numPr?.numId && indentLeft === void 0) {
+	if (pmAttrs.numPr?.numId && indentLeft === void 0 && indentFirstLine === void 0) {
 		indentLeft = ((pmAttrs.numPr.ilvl ?? 0) + 1) * 720;
 		if (indentFirstLine === void 0) {
 			indentFirstLine = -360;
@@ -829,6 +834,7 @@ function convertParagraph(node, startPos, options) {
 	const attrs = convertParagraphAttrs(pmAttrs, options.theme, options.listCounters, options.listAbstractCounters, options.listSeenNumIds, options.defaultTabStopTwips, options.originalListCounters, options.originalListAbstractCounters, options.originalListSeenNumIds);
 	const defaultTextFormatting = pmAttrs.defaultTextFormatting;
 	if (runs.length === 0) {
+		if (pmAttrs._originalFormatting && Object.entries(pmAttrs._originalFormatting).some(([key, value]) => key !== "runProperties" && value !== void 0 && value !== null)) attrs.hasDirectParagraphFormatting = true;
 		const paragraphMarkFormatting = pmAttrs._originalFormatting?.runProperties;
 		if (paragraphMarkFormatting?.fontSize !== void 0) attrs.defaultFontSize = paragraphMarkFormatting.fontSize / 2;
 		const paragraphMarkFontFamily = paragraphMarkFormatting?.fontFamily?.ascii ?? paragraphMarkFormatting?.fontFamily?.hAnsi;
@@ -851,6 +857,37 @@ function convertParagraph(node, startPos, options) {
 	};
 }
 /**
+* Word keeps terminal empty body paragraphs after a final table as editable
+* anchors, but they do not create a page of their own. Preserve every block
+* and PM range while collapsing only the contiguous, run-free suffix; empty
+* paragraphs elsewhere still retain their normal line height.
+*/
+function isPaintlessTerminalParagraph(block) {
+	if (block?.kind !== "paragraph" || block.runs.length !== 0) return false;
+	const attrs = block.attrs;
+	return !(attrs?.listMarker !== void 0 && !attrs.listMarkerHidden || attrs?.borders?.top || attrs?.borders?.bottom || attrs?.borders?.left || attrs?.borders?.right || attrs?.borders?.between || attrs?.borders?.bar || attrs?.shading || attrs?.spacingExplicit?.before || attrs?.spacingExplicit?.after || attrs?.pageBreakBefore || attrs?.renderedPageBreakBefore);
+}
+function suppressTerminalEmptyParagraphsAfterTable(blocks) {
+	let suffixStart = blocks.length;
+	while (suffixStart > 0 && isPaintlessTerminalParagraph(blocks[suffixStart - 1])) suffixStart -= 1;
+	if (suffixStart === blocks.length || suffixStart === 0 || blocks[suffixStart - 1]?.kind !== "table") return;
+	for (let index = suffixStart; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		if (isPaintlessTerminalParagraph(block)) block.attrs = {
+			...block.attrs,
+			suppressEmptyParagraphHeight: true
+		};
+	}
+}
+function reserveLeadingEmptyOutlineHeight(blocks) {
+	const firstBlock = blocks.at(0);
+	if (firstBlock?.kind !== "paragraph" || firstBlock.runs.length !== 0 || firstBlock.attrs?.outlineLevel !== 0) return;
+	firstBlock.attrs = {
+		...firstBlock.attrs,
+		reserveEmptyOutlineHeight: true
+	};
+}
+/**
 * Convert border width from eighths of a point to pixels.
 * OOXML stores border widths in eighths of a point.
 */
@@ -1001,7 +1038,8 @@ function convertTable(node, startPos, options) {
 	}
 	const justification = attrs.justification;
 	const originalFormatting = attrs._originalFormatting;
-	const indentPx = originalFormatting?.indent?.value && originalFormatting.indent.type === "dxa" ? twipsToPixels(originalFormatting.indent.value) : void 0;
+	const effectiveIndent = attrs._resolvedIndent ?? originalFormatting?.indent;
+	const indentPx = effectiveIndent?.value !== void 0 && effectiveIndent?.type === "dxa" ? twipsToPixels(effectiveIndent.value) : void 0;
 	const floating = attrs.floating;
 	let floatingPx;
 	if (floating) {
@@ -1216,8 +1254,12 @@ function toFlowBlocks(doc, options = {}) {
 		switch (node.type.name) {
 			case "paragraph": {
 				const pmAttrs = expectParagraphAttrs(node);
-				const onlyChild = node.childCount === 1 ? node.firstChild : null;
-				if (onlyChild?.type.name === "hardBreak" && expectHardBreakAttrs(onlyChild).breakType === "column") {
+				const secProps = pmAttrs._sectionProperties;
+				const hasSectionBreak = secProps !== void 0 || pmAttrs.sectionBreakType !== null && pmAttrs.sectionBreakType !== void 0;
+				const hasListFormatting = pmAttrs.numPr !== null && pmAttrs.numPr !== void 0 || pmAttrs.listMarker !== null && pmAttrs.listMarker !== void 0;
+				const firstChild = node.firstChild;
+				const startsWithColumnBreak = firstChild?.type.name === "hardBreak" && expectHardBreakAttrs(firstChild).breakType === "column";
+				if (node.childCount === 1 && startsWithColumnBreak) {
 					const columnBreak = {
 						kind: "columnBreak",
 						id: nextBlockId(),
@@ -1225,9 +1267,19 @@ function toFlowBlocks(doc, options = {}) {
 						pmEnd: pos + node.nodeSize
 					};
 					trackedPush(columnBreak);
-				} else trackedPush(convertParagraph(node, pos, opts));
-				const secProps = pmAttrs._sectionProperties;
-				if (secProps || pmAttrs.sectionBreakType) {
+				} else if (startsWithColumnBreak && firstChild) {
+					const columnBreak = {
+						kind: "columnBreak",
+						id: nextBlockId(),
+						pmStart: pos + 1,
+						pmEnd: pos + 1 + firstChild.nodeSize
+					};
+					trackedPush(columnBreak);
+					const paragraph = convertParagraph(node, pos, opts);
+					if (paragraph.runs.at(0)?.kind === "lineBreak") paragraph.runs.shift();
+					trackedPush(paragraph);
+				} else if (node.content.size > 0 || hasListFormatting || !hasSectionBreak) trackedPush(convertParagraph(node, pos, opts));
+				if (hasSectionBreak) {
 					const sectionBreak = {
 						kind: "sectionBreak",
 						id: nextBlockId()
@@ -1288,6 +1340,8 @@ function toFlowBlocks(doc, options = {}) {
 	doc.forEach((node, nodeOffset) => {
 		visit(node, offset + nodeOffset);
 	});
+	reserveLeadingEmptyOutlineHeight(blocks);
+	suppressTerminalEmptyParagraphsAfterTable(blocks);
 	return mergeRunInParagraphs(blocks);
 }
 /**