@stll/folio-core 0.29.0 → 0.30.0

package/dist/docx/vmlPreview.js

@@ -0,0 +1,535 @@
+import { findChild, findDeep, getAttribute, getChildElements, getLocalName } from "./xmlParser.js";
+//#region src/docx/vmlPreview.ts
+const MAX_VML_PREVIEW_DEPTH = 16;
+const MAX_VML_PREVIEW_ELEMENTS = 256;
+const MAX_VML_PREVIEW_PATH_POINTS = 2e4;
+const MAX_VML_PREVIEW_COORDINATE = 1e6;
+const MAX_VML_PREVIEW_DIMENSION_PX = 2e4;
+const MAX_VML_SVG_CHARACTERS = 1e6;
+const MAX_PACKAGE_VML_PREVIEW_CHARACTERS = 8 * 1024 * 1024;
+const VML_PREVIEW_DATA_URL_PREFIX = "data:image/svg+xml;charset=utf-8,";
+const VML_PREVIEW_FILENAME = "vml-shape-preview.svg";
+const VML_PREVIEW_MIME_TYPE = "image/svg+xml";
+const SAFE_VML_COLORS = /* @__PURE__ */ new Set([
+	"black",
+	"white",
+	"red",
+	"green",
+	"blue",
+	"yellow",
+	"gray",
+	"grey",
+	"silver",
+	"maroon",
+	"purple",
+	"fuchsia",
+	"lime",
+	"olive",
+	"navy",
+	"teal",
+	"aqua"
+]);
+const PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const EMPTY_RESULT = { type: "empty" };
+const INVALID_RESULT = { type: "invalid" };
+const isVmlPathCommand = (value) => {
+	switch (value) {
+		case "e":
+		case "l":
+		case "m":
+		case "r": return true;
+		default: return false;
+	}
+};
+/** Parse a VML/CSS length into CSS pixels without accepting partial numbers. */
+const vmlCssLengthToPx = (raw) => {
+	if (!raw) return;
+	const match = /^(?<amount>-?(?:\d+(?:\.\d+)?|\.\d+))\s*(?<unit>pt|in|px|cm|mm|pc)?$/iu.exec(raw.trim());
+	const amountText = match?.groups?.["amount"];
+	if (amountText === void 0) return;
+	const value = Number.parseFloat(amountText);
+	if (!Number.isFinite(value)) return;
+	switch (match?.groups?.["unit"]?.toLowerCase()) {
+		case "pt": return value / 72 * 96;
+		case "in": return value * 96;
+		case "cm": return value / 2.54 * 96;
+		case "mm": return value / 25.4 * 96;
+		case "pc": return value / 6 * 96;
+		case "px":
+		case void 0: return value;
+		default: return;
+	}
+};
+/** Read a VML `style` attribute into a prototype-free lowercased record. */
+const parseVmlStyle = (style) => {
+	const result = Object.create(null);
+	if (!style) return result;
+	for (const declaration of style.split(";")) {
+		const colon = declaration.indexOf(":");
+		if (colon < 0) continue;
+		const key = declaration.slice(0, colon).trim().toLowerCase();
+		const value = declaration.slice(colon + 1).trim();
+		if (!key || PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
+		result[key] = value;
+	}
+	return result;
+};
+/** Parse a finite VML number without exponent or partial-number coercion. */
+const parseVmlNumber = (raw) => {
+	if (!raw || !/^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(raw.trim())) return;
+	const value = Number.parseFloat(raw);
+	return Number.isFinite(value) ? value : void 0;
+};
+/** Check a physical preview dimension against the retained SVG layout bound. */
+const isValidVmlPreviewDimension = (value) => value !== void 0 && value > 0 && value <= MAX_VML_PREVIEW_DIMENSION_PX;
+/** Encode a generated, already-sanitized SVG without exceeding its output cap. */
+const vmlSvgDataUrl = (svg) => svg.length <= MAX_VML_SVG_CHARACTERS ? `${VML_PREVIEW_DATA_URL_PREFIX}${encodeURIComponent(svg)}` : void 0;
+const validCoordinate = (value) => value !== void 0 && Math.abs(value) <= MAX_VML_PREVIEW_COORDINATE;
+const validExtent = (value) => value !== void 0 && value > 0 && value <= MAX_VML_PREVIEW_COORDINATE;
+const coordinatePair = (raw) => {
+	const [xRaw, yRaw, extra] = raw?.split(",").map((part) => part.trim()) ?? [];
+	if (extra !== void 0) return;
+	const x = parseVmlNumber(xRaw);
+	const y = parseVmlNumber(yRaw);
+	return validCoordinate(x) && validCoordinate(y) ? {
+		x,
+		y
+	} : void 0;
+};
+const localCoordinateSpace = (element, fallbackWidth, fallbackHeight) => {
+	const originRaw = getAttribute(element, null, "coordorigin");
+	const sizeRaw = getAttribute(element, null, "coordsize");
+	const origin = originRaw ? coordinatePair(originRaw) : {
+		x: 0,
+		y: 0
+	};
+	const size = sizeRaw ? coordinatePair(sizeRaw) : {
+		x: fallbackWidth,
+		y: fallbackHeight
+	};
+	if (!origin || !size) return;
+	return validExtent(size.x) && validExtent(size.y) ? {
+		origin,
+		size
+	} : void 0;
+};
+const coordinateViewport = (style) => {
+	const x = parseVmlNumber(style["left"]) ?? 0;
+	const y = parseVmlNumber(style["top"]) ?? 0;
+	const width = parseVmlNumber(style["width"]);
+	const height = parseVmlNumber(style["height"]);
+	return validCoordinate(x) && validCoordinate(y) && validExtent(width) && validExtent(height) ? {
+		x,
+		y,
+		width,
+		height
+	} : void 0;
+};
+const transformMatrix = (viewport, space) => {
+	const scaleX = viewport.width / space.size.x;
+	const scaleY = viewport.height / space.size.y;
+	const translateX = viewport.x - space.origin.x * scaleX;
+	const translateY = viewport.y - space.origin.y * scaleY;
+	if ([
+		scaleX,
+		scaleY,
+		translateX,
+		translateY
+	].some((value) => !Number.isFinite(value) || Math.abs(value) > MAX_VML_PREVIEW_COORDINATE)) return;
+	return `matrix(${scaleX} 0 0 ${scaleY} ${translateX} ${translateY})`;
+};
+const safeColor = (raw, fallback) => {
+	const normalized = raw?.trim().toLowerCase();
+	if (!normalized) return fallback;
+	if (normalized === "none") return "none";
+	if (SAFE_VML_COLORS.has(normalized)) return normalized;
+	if (/^#[0-9a-f]{3}(?:[0-9a-f]{3})?$/u.test(normalized)) return normalized;
+	return /^[0-9a-f]{6}$/u.test(normalized) ? `#${normalized}` : fallback;
+};
+const isVmlFalse = (raw) => {
+	switch (raw?.trim().toLowerCase()) {
+		case "0":
+		case "f":
+		case "false": return true;
+		default: return false;
+	}
+};
+const shapePaint = (shape) => {
+	const fill = isVmlFalse(getAttribute(shape, null, "filled")) ? "none" : safeColor(getAttribute(shape, null, "fillcolor"), "white");
+	const stroke = isVmlFalse(getAttribute(shape, null, "stroked")) ? "none" : safeColor(getAttribute(shape, null, "strokecolor"), "black");
+	return fill === "none" && stroke === "none" ? EMPTY_RESULT : {
+		type: "painted",
+		fill,
+		stroke
+	};
+};
+const isHidden = (style) => style["visibility"]?.toLowerCase() === "hidden" || style["display"]?.toLowerCase() === "none";
+const consumeSvgCharacters = (budget, count) => {
+	if (budget.svgCharacters + count > MAX_VML_SVG_CHARACTERS) return false;
+	budget.svgCharacters += count;
+	return true;
+};
+const consumePathPoint = (budget) => {
+	if (budget.pathPoints >= MAX_VML_PREVIEW_PATH_POINTS) return false;
+	budget.pathPoints += 1;
+	return true;
+};
+const skipPathWhitespace = (cursor) => {
+	while (/\s/u.test(cursor.raw.charAt(cursor.offset))) cursor.offset += 1;
+};
+const nextPathNumber = (cursor) => {
+	skipPathWhitespace(cursor);
+	if (cursor.offset >= cursor.raw.length) {
+		if (!cursor.afterComma) return { type: "end" };
+		cursor.afterComma = false;
+		return {
+			type: "value",
+			value: 0
+		};
+	}
+	if (cursor.raw.charAt(cursor.offset) === ",") {
+		cursor.offset += 1;
+		cursor.afterComma = true;
+		return {
+			type: "value",
+			value: 0
+		};
+	}
+	cursor.afterComma = false;
+	const start = cursor.offset;
+	while (cursor.offset < cursor.raw.length && !/[,\s]/u.test(cursor.raw.charAt(cursor.offset))) cursor.offset += 1;
+	const value = parseVmlNumber(cursor.raw.slice(start, cursor.offset));
+	if (!validCoordinate(value)) return INVALID_RESULT;
+	skipPathWhitespace(cursor);
+	if (cursor.raw.charAt(cursor.offset) === ",") {
+		cursor.offset += 1;
+		cursor.afterComma = true;
+	}
+	return {
+		type: "value",
+		value
+	};
+};
+const pathNumberCursor = (raw) => ({
+	afterComma: false,
+	offset: 0,
+	raw
+});
+const parseMovePair = (raw, budget) => {
+	const cursor = pathNumberCursor(raw);
+	const x = nextPathNumber(cursor);
+	const y = nextPathNumber(cursor);
+	const end = nextPathNumber(cursor);
+	return x.type === "value" && y.type === "value" && end.type === "end" && consumePathPoint(budget) ? {
+		x: x.value,
+		y: y.value
+	} : void 0;
+};
+const appendLinePairs = ({ raw, budget, commands, relative, startX, startY }) => {
+	const cursor = pathNumberCursor(raw);
+	let x = startX;
+	let y = startY;
+	let pairCount = 0;
+	while (true) {
+		const nextX = nextPathNumber(cursor);
+		if (nextX.type === "end") return pairCount > 0 ? {
+			x,
+			y
+		} : void 0;
+		const nextY = nextPathNumber(cursor);
+		if (nextX.type !== "value" || nextY.type !== "value") return;
+		x = relative ? x + nextX.value : nextX.value;
+		y = relative ? y + nextY.value : nextY.value;
+		if (!validCoordinate(x) || !validCoordinate(y) || !consumePathPoint(budget) || !appendPathCommand(commands, `L ${x} ${y}`, budget)) return;
+		pairCount += 1;
+	}
+};
+const appendPathCommand = (commands, command, budget) => {
+	if (!consumeSvgCharacters(budget, command.length + 1)) return false;
+	commands.push(command);
+	return true;
+};
+const startPathSubpath = (state, point, budget) => {
+	const commands = state.type === "building" ? state.commands : [];
+	const hasLine = state.type === "building" && state.hasLine;
+	if (!appendPathCommand(commands, `M ${point.x} ${point.y}`, budget)) return;
+	return {
+		type: "building",
+		x: point.x,
+		y: point.y,
+		commands,
+		hasLine,
+		pathSets: state.pathSets
+	};
+};
+const renderVmlPath = (raw, budget) => {
+	if (raw.length > MAX_VML_SVG_CHARACTERS) return INVALID_RESULT;
+	let state = {
+		type: "between-sets",
+		pathSets: []
+	};
+	let offset = 0;
+	while (offset < raw.length) {
+		while (/\s/u.test(raw.charAt(offset))) offset += 1;
+		if (offset >= raw.length) break;
+		const command = raw.charAt(offset).toLowerCase();
+		if (!isVmlPathCommand(command)) return INVALID_RESULT;
+		offset += 1;
+		const argumentStart = offset;
+		while (offset < raw.length && !/[a-z]/iu.test(raw.charAt(offset))) offset += 1;
+		const rawArguments = raw.slice(argumentStart, offset).trim();
+		switch (command) {
+			case "m": {
+				const point = parseMovePair(rawArguments, budget);
+				if (!point) return INVALID_RESULT;
+				const nextState = startPathSubpath(state, point, budget);
+				if (!nextState) return INVALID_RESULT;
+				state = nextState;
+				break;
+			}
+			case "l":
+			case "r": {
+				if (state.type !== "building") return INVALID_RESULT;
+				const endPoint = appendLinePairs({
+					raw: rawArguments,
+					budget,
+					commands: state.commands,
+					relative: command === "r",
+					startX: state.x,
+					startY: state.y
+				});
+				if (!endPoint) return INVALID_RESULT;
+				state = {
+					type: "building",
+					x: endPoint.x,
+					y: endPoint.y,
+					commands: state.commands,
+					hasLine: true,
+					pathSets: state.pathSets
+				};
+				break;
+			}
+			case "e":
+				if (rawArguments || state.type !== "building") return INVALID_RESULT;
+				if (state.hasLine) state.pathSets.push(state.commands.join(" "));
+				state = {
+					type: "between-sets",
+					pathSets: state.pathSets
+				};
+				break;
+			default:
+		}
+	}
+	switch (state.type) {
+		case "between-sets": return state.pathSets.length > 0 ? {
+			type: "painted",
+			pathSets: state.pathSets
+		} : EMPTY_RESULT;
+		case "building": return INVALID_RESULT;
+		default: return state;
+	}
+};
+const primitiveShapeFragment = (shape, viewport, budget) => {
+	const paint = shapePaint(shape);
+	if (paint.type === "empty") return EMPTY_RESULT;
+	const localName = getLocalName(shape.name ?? "");
+	let svg;
+	if (localName === "oval") svg = `<ellipse cx="${viewport.x + viewport.width / 2}" cy="${viewport.y + viewport.height / 2}" rx="${viewport.width / 2}" ry="${viewport.height / 2}" fill="${paint.fill}" stroke="${paint.stroke}"/>`;
+	else {
+		const radius = localName === "roundrect" ? Math.min(viewport.width, viewport.height) * .1 : 0;
+		svg = `<rect x="${viewport.x}" y="${viewport.y}" width="${viewport.width}" height="${viewport.height}" rx="${radius}" fill="${paint.fill}" stroke="${paint.stroke}"/>`;
+	}
+	return consumeSvgCharacters(budget, svg.length) ? {
+		type: "painted",
+		svg
+	} : INVALID_RESULT;
+};
+const lineFragment = (line, budget) => {
+	if (isVmlFalse(getAttribute(line, null, "stroked"))) return EMPTY_RESULT;
+	const from = coordinatePair(getAttribute(line, null, "from"));
+	const to = coordinatePair(getAttribute(line, null, "to"));
+	if (!from || !to) return INVALID_RESULT;
+	const stroke = safeColor(getAttribute(line, null, "strokecolor"), "black");
+	const svg = `<line x1="${from.x}" y1="${from.y}" x2="${to.x}" y2="${to.y}" stroke="${stroke}"/>`;
+	return consumeSvgCharacters(budget, svg.length) ? {
+		type: "painted",
+		svg
+	} : INVALID_RESULT;
+};
+const pathShapeFragment = (shape, budget) => {
+	if (findChild(shape, "v", "textbox") || findChild(shape, "v", "imagedata")) return EMPTY_RESULT;
+	const style = parseVmlStyle(getAttribute(shape, null, "style"));
+	if (isHidden(style)) return EMPTY_RESULT;
+	const paint = shapePaint(shape);
+	if (paint.type === "empty") return EMPTY_RESULT;
+	const rawPath = getAttribute(shape, null, "path");
+	if (!rawPath) return EMPTY_RESULT;
+	const viewport = coordinateViewport(style);
+	if (!viewport) return INVALID_RESULT;
+	const space = localCoordinateSpace(shape, viewport.width, viewport.height);
+	const transform = space ? transformMatrix(viewport, space) : void 0;
+	if (!transform) return INVALID_RESULT;
+	const path = renderVmlPath(rawPath, budget);
+	if (path.type !== "painted") return path;
+	const fragments = [];
+	for (const pathData of path.pathSets) {
+		const svg = `<path transform="${transform}" d="${pathData}" fill="${paint.fill}" fill-rule="evenodd" stroke="${paint.stroke}"/>`;
+		if (!consumeSvgCharacters(budget, svg.length - pathData.length)) return INVALID_RESULT;
+		fragments.push(svg);
+	}
+	return {
+		type: "painted",
+		svg: fragments.join("")
+	};
+};
+const renderGroupChildren = (group, budget, depth) => {
+	const fragments = [];
+	for (const child of getChildElements(group)) {
+		if (budget.elements >= MAX_VML_PREVIEW_ELEMENTS) return INVALID_RESULT;
+		budget.elements += 1;
+		const localName = getLocalName(child.name ?? "");
+		let result;
+		switch (localName) {
+			case "group": {
+				if (depth >= MAX_VML_PREVIEW_DEPTH) return INVALID_RESULT;
+				const style = parseVmlStyle(getAttribute(child, null, "style"));
+				if (isHidden(style)) {
+					result = EMPTY_RESULT;
+					break;
+				}
+				const viewport = coordinateViewport(style);
+				const space = viewport ? localCoordinateSpace(child, viewport.width, viewport.height) : void 0;
+				const transform = viewport && space ? transformMatrix(viewport, space) : void 0;
+				if (!transform) return INVALID_RESULT;
+				const content = renderGroupChildren(child, budget, depth + 1);
+				if (content.type !== "painted") {
+					result = content;
+					break;
+				}
+				const svg = `<g transform="${transform}">${content.svg}</g>`;
+				const wrapperCharacters = svg.length - content.svg.length;
+				result = consumeSvgCharacters(budget, wrapperCharacters) ? {
+					type: "painted",
+					svg
+				} : INVALID_RESULT;
+				break;
+			}
+			case "shape":
+				result = pathShapeFragment(child, budget);
+				break;
+			case "line":
+				result = lineFragment(child, budget);
+				break;
+			case "oval":
+			case "rect":
+			case "roundrect": {
+				const style = parseVmlStyle(getAttribute(child, null, "style"));
+				if (isHidden(style)) {
+					result = EMPTY_RESULT;
+					break;
+				}
+				const viewport = coordinateViewport(style);
+				result = viewport ? primitiveShapeFragment(child, viewport, budget) : INVALID_RESULT;
+				break;
+			}
+			default: result = EMPTY_RESULT;
+		}
+		switch (result.type) {
+			case "painted":
+				fragments.push(result.svg);
+				break;
+			case "empty": break;
+			case "invalid": return INVALID_RESULT;
+			default:
+		}
+	}
+	return fragments.length > 0 ? {
+		type: "painted",
+		svg: fragments.join("")
+	} : EMPTY_RESULT;
+};
+/** Render a bounded standalone VML rectangle or oval preview. */
+const renderStandaloneVmlPreview = (shape) => {
+	if (findDeep(shape, "v", "textbox")) return EMPTY_RESULT;
+	const style = parseVmlStyle(getAttribute(shape, null, "style"));
+	const widthPx = vmlCssLengthToPx(style["width"]);
+	const heightPx = vmlCssLengthToPx(style["height"]);
+	if (!isValidVmlPreviewDimension(widthPx) || !isValidVmlPreviewDimension(heightPx)) return INVALID_RESULT;
+	const budget = {
+		elements: 1,
+		pathPoints: 0,
+		svgCharacters: 0
+	};
+	const content = primitiveShapeFragment(shape, {
+		x: 0,
+		y: 0,
+		width: widthPx,
+		height: heightPx
+	}, budget);
+	if (content.type !== "painted") return content;
+	const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${widthPx} ${heightPx}" width="${widthPx}" height="${heightPx}">${content.svg}</svg>`;
+	if (!consumeSvgCharacters(budget, svg.length - content.svg.length)) return INVALID_RESULT;
+	return {
+		type: "rendered",
+		svg,
+		widthPx,
+		heightPx,
+		style
+	};
+};
+/** Render a VML group through bounded, non-clipping local-coordinate transforms. */
+const renderVmlGroupPreview = (group) => {
+	const style = parseVmlStyle(getAttribute(group, null, "style"));
+	const widthPx = vmlCssLengthToPx(style["width"]);
+	const heightPx = vmlCssLengthToPx(style["height"]);
+	if (!isValidVmlPreviewDimension(widthPx) || !isValidVmlPreviewDimension(heightPx)) return INVALID_RESULT;
+	const space = localCoordinateSpace(group, widthPx, heightPx);
+	if (!space) return INVALID_RESULT;
+	const budget = {
+		elements: 1,
+		pathPoints: 0,
+		svgCharacters: 0
+	};
+	const content = renderGroupChildren(group, budget, 0);
+	if (content.type !== "painted") return content;
+	const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${space.origin.x} ${space.origin.y} ${space.size.x} ${space.size.y}" width="${widthPx}" height="${heightPx}">${content.svg}</svg>`;
+	if (!consumeSvgCharacters(budget, svg.length - content.svg.length)) return INVALID_RESULT;
+	return {
+		type: "rendered",
+		svg,
+		widthPx,
+		heightPx,
+		style
+	};
+};
+/** Bound retained synthetic VML previews while preserving their raw replay nodes. */
+const enforcePackageVmlPreviewBudget = (root, maxCharacters = MAX_PACKAGE_VML_PREVIEW_CHARACTERS) => {
+	let remainingCharacters = Math.max(0, maxCharacters);
+	const visited = /* @__PURE__ */ new WeakSet();
+	const visit = (value) => {
+		if (value === null || typeof value !== "object" || visited.has(value)) return;
+		visited.add(value);
+		if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return;
+		if (value instanceof Map) {
+			for (const child of value.values()) visit(child);
+			return;
+		}
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child);
+			return;
+		}
+		if ("type" in value && value.type === "image" && "rId" in value && value.rId === "" && "mimeType" in value && value.mimeType === VML_PREVIEW_MIME_TYPE && "filename" in value && value.filename === VML_PREVIEW_FILENAME && "src" in value && typeof value.src === "string" && value.src.startsWith(VML_PREVIEW_DATA_URL_PREFIX)) if (value.src.length <= remainingCharacters) remainingCharacters -= value.src.length;
+		else {
+			remainingCharacters = 0;
+			delete value.src;
+		}
+		for (const child of Object.values(value)) visit(child);
+	};
+	visit(root);
+};
+//#endregion
+export { enforcePackageVmlPreviewBudget, isValidVmlPreviewDimension, parseVmlNumber, parseVmlStyle, renderStandaloneVmlPreview, renderVmlGroupPreview, vmlCssLengthToPx, vmlSvgDataUrl };

