@stll/folio-core 0.28.1 → 0.30.0

package/dist/docx/metafileSvg.js

@@ -0,0 +1,462 @@
+//#region src/docx/metafileSvg.ts
+/**
+* Render a deliberately small, browser-safe EMF subset to generated SVG.
+*
+* This covers vector logos built from filled paths. Unsupported records fail
+* closed: a partial metafile is more misleading than the existing placeholder.
+* Original EMF bytes remain the source of truth for DOCX round-trip.
+*/
+const EMF_SIGNATURE = 1179469088;
+const MAX_EMF_RECORDS = 1e4;
+const MAX_EMF_POINTS = 2e4;
+const MAX_EMF_DIMENSION = 1e5;
+const MAX_EMF_SVG_CHARACTERS = 1e6;
+const MAX_EMF_STATE_DEPTH = 256;
+const EMR = {
+	header: 1,
+	setWindowExtEx: 9,
+	setWindowOrgEx: 10,
+	setViewportExtEx: 11,
+	setViewportOrgEx: 12,
+	eof: 14,
+	setMapMode: 17,
+	setBackgroundMode: 18,
+	setPolyFillMode: 19,
+	moveToEx: 27,
+	saveDc: 33,
+	restoreDc: 34,
+	selectObject: 37,
+	createBrushIndirect: 39,
+	deleteObject: 40,
+	beginPath: 59,
+	endPath: 60,
+	closeFigure: 61,
+	fillPath: 62,
+	polyBezierTo16: 88,
+	polyPolygon16: 91,
+	extCreatePen: 95
+};
+const MAP_MODE_TEXT = 1;
+const MAP_MODE_ANISOTROPIC = 8;
+const POLY_FILL_ALTERNATE = 1;
+const POLY_FILL_WINDING = 2;
+const STOCK_OBJECT_FLAG = 2147483648;
+const initialState = () => ({
+	mapMode: MAP_MODE_TEXT,
+	windowOrigin: {
+		x: 0,
+		y: 0
+	},
+	windowExtent: {
+		x: 1,
+		y: 1
+	},
+	viewportOrigin: {
+		x: 0,
+		y: 0
+	},
+	viewportExtent: {
+		x: 1,
+		y: 1
+	},
+	fillRule: "nonzero",
+	brush: null,
+	pen: null,
+	currentPoint: {
+		x: 0,
+		y: 0
+	}
+});
+const cloneState = (state) => ({
+	...state,
+	windowOrigin: { ...state.windowOrigin },
+	windowExtent: { ...state.windowExtent },
+	viewportOrigin: { ...state.viewportOrigin },
+	viewportExtent: { ...state.viewportExtent },
+	currentPoint: { ...state.currentPoint }
+});
+const int16 = (view, offset, end) => offset >= 0 && offset + 2 <= end ? view.getInt16(offset, true) : void 0;
+const uint32 = (view, offset, end) => offset >= 0 && offset + 4 <= end ? view.getUint32(offset, true) : void 0;
+const int32 = (view, offset, end) => offset >= 0 && offset + 4 <= end ? view.getInt32(offset, true) : void 0;
+const numberText = (value) => {
+	const rounded = Math.round(value * 1e4) / 1e4;
+	return Object.is(rounded, -0) ? "0" : String(rounded);
+};
+const colorRefToCss = (color) => {
+	const red = color & 255;
+	const green = color >>> 8 & 255;
+	const blue = color >>> 16 & 255;
+	return `#${red.toString(16).padStart(2, "0")}${green.toString(16).padStart(2, "0")}${blue.toString(16).padStart(2, "0")}`;
+};
+const stockObject = (handle) => {
+	switch (handle) {
+		case 2147483648: return {
+			type: "brush",
+			fill: "#ffffff"
+		};
+		case 2147483649: return {
+			type: "brush",
+			fill: "#c0c0c0"
+		};
+		case 2147483650: return {
+			type: "brush",
+			fill: "#808080"
+		};
+		case 2147483651: return {
+			type: "brush",
+			fill: "#404040"
+		};
+		case 2147483652: return {
+			type: "brush",
+			fill: "#000000"
+		};
+		case 2147483653: return {
+			type: "brush",
+			fill: null
+		};
+		case 2147483656: return {
+			type: "pen",
+			stroke: null
+		};
+		default: return;
+	}
+};
+const mappedPoint = (state, bounds, x, y) => {
+	let mappedX;
+	let mappedY;
+	if (state.mapMode === MAP_MODE_TEXT) {
+		mappedX = x - state.windowOrigin.x + state.viewportOrigin.x - bounds.left;
+		mappedY = y - state.windowOrigin.y + state.viewportOrigin.y - bounds.top;
+	} else {
+		const { windowExtent, windowOrigin, viewportExtent, viewportOrigin } = state;
+		if (windowExtent.x === 0 || windowExtent.y === 0) return;
+		mappedX = (x - windowOrigin.x) * viewportExtent.x / windowExtent.x + viewportOrigin.x - bounds.left;
+		mappedY = (y - windowOrigin.y) * viewportExtent.y / windowExtent.y + viewportOrigin.y - bounds.top;
+	}
+	if (!Number.isFinite(mappedX) || !Number.isFinite(mappedY)) return;
+	if (Math.abs(mappedX) > MAX_EMF_DIMENSION * 100 || Math.abs(mappedY) > MAX_EMF_DIMENSION * 100) return;
+	return {
+		x: mappedX,
+		y: mappedY
+	};
+};
+const pathPoint = (command, point) => `${command}${numberText(point.x)} ${numberText(point.y)}`;
+const selectGraphicsObject = (state, objects, handle) => {
+	const object = handle >= STOCK_OBJECT_FLAG ? stockObject(handle) : objects.get(handle);
+	if (!object) return false;
+	if (object.type === "brush") state.brush = object;
+	else state.pen = object;
+	return true;
+};
+/** Convert the supported filled-path EMF subset to inert generated SVG. */
+function renderEmfSvg(data) {
+	const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+	if (bytes.byteLength < 88) return null;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const headerType = uint32(view, 0, bytes.byteLength);
+	const headerSize = uint32(view, 4, bytes.byteLength);
+	const signature = uint32(view, 40, bytes.byteLength);
+	const declaredBytes = uint32(view, 48, bytes.byteLength);
+	const declaredRecords = uint32(view, 52, bytes.byteLength);
+	const left = int32(view, 8, bytes.byteLength);
+	const top = int32(view, 12, bytes.byteLength);
+	const right = int32(view, 16, bytes.byteLength);
+	const bottom = int32(view, 20, bytes.byteLength);
+	if (headerType !== EMR.header || headerSize === void 0 || headerSize < 88 || headerSize % 4 !== 0 || headerSize > bytes.byteLength || signature !== EMF_SIGNATURE || declaredBytes !== bytes.byteLength || declaredRecords === void 0 || declaredRecords < 2 || declaredRecords > MAX_EMF_RECORDS || left === void 0 || top === void 0 || right === void 0 || bottom === void 0) return null;
+	const width = right - left;
+	const height = bottom - top;
+	if (width <= 0 || height <= 0 || width > MAX_EMF_DIMENSION || height > MAX_EMF_DIMENSION) return null;
+	const bounds = {
+		left,
+		top,
+		width,
+		height
+	};
+	const objects = /* @__PURE__ */ new Map();
+	const stack = [];
+	let state = initialState();
+	let offset = headerSize;
+	let recordCount = 1;
+	let pointCount = 0;
+	let pathState = { type: "idle" };
+	const renderedPaths = [];
+	let sawEof = false;
+	while (offset + 8 <= bytes.byteLength && recordCount < MAX_EMF_RECORDS) {
+		const type = uint32(view, offset, bytes.byteLength);
+		const size = uint32(view, offset + 4, bytes.byteLength);
+		if (type === void 0 || size === void 0 || size < 8 || size % 4 !== 0 || size > bytes.byteLength - offset) return null;
+		const end = offset + size;
+		recordCount += 1;
+		switch (type) {
+			case EMR.eof:
+				if (size !== 20 || end !== bytes.byteLength || recordCount !== declaredRecords) return null;
+				sawEof = true;
+				break;
+			case EMR.setMapMode: {
+				const mode = int32(view, offset + 8, end);
+				if (size !== 12 || mode !== MAP_MODE_TEXT && mode !== MAP_MODE_ANISOTROPIC) return null;
+				state.mapMode = mode;
+				break;
+			}
+			case EMR.setBackgroundMode:
+				if (size !== 12 || uint32(view, offset + 8, end) === void 0) return null;
+				break;
+			case EMR.setPolyFillMode: {
+				const mode = uint32(view, offset + 8, end);
+				if (size !== 12 || mode !== POLY_FILL_ALTERNATE && mode !== POLY_FILL_WINDING) return null;
+				state.fillRule = mode === POLY_FILL_ALTERNATE ? "evenodd" : "nonzero";
+				break;
+			}
+			case EMR.setWindowOrgEx:
+			case EMR.setWindowExtEx:
+			case EMR.setViewportOrgEx:
+			case EMR.setViewportExtEx: {
+				const x = int32(view, offset + 8, end);
+				const y = int32(view, offset + 12, end);
+				if (size !== 16 || x === void 0 || y === void 0) return null;
+				if (type === EMR.setWindowOrgEx) state.windowOrigin = {
+					x,
+					y
+				};
+				else if (type === EMR.setWindowExtEx) {
+					if (state.mapMode === MAP_MODE_ANISOTROPIC) {
+						if (x === 0 || y === 0) return null;
+						state.windowExtent = {
+							x,
+							y
+						};
+					}
+				} else if (type === EMR.setViewportOrgEx) state.viewportOrigin = {
+					x,
+					y
+				};
+				else if (state.mapMode === MAP_MODE_ANISOTROPIC) {
+					if (x === 0 || y === 0) return null;
+					state.viewportExtent = {
+						x,
+						y
+					};
+				}
+				break;
+			}
+			case EMR.saveDc:
+				if (size !== 8 || stack.length >= MAX_EMF_STATE_DEPTH) return null;
+				stack.push(cloneState(state));
+				break;
+			case EMR.restoreDc: {
+				const relative = int32(view, offset + 8, end);
+				if (size !== 12 || relative === void 0 || relative >= 0 || -relative > stack.length) return null;
+				let restored;
+				for (let index = 0; index < -relative; index += 1) restored = stack.pop();
+				if (!restored) return null;
+				state = restored;
+				break;
+			}
+			case EMR.createBrushIndirect: {
+				const handle = uint32(view, offset + 8, end);
+				const style = uint32(view, offset + 12, end);
+				const color = uint32(view, offset + 16, end);
+				if (size !== 24 || handle === void 0 || handle >= STOCK_OBJECT_FLAG || objects.has(handle) || style === void 0 || color === void 0) return null;
+				if (style !== 0 && style !== 1) return null;
+				objects.set(handle, {
+					type: "brush",
+					fill: style === 1 ? null : colorRefToCss(color)
+				});
+				break;
+			}
+			case EMR.extCreatePen: {
+				const handle = uint32(view, offset + 8, end);
+				const style = uint32(view, offset + 28, end);
+				const bmiBytes = uint32(view, offset + 16, end);
+				const bitmapBytes = uint32(view, offset + 24, end);
+				const styleEntries = uint32(view, offset + 48, end);
+				if (size !== 52 || handle === void 0 || handle >= STOCK_OBJECT_FLAG || objects.has(handle) || style === void 0 || bmiBytes !== 0 || bitmapBytes !== 0 || styleEntries !== 0 || (style & 15) !== 5) return null;
+				objects.set(handle, {
+					type: "pen",
+					stroke: null
+				});
+				break;
+			}
+			case EMR.selectObject: {
+				const handle = uint32(view, offset + 8, end);
+				if (size !== 12 || handle === void 0 || !selectGraphicsObject(state, objects, handle)) return null;
+				break;
+			}
+			case EMR.deleteObject: {
+				const handle = uint32(view, offset + 8, end);
+				if (size !== 12 || handle === void 0) return null;
+				const object = objects.get(handle);
+				if (object === state.brush) state.brush = null;
+				else if (object === state.pen) state.pen = null;
+				for (const savedState of stack) if (object === savedState.brush) savedState.brush = null;
+				else if (object === savedState.pen) savedState.pen = null;
+				objects.delete(handle);
+				break;
+			}
+			case EMR.beginPath:
+				if (size !== 8) return null;
+				switch (pathState.type) {
+					case "idle":
+						pathState = {
+							type: "building",
+							commands: []
+						};
+						break;
+					case "building":
+					case "completed": return null;
+					default:
+				}
+				break;
+			case EMR.moveToEx: {
+				const x = int32(view, offset + 8, end);
+				const y = int32(view, offset + 12, end);
+				if (size !== 16 || x === void 0 || y === void 0) return null;
+				state.currentPoint = {
+					x,
+					y
+				};
+				switch (pathState.type) {
+					case "idle":
+					case "completed": break;
+					case "building": {
+						const mapped = mappedPoint(state, bounds, x, y);
+						if (!mapped) return null;
+						pathState.commands.push(pathPoint("M", mapped));
+						break;
+					}
+					default:
+				}
+				break;
+			}
+			case EMR.polyBezierTo16: {
+				let commands;
+				switch (pathState.type) {
+					case "building":
+						commands = pathState.commands;
+						break;
+					case "idle":
+					case "completed": return null;
+					default: return null;
+				}
+				const count = uint32(view, offset + 24, end);
+				if (count === void 0 || count === 0 || count % 3 !== 0 || count > MAX_EMF_POINTS - pointCount || size !== 28 + count * 4) return null;
+				pointCount += count;
+				if (commands.length === 0) {
+					const mapped = mappedPoint(state, bounds, state.currentPoint.x, state.currentPoint.y);
+					if (!mapped) return null;
+					commands.push(pathPoint("M", mapped));
+				}
+				for (let index = 0; index < count; index += 3) {
+					const points = [];
+					for (let controlIndex = 0; controlIndex < 3; controlIndex += 1) {
+						const pointOffset = offset + 28 + (index + controlIndex) * 4;
+						const x = int16(view, pointOffset, end);
+						const y = int16(view, pointOffset + 2, end);
+						if (x === void 0 || y === void 0) return null;
+						const mapped = mappedPoint(state, bounds, x, y);
+						if (!mapped) return null;
+						points.push(mapped);
+						state.currentPoint = {
+							x,
+							y
+						};
+					}
+					const [first, second, third] = points;
+					if (!first || !second || !third) return null;
+					commands.push(`C${numberText(first.x)} ${numberText(first.y)} ${numberText(second.x)} ${numberText(second.y)} ${numberText(third.x)} ${numberText(third.y)}`);
+				}
+				break;
+			}
+			case EMR.polyPolygon16: {
+				const polygonCount = uint32(view, offset + 24, end);
+				const totalPoints = uint32(view, offset + 28, end);
+				if (polygonCount === void 0 || totalPoints === void 0 || polygonCount === 0 || totalPoints === 0 || polygonCount > totalPoints || totalPoints > MAX_EMF_POINTS - pointCount || polygonCount > Math.floor((end - (offset + 32)) / 4)) return null;
+				const pointsOffset = offset + 32 + polygonCount * 4;
+				if (size !== 32 + polygonCount * 4 + totalPoints * 4) return null;
+				pointCount += totalPoints;
+				let consumedPoints = 0;
+				const polygonPath = [];
+				for (let polygonIndex = 0; polygonIndex < polygonCount; polygonIndex += 1) {
+					const count = uint32(view, offset + 32 + polygonIndex * 4, end);
+					if (count === void 0 || count < 2 || count > totalPoints - consumedPoints) return null;
+					for (let index = 0; index < count; index += 1) {
+						const pointOffset = pointsOffset + (consumedPoints + index) * 4;
+						const x = int16(view, pointOffset, end);
+						const y = int16(view, pointOffset + 2, end);
+						if (x === void 0 || y === void 0) return null;
+						const mapped = mappedPoint(state, bounds, x, y);
+						if (!mapped) return null;
+						polygonPath.push(pathPoint(index === 0 ? "M" : "L", mapped));
+					}
+					polygonPath.push("Z");
+					consumedPoints += count;
+				}
+				if (consumedPoints !== totalPoints) return null;
+				switch (pathState.type) {
+					case "building":
+						pathState.commands.push(...polygonPath);
+						break;
+					case "idle":
+					case "completed":
+						if (!state.brush?.fill) return null;
+						renderedPaths.push(`<path d="${polygonPath.join(" ")}" fill="${state.brush.fill}" fill-rule="${state.fillRule}"/>`);
+						break;
+					default:
+				}
+				break;
+			}
+			case EMR.closeFigure:
+				if (size !== 8) return null;
+				switch (pathState.type) {
+					case "building":
+						pathState.commands.push("Z");
+						break;
+					case "idle":
+					case "completed": return null;
+					default:
+				}
+				break;
+			case EMR.endPath:
+				if (size !== 8) return null;
+				switch (pathState.type) {
+					case "building":
+						if (pathState.commands.length === 0) return null;
+						pathState = {
+							type: "completed",
+							commands: pathState.commands
+						};
+						break;
+					case "idle":
+					case "completed": return null;
+					default:
+				}
+				break;
+			case EMR.fillPath:
+				if (size !== 24 || !state.brush?.fill) return null;
+				switch (pathState.type) {
+					case "completed":
+						renderedPaths.push(`<path d="${pathState.commands.join(" ")}" fill="${state.brush.fill}" fill-rule="${state.fillRule}"/>`);
+						pathState = { type: "idle" };
+						break;
+					case "idle":
+					case "building": return null;
+					default:
+				}
+				break;
+			default: return null;
+		}
+		offset = end;
+		if (sawEof) break;
+	}
+	if (!sawEof || offset !== bytes.byteLength || recordCount !== declaredRecords || renderedPaths.length === 0) return null;
+	switch (pathState.type) {
+		case "idle": break;
+		case "building":
+		case "completed": return null;
+		default:
+	}
+	const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${numberText(width)} ${numberText(height)}">${renderedPaths.join("")}</svg>`;
+	return svg.length <= MAX_EMF_SVG_CHARACTERS ? svg : null;
+}
+//#endregion
+export { renderEmfSvg };

