@stll/folio-core 0.6.1 → 0.8.0

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/numberingParser.js

@@ -604,6 +604,7 @@ function computeListRendering(numPr, numbering) {
 	if (markerFont) rendering.markerFontFamily = markerFont;
 	if (level.rPr?.fontSize) rendering.markerFontSize = level.rPr.fontSize / 2;
 	if (level.rPr?.allCaps) rendering.markerAllCaps = true;
+	if (level.lvlJc) rendering.markerAlignment = level.lvlJc;
 	if (level.suffix) rendering.markerSuffix = level.suffix;
 	if (instance?.abstractNumId !== void 0) rendering.abstractNumId = instance.abstractNumId;
 	if (overrideForLevel?.startOverride !== void 0) rendering.startOverride = overrideForLevel.startOverride;

package/dist/docx/paragraphParser.js

@@ -110,10 +110,18 @@ function parseTabStops(tabs) {
 function parseFrameProperties(framePr) {
 	if (!framePr) return;
 	const frame = {};
+	const dropCap = getAttribute(framePr, "w", "dropCap");
+	if (dropCap === "none" || dropCap === "drop" || dropCap === "margin") frame.dropCap = dropCap;
+	const lines = parseNumericAttribute(framePr, "w", "lines");
+	if (lines !== void 0) frame.lines = lines;
 	const w = parseNumericAttribute(framePr, "w", "w");
 	if (w !== void 0) frame.width = w;
 	const h = parseNumericAttribute(framePr, "w", "h");
 	if (h !== void 0) frame.height = h;
+	const hSpace = parseNumericAttribute(framePr, "w", "hSpace");
+	if (hSpace !== void 0) frame.hSpace = hSpace;
+	const vSpace = parseNumericAttribute(framePr, "w", "vSpace");
+	if (vSpace !== void 0) frame.vSpace = vSpace;
 	const hAnchor = getAttribute(framePr, "w", "hAnchor");
 	if (hAnchor === "text" || hAnchor === "margin" || hAnchor === "page") frame.hAnchor = hAnchor;
 	const vAnchor = getAttribute(framePr, "w", "vAnchor");
@@ -974,6 +982,7 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 				if (markerFont) listRendering.markerFontFamily = markerFont;
 				if (level.rPr?.fontSize) listRendering.markerFontSize = level.rPr.fontSize / 2;
 				if (level.rPr?.allCaps) listRendering.markerAllCaps = true;
+				if (level.lvlJc) listRendering.markerAlignment = level.lvlJc;
 				if (level.suffix) listRendering.markerSuffix = level.suffix;
 				let implicitChildLevelAdvances = 0;
 				const foldedMarkerSuffix = [];

package/dist/docx/paragraphTextBoxEnrichment.js

@@ -1,7 +1,77 @@
-import { findDeep, getChildElements, getLocalName } from "./xmlParser.js";
+import { findDeep, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
+import { pixelsToEmu } from "../utils/units.js";
 import { getTextBoxContentElement, isTextBoxDrawing, parseTextBox, parseTextBoxContent } from "./textBoxParser.js";
 import { parseParagraph } from "./paragraphParser.js";
 //#region src/docx/paragraphTextBoxEnrichment.ts
+const VML_HORIZONTAL_RELATIVES = /* @__PURE__ */ new Set([
+	"character",
+	"column",
+	"insideMargin",
+	"leftMargin",
+	"margin",
+	"outsideMargin",
+	"page",
+	"rightMargin"
+]);
+const VML_VERTICAL_RELATIVES = /* @__PURE__ */ new Set([
+	"insideMargin",
+	"line",
+	"margin",
+	"outsideMargin",
+	"page",
+	"paragraph",
+	"topMargin",
+	"bottomMargin"
+]);
+const parseVmlStyle = (value) => {
+	const declarations = {};
+	for (const declaration of value?.split(";") ?? []) {
+		const separator = declaration.indexOf(":");
+		if (separator < 0) continue;
+		const key = declaration.slice(0, separator).trim().toLowerCase();
+		if (key) declarations[key] = declaration.slice(separator + 1).trim();
+	}
+	return declarations;
+};
+const vmlLengthToPixels = (value) => {
+	const match = /^(?<amount>-?(?:\d+(?:\.\d+)?|\.\d+))\s*(?<unit>pt|in|px|cm|mm|pc)?$/iu.exec(value?.trim() ?? "");
+	const amount = Number.parseFloat(match?.groups?.["amount"] ?? "");
+	if (!Number.isFinite(amount)) return;
+	switch (match?.groups?.["unit"]?.toLowerCase()) {
+		case "pt": return amount / 72 * 96;
+		case "in": return amount * 96;
+		case "cm": return amount / 2.54 * 96;
+		case "mm": return amount / 25.4 * 96;
+		case "pc": return amount * 16;
+		case "px":
+		case void 0: return amount;
+		default: return;
+	}
+};
+const horizontalRelativeTo = (value) => {
+	for (const relative of VML_HORIZONTAL_RELATIVES) if (relative.toLowerCase() === value?.toLowerCase()) return relative;
+	return "character";
+};
+const verticalRelativeTo = (value) => {
+	for (const relative of VML_VERTICAL_RELATIVES) if (relative.toLowerCase() === value?.toLowerCase()) return relative;
+	return "paragraph";
+};
+const parseVmlInsets = (textBoxEl) => {
+	const [left, top, right, bottom, extra] = getAttribute(textBoxEl, null, "inset")?.split(",").map((value) => vmlLengthToPixels(value)) ?? [];
+	if (extra !== void 0 || left === void 0 || top === void 0 || right === void 0 || bottom === void 0) return;
+	return {
+		left: pixelsToEmu(left),
+		top: pixelsToEmu(top),
+		right: pixelsToEmu(right),
+		bottom: pixelsToEmu(bottom)
+	};
+};
+const parseVmlFill = (shapeEl) => getAttribute(shapeEl, null, "filled")?.toLowerCase() === "f" ? { type: "none" } : void 0;
+const vmlWrapType = (positioned, zIndex) => {
+	if (!positioned) return "inline";
+	if (Number.isFinite(zIndex) && zIndex < 0) return "behind";
+	return "inFront";
+};
 const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering, rels, media) => {
 	const xmlChildren = getChildElements(paraXml);
 	let parsedIndex = 0;
@@ -11,7 +81,7 @@ const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering,
 			if (parsedIndex < paragraph.content.length && paragraph.content[parsedIndex]?.type !== "run") parsedIndex += 1;
 			continue;
 		}
-		const { textBoxDrawings, hasNonTextBoxContent } = scanRunForTextBoxDrawings(xmlChild);
+		const { textBoxDrawings, vmlTextBoxes, hasNonTextBoxContent } = scanRunForTextBoxDrawings(xmlChild);
 		const parsedContent = paragraph.content[parsedIndex];
 		const parsedRun = parsedContent?.type === "run" ? parsedContent : void 0;
 		const targetRun = parsedRun ?? (hasNonTextBoxContent ? lastConsumedRun : void 0);
@@ -33,6 +103,7 @@ const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering,
 				...textBox.outline !== void 0 ? { outline: textBox.outline } : {},
 				textBody: {
 					content: textBox.content,
+					...textBox.autoFit !== void 0 ? { autoFit: textBox.autoFit } : {},
 					...textBox.margins !== void 0 ? { margins: textBox.margins } : {}
 				}
 			};
@@ -52,6 +123,24 @@ const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering,
 				parsedIndex += 1;
 			}
 		}