package/dist/docx/wrapTypes.d.ts

@@ -1,36 +1,2 @@
-//#region src/docx/wrapTypes.d.ts
-/**
- * Wrap-type predicates shared across the layout pipeline.
- *
- * Mirrors eigenpal docx-editor `wrapTypes` so that the new textBoxFlow
- * predicates (eigenpal #474) and the existing image classifiers agree on
- * which OOXML wrap variants are floating, which paint over body text, and
- * which wrap around it.
- */
-/**
- * OOXML text-wrap variants for a drawing anchor (`wp:inline` vs the
- * `wp:wrap*` elements). `inline` keeps the object in the text run; every other
- * variant takes it out of inline flow. Mirrors the eigenpal docx-editor union
- * so adapters share one wrap vocabulary.
- */
-type WrapType = "inline" | "square" | "tight" | "through" | "topAndBottom" | "behind" | "inFront";
-/**
- * `true` for any wrap type that takes the object out of inline flow.
- * Includes `topAndBottom` and the wrapNone variants (`behind`/`inFront`):
- * those are anchored at absolute coordinates even though they don't shrink
- * line widths.
- */
-declare function isFloatingWrapType(wrapType: string | undefined): boolean;
-/**
- * `true` for `behind` and `inFront` — wrapNone variants that don't shrink
- * line widths; text paints over or under the object.
- */
-declare function isWrapNone(wrapType: string | undefined): boolean;
-/**
- * `true` for wrap types that actually divert lines around the object
- * (`square` / `tight` / `through`). Excludes `topAndBottom` (block flow)
- * and the wrapNone variants.
- */
-declare function wrapsAroundText(wrapType: string | undefined): boolean;
-//#endregion
-export { WrapType, isFloatingWrapType, isWrapNone, wrapsAroundText };
+import { WrapType, isFloatingWrapType, isWrapNone, wrapsAroundText } from "../types/wrap.js";
+export { type WrapType, isFloatingWrapType, isWrapNone, wrapsAroundText };

