@stll/folio-core 0.62.0 → 0.63.0

package/dist/docx/markupRangeMarker.js

@@ -1,3 +1,4 @@
+import { parseCopyOriginAncestors } from "./reviewResolutionProvenance.js";
 import { getAttribute, parseNumericAttribute } from "./xmlParser.js";
 //#region src/docx/markupRangeMarker.ts
 /** ST_DisplacedByCustomXml. A value outside it is not a placement folio can honour. */
@@ -12,9 +13,14 @@ const parseMarkupRangeMarker = (node) => {
 	if (displacedByCustomXml !== void 0) marker.displacedByCustomXml = displacedByCustomXml;
 	return marker;
 };
+const parseCopyOriginMarker = (node) => {
+	const copyOriginAncestors = parseCopyOriginAncestors(node);
+	return copyOriginAncestors === void 0 ? {} : { copyOriginAncestors };
+};
 const parseBookmarkRangeMarker = (node) => {
 	const marker = {
 		...parseMarkupRangeMarker(node),
+		...parseCopyOriginMarker(node),
 		name: getAttribute(node, "w", "name") ?? ""
 	};
 	const colFirst = parseNumericAttribute(node, "w", "colFirst");
@@ -40,5 +46,33 @@ const parseMoveBookmarkMarker = (node) => {
 	if (date.length > 0) marker.date = date;
 	return marker;
 };
+const BLOCK_MOVE_RANGE_MARKER_HANDLERS = {
+	moveFromRangeStart: (child, { modelled }) => {
+		modelled.push({
+			type: "moveFromRangeStart",
+			...parseMoveBookmarkMarker(child)
+		});
+	},
+	moveFromRangeEnd: (child, { modelled }) => {
+		modelled.push({
+			type: "moveFromRangeEnd",
+			...parseMarkupRangeMarker(child),
+			...parseCopyOriginMarker(child)
+		});
+	},
+	moveToRangeStart: (child, { modelled }) => {
+		modelled.push({
+			type: "moveToRangeStart",
+			...parseMoveBookmarkMarker(child)
+		});
+	},
+	moveToRangeEnd: (child, { modelled }) => {
+		modelled.push({
+			type: "moveToRangeEnd",
+			...parseMarkupRangeMarker(child),
+			...parseCopyOriginMarker(child)
+		});
+	}
+};
 //#endregion
-export { parseBookmarkRangeMarker, parseMarkupRangeMarker, parseMoveBookmarkMarker };
+export { BLOCK_MOVE_RANGE_MARKER_HANDLERS, parseBookmarkRangeMarker, parseCopyOriginMarker, parseMarkupRangeMarker, parseMoveBookmarkMarker };

package/dist/docx/mathToMathml.d.ts

@@ -1,5 +1,11 @@
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/mathToMathml.d.ts
+/**
+ * Return the shared run size when every OMML math run explicitly carries
+ * the same `w:sz`. Mixed or partially specified equations inherit surrounding
+ * text size instead.
+ */
+export declare function sharedMathRunFontSize(ommlXml: string): number | undefined;
 /**
  * Convert an OMML element (`<m:oMath>` or `<m:oMathPara>`) into a MathML
  * XML string.
@@ -9,6 +15,5 @@ import { XmlElement } from "./xmlParser.js";
  * `Range.createContextualFragment`. Returns `null` if `omml` is not an
  * OMML root element or contains no convertible children.
  */
-declare function ommlToMathml(omml: XmlElement): string | null;
-//#endregion
-export { ommlToMathml };
+export declare function ommlToMathml(omml: XmlElement): string | null;
+//#endregion

package/dist/docx/mathToMathml.js

@@ -1,4 +1,5 @@
-import { findChildByLocalName, getLocalName } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, findChildByLocalName, findChildByNamespaceUri, getAttributeByNamespaceUri, getLocalName, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
+import { assertXmlResourceLimits } from "./xmlResourceLimits.js";
 import { escapeXmlText } from "@stll/docx-core";
 //#region src/docx/mathToMathml.ts
 /**
@@ -29,6 +30,53 @@ import { escapeXmlText } from "@stll/docx-core";
 * implement against folio's own `XmlElement` rather than vendoring the
 * stylesheet.
 */
+const MATH_NAMESPACE_URIS = /* @__PURE__ */ new Set(["http://schemas.openxmlformats.org/officeDocument/2006/math", "http://purl.oclc.org/ooxml/officeDocument/math"]);
+/**
+* Return the shared run size when every OMML math run explicitly carries
+* the same `w:sz`. Mixed or partially specified equations inherit surrounding
+* text size instead.
+*/
+function sharedMathRunFontSize(ommlXml) {
+	assertXmlResourceLimits({ xml: ommlXml });
+	const root = parseXmlDocument(ommlXml);
+	if (!root || !MATH_NAMESPACE_URIS.has(getNamespaceUri(root) ?? "") || getLocalName(root.name) !== "oMath" && getLocalName(root.name) !== "oMathPara") return;
+	let sharedHalfPoints;
+	let hasRun = false;
+	let hasMixedSize = false;
+	const visit = (element) => {
+		if (hasMixedSize) return;
+		if (element.type === "element" && MATH_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "") && getLocalName(element.name) === "r") {
+			hasRun = true;
+			const runProperties = findChildByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "rPr");
+			const size = findChildByNamespaceUri(runProperties, WORDPROCESSINGML_NAMESPACE_URIS, "sz");
+			const halfPoints = Number(getAttributeByNamespaceUri(size, WORDPROCESSINGML_NAMESPACE_URIS, "val"));
+			if (!Number.isFinite(halfPoints) || halfPoints <= 0) {
+				hasMixedSize = true;
+				return;
+			}
+			if (sharedHalfPoints === void 0) sharedHalfPoints = halfPoints;
+			else if (sharedHalfPoints !== halfPoints) {
+				hasMixedSize = true;
+				return;
+			}
+		}
+		for (const child of element.elements ?? []) visit(child);
+	};
+	visit(root);
+	if (!hasRun || hasMixedSize || sharedHalfPoints === void 0) return;
+	return sharedHalfPoints / 2;
+}
+const MATH_VARIANTS = {
+	plain: "normal",
+	bold: "bold",
+	italic: "italic",
+	boldItalic: "bold-italic"
+};
+const MATH_ON_VALUES = /* @__PURE__ */ new Set([
+	"1",
+	"on",
+	"true"
+]);
 /**
 * Convert an OMML element (`<m:oMath>` or `<m:oMathPara>`) into a MathML
 * XML string.
@@ -171,7 +219,27 @@ function renderRun(run) {
 	if (tElems.length === 0) return "";
 	let out = "";
 	for (const tEl of tElems) out += tokenizeMathText(extractText(tEl));
-	return out;
+	const properties = findChildByNamespaceUri(run, MATH_NAMESPACE_URIS, "rPr");
+	const normal = findChildByNamespaceUri(properties, MATH_NAMESPACE_URIS, "nor");
+	const normalValue = normal ? getAttributeByNamespaceUri(normal, MATH_NAMESPACE_URIS, "val")?.toLowerCase() ?? "1" : void 0;
+	const enablesMathStyle = normalValue !== void 0 && MATH_ON_VALUES.has(normalValue);
+	const style = findChildByNamespaceUri(properties, MATH_NAMESPACE_URIS, "sty");
+	const styleValue = getAttributeByNamespaceUri(style, MATH_NAMESPACE_URIS, "val");
+	let mathVariant;
+	if (enablesMathStyle) mathVariant = MATH_VARIANTS.plain;
+	else switch (styleValue) {
+		case "p":
+			mathVariant = MATH_VARIANTS.plain;
+			break;
+		case "b":
+			mathVariant = MATH_VARIANTS.bold;
+			break;
+		case "i":
+			mathVariant = MATH_VARIANTS.italic;
+			break;
+		case "bi": mathVariant = MATH_VARIANTS.boldItalic;
+	}
+	return mathVariant === void 0 ? out : out.replaceAll(/<(mi|mn|mo)>/gu, `<$1 mathvariant="${mathVariant}">`);
 }
 function tokenizeMathText(text) {
 	if (!text) return "";
@@ -297,7 +365,7 @@ function renderAccent(el) {
 function renderBar(el) {
 	const barPr = findChildByLocalName(el, "barPr");
 	const posEl = barPr ? findChildByLocalName(barPr, "pos") : null;
-	const pos = posEl ? getAttrValue(posEl, "val") ?? "top" : "top";
+	const pos = posEl ? getAttrValue(posEl, "val") ?? "bot" : "bot";
 	const base = findChildByLocalName(el, "e");
 	const baseMml = base ? wrapMrow(renderChildren(base)) : "<mrow/>";
 	const bar = "<mo stretchy=\"true\">¯</mo>";
@@ -352,4 +420,4 @@ function getAttrValue(el, localAttr) {
 	}
 }
 //#endregion
-export { ommlToMathml };
+export { ommlToMathml, sharedMathRunFontSize };

package/dist/docx/metadataPrivacy.d.ts

@@ -1,38 +1,38 @@
 //#region src/docx/metadataPrivacy.d.ts
-declare const FOLIO_DOCUMENT_METADATA_PROPERTIES: readonly ["title", "subject", "creator", "keywords", "description", "lastModifiedBy", "revision", "created", "modified"];
-type FolioDocumentMetadataProperty = (typeof FOLIO_DOCUMENT_METADATA_PROPERTIES)[number];
-declare const FOLIO_DOCUMENT_PRIVACY_TRANSFORMS: readonly ["remove-attribution", "remove-timestamps", "remove-descriptive-metadata"];
-type FolioDocumentPrivacyTransform = (typeof FOLIO_DOCUMENT_PRIVACY_TRANSFORMS)[number];
-declare const isFolioDocumentPrivacyTransform: (value: unknown) => value is FolioDocumentPrivacyTransform;
-type FolioDocumentPrivacyOptions = {
+export declare const FOLIO_DOCUMENT_METADATA_PROPERTIES: readonly ["title", "subject", "creator", "keywords", "description", "lastModifiedBy", "revision", "created", "modified"];
+export type FolioDocumentMetadataProperty = (typeof FOLIO_DOCUMENT_METADATA_PROPERTIES)[number];
+export declare const FOLIO_DOCUMENT_PRIVACY_TRANSFORMS: readonly ["remove-attribution", "remove-timestamps", "remove-descriptive-metadata"];
+export type FolioDocumentPrivacyTransform = (typeof FOLIO_DOCUMENT_PRIVACY_TRANSFORMS)[number];
+export declare const isFolioDocumentPrivacyTransform: (value: unknown) => value is FolioDocumentPrivacyTransform;
+export type FolioDocumentPrivacyOptions = {
   transforms: readonly FolioDocumentPrivacyTransform[];
 };
-type FolioDocumentPrivacyReport = {
+export type FolioDocumentPrivacyReport = {
   appliedTransforms: FolioDocumentPrivacyTransform[];
   removedMetadataProperties: FolioDocumentMetadataProperty[];
 };
-type RewriteDocxMetadataPrivacyResult = {
+export type RewriteDocxMetadataPrivacyResult = {
   buffer: ArrayBuffer;
   privacyReport: FolioDocumentPrivacyReport;
 };
 declare const InvalidFolioDocumentPrivacyOptionsError_base: import("better-result").TaggedErrorClass<"InvalidFolioDocumentPrivacyOptionsError">;
-declare class InvalidFolioDocumentPrivacyOptionsError extends InvalidFolioDocumentPrivacyOptionsError_base<{
+export declare class InvalidFolioDocumentPrivacyOptionsError extends InvalidFolioDocumentPrivacyOptionsError_base<{
   message: string;
   receivedValue: unknown;
 }> {}
 declare const FolioDocumentPrivacyArchiveError_base: import("better-result").TaggedErrorClass<"FolioDocumentPrivacyArchiveError">;
-declare class FolioDocumentPrivacyArchiveError extends FolioDocumentPrivacyArchiveError_base<{
+export declare class FolioDocumentPrivacyArchiveError extends FolioDocumentPrivacyArchiveError_base<{
   message: string;
   reason: "input-too-large" | "load-failed" | "too-many-entries" | "core-properties-too-large";
   cause?: unknown;
 }> {}
-declare const PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM: {
+export declare const PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM: {
   readonly "remove-attribution": readonly ["creator", "lastModifiedBy"];
   readonly "remove-timestamps": readonly ["created", "modified"];
   readonly "remove-descriptive-metadata": readonly ["title", "subject", "keywords", "description"];
 };
-declare const resolveFolioDocumentPrivacyTransforms: (transforms: unknown) => FolioDocumentPrivacyTransform[];
+export declare const resolveFolioDocumentPrivacyTransforms: (transforms: unknown) => FolioDocumentPrivacyTransform[];
 /** Rewrite selected package metadata fields without changing other package parts. */