package/dist/docx/paragraphTextBoxEnrichment.js

@@ -23,9 +23,18 @@ const VML_VERTICAL_RELATIVES = /* @__PURE__ */ new Set([
 	"topMargin",
 	"bottomMargin"
 ]);
+const VML_TEXTBOX_INSET_DEFAULTS = [
+	"0.1in",
+	"0.05in",
+	"0.1in",
+	"0.05in"
+];
+const MAX_VML_TEXTBOX_INSET_TOKEN_CHARACTERS = 64;
+const MAX_VML_STYLE_CHARACTERS = 16384;
 const parseVmlStyle = (value) => {
 	const declarations = {};
-	for (const declaration of value?.split(";") ?? []) {
+	if (!value || value.length > MAX_VML_STYLE_CHARACTERS) return declarations;
+	for (const declaration of value.split(";")) {
 		const separator = declaration.indexOf(":");
 		if (separator < 0) continue;
 		const key = declaration.slice(0, separator).trim().toLowerCase();
@@ -56,9 +65,39 @@ const verticalRelativeTo = (value) => {
 	for (const relative of VML_VERTICAL_RELATIVES) if (relative.toLowerCase() === value?.toLowerCase()) return relative;
 	return "paragraph";
 };
+const parseVmlInsetFields = (rawInset) => {
+	const fields = [];
+	let offset = 0;
+	let segmentHasField = false;
+	while (offset <= rawInset.length) {
+		while (/\s/u.test(rawInset.charAt(offset))) offset += 1;
+		if (offset >= rawInset.length) {
+			if (!segmentHasField) fields.push(void 0);
+			return fields.length <= VML_TEXTBOX_INSET_DEFAULTS.length ? fields : void 0;
+		}
+		if (rawInset.charAt(offset) === ",") {
+			if (!segmentHasField) fields.push(void 0);
+			if (fields.length > VML_TEXTBOX_INSET_DEFAULTS.length) return;
+			segmentHasField = false;
+			offset += 1;
+			continue;
+		}
+		const tokenStart = offset;
+		while (offset < rawInset.length && !/[,\s]/u.test(rawInset.charAt(offset))) {
+			offset += 1;
+			if (offset - tokenStart > MAX_VML_TEXTBOX_INSET_TOKEN_CHARACTERS) return;
+		}
+		fields.push(rawInset.slice(tokenStart, offset));
+		if (fields.length > VML_TEXTBOX_INSET_DEFAULTS.length) return;
+		segmentHasField = true;
+	}
+};
 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;
+	const rawInset = getAttribute(textBoxEl, null, "inset") ?? "";
+	const fields = parseVmlInsetFields(rawInset);
+	if (!fields) return;
+	const [left, top, right, bottom] = VML_TEXTBOX_INSET_DEFAULTS.map((fallback, index) => vmlLengthToPixels(fields.at(index) ?? fallback));
+	if (left === void 0 || top === void 0 || right === void 0 || bottom === void 0) return;
 	return {
 		left: pixelsToEmu(left),
 		top: pixelsToEmu(top),
@@ -67,6 +106,14 @@ const parseVmlInsets = (textBoxEl) => {
 	};
 };
 const parseVmlFill = (shapeEl) => getAttribute(shapeEl, null, "filled")?.toLowerCase() === "f" ? { type: "none" } : void 0;
+const parseVmlTextAnchor = (value) => {
+	switch (value?.toLowerCase()) {
+		case "top": return "top";
+		case "middle": return "middle";
+		case "bottom": return "bottom";
+		default: return;
+	}
+};
 const vmlWrapType = (positioned, zIndex) => {
 	if (!positioned) return "inline";
 	if (Number.isFinite(zIndex) && zIndex < 0) return "behind";
@@ -159,6 +206,7 @@ const enrichTextBoxRuns = ({ content, xmlChildren, styles, theme, numbering, rel
 					content: textBox.content,
 					...textBox.autoFit !== void 0 ? { autoFit: textBox.autoFit } : {},
 					...textBox.textWrap !== void 0 ? { textWrap: textBox.textWrap } : {},
+					...textBox.verticalAlign !== void 0 ? { anchor: textBox.verticalAlign } : {},
 					...textBox.margins !== void 0 ? { margins: textBox.margins } : {}
 				}
 			};
@@ -258,6 +306,7 @@ const parseVmlTextBoxShape = (pictEl, styles, theme, numbering, rels, media, par
 	const contentEl = textBoxEl ? findDeep(textBoxEl, "w", "txbxContent") : null;
 	if (!shapeEl || !textBoxEl || !contentEl) return null;
 	const style = parseVmlStyle(getAttribute(shapeEl, null, "style"));
+	const textBoxStyle = parseVmlStyle(getAttribute(textBoxEl, 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;
@@ -266,6 +315,7 @@ const parseVmlTextBoxShape = (pictEl, styles, theme, numbering, rels, media, par
 	const positioned = style["position"]?.toLowerCase() === "absolute";
 	const zIndex = Number.parseInt(style["z-index"] ?? "", 10);
 	const margins = parseVmlInsets(textBoxEl);
+	const anchor = parseVmlTextAnchor(textBoxStyle["v-text-anchor"]);
 	const fill = parseVmlFill(shapeEl);
 	const shape = {
 		type: "shape",
@@ -278,7 +328,8 @@ const parseVmlTextBoxShape = (pictEl, styles, theme, numbering, rels, media, par
 		wrap: { type: vmlWrapType(positioned, zIndex) },
 		textBody: {
 			content: parseTextBoxContent(contentEl, parseParagraph, parseTable, styles, theme, numbering, rels, media),
-			...margins === void 0 ? {} : { margins }
+			...margins === void 0 ? {} : { margins },
+			...anchor === void 0 ? {} : { anchor }
 		}
 	};
 	const id = getAttribute(shapeEl, null, "id");

package/dist/docx/parser.d.ts

@@ -11,8 +11,8 @@ type ProgressCallback = (stage: string, percent: number) => void;
  * (EMF/WMF/TIFF) into a displayable `data:` or `blob:` URL. Receives the
  * parsed {@link MediaFile} (original bytes on `.data`); return the replacement
  * URL, or `null`/`undefined` to keep the built-in handling. Built-in handling
- * already extracts an embedded PNG/JPEG from EMF/WMF when one exists; this
- * hook is for vector-only metafiles where the host rasterizes server-side.
+ * extracts embedded PNG/JPEG previews and renders a bounded filled-path EMF
+ * subset; this hook covers remaining formats and unsupported vector records.
  */
 type MediaResolver = (file: document_d_exports.MediaFile) => Promise<string | null | undefined>;
 /**

package/dist/docx/parser.js

@@ -14,6 +14,7 @@ import { parseFooter, parseHeader } from "./headerFooterParser.js";
 import { normalizeHeaderFooterReferences } from "./headerFooterReferenceNormalization.js";
 import { assignHeaderFooterVerbatimXml, refreshHeaderFooterVerbatimFingerprint } from "./headerFooterVerbatim.js";
 import { extractMetafileRaster, isMetafileMimeType } from "./metafileRaster.js";
+import { renderEmfSvg } from "./metafileSvg.js";
 import { DocxModelValidationError, formatDocumentModelIssues, validateFolioDocumentModel } from "./modelValidation.js";
 import { parseNumbering } from "./numberingParser.js";
 import { normalizeNumberingReferences } from "./numberingReferenceNormalization.js";
@@ -24,6 +25,7 @@ import { parseStylesPackage } from "./styleParser.js";
 import { applyThemeFontLang, parseTheme } from "./themeParser.js";
 import { normalizeTrackedMoveRanges } from "./trackedMoveRangeNormalization.js";
 import { getMediaMimeType, mediaToDataUrl, unzipDocx } from "./unzip.js";
+import { enforcePackageVmlPreviewBudget } from "./vmlPreview.js";
 import { TaggedError } from "better-result";
 //#region src/docx/parser.ts
 /**
@@ -45,6 +47,9 @@ import { TaggedError } from "better-result";
 * 10. Build media file map
 * 11. Assemble final Document
 */
+const EMF_MIME_TYPE = "image/x-emf";
+const SVG_MIME_TYPE = "image/svg+xml";
+const MAX_PACKAGE_EMF_PREVIEW_BYTES = 8 * 1024 * 1024;
 /**
 * Parse a DOCX file into a complete Document model
 *
@@ -211,6 +216,7 @@ async function parseDocx(input, options = {}) {
 			...templateVariables !== void 0 ? { templateVariables } : {},
 			...requiredFonts.length > 0 ? { requiredFonts } : {}
 		};
+		enforcePackageVmlPreviewBudget(document.package);
 		const validation = validateFolioDocumentModel(document);
 		const parsedCompleteModel = parseHeadersFooters && parseNotes;
 		if (!validation.valid && parsedCompleteModel) throw new DocxModelValidationError("Parsed DOCX produced an invalid document model", validation.issues);
@@ -260,6 +266,7 @@ async function buildMediaMap(raw, rels) {
 	const media = /* @__PURE__ */ new Map();
 	const referenced = collectReferencedMediaPaths(raw, rels);
 	let remainingTiffPixels = MAX_PACKAGE_TIFF_PIXELS;
+	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);
@@ -295,6 +302,25 @@ async function buildMediaMap(raw, rels) {
 			if (normalizedPath !== path) media.set(normalizedPath, mediaFile);
 			continue;
 		}
+		const emfSvg = isReferenced && mimeType === EMF_MIME_TYPE && remainingEmfPreviewBytes > 0 ? renderEmfSvg(data) : null;
+		if (emfSvg) {
+			const svgBytes = new TextEncoder().encode(emfSvg);
+			if (svgBytes.byteLength <= remainingEmfPreviewBytes) {
+				remainingEmfPreviewBytes -= svgBytes.byteLength;
+				const mediaFile = {
+					path,
+					filename,
+					mimeType,
+					data,
+					dataUrl: mediaToDataUrl(copyBytesToArrayBuffer(svgBytes), SVG_MIME_TYPE)
+				};
+				media.set(path, mediaFile);
+				const normalizedPath = path.replace(/^word\//u, "");
+				if (normalizedPath !== path) media.set(normalizedPath, mediaFile);
+				continue;
+			}
+			remainingEmfPreviewBytes = 0;
+		}
 		const mediaFile = {
 			path,
 			filename,

package/dist/docx/runParser.js

@@ -1,4 +1,5 @@
 import { isValidHexColor } from "../utils/colorResolver.js";
+import { parseHorizontalScalePercent } from "../utils/horizontalScale.js";
 import { parseGroupDrawing } from "./groupDrawingParser.js";
 import { parseImage } from "./imageParser.js";
 import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSchema, PositionalTabAlignmentSchema, PositionalTabLeaderSchema, PositionalTabRelativeToSchema, ShadingPatternSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
@@ -302,7 +303,7 @@ function parseRunProperties(rPr, theme, _styles) {
 	}
 	const w = propertyChildren.w;
 	if (w) {
-		const val = parseNumericAttribute(w, "w", "val");
+		const val = parseHorizontalScalePercent(getAttribute(w, "w", "val"));
 		if (val !== void 0) formatting.scale = val;
 	}
 	const kern = propertyChildren.kern;