+		for (const pictEl of vmlTextBoxes) {
+			const shape = parseVmlTextBoxShape(pictEl, styles, theme, numbering, rels, media);
+			if (!shape) continue;
+			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;
@@ -60,6 +149,7 @@ const enrichParagraphTextBoxes = (paragraph, paraXml, styles, theme, numbering,
 };
 const scanRunForTextBoxDrawings = (xmlRun) => {
 	const textBoxDrawings = [];
+	const vmlTextBoxes = [];
 	let hasNonTextBoxContent = false;
 	const visitDrawing = (drawingEl) => {
 		if (isTextBoxDrawing(drawingEl)) {
@@ -75,6 +165,11 @@ const scanRunForTextBoxDrawings = (xmlRun) => {
 			visitDrawing(el);
 			continue;
 		}
+		if (name === "pict") {
+			if (findDeep(el, "v", "textbox")) vmlTextBoxes.push(el);
+			else hasNonTextBoxContent = true;
+			continue;
+		}
 		if (name === "AlternateContent") {
 			const branches = getChildElements(el);
 			const choice = branches.find((branch) => getLocalName(branch.name ?? "") === "Choice");
@@ -97,8 +192,52 @@ const scanRunForTextBoxDrawings = (xmlRun) => {
 	}
 	return {
 		textBoxDrawings,
+		vmlTextBoxes,
 		hasNonTextBoxContent
 	};
 };
+const parseVmlTextBoxShape = (pictEl, styles, theme, numbering, rels, media) => {
+	const shapeEl = findDeep(pictEl, "v", "shape");
+	const textBoxEl = shapeEl ? findDeep(shapeEl, "v", "textbox") : null;
+	const contentEl = textBoxEl ? findDeep(textBoxEl, "w", "txbxContent") : null;
+	if (!shapeEl || !textBoxEl || !contentEl) return null;
+	const style = parseVmlStyle(getAttribute(shapeEl, null, "style"));
+	const width = vmlLengthToPixels(style["width"]);
+	const height = vmlLengthToPixels(style["height"]);
+	if (width === void 0 || height === void 0 || width <= 0 || height <= 0) return null;
+	const left = vmlLengthToPixels(style["margin-left"] ?? style["left"]);
+	const top = vmlLengthToPixels(style["margin-top"] ?? style["top"]);
+	const positioned = style["position"]?.toLowerCase() === "absolute";
+	const zIndex = Number.parseInt(style["z-index"] ?? "", 10);
+	const margins = parseVmlInsets(textBoxEl);
+	const fill = parseVmlFill(shapeEl);
+	const shape = {
+		type: "shape",
+		shapeType: "textBox",
+		size: {
+			width: pixelsToEmu(width),
+			height: pixelsToEmu(height)
+		},
+		...fill === void 0 ? {} : { fill },
+		wrap: { type: vmlWrapType(positioned, zIndex) },
+		textBody: {
+			content: parseTextBoxContent(contentEl, parseParagraph, null, styles, theme, numbering, rels ?? void 0, media ?? void 0),
+			...margins === void 0 ? {} : { margins }
+		}
+	};
+	const id = getAttribute(shapeEl, null, "id");
+	if (id) shape.id = id;
+	if (positioned) shape.position = {
+		horizontal: {
+			relativeTo: horizontalRelativeTo(style["mso-position-horizontal-relative"]),
+			...left === void 0 ? {} : { posOffset: pixelsToEmu(left) }
+		},
+		vertical: {
+			relativeTo: verticalRelativeTo(style["mso-position-vertical-relative"]),
+			...top === void 0 ? {} : { posOffset: pixelsToEmu(top) }
+		}
+	};
+	return shape;
+};
 //#endregion
 export { enrichParagraphTextBoxes };

package/dist/docx/parser.js

@@ -11,6 +11,7 @@ import { toArrayBuffer } from "../utils/docxInput.js";
 import { loadFontsWithMapping } from "../utils/fontLoader.js";
 import { convertTiffToPngDataUrl, isTiffMimeType } from "../utils/tiffConverter.js";
 import { normalizeCommentReferences } from "./commentReferenceNormalization.js";
+import { detectDocxConformanceClass } from "./conformance.js";
 import { extractAllTemplateVariables, parseDocumentBody } from "./documentParser.js";
 import { normalizeHeaderFooterReferences } from "./headerFooterReferenceNormalization.js";
 import { extractMetafileRaster, isMetafileMimeType } from "./metafileRaster.js";
@@ -167,6 +168,7 @@ async function parseDocx(input, options = {}) {
 		onProgress("Assembling document...", 95);
 		const document = {
 			package: {
+				conformanceClass: detectDocxConformanceClass(raw.documentXml),
 				document: documentBody,
 				settings,
 				...styleDefinitions !== void 0 ? { styles: styleDefinitions } : {},

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/selectiveXmlPatch.d.ts

@@ -6,6 +6,15 @@
  * unchanged content byte-for-byte. Uses string offset tracking
  * with proper tag depth counting (not regex) to handle nested elements.
  */
+/**
+ * Whether `char` ends an element's tag name in XML — a whitespace separator
+ * (space, tab, CR, or LF, all valid before attributes per XML 1.0 §3.1), the
+ * tag close `>`, or a self-close `/`. Manual tag scanners must accept every
+ * whitespace form, not just a literal space, so newline-formatted markup
+ * (`<w:p\n  w14:paraId="…">`) is still recognized as the element rather than
+ * mistaken for a longer-named sibling.
+ */
+declare function isXmlNameBoundary(char: string | undefined): boolean;
 /**
  * Find the exact string start and end offsets of a <w:p> element
  * identified by its w14:paraId attribute.
@@ -100,4 +109,4 @@ declare function collectChangedNumberingDefs(baselineXml: string, currentXml: st
  */
 declare function buildPatchedNumberingXml(originalXml: string, currentXml: string, changed: ChangedNumberingDefs): string | null;
 //#endregion
-export { ChangedNumberingDefs, PatchSafetyOptions, PatchValidationResult, buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, validatePatchSafety };
+export { ChangedNumberingDefs, PatchSafetyOptions, PatchValidationResult, buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };

package/dist/docx/selectiveXmlPatch.js

@@ -484,4 +484,4 @@ function escapeRegExp(str) {
 	return str.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 //#endregion
-export { buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, validatePatchSafety };
+export { buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, validatePatchSafety };

package/dist/docx/serializer/paragraphSerializer.js

@@ -112,8 +112,12 @@ function serializeNumbering(numPr) {
 function serializeFrameProperties(frame) {
 	if (!frame) return "";
 	const attrs = [];
+	if (frame.dropCap) attrs.push(`w:dropCap="${frame.dropCap}"`);
+	if (frame.lines !== void 0) attrs.push(`w:lines="${intAttr(frame.lines)}"`);
 	if (frame.width !== void 0) attrs.push(`w:w="${intAttr(frame.width)}"`);
 	if (frame.height !== void 0) attrs.push(`w:h="${intAttr(frame.height)}"`);
+	if (frame.hSpace !== void 0) attrs.push(`w:hSpace="${intAttr(frame.hSpace)}"`);
+	if (frame.vSpace !== void 0) attrs.push(`w:vSpace="${intAttr(frame.vSpace)}"`);
 	if (frame.hAnchor) attrs.push(`w:hAnchor="${frame.hAnchor}"`);
 	if (frame.vAnchor) attrs.push(`w:vAnchor="${frame.vAnchor}"`);
 	if (frame.x !== void 0) attrs.push(`w:x="${frame.x}"`);

package/dist/docx/serializer/runSerializer.js

@@ -456,13 +456,18 @@ function serializeShapeContent(content) {
 			if (tb.margins.right != null) bpAttrs.push(`rIns="${intAttr(tb.margins.right)}"`);
 			if (tb.margins.bottom != null) bpAttrs.push(`bIns="${intAttr(tb.margins.bottom)}"`);
 		}
+		let autoFitXml = "";
+		if (tb.autoFit === "shape") autoFitXml = "<a:spAutoFit/>";
+		else if (tb.autoFit === "normal") autoFitXml = "<a:normAutofit/>";
+		else if (tb.autoFit === "none") autoFitXml = "<a:noAutofit/>";
+		const bodyPrXml = autoFitXml ? `<wps:bodyPr ${bpAttrs.join(" ")}>${autoFitXml}</wps:bodyPr>` : `<wps:bodyPr ${bpAttrs.join(" ")}/>`;
 		if (isTextBox) textBody = [
 			"<wps:txbx><w:txbxContent>",
 			serializeShapeTextBody(tb.content),
 			"</w:txbxContent></wps:txbx>",
-			`<wps:bodyPr ${bpAttrs.join(" ")}/>`
+			bodyPrXml
 		].join("");
-		else textBody = [`<wps:bodyPr ${bpAttrs.join(" ")}/>`].join("");
+		else textBody = bodyPrXml;
 	}
 	const graphic = [
 		"<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">",

package/dist/docx/serializer/tableSerializer.js

@@ -172,6 +172,10 @@ function serializeTablePropertyChange(change) {
 function serializeTableRowFormatting(formatting, propertyChanges, structuralChange) {
 	const parts = [];
 	if (formatting) {
+		if (formatting.gridBefore) parts.push(`<w:gridBefore w:val="${intAttr(formatting.gridBefore)}"/>`);
+		if (formatting.widthBefore) parts.push(`<w:wBefore w:w="${intAttr(formatting.widthBefore.value)}" w:type="${formatting.widthBefore.type}"/>`);
+		if (formatting.gridAfter) parts.push(`<w:gridAfter w:val="${intAttr(formatting.gridAfter)}"/>`);
+		if (formatting.widthAfter) parts.push(`<w:wAfter w:w="${intAttr(formatting.widthAfter.value)}" w:type="${formatting.widthAfter.type}"/>`);
 		if (formatting.cantSplit) parts.push("<w:cantSplit/>");
 		if (formatting.header) parts.push("<w:tblHeader/>");
 		if (formatting.height) {

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