-declare const rewriteDocxMetadataPrivacy: (buffer: ArrayBuffer, { transforms }: FolioDocumentPrivacyOptions) => Promise<RewriteDocxMetadataPrivacyResult>;
+export declare const rewriteDocxMetadataPrivacy: (buffer: ArrayBuffer, { transforms }: FolioDocumentPrivacyOptions) => Promise<RewriteDocxMetadataPrivacyResult>;
 //#endregion
-export { FOLIO_DOCUMENT_METADATA_PROPERTIES, FOLIO_DOCUMENT_PRIVACY_TRANSFORMS, FolioDocumentMetadataProperty, FolioDocumentPrivacyArchiveError, FolioDocumentPrivacyOptions, FolioDocumentPrivacyReport, FolioDocumentPrivacyTransform, InvalidFolioDocumentPrivacyOptionsError, PRIVATE_METADATA_PROPERTIES_BY_TRANSFORM, RewriteDocxMetadataPrivacyResult, isFolioDocumentPrivacyTransform, resolveFolioDocumentPrivacyTransforms, rewriteDocxMetadataPrivacy };
+export {};

package/dist/docx/metadataPrivacy.js

@@ -2,8 +2,8 @@ import { decodeText, encodeUtf8 } from "../utils/textEncoding.js";
 import { countCentralDirectoryRecords, createInflationBudget, inflateEntryWithinLimits } from "./archiveInflation.js";
 import { elementToXml, getLocalName, parseXmlDocument } from "./xmlParser.js";
 import { TaggedError } from "better-result";