package/dist/docx/wrapTypes.js

@@ -1,40 +1,2 @@
-//#region src/docx/wrapTypes.ts
-const FLOATING_WRAP_TYPES = /* @__PURE__ */ new Set([
-	"square",
-	"tight",
-	"through",
-	"topAndBottom",
-	"behind",
-	"inFront"
-]);
-const TEXT_WRAPPING_TYPES = /* @__PURE__ */ new Set([
-	"square",
-	"tight",
-	"through"
-]);
-/**
-* `true` for any wrap type that takes the object out of inline flow.
-* Includes `topAndBottom` and the wrapNone variants (`behind`/`inFront`):
-* those are anchored at absolute coordinates even though they don't shrink
-* line widths.
-*/
-function isFloatingWrapType(wrapType) {
-	return wrapType !== void 0 && FLOATING_WRAP_TYPES.has(wrapType);
-}
-/**
-* `true` for `behind` and `inFront` — wrapNone variants that don't shrink
-* line widths; text paints over or under the object.
-*/
-function isWrapNone(wrapType) {
-	return wrapType === "behind" || wrapType === "inFront";
-}
-/**
-* `true` for wrap types that actually divert lines around the object
-* (`square` / `tight` / `through`). Excludes `topAndBottom` (block flow)
-* and the wrapNone variants.
-*/
-function wrapsAroundText(wrapType) {
-	return wrapType !== void 0 && TEXT_WRAPPING_TYPES.has(wrapType);
-}
-//#endregion
+import { isFloatingWrapType, isWrapNone, wrapsAroundText } from "../types/wrap.js";
 export { isFloatingWrapType, isWrapNone, wrapsAroundText };

package/dist/fonts/fontAlternates.d.ts

@@ -0,0 +1,8 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/fonts/fontAlternates.d.ts
+type FontAlternates = ReadonlyMap<string, string>;
+/** Build a document-scoped primary-name → OOXML alternate-name lookup. */
+declare const buildFontAlternates: (fontTable: document_d_exports.FontTable | null | undefined) => FontAlternates;
+declare const getFontAlternate: (family: string | undefined, alternates: FontAlternates | undefined) => string | undefined;
+//#endregion
+export { FontAlternates, buildFontAlternates, getFontAlternate };

package/dist/fonts/fontAlternates.js

@@ -0,0 +1,16 @@
+//#region src/fonts/fontAlternates.ts
+const normalizeFontName = (name) => name.trim().toLowerCase();
+/** Build a document-scoped primary-name → OOXML alternate-name lookup. */
+const buildFontAlternates = (fontTable) => {
+	const alternates = /* @__PURE__ */ new Map();
+	for (const font of fontTable?.fonts ?? []) {
+		const primary = normalizeFontName(font.name);
+		const alternate = font.altName?.trim();
+		if (!primary || !alternate || normalizeFontName(alternate) === primary) continue;
+		alternates.set(primary, alternate);
+	}
+	return alternates;
+};
+const getFontAlternate = (family, alternates) => family === void 0 ? void 0 : alternates?.get(normalizeFontName(family));
+//#endregion
+export { buildFontAlternates, getFontAlternate };

package/dist/layout-bridge/convert/footnoteLayout.d.ts

@@ -6,6 +6,7 @@ type MeasureBlocksFn = (blocks: FlowBlock[], contentWidth: number) => Measure[];
 type ConvertFootnoteOptions = {
   styles?: document_d_exports.StyleDefinitions | null;
   theme?: document_d_exports.Theme | null;
+  fontAlternates?: ToFlowBlocksOptions["fontAlternates"];
   measureBlocks?: MeasureBlocksFn;
   /** Document-wide `w:defaultTabStop` in twips — forwarded to toFlowBlocks. */
   defaultTabStopTwips?: number;