-import { writeZipPart } from "@stll/docx-core/zip";
 import JSZip from "jszip";
+import { writeZipPart } from "@stll/docx-core/zip";
 //#region src/docx/metadataPrivacy.ts
 const FOLIO_DOCUMENT_METADATA_PROPERTIES = Object.freeze([
 	"title",
@@ -44,9 +44,9 @@ const resolveFolioDocumentPrivacyTransforms = (transforms) => {
 	return FOLIO_DOCUMENT_PRIVACY_TRANSFORMS.filter((transform) => requested.has(transform));
 };
 const XML_DECLARATION_PATTERN = /^\s*<\?xml[^?]*\?>/u;
-const MAX_INPUT_BYTES = 50 * 1024 * 1024;
+const MAX_INPUT_BYTES = 52428800;
 const MAX_ARCHIVE_ENTRIES = 5e3;
-const MAX_CORE_PROPERTIES_BYTES = 1024 * 1024;
+const MAX_CORE_PROPERTIES_BYTES = 1048576;
 const CORE_PROPERTIES_PATH_LOWER = "docprops/core.xml";
 /**
 * Look up a package part by its conventional lowercase path, falling back to

package/dist/docx/metafileRaster.d.ts

@@ -15,7 +15,7 @@
  * When no embedded raster is found this returns `null`; callers fall back to a
  * sized placeholder and/or the host-supplied `mediaResolver` hook.
  */
-type ExtractedRaster = {
+export type ExtractedRaster = {
   bytes: Uint8Array;
   mimeType: "image/png" | "image/jpeg";
 };
@@ -23,8 +23,7 @@ type ExtractedRaster = {
  * Scan a metafile (EMF or WMF) for an embedded browser-renderable raster.
  * Returns the first PNG, else first JPEG found; `null` when none is present.
  */
-declare function extractMetafileRaster(data: ArrayBuffer | Uint8Array): ExtractedRaster | null;
+export declare function extractMetafileRaster(data: ArrayBuffer | Uint8Array): ExtractedRaster | null;
 /** True for EMF/WMF MIME types — the formats browsers cannot render natively. */
-declare function isMetafileMimeType(mimeType: string | undefined): boolean;
-//#endregion
-export { ExtractedRaster, extractMetafileRaster, isMetafileMimeType };
+export declare function isMetafileMimeType(mimeType: string | undefined): boolean;
+//#endregion

package/dist/docx/metafileSvg.d.ts

@@ -7,6 +7,5 @@
  * Original EMF bytes remain the source of truth for DOCX round-trip.
  */
 /** Convert the supported filled-path EMF subset to inert generated SVG. */
-declare function renderEmfSvg(data: ArrayBuffer | Uint8Array): string | null;
-//#endregion
-export { renderEmfSvg };
+export declare function renderEmfSvg(data: ArrayBuffer | Uint8Array): string | null;
+//#endregion

package/dist/docx/metafileSvg.js

@@ -1,3 +1,4 @@
+import { assembleMetafileSvg, metafileColorRefToCss, metafileNumberText, transformMetafilePoint } from "./metafileSvgShared.js";
 //#region src/docx/metafileSvg.ts
 /**
 * Render a deliberately small, browser-safe EMF subset to generated SVG.
@@ -78,16 +79,6 @@ const cloneState = (state) => ({
 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 {
@@ -122,25 +113,27 @@ const stockObject = (handle) => {
 	}
 };
 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 unitExtent = {
+		x: 1,
+		y: 1
 	};
+	return transformMetafilePoint({
+		point: {
+			x,
+			y
+		},
+		windowOrigin: state.windowOrigin,
+		windowExtent: state.mapMode === MAP_MODE_TEXT ? unitExtent : state.windowExtent,
+		viewportOrigin: state.viewportOrigin,
+		viewportExtent: state.mapMode === MAP_MODE_TEXT ? unitExtent : state.viewportExtent,
+		outputOrigin: {
+			x: bounds.left,
+			y: bounds.top
+		},
+		maxCoordinate: MAX_EMF_DIMENSION * 100
+	});
 };
-const pathPoint = (command, point) => `${command}${numberText(point.x)} ${numberText(point.y)}`;
+const pathPoint = (command, point) => `${command}${metafileNumberText(point.x)} ${metafileNumberText(point.y)}`;
 const selectGraphicsObject = (state, objects, handle) => {
 	const object = handle >= STOCK_OBJECT_FLAG ? stockObject(handle) : objects.get(handle);
 	if (!object) return false;
@@ -260,7 +253,7 @@ function renderEmfSvg(data) {
 				if (style !== 0 && style !== 1) return null;
 				objects.set(handle, {
 					type: "brush",
-					fill: style === 1 ? null : colorRefToCss(color)
+					fill: style === 1 ? null : metafileColorRefToCss(color)
 				});
 				break;
 			}
@@ -304,7 +297,6 @@ function renderEmfSvg(data) {
 						break;
 					case "building":
 					case "completed": return null;
-					default:
 				}
 				break;
 			case EMR.moveToEx: {
@@ -324,7 +316,6 @@ function renderEmfSvg(data) {
 						pathState.commands.push(pathPoint("M", mapped));
 						break;
 					}
-					default:
 				}
 				break;
 			}
@@ -363,7 +354,7 @@ function renderEmfSvg(data) {
 					}
 					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)}`);
+					commands.push(`C${metafileNumberText(first.x)} ${metafileNumberText(first.y)} ${metafileNumberText(second.x)} ${metafileNumberText(second.y)} ${metafileNumberText(third.x)} ${metafileNumberText(third.y)}`);
 				}
 				break;
 			}
@@ -400,8 +391,6 @@ function renderEmfSvg(data) {
 					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;
 			}
@@ -413,7 +402,6 @@ function renderEmfSvg(data) {
 						break;
 					case "idle":
 					case "completed": return null;
-					default:
 				}
 				break;
 			case EMR.endPath:
@@ -428,7 +416,6 @@ function renderEmfSvg(data) {
 						break;
 					case "idle":
 					case "completed": return null;
-					default:
 				}
 				break;
 			case EMR.fillPath:
@@ -440,7 +427,6 @@ function renderEmfSvg(data) {
 						break;
 					case "idle":
 					case "building": return null;
-					default:
 				}
 				break;
 			default: return null;
@@ -453,10 +439,13 @@ function renderEmfSvg(data) {
 		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;
+	return assembleMetafileSvg({
+		width,
+		height,
+		elements: renderedPaths,
+		maxCharacters: MAX_EMF_SVG_CHARACTERS
+	});
 }
 //#endregion
 export { renderEmfSvg };

package/dist/docx/metafileSvgShared.d.ts

@@ -0,0 +1,27 @@
+//#region src/docx/metafileSvgShared.d.ts
+/** Helpers shared by the fail-closed EMF and WMF SVG renderers. */
+export type MetafilePoint = {
+  x: number;
+  y: number;
+};
+type TransformMetafilePointOptions = {
+  point: MetafilePoint;
+  windowOrigin: MetafilePoint;
+  windowExtent: MetafilePoint;
+  viewportOrigin: MetafilePoint;
+  viewportExtent: MetafilePoint;
+  outputOrigin: MetafilePoint;
+  maxCoordinate: number;
+};
+export declare const transformMetafilePoint: ({ point, windowOrigin, windowExtent, viewportOrigin, viewportExtent, outputOrigin, maxCoordinate }: TransformMetafilePointOptions) => MetafilePoint | undefined;
+export declare const metafileNumberText: (value: number) => string;
+export declare const metafileColorRefToCss: (color: number) => string;
+type AssembleMetafileSvgOptions = {
+  width: number;
+  height: number;
+  elements: readonly string[];
+  maxCharacters: number;
+};
+export declare const assembleMetafileSvg: ({ width, height, elements, maxCharacters }: AssembleMetafileSvgOptions) => string | null;
+//#endregion
+export {};

package/dist/docx/metafileSvgShared.js

@@ -0,0 +1,28 @@
+//#region src/docx/metafileSvgShared.ts
+const transformMetafilePoint = ({ point, windowOrigin, windowExtent, viewportOrigin, viewportExtent, outputOrigin, maxCoordinate }) => {
+	if (windowExtent.x === 0 || windowExtent.y === 0) return;
+	const x = (point.x - windowOrigin.x) * viewportExtent.x / windowExtent.x + viewportOrigin.x - outputOrigin.x;
+	const y = (point.y - windowOrigin.y) * viewportExtent.y / windowExtent.y + viewportOrigin.y - outputOrigin.y;
+	if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+	if (Math.abs(x) > maxCoordinate || Math.abs(y) > maxCoordinate) return;
+	return {
+		x,
+		y
+	};
+};
+const metafileNumberText = (value) => {
+	const rounded = Math.round(value * 1e4) / 1e4;
+	return Object.is(rounded, -0) ? "0" : String(rounded);
+};
+const metafileColorRefToCss = (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 assembleMetafileSvg = ({ width, height, elements, maxCharacters }) => {
+	const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${metafileNumberText(width)} ${metafileNumberText(height)}">${elements.join("")}</svg>`;
+	return svg.length <= maxCharacters ? svg : null;
+};
+//#endregion
+export { assembleMetafileSvg, metafileColorRefToCss, metafileNumberText, transformMetafilePoint };

package/dist/docx/modelValidation.d.ts

@@ -1,12 +1,11 @@
 import { document_d_exports } from "../types/document.js";
 import { ValidateDocumentModelIssue, ValidateDocumentModelResult } from "@stll/docx-core";
 //#region src/docx/modelValidation.d.ts
-declare class DocxModelValidationError extends Error {
+export declare class DocxModelValidationError extends Error {
   readonly issues: ValidateDocumentModelIssue[];
   constructor(context: string, issues: ValidateDocumentModelIssue[]);
 }
-declare const validateFolioDocumentModel: (document: document_d_exports.Document) => ValidateDocumentModelResult;
-declare const assertValidFolioDocumentModel: (document: document_d_exports.Document, context: string) => void;
-declare const formatDocumentModelIssues: (issues: ValidateDocumentModelIssue[]) => string[];
-//#endregion
-export { DocxModelValidationError, assertValidFolioDocumentModel, formatDocumentModelIssues, validateFolioDocumentModel };
+export declare const validateFolioDocumentModel: (document: document_d_exports.Document) => ValidateDocumentModelResult;
+export declare const assertValidFolioDocumentModel: (document: document_d_exports.Document, context: string) => void;
+export declare const formatDocumentModelIssues: (issues: ValidateDocumentModelIssue[]) => string[];
+//#endregion

package/dist/docx/modelValidation.js

@@ -1,4 +1,5 @@
 import { validateDocumentModel } from "@stll/docx-core";
+import { isCanonicallyEmptyParagraphFormatting } from "@stll/docx-core/model";
 //#region src/docx/modelValidation.ts
 var DocxModelValidationError = class extends Error {
 	issues;
@@ -8,7 +9,149 @@ var DocxModelValidationError = class extends Error {
 		this.issues = issues;
 	}
 };
-const validateFolioDocumentModel = (document) => validateDocumentModel(document);
+const validateFolioDocumentModel = (document) => {
+	const issues = [];
+	try {
+		issues.push(...validateDocumentModel(document).issues);
+	} catch {
+		issues.push({
+			path: "package.document",
+			message: "Document structure is malformed.",
+			severity: "error"
+		});
+	}
+	const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+	const addMalformedIssue = (path, expected) => {
+		issues.push({
+			path,
+			message: `Expected ${expected}.`,
+			severity: "error"
+		});
+	};
+	const input = document;
+	if (!isRecord(input)) {
+		addMalformedIssue("document", "an object");
+		return {
+			valid: false,
+			issues
+		};
+	}
+	const documentPackage = input["package"];
+	if (!isRecord(documentPackage)) {
+		addMalformedIssue("package", "an object");
+		return {
+			valid: false,
+			issues
+		};
+	}
+	const documentBody = documentPackage["document"];
+	if (!isRecord(documentBody)) {
+		addMalformedIssue("package.document", "an object");
+		return {
+			valid: false,
+			issues
+		};
+	}
+	if (Array.isArray(documentBody["comments"]) && documentBody["comments"].length === 0) issues.push({
+		path: "package.document.comments",
+		message: "Empty comment lists must be absent.",
+		severity: "error"
+	});
+	const validateBlocks = (blocks, path) => {
+		if (!Array.isArray(blocks)) {
+			addMalformedIssue(path, "an array");
+			return;
+		}
+		for (const [index, block] of blocks.entries()) {
+			const blockPath = `${path}[${String(index)}]`;
+			if (!isRecord(block)) {
+				addMalformedIssue(blockPath, "an object");
+				continue;
+			}
+			if (block["type"] === "paragraph") {
+				if (block["formatting"] !== void 0 && !isRecord(block["formatting"])) addMalformedIssue(`${blockPath}.formatting`, "an object");
+				else if (block["formatting"] !== void 0 && isRecord(block["formatting"]) && isCanonicallyEmptyParagraphFormatting(block["formatting"])) issues.push({
+					path: `${blockPath}.formatting`,
+					message: "Empty paragraph formatting must be absent.",
+					severity: "error"
+				});
+				continue;
+			}
+			if (block["type"] === "table") {
+				if (!Array.isArray(block["rows"])) {
+					addMalformedIssue(`${blockPath}.rows`, "an array");
+					continue;
+				}
+				for (const [rowIndex, row] of block["rows"].entries()) {
+					const rowPath = `${blockPath}.rows[${String(rowIndex)}]`;
+					if (!isRecord(row)) {
+						addMalformedIssue(rowPath, "an object");
+						continue;
+					}
+					if (!Array.isArray(row["cells"])) {
+						addMalformedIssue(`${rowPath}.cells`, "an array");
+						continue;
+					}
+					for (const [cellIndex, cell] of row["cells"].entries()) {
+						const cellPath = `${rowPath}.cells[${String(cellIndex)}]`;
+						if (!isRecord(cell)) {
+							addMalformedIssue(cellPath, "an object");
+							continue;
+						}
+						validateBlocks(cell["content"], `${cellPath}.content`);
+					}
+				}
+			} else if (block["type"] === "blockSdt" || block["type"] === "blockCustomXml") validateBlocks(block["content"], `${blockPath}.content`);
+		}
+	};
+	validateBlocks(documentBody["content"], "package.document.content");
+	const validateStoryMap = (stories, path) => {
+		if (stories === void 0) return;
+		if (!(stories instanceof Map)) {
+			addMalformedIssue(path, "a map");
+			return;
+		}
+		for (const [id, story] of stories) {
+			const storyPath = `${path}[${JSON.stringify(id)}]`;
+			if (!isRecord(story)) {
+				addMalformedIssue(storyPath, "an object");
+				continue;
+			}
+			validateBlocks(story["content"], `${storyPath}.content`);
+		}
+	};
+	const validateNoteStories = (notes, path) => {
+		if (notes === void 0) return;
+		if (!Array.isArray(notes)) {
+			addMalformedIssue(path, "an array");
+			return;
+		}
+		for (const [index, note] of notes.entries()) {
+			const notePath = `${path}[${String(index)}]`;
+			if (!isRecord(note)) {
+				addMalformedIssue(notePath, "an object");
+				continue;
+			}
+			validateBlocks(note["content"], `${notePath}.content`);
+		}
+	};
+	validateStoryMap(documentPackage["headers"], "package.headers");
+	validateStoryMap(documentPackage["footers"], "package.footers");
+	validateNoteStories(documentPackage["footnotes"], "package.footnotes");
+	validateNoteStories(documentPackage["endnotes"], "package.endnotes");
+	if (Array.isArray(documentBody["comments"])) for (const [index, comment] of documentBody["comments"].entries()) {
+		const commentPath = `package.document.comments[${String(index)}]`;
+		if (!isRecord(comment)) {
+			addMalformedIssue(commentPath, "an object");
+			continue;
+		}
+		validateBlocks(comment["content"], `${commentPath}.content`);
+	}
+	return {
+		valid: issues.every(({ severity }) => severity !== "error"),
+		issues
+	};
+};
 const assertValidFolioDocumentModel = (document, context) => {
 	const validation = validateFolioDocumentModel(document);
 	if (validation.valid) return;